starknet 5.8.0 → 5.9.1

package/dist/index.mjs

@@ -43,9 +43,12 @@ var RPC;
   })(TransactionType2 = RPC2.TransactionType || (RPC2.TransactionType = {}));
 })(RPC || (RPC = {}));
 
-// src/utils/fetchPonyfill.ts
-import isomorphicFetch from "isomorphic-fetch";
-var fetchPonyfill_default = typeof window !== "undefined" && window.fetch || typeof global !== "undefined" && global.fetch || isomorphicFetch;
+// src/utils/assert.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || "Assertion failure");
+  }
+}
 
 // src/utils/hash.ts
 var hash_exports = {};
@@ -2271,15 +2274,6 @@ __export(num_exports, {
   toHexString: () => toHexString
 });
 import { hexToBytes as hexToBytesNoble } from "@noble/curves/abstract/utils";
-
-// src/utils/assert.ts
-function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message || "Assertion failure");
-  }
-}
-
-// src/utils/num.ts
 function isHex(hex) {
   return /^0x[0-9a-f]*$/i.test(hex);
 }
@@ -2743,185 +2737,6 @@ function computeContractClassHash(contract) {
   return computeLegacyContractClassHash(compiledContract);
 }
 
-// src/utils/contract.ts
-function isSierra(contract) {
-  const compiledContract = typeof contract === "string" ? parse2(contract) : contract;
-  return "sierra_program" in compiledContract;
-}
-function extractContractHashes(payload) {
-  const response = { ...payload };
-  if (isSierra(payload.contract)) {
-    if (!payload.compiledClassHash && payload.casm) {
-      response.compiledClassHash = computeCompiledClassHash(payload.casm);
-    }
-    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;
-}
-
-// src/utils/stark.ts
-var stark_exports = {};
-__export(stark_exports, {
-  compressProgram: () => compressProgram,
-  estimatedFeeToMaxFee: () => estimatedFeeToMaxFee,
-  formatSignature: () => formatSignature,
-  makeAddress: () => makeAddress,
-  randomAddress: () => randomAddress,
-  signatureToDecimalArray: () => signatureToDecimalArray,
-  signatureToHexArray: () => signatureToHexArray
-});
-import { getStarkKey, utils } from "micro-starknet";
-import { gzip } from "pako";
-function compressProgram(jsonProgram) {
-  const stringified = typeof jsonProgram === "string" ? jsonProgram : stringify2(jsonProgram);
-  const compressedProgram = gzip(stringified);
-  return btoaUniversal(compressedProgram);
-}
-function randomAddress() {
-  const randomKeyPair = utils.randomPrivateKey();
-  return getStarkKey(randomKeyPair);
-}
-function makeAddress(input) {
-  return addHexPrefix(input).toLowerCase();
-}
-function formatSignature(sig) {
-  if (!sig)
-    throw Error("formatSignature: provided signature is undefined");
-  if (Array.isArray(sig)) {
-    return sig.map((it) => toHex(it));
-  }
-  try {
-    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");
-  }
-}
-function signatureToDecimalArray(sig) {
-  return bigNumberishArrayToDecimalStringArray(formatSignature(sig));
-}
-function signatureToHexArray(sig) {
-  return bigNumberishArrayToHexadecimalStringArray(formatSignature(sig));
-}
-function estimatedFeeToMaxFee(estimatedFee, overhead = 0.5) {
-  const overHeadPercent = Math.round((1 + overhead) * 100);
-  return toBigInt(estimatedFee) * toBigInt(overHeadPercent) / 100n;
-}
-
-// src/utils/provider.ts
-function wait(delay) {
-  return new Promise((res) => {
-    setTimeout(res, delay);
-  });
-}
-function parseCalldata(calldata = []) {
-  return calldata.map((data) => {
-    if (typeof data === "string" && isHex(data)) {
-      return data;
-    }
-    return toHex(data);
-  });
-}
-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 = compressProgram(result.sierra_program);
-  return result;
-}
-function parseContract(contract) {
-  const parsedContract = typeof contract === "string" ? parse2(contract) : contract;
-  if (!isSierra(contract)) {
-    return {
-      ...parsedContract,
-      ..."program" in parsedContract && { program: compressProgram(parsedContract.program) }
-    };
-  }
-  return createSierraContractClass(parsedContract);
-}
-
-// src/utils/responseParser/rpc.ts
-var RPCResponseParser = class {
-  parseGetBlockResponse(res) {
-    return {
-      timestamp: res.timestamp,
-      block_hash: res.block_hash,
-      block_number: res.block_number,
-      new_root: res.new_root,
-      parent_hash: res.parent_hash,
-      status: res.status,
-      transactions: res.transactions
-    };
-  }
-  parseGetTransactionResponse(res) {
-    return {
-      calldata: res.calldata || [],
-      contract_address: res.contract_address,
-      sender_address: res.contract_address,
-      max_fee: res.max_fee,
-      nonce: res.nonce,
-      signature: res.signature || [],
-      transaction_hash: res.transaction_hash,
-      version: res.version
-    };
-  }
-  parseFeeEstimateResponse(res) {
-    return {
-      overall_fee: toBigInt(res.overall_fee),
-      gas_consumed: toBigInt(res.gas_consumed),
-      gas_price: toBigInt(res.gas_price)
-    };
-  }
-  parseCallContractResponse(res) {
-    return {
-      result: res
-    };
-  }
-};
-
-// src/provider/errors.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 {
-  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 GatewayError = class extends LibraryError {
-  constructor(message, errorCode) {
-    super(message);
-    this.errorCode = errorCode;
-  }
-};
-var HttpError = class extends LibraryError {
-  constructor(message, errorCode) {
-    super(message);
-    this.errorCode = errorCode;
-  }
-};
-
 // src/utils/calldata/formatter.ts
 var guard = {
   isBN: (data, type, key) => {
@@ -3039,6 +2854,15 @@ function extractTupleMemberTypes(type) {
 }
 
 // src/utils/calldata/requestParser.ts
+function parseBaseTypes(type, val) {
+  switch (true) {
+    case isTypeUint256(type):
+      const el_uint256 = uint256(val);
+      return [felt(el_uint256.low), felt(el_uint256.high)];
+    default:
+      return felt(val);
+  }
+}
 function parseTuple(element, typeStr) {
   const memberTypes = extractTupleMemberTypes(typeStr);
   const elements = Object.values(element);
@@ -3063,10 +2887,6 @@ function parseCalldataValue(element, type, structs) {
   if (Array.isArray(element)) {
     throw Error(`Array inside array (nD) are not supported by cairo. Element: ${element} ${type}`);
   }
-  if (isTypeUint256(type)) {
-    const el_uint256 = uint256(element);
-    return [felt(el_uint256.low), felt(el_uint256.high)];
-  }
   if (structs[type] && structs[type].members.length) {
     const { members } = structs[type];
     const subElement = element;
@@ -3084,7 +2904,7 @@ function parseCalldataValue(element, type, structs) {
   if (typeof element === "object") {
     throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
   }
-  return felt(element);
+  return parseBaseTypes(type, element);
 }
 function parseCalldataField(argsIterator, input, structs) {
   const { name, type } = input;
@@ -3101,25 +2921,42 @@ function parseCalldataField(argsIterator, input, structs) {
       result.push(felt(value.length));
       const arrayType = getArrayType(input.type);
       return value.reduce((acc, el) => {
-        if (isTypeFelt(arrayType) || isTypeUint(arrayType) || isTypeContractAddress(arrayType)) {
-          acc.push(felt(el));
-        } else if (isTypeBool(arrayType) && typeof el === "boolean") {
-          acc.push(el.toString());
-        } else {
+        if (isTypeStruct(arrayType, structs) || isTypeTuple(arrayType) || isTypeArray(arrayType)) {
           acc.push(...parseCalldataValue(el, arrayType, structs));
+        } else {
+          return acc.concat(parseBaseTypes(arrayType, el));
         }
         return acc;
       }, result);
-    case (isTypeStruct(type, structs) || isTypeTuple(type) || isTypeUint256(type)):
+    case (isTypeStruct(type, structs) || isTypeTuple(type)):
       return parseCalldataValue(value, type, structs);
-    case isTypeBool(type):
-      return `${+value}`;
+    case isTypeUint256(type):
+      if (typeof value === "object") {
+        return [felt(value.low), felt(value.high)];
+      }
+      const el_uint256 = uint256(value);
+      return [felt(el_uint256.low), felt(el_uint256.high)];
     default:
-      return felt(value);
+      return parseBaseTypes(type, value);
   }
 }
 
 // src/utils/calldata/responseParser.ts
+function parseBaseTypes2(type, it) {
+  let temp;
+  switch (true) {
+    case isTypeBool(type):
+      temp = it.next().value;
+      return Boolean(BigInt(temp));
+    case isTypeUint256(type):
+      const low = it.next().value;
+      const high = it.next().value;
+      return uint256ToBN({ low, high });
+    default:
+      temp = it.next().value;
+      return BigInt(temp);
+  }
+}
 function parseResponseStruct(responseIterator, type, structs) {
   if (type in structs && structs[type]) {
     return structs[type].members.reduce((acc, el) => {
@@ -3136,8 +2973,7 @@ function parseResponseStruct(responseIterator, type, structs) {
       return acc;
     }, {});
   }
-  const temp = responseIterator.next().value;
-  return BigInt(temp);
+  return parseBaseTypes2(type, responseIterator);
 }
 function responseParser(responseIterator, output, structs, parsedResult) {
   const { name, type } = output;
@@ -3146,21 +2982,13 @@ function responseParser(responseIterator, output, structs, parsedResult) {
     case isLen(name):
       temp = responseIterator.next().value;
       return BigInt(temp);
-    case isTypeBool(type):
-      temp = responseIterator.next().value;
-      return Boolean(BigInt(temp));
-    case isTypeUint256(type):
-      const low = responseIterator.next().value;
-      const high = responseIterator.next().value;
-      return uint256ToBN({ low, high });
     case isTypeArray(type):
       const parsedDataArr = [];
       if (isCairo1Type(type)) {
-        responseIterator.next();
-        let it = responseIterator.next();
-        while (!it.done) {
-          parsedDataArr.push(BigInt(it.value));
-          it = responseIterator.next();
+        const arrayType = getArrayType(type);
+        const len = BigInt(responseIterator.next().value);
+        while (parsedDataArr.length < len) {
+          parsedDataArr.push(parseResponseStruct(responseIterator, arrayType, structs));
         }
         return parsedDataArr;
       }
@@ -3176,8 +3004,7 @@ function responseParser(responseIterator, output, structs, parsedResult) {
     case (type in structs || isTypeTuple(type)):
       return parseResponseStruct(responseIterator, type, structs);
     default:
-      temp = responseIterator.next().value;
-      return BigInt(temp);
+      return parseBaseTypes2(type, responseIterator);
   }
 }
 
@@ -3196,10 +3023,10 @@ var validateUint = (parameter, input) => {
     );
   }
   assert(
-    typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint",
-    `Validate: arg ${input.name} of cairo type ${input.type} should be type (String, Number or BigInt)`
+    typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint" || typeof parameter === "object" && "low" in parameter && "high" in parameter,
+    `Validate: arg ${input.name} of cairo ZORG type ${input.type} should be type (String, Number or BigInt)`
   );
-  const param = toBigInt(parameter);
+  const param = typeof parameter === "object" ? uint256ToBN(parameter) : toBigInt(parameter);
   switch (input.type) {
     case "core::integer::u8" /* u8 */:
       assert(
@@ -3375,6 +3202,8 @@ var CallData = class {
           let value = v;
           if (isLongText(value))
             value = splitLongString(value);
+          if (k === "entrypoint")
+            value = getSelectorFromName(value);
           const kk = Array.isArray(oe) && k === "0" ? "$$len" : k;
           if (isBigInt(value))
             return [[`${prefix}${kk}`, felt(value)]];
@@ -3428,6 +3257,188 @@ var CallData = class {
       {}
     );
   }
+  static toCalldata(rawCalldata = []) {
+    return CallData.compile(rawCalldata);
+  }
+  static toHex(rawCalldata = []) {
+    const calldata = CallData.compile(rawCalldata);
+    return calldata.map((it) => toHex(it));
+  }
+};
+
+// src/utils/fetchPonyfill.ts
+import isomorphicFetch from "isomorphic-fetch";
+var fetchPonyfill_default = typeof window !== "undefined" && window.fetch || typeof global !== "undefined" && global.fetch || isomorphicFetch;
+
+// src/utils/contract.ts
+function isSierra(contract) {
+  const compiledContract = typeof contract === "string" ? parse2(contract) : contract;
+  return "sierra_program" in compiledContract;
+}
+function extractContractHashes(payload) {
+  const response = { ...payload };
+  if (isSierra(payload.contract)) {
+    if (!payload.compiledClassHash && payload.casm) {
+      response.compiledClassHash = computeCompiledClassHash(payload.casm);
+    }
+    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;
+}
+
+// src/utils/stark.ts
+var stark_exports = {};
+__export(stark_exports, {
+  compressProgram: () => compressProgram,
+  estimatedFeeToMaxFee: () => estimatedFeeToMaxFee,
+  formatSignature: () => formatSignature,
+  makeAddress: () => makeAddress,
+  randomAddress: () => randomAddress,
+  signatureToDecimalArray: () => signatureToDecimalArray,
+  signatureToHexArray: () => signatureToHexArray
+});
+import { getStarkKey, utils } from "micro-starknet";
+import { gzip } from "pako";
+function compressProgram(jsonProgram) {
+  const stringified = typeof jsonProgram === "string" ? jsonProgram : stringify2(jsonProgram);
+  const compressedProgram = gzip(stringified);
+  return btoaUniversal(compressedProgram);
+}
+function randomAddress() {
+  const randomKeyPair = utils.randomPrivateKey();
+  return getStarkKey(randomKeyPair);
+}
+function makeAddress(input) {
+  return addHexPrefix(input).toLowerCase();
+}
+function formatSignature(sig) {
+  if (!sig)
+    throw Error("formatSignature: provided signature is undefined");
+  if (Array.isArray(sig)) {
+    return sig.map((it) => toHex(it));
+  }
+  try {
+    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");
+  }
+}
+function signatureToDecimalArray(sig) {
+  return bigNumberishArrayToDecimalStringArray(formatSignature(sig));
+}
+function signatureToHexArray(sig) {
+  return bigNumberishArrayToHexadecimalStringArray(formatSignature(sig));
+}
+function estimatedFeeToMaxFee(estimatedFee, overhead = 0.5) {
+  const overHeadPercent = Math.round((1 + overhead) * 100);
+  return toBigInt(estimatedFee) * toBigInt(overHeadPercent) / 100n;
+}
+
+// src/utils/provider.ts
+function wait(delay) {
+  return new Promise((res) => {
+    setTimeout(res, delay);
+  });
+}
+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 = compressProgram(result.sierra_program);
+  return result;
+}
+function parseContract(contract) {
+  const parsedContract = typeof contract === "string" ? parse2(contract) : contract;
+  if (!isSierra(contract)) {
+    return {
+      ...parsedContract,
+      ..."program" in parsedContract && { program: compressProgram(parsedContract.program) }
+    };
+  }
+  return createSierraContractClass(parsedContract);
+}
+
+// src/utils/responseParser/rpc.ts
+var RPCResponseParser = class {
+  parseGetBlockResponse(res) {
+    return {
+      timestamp: res.timestamp,
+      block_hash: res.block_hash,
+      block_number: res.block_number,
+      new_root: res.new_root,
+      parent_hash: res.parent_hash,
+      status: res.status,
+      transactions: res.transactions
+    };
+  }
+  parseGetTransactionResponse(res) {
+    return {
+      calldata: res.calldata || [],
+      contract_address: res.contract_address,
+      sender_address: res.contract_address,
+      max_fee: res.max_fee,
+      nonce: res.nonce,
+      signature: res.signature || [],
+      transaction_hash: res.transaction_hash,
+      version: res.version
+    };
+  }
+  parseFeeEstimateResponse(res) {
+    return {
+      overall_fee: toBigInt(res.overall_fee),
+      gas_consumed: toBigInt(res.gas_consumed),
+      gas_price: toBigInt(res.gas_price)
+    };
+  }
+  parseCallContractResponse(res) {
+    return {
+      result: res
+    };
+  }
+};
+
+// src/provider/errors.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 {
+  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 GatewayError = class extends LibraryError {
+  constructor(message, errorCode) {
+    super(message);
+    this.errorCode = errorCode;
+  }
+};
+var HttpError = class extends LibraryError {
+  constructor(message, errorCode) {
+    super(message);
+    this.errorCode = errorCode;
+  }
 };
 
 // src/utils/starknetId.ts
@@ -3760,7 +3771,7 @@ var RpcProvider = class {
       request: {
         type: RPC.TransactionType.INVOKE,
         sender_address: invocation.contractAddress,
-        calldata: parseCalldata(invocation.calldata),
+        calldata: CallData.toHex(invocation.calldata),
         signature: signatureToHexArray(invocation.signature),
         version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 0),
         nonce: toHex(invocationDetails.nonce),
@@ -3848,7 +3859,7 @@ var RpcProvider = class {
     return this.fetchEndpoint("starknet_addInvokeTransaction", {
       invoke_transaction: {
         sender_address: functionInvocation.contractAddress,
-        calldata: parseCalldata(functionInvocation.calldata),
+        calldata: CallData.toHex(functionInvocation.calldata),
         type: RPC.TransactionType.INVOKE,
         max_fee: toHex(details.maxFee || 0),
         version: "0x1",
@@ -3863,7 +3874,7 @@ var RpcProvider = class {
       request: {
         contract_address: call.contractAddress,
         entry_point_selector: getSelectorFromName(call.entrypoint),
-        calldata: parseCalldata(call.calldata)
+        calldata: CallData.toHex(call.calldata)
       },
       block_id
     });
@@ -4333,7 +4344,7 @@ var SequencerProvider = class {
     return this.fetchEndpoint("add_transaction", void 0, {
       type: "INVOKE_FUNCTION" /* INVOKE */,
       sender_address: functionInvocation.contractAddress,
-      calldata: bigNumberishArrayToDecimalStringArray(functionInvocation.calldata ?? []),
+      calldata: CallData.compile(functionInvocation.calldata ?? []),
       signature: signatureToDecimalArray(functionInvocation.signature),
       nonce: toHex(details.nonce),
       max_fee: toHex(details.maxFee || 0),
@@ -4344,7 +4355,7 @@ var SequencerProvider = class {
     return this.fetchEndpoint("add_transaction", void 0, {
       type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
       contract_address_salt: addressSalt ?? randomAddress(),
-      constructor_calldata: bigNumberishArrayToDecimalStringArray(constructorCalldata ?? []),
+      constructor_calldata: CallData.compile(constructorCalldata ?? []),
       class_hash: toHex(classHash),
       max_fee: toHex(details.maxFee || 0),
       version: toHex(details.version || 0),
@@ -4428,7 +4439,7 @@ var SequencerProvider = class {
       {
         type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
         class_hash: toHex(classHash),
-        constructor_calldata: bigNumberishArrayToDecimalStringArray(constructorCalldata || []),
+        constructor_calldata: CallData.compile(constructorCalldata || []),
         contract_address_salt: toHex(addressSalt || 0),
         signature: signatureToDecimalArray(signature),
         version: toHex((details == null ? void 0 : details.version) || 0),
@@ -4455,9 +4466,7 @@ var SequencerProvider = class {
         res = {
           type: invocation.type,
           class_hash: toHex(toBigInt(invocation.classHash)),
-          constructor_calldata: bigNumberishArrayToDecimalStringArray(
-            invocation.constructorCalldata || []
-          ),
+          constructor_calldata: CallData.compile(invocation.constructorCalldata || []),
           contract_address_salt: toHex(toBigInt(invocation.addressSalt || 0))
         };
       }
@@ -4952,19 +4961,13 @@ var transformCallsToMulticallArrays = (calls) => {
   });
   return {
     callArray,
-    calldata: bigNumberishArrayToDecimalStringArray(calldata)
+    calldata: CallData.compile({ calldata })
   };
 };
 var fromCallsToExecuteCalldata = (calls) => {
   const { callArray, calldata } = transformCallsToMulticallArrays(calls);
-  return [
-    callArray.length.toString(),
-    ...callArray.map(
-      ({ to, selector, data_offset, data_len }) => [to, selector, data_offset, data_len]
-    ).flat(),
-    calldata.length.toString(),
-    ...calldata
-  ];
+  const compiledCalls = CallData.compile({ callArray });
+  return [...compiledCalls, ...calldata];
 };
 var fromCallsToExecuteCalldataWithNonce = (calls, nonce) => {
   return [...fromCallsToExecuteCalldata(calls), toBigInt(nonce).toString()];
@@ -4973,20 +4976,16 @@ var transformCallsToMulticallArrays_cairo1 = (calls) => {
   const callArray = calls.map((call) => ({
     to: toBigInt(call.contractAddress).toString(10),
     selector: toBigInt(getSelectorFromName(call.entrypoint)).toString(10),
-    calldata: bigNumberishArrayToDecimalStringArray(call.calldata || [])
+    calldata: CallData.compile(call.calldata || [])
   }));
   return callArray;
 };
 var fromCallsToExecuteCalldata_cairo1 = (calls) => {
-  const callArray = transformCallsToMulticallArrays_cairo1(calls);
-  return [
-    callArray.length.toString(),
-    ...callArray.map(({ to, selector, calldata }) => [to, selector, calldata.length.toString(), ...calldata]).flat()
-  ];
+  return CallData.compile({ calls });
 };
 var getExecuteCalldata = (calls, cairoVersion = "0") => {
   if (cairoVersion === "1") {
-    return fromCallsToExecuteCalldata_cairo1(calls);
+    return CallData.compile({ calls });
   }
   return fromCallsToExecuteCalldata(calls);
 };
@@ -5592,7 +5591,8 @@ var Account = class extends Provider {
     const version = toBigInt(transactionVersion);
     const nonce = ZERO;
     const chainId = await this.getChainId();
-    const contractAddress = providedContractAddress ?? calculateContractAddressFromHash(addressSalt, classHash, constructorCalldata, 0);
+    const compiledCalldata = CallData.compile(constructorCalldata);
+    const contractAddress = providedContractAddress ?? calculateContractAddressFromHash(addressSalt, classHash, compiledCalldata, 0);
     const maxFee = transactionsDetail.maxFee ?? await this.getSuggestedMaxFee(
       {
         type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
@@ -5690,7 +5690,8 @@ var Account = class extends Provider {
     constructorCalldata = [],
     contractAddress: providedContractAddress
   }, { nonce, chainId, version, maxFee }) {
-    const contractAddress = providedContractAddress ?? calculateContractAddressFromHash(addressSalt, classHash, constructorCalldata, 0);
+    const compiledCalldata = CallData.compile(constructorCalldata);
+    const contractAddress = providedContractAddress ?? calculateContractAddressFromHash(addressSalt, classHash, compiledCalldata, 0);
     const signature = await this.signer.signDeployAccountTransaction({
       classHash,
       contractAddress,