@prosopo/scripts 3.0.10 → 3.0.12

package/dist/contract/import.js

@@ -2,163 +2,183 @@ import fs from "node:fs";
 import path from "node:path";
 import { ProsopoEnvError } from "@prosopo/common";
 import { lodash } from "@prosopo/util/lodash";
-import { exec } from "../util/index.js";
+import "../util/index.js";
+import { exec } from "../util/exec.js";
 const replaceExtension = (file, ext) => {
-    const parts = file.split(".");
-    parts.pop();
-    parts.push(ext);
-    return parts.join(".");
+  const parts = file.split(".");
+  parts.pop();
+  parts.push(ext);
+  return parts.join(".");
 };
 async function importContract(pathToAbis, pathToOutput) {
-    const verbose = false;
-    pathToAbis = path.relative(process.cwd(), pathToAbis);
-    pathToOutput = path.relative(process.cwd(), pathToOutput);
-    if (!fs.existsSync(pathToAbis))
-        throw new ProsopoEnvError("FS.FILE_NOT_FOUND", {
-            context: { error: `Path to ABIs does not exist: ${pathToAbis}` },
-        });
-    await exec(`mkdir -p ${pathToOutput}`);
-    const cmd = `npx @prosopo/typechain-polkadot --in ${pathToAbis} --out ${pathToOutput}`;
-    await exec(cmd);
-    const name = path.basename(pathToAbis);
-    await exec(`cp ${pathToAbis}/${name}.json ${pathToOutput}/${name}.json`);
-    const _ = lodash();
-    const writeIndexJsFiles = (src) => {
-        const typeChainDirs = fs.readdirSync(src).filter((file) => {
-            return fs.lstatSync(`${src}/${file}`).isDirectory();
-        });
-        const rootExports = [];
-        const typeChainExports = [
-            {
-                dir: "build-extrinsic",
-                defaultExportName: "extrinsics",
-            },
-            {
-                dir: "constructors",
-            },
-            {
-                dir: "contract-info",
-                exports: [
-                    {
-                        name: "ContractAbi",
-                    },
-                    {
-                        name: "ContractFile",
-                    },
-                ],
-            },
-            {
-                dir: "contracts",
-                defaultExportName: "contract",
-            },
-            {
-                dir: "data",
-            },
-            {
-                dir: "event-data",
-            },
-            {
-                dir: "events",
-            },
-            {
-                dir: "mixed-methods",
-                defaultExportName: "methods",
-            },
-            {
-                dir: "query",
-                defaultExportName: "query",
-            },
-            {
-                dir: "tx-sign-and-send",
-                defaultExportName: "tx",
-            },
-        ];
-        let file = "";
-        for (const typeChainExport of typeChainExports) {
-            const dirPath = `${src}/${typeChainExport.dir}`;
-            const files = fs.readdirSync(dirPath);
-            if (files.length !== 1) {
-                throw new ProsopoEnvError("FS.INVALID_DIR_FORMAT", {
-                    context: {
-                        error: `Expected 1 file in ${dirPath}, found ${files.length}`,
-                    },
-                });
-            }
-            file = files[0] || "";
-            if (file === "") {
-                throw new ProsopoEnvError("FS.FILE_NOT_FOUND", {
-                    context: { error: `No file found in ${dirPath}` },
-                });
-            }
-            if (file.endsWith(".ts")) {
-                file = replaceExtension(file, "js");
-            }
-            if (typeChainExport.defaultExportName !== undefined) {
-                const name = _.upperFirst(_.camelCase(typeChainExport.defaultExportName || typeChainExport.dir));
-                rootExports.push(`export { default as ${name} } from './${typeChainExport.dir}/${file}'`);
-            }
-            if (typeChainExport.exports !== undefined) {
-                for (const namedExport of typeChainExport.exports) {
-                    const alias = namedExport.alias ? ` as ${namedExport.alias}` : "";
-                    rootExports.push(`export { ${namedExport.name}${alias} } from './${typeChainExport.dir}/${file}'`);
-                }
-            }
-        }
-        rootExports.push(`export * from './shared/utils.js'`);
-        const regex = /export\s+([a-z]+)\s+(\w+)/g;
-        const fileTs = replaceExtension(file, "ts");
-        const typesArgumentsFileContent = fs.readFileSync(`${src}/types-arguments/${fileTs}`, "utf8");
-        const typesReturnsFileContent = fs.readFileSync(`${src}/types-returns/${fileTs}`, "utf8");
-        const argumentTypes = Array.from(typesArgumentsFileContent.matchAll(regex)).map((match) => {
-            return {
-                name: match[2] || "",
-                category: match[1] || "",
-            };
+  const verbose = false;
+  pathToAbis = path.relative(process.cwd(), pathToAbis);
+  pathToOutput = path.relative(process.cwd(), pathToOutput);
+  if (!fs.existsSync(pathToAbis))
+    throw new ProsopoEnvError("FS.FILE_NOT_FOUND", {
+      context: { error: `Path to ABIs does not exist: ${pathToAbis}` }
+    });
+  await exec(`mkdir -p ${pathToOutput}`);
+  const cmd = `npx @prosopo/typechain-polkadot --in ${pathToAbis} --out ${pathToOutput}`;
+  await exec(cmd);
+  const name = path.basename(pathToAbis);
+  await exec(`cp ${pathToAbis}/${name}.json ${pathToOutput}/${name}.json`);
+  const _ = lodash();
+  const writeIndexJsFiles = (src) => {
+    const typeChainDirs = fs.readdirSync(src).filter((file2) => {
+      return fs.lstatSync(`${src}/${file2}`).isDirectory();
+    });
+    const rootExports = [];
+    const typeChainExports = [
+      {
+        dir: "build-extrinsic",
+        defaultExportName: "extrinsics"
+      },
+      {
+        dir: "constructors"
+      },
+      {
+        dir: "contract-info",
+        exports: [
+          {
+            name: "ContractAbi"
+          },
+          {
+            name: "ContractFile"
+          }
+        ]
+      },
+      {
+        dir: "contracts",
+        defaultExportName: "contract"
+      },
+      {
+        dir: "data"
+      },
+      {
+        dir: "event-data"
+      },
+      // { // no events used so this is empty - not sure about structure so left out
+      //     dir: 'event-types'
+      // },
+      {
+        dir: "events"
+      },
+      {
+        dir: "mixed-methods",
+        defaultExportName: "methods"
+      },
+      {
+        dir: "query",
+        defaultExportName: "query"
+      },
+      {
+        dir: "tx-sign-and-send",
+        defaultExportName: "tx"
+      }
+    ];
+    let file = "";
+    for (const typeChainExport of typeChainExports) {
+      const dirPath = `${src}/${typeChainExport.dir}`;
+      const files = fs.readdirSync(dirPath);
+      if (files.length !== 1) {
+        throw new ProsopoEnvError("FS.INVALID_DIR_FORMAT", {
+          context: {
+            error: `Expected 1 file in ${dirPath}, found ${files.length}`
+          }
         });
-        const returnTypes = Array.from(typesReturnsFileContent.matchAll(regex)).map((match) => {
-            return {
-                name: match[2] || "",
-                category: match[1] || "",
-            };
+      }
+      file = files[0] || "";
+      if (file === "") {
+        throw new ProsopoEnvError("FS.FILE_NOT_FOUND", {
+          context: { error: `No file found in ${dirPath}` }
         });
-        const argumentTypeNames = argumentTypes.map((entry) => entry.name);
-        const uniqueTypes = [...argumentTypes];
-        const locations = [...argumentTypes.map(() => "types-arguments")];
-        for (const entry of returnTypes) {
-            if (!argumentTypeNames.includes(entry.name)) {
-                uniqueTypes.push(entry);
-                locations.push("types-arguments");
-            }
-            else {
-                locations.push("types-returns");
-            }
+      }
+      if (file.endsWith(".ts")) {
+        file = replaceExtension(file, "js");
+      }
+      if (typeChainExport.defaultExportName !== void 0) {
+        const name2 = _.upperFirst(
+          _.camelCase(typeChainExport.defaultExportName || typeChainExport.dir)
+        );
+        rootExports.push(
+          `export { default as ${name2} } from './${typeChainExport.dir}/${file}'`
+        );
+      }
+      if (typeChainExport.exports !== void 0) {
+        for (const namedExport of typeChainExport.exports) {
+          const alias = namedExport.alias ? ` as ${namedExport.alias}` : "";
+          rootExports.push(
+            `export { ${namedExport.name}${alias} } from './${typeChainExport.dir}/${file}'`
+          );
         }
-        uniqueTypes.forEach((entry, i) => {
-            const location = locations[i];
-            const prefix = entry.category === "type" || entry.category === "interface"
-                ? " type"
-                : "";
-            rootExports.push(`export${prefix} { ${entry.name} } from './${location}/${file}'`);
-        });
-        fs.writeFileSync(`${src}/index.ts`, rootExports.join("\n"));
-    };
-    writeIndexJsFiles(pathToOutput);
-}
-const getExtension = (str) => {
-    const i = str.indexOf("assert");
-    if (i >= 0) {
-        str = str.slice(0, i);
+      }
     }
-    const arr = str.split(".");
-    if (arr.length <= 1) {
-        return "";
+    rootExports.push(`export * from './shared/utils.js'`);
+    const regex = /export\s+([a-z]+)\s+(\w+)/g;
+    const fileTs = replaceExtension(file, "ts");
+    const typesArgumentsFileContent = fs.readFileSync(
+      `${src}/types-arguments/${fileTs}`,
+      "utf8"
+    );
+    const typesReturnsFileContent = fs.readFileSync(
+      `${src}/types-returns/${fileTs}`,
+      "utf8"
+    );
+    const argumentTypes = Array.from(
+      typesArgumentsFileContent.matchAll(regex)
+    ).map((match) => {
+      return {
+        name: match[2] || "",
+        category: match[1] || ""
+      };
+    });
+    const returnTypes = Array.from(
+      typesReturnsFileContent.matchAll(regex)
+    ).map((match) => {
+      return {
+        name: match[2] || "",
+        category: match[1] || ""
+      };
+    });
+    const argumentTypeNames = argumentTypes.map((entry) => entry.name);
+    const uniqueTypes = [...argumentTypes];
+    const locations = [...argumentTypes.map(() => "types-arguments")];
+    for (const entry of returnTypes) {
+      if (!argumentTypeNames.includes(entry.name)) {
+        uniqueTypes.push(entry);
+        locations.push("types-arguments");
+      } else {
+        locations.push("types-returns");
+      }
     }
-    return arr.pop();
+    uniqueTypes.forEach((entry, i) => {
+      const location = locations[i];
+      const prefix = entry.category === "type" || entry.category === "interface" ? " type" : "";
+      rootExports.push(
+        `export${prefix} { ${entry.name} } from './${location}/${file}'`
+      );
+    });
+    fs.writeFileSync(`${src}/index.ts`, rootExports.join("\n"));
+  };
+  writeIndexJsFiles(pathToOutput);
+}
+const getExtension = (str) => {
+  const i = str.indexOf("assert");
+  if (i >= 0) {
+    str = str.slice(0, i);
+  }
+  const arr = str.split(".");
+  if (arr.length <= 1) {
+    return "";
+  }
+  return arr.pop();
 };
 const getPath = (str) => {
-    const j = Math.max(str.lastIndexOf('"'), str.lastIndexOf("'"));
-    const i = Math.max(str.indexOf('"'), str.indexOf("'"));
-    return str.slice(i + 1, j);
+  const j = Math.max(str.lastIndexOf('"'), str.lastIndexOf("'"));
+  const i = Math.max(str.indexOf('"'), str.indexOf("'"));
+  return str.slice(i + 1, j);
+};
+export {
+  importContract as default
 };
-export default importContract;
-//# sourceMappingURL=import.js.map

package/dist/contract/index.js

@@ -1,2 +1,4 @@
-export { default as importContract } from "./import.js";
-//# sourceMappingURL=index.js.map
+import { default as default2 } from "./import.js";
+export {
+  default2 as importContract
+};

package/dist/index.js

@@ -1,5 +1,25 @@
-export * from "./setup/index.js";
-export * from "./util/index.js";
-export * from "./cli/index.js";
-export * from "./contract/index.js";
-//# sourceMappingURL=index.js.map
+import "./setup/index.js";
+import "./util/index.js";
+import { processArgs } from "./cli/index.js";
+import "./contract/index.js";
+import { setup, updateEnvFile } from "./setup/setup.js";
+import { setupProvider } from "./setup/provider.js";
+import { AbiJSON, Wasm } from "./util/loadContractFiles.js";
+import { findEnvFiles, updateDemoHTMLFiles, updateEnvFiles } from "./util/updateEnv.js";
+import { exec } from "./util/exec.js";
+import { extractReferrersFromLogs } from "./util/fluxLogDappDetails.js";
+import { default as default2 } from "./contract/import.js";
+export {
+  AbiJSON,
+  Wasm,
+  exec,
+  extractReferrersFromLogs,
+  findEnvFiles,
+  default2 as importContract,
+  processArgs,
+  setup,
+  setupProvider,
+  updateDemoHTMLFiles,
+  updateEnvFile,
+  updateEnvFiles
+};

package/dist/scripts/setVersion.js

@@ -1,139 +1,133 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parse, stringify } from "@iarna/toml";
-import { getLogger, parseLogLevel } from "@prosopo/common";
-import { getRootDir } from "@prosopo/config";
+import { parseLogLevel, getLogger } from "@prosopo/common";
 import { loadEnv } from "@prosopo/dotenv";
+import { getRootDir } from "@prosopo/workspace";
 loadEnv();
 const logLevel = parseLogLevel(process.env.PROSOPO_LOG_LEVEL);
 const log = getLogger(logLevel, "setVersion");
 log.info(() => ({ data: { logLevel } }));
 const parseVersion = (version) => {
-    try {
-        const parts = version.split(".");
-        if (parts.length !== 3) {
-            throw new Error();
-        }
-        let [major, minor, patch] = parts;
-        major = Number.parseInt(major ?? "").toString();
-        minor = Number.parseInt(minor ?? "").toString();
-        patch = Number.parseInt(patch ?? "").toString();
-        if (major === "NaN" || minor === "NaN" || patch === "NaN") {
-            throw new Error();
-        }
-        return `${major}.${minor}.${patch}`;
+  try {
+    const parts = version.split(".");
+    if (parts.length !== 3) {
+      throw new Error();
     }
-    catch (e) {
-        throw new Error("Version must be in the format of x.y.z");
+    let [major, minor, patch] = parts;
+    major = Number.parseInt(major ?? "").toString();
+    minor = Number.parseInt(minor ?? "").toString();
+    patch = Number.parseInt(patch ?? "").toString();
+    if (major === "NaN" || minor === "NaN" || patch === "NaN") {
+      throw new Error();
     }
+    return `${major}.${minor}.${patch}`;
+  } catch (e) {
+    throw new Error("Version must be in the format of x.y.z");
+  }
 };
 const find = (pth, filter) => {
-    const files = fs.readdirSync(pth);
-    const results = [];
-    for (const file of files) {
-        const fullPath = path.join(pth, file);
-        if (filter(fullPath)) {
-            results.push(fullPath);
-        }
-        try {
-            if (fs.statSync(fullPath).isDirectory()) {
-                results.push(...find(fullPath, filter));
-            }
-        }
-        catch (e) {
-            log.debug(() => ({ data: { fullPath }, msg: "Not a directory" }));
-        }
+  const files = fs.readdirSync(pth);
+  const results = [];
+  for (const file of files) {
+    const fullPath = path.join(pth, file);
+    if (filter(fullPath)) {
+      results.push(fullPath);
+    }
+    try {
+      if (fs.statSync(fullPath).isDirectory()) {
+        results.push(...find(fullPath, filter));
+      }
+    } catch (e) {
+      log.debug(() => ({ data: { fullPath }, msg: "Not a directory" }));
     }
-    return results;
+  }
+  return results;
 };
-export default async function setVersion(versionIn, ignore) {
-    log.info(() => ({ data: { versionIn }, msg: "Setting version to" }));
-    const version = parseVersion(versionIn);
-    const root = getRootDir();
-    const ignorePaths = ["node_modules", "cargo-cache", ...(ignore ?? [])];
-    log.debug(() => ({ data: { ignorePaths }, msg: "Ignoring paths" }));
-    const files = find(root, (pth) => {
-        if (ignorePaths.some((ignorePath) => pth.includes(ignorePath))) {
-            return false;
-        }
-        const basename = path.basename(pth);
-        return basename === "package.json" || basename === "Cargo.toml";
-    });
-    files
-        .filter((pth) => path.extname(pth) === ".json")
-        .forEach((pth) => {
-        log.debug(() => ({ data: { pth }, msg: "setting version in" }));
-        const content = fs.readFileSync(pth, "utf8");
-        const jsonContent = JSON.parse(content);
-        if (jsonContent.version) {
-            jsonContent.version = version;
-        }
-        for (const obj of [
-            jsonContent.dependencies ?? {},
-            jsonContent.devDependencies ?? {},
-            jsonContent.peerDependencies ?? {},
-        ]) {
-            for (const key of Object.keys(obj)) {
-                if (key.startsWith("@prosopo") && !key.includes("typechain")) {
-                    log.debug(() => ({
-                        data: { key, version, pth },
-                        msg: "setting dependency version",
-                    }));
-                    obj[key] = version;
-                }
-            }
-        }
-        fs.writeFileSync(pth, `${JSON.stringify(jsonContent, null, 4)}\n`);
-    });
-    files
-        .filter((pth) => path.extname(pth) === ".toml")
-        .filter((pth) => {
-        return !ignorePaths.some((ignorePath) => pth.includes(ignorePath));
-    })
-        .forEach((pth) => {
-        log.debug(() => ({ data: { pth }, msg: "setting version in" }));
-        const content = fs.readFileSync(pth, "utf8");
-        const tomlContent = parse(content);
-        if (tomlContent.workspace) {
-            if (tomlContent.workspace.version) {
-                tomlContent.workspace.version = version;
-            }
-        }
-        else {
-            tomlContent.package.version = version;
-        }
-        fs.writeFileSync(pth, `${stringify(tomlContent)}\n`);
-    });
-    files
-        .filter((pth) => path.extname(pth) === ".toml")
-        .forEach((pth) => {
-        log.debug(() => ({
-            data: { pth },
-            msg: "setting dependency versions in",
-        }));
-        const content = fs.readFileSync(pth, "utf8");
-        const tomlContent = parse(content);
-        if (tomlContent.workspace) {
-            if (tomlContent.workspace.version) {
-                tomlContent.workspace.version = version;
-            }
+async function setVersion(versionIn, ignore) {
+  log.info(() => ({ data: { versionIn }, msg: "Setting version to" }));
+  const version = parseVersion(versionIn);
+  const root = getRootDir();
+  const ignorePaths = ["node_modules", "cargo-cache", ...ignore ?? []];
+  log.debug(() => ({ data: { ignorePaths }, msg: "Ignoring paths" }));
+  const files = find(root, (pth) => {
+    if (ignorePaths.some((ignorePath) => pth.includes(ignorePath))) {
+      return false;
+    }
+    const basename = path.basename(pth);
+    return basename === "package.json" || basename === "Cargo.toml";
+  });
+  files.filter((pth) => path.extname(pth) === ".json").forEach((pth) => {
+    log.debug(() => ({ data: { pth }, msg: "setting version in" }));
+    const content = fs.readFileSync(pth, "utf8");
+    const jsonContent = JSON.parse(content);
+    if (jsonContent.version) {
+      jsonContent.version = version;
+    }
+    for (const obj of [
+      jsonContent.dependencies ?? {},
+      jsonContent.devDependencies ?? {},
+      jsonContent.peerDependencies ?? {}
+    ]) {
+      for (const key of Object.keys(obj)) {
+        if (key.startsWith("@prosopo") && !key.includes("typechain")) {
+          log.debug(() => ({
+            data: { key, version, pth },
+            msg: "setting dependency version"
+          }));
+          obj[key] = version;
         }
-        else {
-            for (const obj of [
-                tomlContent.dependencies ?? {},
-                tomlContent["dev-dependencies"] ?? {},
-            ]) {
-                for (const [key, value] of Object.entries(obj)) {
-                    if (value.path) {
-                        path.join(value.path, "Cargo.toml");
-                        const depContent = fs.readFileSync(pth, "utf8");
-                        const depTomlContent = parse(depContent);
-                        value.version = depTomlContent.version;
-                    }
-                }
-            }
+      }
+    }
+    fs.writeFileSync(pth, `${JSON.stringify(jsonContent, null, 4)}
+`);
+  });
+  files.filter((pth) => path.extname(pth) === ".toml").filter((pth) => {
+    return !ignorePaths.some((ignorePath) => pth.includes(ignorePath));
+  }).forEach((pth) => {
+    log.debug(() => ({ data: { pth }, msg: "setting version in" }));
+    const content = fs.readFileSync(pth, "utf8");
+    const tomlContent = parse(content);
+    if (tomlContent.workspace) {
+      if (tomlContent.workspace.version) {
+        tomlContent.workspace.version = version;
+      }
+    } else {
+      tomlContent.package.version = version;
+    }
+    fs.writeFileSync(pth, `${stringify(tomlContent)}
+`);
+  });
+  files.filter((pth) => path.extname(pth) === ".toml").forEach((pth) => {
+    log.debug(() => ({
+      data: { pth },
+      msg: "setting dependency versions in"
+    }));
+    const content = fs.readFileSync(pth, "utf8");
+    const tomlContent = parse(content);
+    if (tomlContent.workspace) {
+      if (tomlContent.workspace.version) {
+        tomlContent.workspace.version = version;
+      }
+    } else {
+      for (const obj of [
+        tomlContent.dependencies ?? {},
+        tomlContent["dev-dependencies"] ?? {}
+      ]) {
+        for (const [key, value] of Object.entries(obj)) {
+          if (value.path) {
+            path.join(value.path, "Cargo.toml");
+            const depContent = fs.readFileSync(pth, "utf8");
+            const depTomlContent = parse(depContent);
+            value.version = depTomlContent.version;
+          }
         }
-        fs.writeFileSync(pth, `${stringify(tomlContent)}\n`);
-    });
+      }
+    }
+    fs.writeFileSync(pth, `${stringify(tomlContent)}
+`);
+  });
 }
-//# sourceMappingURL=setVersion.js.map
+export {
+  setVersion as default
+};

package/dist/setup/index.js

@@ -1,3 +1,7 @@
-export * from "./setup.js";
-export * from "./provider.js";
-//# sourceMappingURL=index.js.map
+import { setup, updateEnvFile } from "./setup.js";
+import { setupProvider } from "./provider.js";
+export {
+  setup,
+  setupProvider,
+  updateEnvFile
+};

package/dist/setup/provider.js

@@ -1,9 +1,11 @@
 import { datasetWithSolutionHashes } from "@prosopo/datasets";
 import { Tasks } from "@prosopo/provider";
-export async function setupProvider(env) {
-    const logger = env.logger;
-    const tasks = new Tasks(env);
-    logger.info(() => ({ msg: "   - providerSetDataset" }));
-    await tasks.datasetManager.providerSetDataset(datasetWithSolutionHashes);
+async function setupProvider(env) {
+  const logger = env.logger;
+  const tasks = new Tasks(env);
+  logger.info(() => ({ msg: "   - providerSetDataset" }));
+  await tasks.datasetManager.providerSetDataset(datasetWithSolutionHashes);
 }
-//# sourceMappingURL=provider.js.map
+export {
+  setupProvider
+};