starknet 9.3.0 → 9.4.0

package/dist/index.js

@@ -133,6 +133,7 @@ __export(index_exports, {
   config: () => config,
   constants: () => constants_exports,
   contractClassResponseToLegacyCompiledContract: () => contractClassResponseToLegacyCompiledContract,
+  contractLoader: () => contractLoader,
   createAbiParser: () => createAbiParser,
   createTransactionReceipt: () => createTransactionReceipt,
   defaultDeployer: () => defaultDeployer,
@@ -154,6 +155,7 @@ __export(index_exports, {
   hash: () => hash_exports,
   hdParsingStrategy: () => hdParsingStrategy,
   isAccount: () => isAccount,
+  isFileSystemAvailable: () => isFileSystemAvailable,
   isNoConstructorValid: () => isNoConstructorValid,
   isPreConfirmedBlock: () => isPreConfirmedBlock,
   isPreConfirmedStateUpdate: () => isPreConfirmedStateUpdate,
@@ -5675,6 +5677,170 @@ function resourceBoundsToBigInt(resourceBounds) {
   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;
@@ -13071,6 +13237,7 @@ function units(amount, simbol = "fri") {
   config,
   constants,
   contractClassResponseToLegacyCompiledContract,
+  contractLoader,
   createAbiParser,
   createTransactionReceipt,
   defaultDeployer,
@@ -13092,6 +13259,7 @@ function units(amount, simbol = "fri") {
   hash,
   hdParsingStrategy,
   isAccount,
+  isFileSystemAvailable,
   isNoConstructorValid,
   isPreConfirmedBlock,
   isPreConfirmedStateUpdate,