@taqueria/plugin-ligo 0.27.2-alpha → 0.27.3-rc

package/index.mjs

@@ -0,0 +1,588 @@
+// index.ts
+import { Option, Plugin, PositionalArg, Task, Template } from "@taqueria/node-sdk";
+
+// createContract.ts
+import { sendAsyncErr } from "@taqueria/node-sdk";
+import { writeFile } from "fs/promises";
+
+// ligo_templates.ts
+var mligo_template = `
+type storage = int
+
+type parameter =
+  Increment of int
+| Decrement of int
+| Reset
+
+type return = operation list * storage
+
+// Two entrypoints
+
+let add (store, delta : storage * int) : storage = store + delta
+let sub (store, delta : storage * int) : storage = store - delta
+
+(* Main access point that dispatches to the entrypoints according to
+   the smart contract parameter. *)
+   
+let main (action, store : parameter * storage) : return =
+ ([] : operation list),    // No operations
+ (match action with
+   Increment (n) -> add (store, n)
+ | Decrement (n) -> sub (store, n)
+ | Reset         -> 0)
+`;
+var pascaligo_template = `
+type storage is int
+
+type parameter is
+  Increment of int
+| Decrement of int
+| Reset
+
+type return is list (operation) * storage
+
+// Two entrypoints
+
+function add (const store : storage; const delta : int) : storage is 
+  store + delta
+
+function sub (const store : storage; const delta : int) : storage is 
+  store - delta
+
+(* Main access point that dispatches to the entrypoints according to
+   the smart contract parameter. *)
+   
+function main (const action : parameter; const store : storage) : return is
+ ((nil : list (operation)),    // No operations
+  case action of [
+    Increment (n) -> add (store, n)
+  | Decrement (n) -> sub (store, n)
+  | Reset         -> 0
+  ])
+`;
+var religo_template = `
+type storage = int;
+
+type parameter =
+  Increment (int)
+| Decrement (int)
+| Reset;
+
+type return = (list (operation), storage);
+
+// Two entrypoints
+
+let add = ((store, delta) : (storage, int)) : storage => store + delta;
+let sub = ((store, delta) : (storage, int)) : storage => store - delta;
+
+/* Main access point that dispatches to the entrypoints according to
+   the smart contract parameter. */
+   
+let main = ((action, store) : (parameter, storage)) : return => {
+ (([] : list (operation)),    // No operations
+ (switch (action) {
+  | Increment (n) => add ((store, n))
+  | Decrement (n) => sub ((store, n))
+  | Reset         => 0}))
+};
+`;
+var jsligo_template = `
+type storage = int;
+
+type parameter =
+  ["Increment", int]
+| ["Decrement", int]
+| ["Reset"];
+
+type ret = [list<operation>, storage];
+
+// Two entrypoints
+
+const add = ([store, delta] : [storage, int]) : storage => store + delta;
+const sub = ([store, delta] : [storage, int]) : storage => store - delta;
+
+/* Main access point that dispatches to the entrypoints according to
+   the smart contract parameter. */
+
+const main = ([action, store] : [parameter, storage]) : ret => {
+ return [list([]) as list<operation>,    // No operations
+ match (action, {
+  Increment:(n: int) => add ([store, n]),
+  Decrement:(n: int) => sub ([store, n]),
+  Reset    :()  => 0})]
+};
+`;
+
+// createContract.ts
+var getLigoTemplate = async (contractName, syntax) => {
+  const matchResult = contractName.match(/\.[^.]+$/);
+  const ext = matchResult ? matchResult[0].substring(1) : null;
+  if (syntax === "mligo")
+    return mligo_template;
+  if (syntax === "ligo")
+    return pascaligo_template;
+  if (syntax === "religo")
+    return religo_template;
+  if (syntax === "jsligo")
+    return jsligo_template;
+  if (syntax === void 0) {
+    if (ext === "mligo")
+      return mligo_template;
+    if (ext === "ligo")
+      return pascaligo_template;
+    if (ext === "religo")
+      return religo_template;
+    if (ext === "jsligo")
+      return jsligo_template;
+    return sendAsyncErr(
+      `Unable to infer LIGO syntax from "${contractName}". Please specify a LIGO syntax via the --syntax option`
+    );
+  } else {
+    return sendAsyncErr(`"${syntax}" is not a valid syntax. Please specify a valid LIGO syntax`);
+  }
+};
+var createContract = (args) => {
+  const unsafeOpts = args;
+  const contractName = unsafeOpts.sourceFileName;
+  const syntax = unsafeOpts.syntax;
+  const contractsDir = `${args.config.projectDir}/${args.config.contractsDir}`;
+  return getLigoTemplate(contractName, syntax).then((ligo_template) => writeFile(`${contractsDir}/${contractName}`, ligo_template));
+};
+var createContract_default = createContract;
+
+// main.ts
+import { sendAsyncErr as sendAsyncErr5, sendAsyncRes } from "@taqueria/node-sdk";
+
+// common.ts
+import { getDockerImage, sendErr } from "@taqueria/node-sdk";
+import { join } from "path";
+var LIGO_DEFAULT_IMAGE = "ligolang/ligo:0.57.0";
+var LIGO_IMAGE_ENV_VAR = "TAQ_LIGO_IMAGE";
+var getLigoDockerImage = () => getDockerImage(LIGO_DEFAULT_IMAGE, LIGO_IMAGE_ENV_VAR);
+var getInputFilenameAbsPath = (parsedArgs, sourceFile) => join(parsedArgs.config.projectDir, parsedArgs.config.contractsDir ?? "contracts", sourceFile);
+var getInputFilenameRelPath = (parsedArgs, sourceFile) => join(parsedArgs.config.contractsDir ?? "contracts", sourceFile);
+var emitExternalError = (err, sourceFile) => {
+  sendErr(`
+=== Error messages for ${sourceFile} ===`);
+  err instanceof Error ? sendErr(err.message.replace(/Command failed.+?\n/, "")) : sendErr(err);
+  sendErr(`
+===`);
+};
+
+// compile.ts
+import { execCmd, getArch, getArtifactsDir, sendAsyncErr as sendAsyncErr2, sendErr as sendErr2, sendJsonRes, sendWarn } from "@taqueria/node-sdk";
+import { access, readFile, writeFile as writeFile2 } from "fs/promises";
+import { basename, extname, join as join2 } from "path";
+var COMPILE_ERR_MSG = "Not compiled";
+var isStorageKind = (exprKind) => exprKind === "storage" || exprKind === "default_storage";
+var isLIGOFile = (sourceFile) => /.+\.(ligo|religo|mligo|jsligo)$/.test(sourceFile);
+var isStorageListFile = (sourceFile) => /.+\.(storageList|storages)\.(ligo|religo|mligo|jsligo)$/.test(sourceFile);
+var isParameterListFile = (sourceFile) => /.+\.(parameterList|parameters)\.(ligo|religo|mligo|jsligo)$/.test(sourceFile);
+var isContractFile = (sourceFile) => isLIGOFile(sourceFile) && !isStorageListFile(sourceFile) && !isParameterListFile(sourceFile);
+var extractExt = (path) => {
+  const matchResult = path.match(/\.(ligo|religo|mligo|jsligo)$/);
+  return matchResult ? matchResult[0] : "";
+};
+var removeExt = (path) => {
+  const extRegex = new RegExp(extractExt(path));
+  return path.replace(extRegex, "");
+};
+var isOutputFormatJSON = (parsedArgs) => parsedArgs.json;
+var getOutputContractFilename = (parsedArgs, sourceFile) => {
+  const outputFile = basename(sourceFile, extname(sourceFile));
+  const ext = isOutputFormatJSON(parsedArgs) ? ".json" : ".tz";
+  return join2(getArtifactsDir(parsedArgs), `${outputFile}${ext}`);
+};
+var getContractNameForExpr = (sourceFile, exprKind) => {
+  try {
+    return isStorageKind(exprKind) ? sourceFile.match(/.+(?=\.(?:storageList|storages)\.(ligo|religo|mligo|jsligo))/).join(".") : sourceFile.match(/.+(?=\.(?:parameterList|parameters)\.(ligo|religo|mligo|jsligo))/).join(".");
+  } catch (err) {
+    throw new Error(`Something went wrong internally when dealing with filename format: ${err}`);
+  }
+};
+var getOutputExprFilename = (parsedArgs, sourceFile, exprKind, exprName) => {
+  const contractName = basename(getContractNameForExpr(sourceFile, exprKind), extname(sourceFile));
+  const ext = isOutputFormatJSON(parsedArgs) ? ".json" : ".tz";
+  const outputFile = exprKind === "default_storage" ? `${contractName}.default_storage${ext}` : `${contractName}.${exprKind}.${exprName}${ext}`;
+  return join2(getArtifactsDir(parsedArgs), `${outputFile}`);
+};
+var getCompileContractCmd = (parsedArgs, sourceFile) => {
+  const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
+  if (!projectDir)
+    throw `No project directory provided`;
+  const baseCmd = `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -w /project -u $(id -u):$(id -g) ${getLigoDockerImage()} compile contract`;
+  const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
+  const outputFile = `-o ${getOutputContractFilename(parsedArgs, sourceFile)}`;
+  const flags = isOutputFormatJSON(parsedArgs) ? " --michelson-format json " : "";
+  const cmd = `${baseCmd} ${inputFile} ${outputFile} ${flags}`;
+  return cmd;
+};
+var getCompileExprCmd = (parsedArgs, sourceFile, exprKind, exprName) => {
+  const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
+  if (!projectDir)
+    throw `No project directory provided`;
+  const compilerType = isStorageKind(exprKind) ? "storage" : "parameter";
+  const baseCmd = `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -w /project -u $(id -u):$(id -g) ${getLigoDockerImage()} compile ${compilerType}`;
+  const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
+  const outputFile = `-o ${getOutputExprFilename(parsedArgs, sourceFile, exprKind, exprName)}`;
+  const flags = isOutputFormatJSON(parsedArgs) ? " --michelson-format json " : "";
+  const cmd = `${baseCmd} ${inputFile} ${exprName} ${outputFile} ${flags}`;
+  return cmd;
+};
+var compileContract = (parsedArgs, sourceFile) => getArch().then(() => getCompileContractCmd(parsedArgs, sourceFile)).then(execCmd).then(({ stderr }) => {
+  if (stderr.length > 0)
+    sendWarn(stderr);
+  return {
+    contract: sourceFile,
+    artifact: getOutputContractFilename(parsedArgs, sourceFile)
+  };
+}).catch((err) => {
+  emitExternalError(err, sourceFile);
+  return {
+    contract: sourceFile,
+    artifact: COMPILE_ERR_MSG
+  };
+});
+var compileExpr = (parsedArgs, sourceFile, exprKind) => (exprName) => getArch().then(() => getCompileExprCmd(parsedArgs, sourceFile, exprKind, exprName)).then(execCmd).then(({ stderr }) => {
+  if (stderr.length > 0)
+    sendWarn(stderr);
+  return {
+    contract: sourceFile,
+    artifact: getOutputExprFilename(parsedArgs, sourceFile, exprKind, exprName)
+  };
+}).catch((err) => {
+  emitExternalError(err, sourceFile);
+  return {
+    contract: sourceFile,
+    artifact: COMPILE_ERR_MSG
+  };
+});
+var getExprNames = (parsedArgs, sourceFile) => readFile(getInputFilenameAbsPath(parsedArgs, sourceFile), "utf8").then((data) => data.match(/(?<=\n\s*(let|const)\s+)[a-zA-Z0-9_]+/g) ?? []);
+var compileExprs = (parsedArgs, sourceFile, exprKind) => getExprNames(parsedArgs, sourceFile).then((exprNames) => {
+  if (exprNames.length === 0)
+    return [];
+  const firstExprName = exprNames.slice(0, 1)[0];
+  const restExprNames = exprNames.slice(1, exprNames.length);
+  const firstExprKind = isStorageKind(exprKind) ? "default_storage" : "parameter";
+  const restExprKind = isStorageKind(exprKind) ? "storage" : "parameter";
+  const firstExprResult = compileExpr(parsedArgs, sourceFile, firstExprKind)(firstExprName);
+  const restExprResults = restExprNames.map(compileExpr(parsedArgs, sourceFile, restExprKind));
+  return Promise.all([firstExprResult].concat(restExprResults));
+}).catch((err) => {
+  emitExternalError(err, sourceFile);
+  return [{
+    contract: sourceFile,
+    artifact: `No ${isStorageKind(exprKind) ? "storage" : "parameter"} values compiled`
+  }];
+}).then(mergeArtifactsOutput(sourceFile));
+var tryLegacyStorageNamingConvention = (parsedArgs, sourceFile) => {
+  const storageListFile = `${removeExt(sourceFile)}.storages${extractExt(sourceFile)}`;
+  const storageListFilename = getInputFilenameAbsPath(parsedArgs, storageListFile);
+  return access(storageListFilename).then(() => {
+    sendWarn(
+      `Warning: The naming convention of "<CONTRACT>.storages.<EXTENSION>" is deprecated and renamed to "<CONTRACT>.storageList.<EXTENSION>". Please adjust your storage file names accordingly
+`
+    );
+    return compileExprs(parsedArgs, storageListFile, "storage");
+  });
+};
+var tryLegacyParameterNamingConvention = (parsedArgs, sourceFile) => {
+  const parameterListFile = `${removeExt(sourceFile)}.parameters${extractExt(sourceFile)}`;
+  const parameterListFilename = getInputFilenameAbsPath(parsedArgs, parameterListFile);
+  return access(parameterListFilename).then(() => {
+    sendWarn(
+      `Warning: The naming convention of "<CONTRACT>.parameters.<EXTENSION>" is deprecated and renamed to "<CONTRACT>.parameterList.<EXTENSION>". Please adjust your parameter file names accordingly
+`
+    );
+    return compileExprs(parsedArgs, parameterListFile, "parameter");
+  });
+};
+var initContentForStorage = (sourceFile) => {
+  const linkToContract = `#include "${sourceFile}"
+
+`;
+  const instruction = "// Define your initial storage values as a list of LIGO variable definitions,\n// the first of which will be considered the default value to be used for origination later on\n";
+  const ext = extractExt(sourceFile);
+  let syntax = "";
+  if (ext === ".ligo")
+    syntax = "// E.g. const aStorageValue : aStorageType = 10;\n\n";
+  else if (ext === ".religo")
+    syntax = "// E.g. let aStorageValue : aStorageType = 10;\n\n";
+  else if (ext === ".mligo")
+    syntax = "// E.g. let aStorageValue : aStorageType = 10\n\n";
+  else if (ext === ".jsligo")
+    syntax = "// E.g. const aStorageValue : aStorageType = 10;\n\n";
+  return linkToContract + instruction + syntax;
+};
+var initContentForParameter = (sourceFile) => {
+  const linkToContract = `#include "${sourceFile}"
+
+`;
+  const instruction = "// Define your parameter values as a list of LIGO variable definitions\n";
+  const ext = extractExt(sourceFile);
+  let syntax = "";
+  if (ext === ".ligo")
+    syntax = "// E.g. const aParameterValue : aParameterType = Increment(1);\n\n";
+  else if (ext === ".religo")
+    syntax = "// E.g. let aParameterValue : aParameterType = (Increment (1));\n\n";
+  else if (ext === ".mligo")
+    syntax = "// E.g. let aParameterValue : aParameterType = Increment 1\n\n";
+  else if (ext === ".jsligo")
+    syntax = "// E.g. const aParameterValue : aParameterType = (Increment (1));\n\n";
+  return linkToContract + instruction + syntax;
+};
+var compileContractWithStorageAndParameter = async (parsedArgs, sourceFile) => {
+  const contractCompileResult = await compileContract(parsedArgs, sourceFile);
+  if (contractCompileResult.artifact === COMPILE_ERR_MSG)
+    return [contractCompileResult];
+  const storageListFile = `${removeExt(sourceFile)}.storageList${extractExt(sourceFile)}`;
+  const storageListFilename = getInputFilenameAbsPath(parsedArgs, storageListFile);
+  const storageCompileResult = await access(storageListFilename).then(() => compileExprs(parsedArgs, storageListFile, "storage")).catch(() => tryLegacyStorageNamingConvention(parsedArgs, sourceFile)).catch(() => {
+    sendWarn(
+      `Note: storage file associated with "${sourceFile}" can't be found, so "${storageListFile}" has been created for you. Use this file to define all initial storage values for this contract
+`
+    );
+    writeFile2(storageListFilename, initContentForStorage(sourceFile), "utf8");
+  });
+  const parameterListFile = `${removeExt(sourceFile)}.parameterList${extractExt(sourceFile)}`;
+  const parameterListFilename = getInputFilenameAbsPath(parsedArgs, parameterListFile);
+  const parameterCompileResult = await access(parameterListFilename).then(() => compileExprs(parsedArgs, parameterListFile, "parameter")).catch(() => tryLegacyParameterNamingConvention(parsedArgs, sourceFile)).catch(() => {
+    sendWarn(
+      `Note: parameter file associated with "${sourceFile}" can't be found, so "${parameterListFile}" has been created for you. Use this file to define all parameter values for this contract
+`
+    );
+    writeFile2(parameterListFilename, initContentForParameter(sourceFile), "utf8");
+  });
+  let compileResults = [contractCompileResult];
+  if (storageCompileResult)
+    compileResults = compileResults.concat(storageCompileResult);
+  if (parameterCompileResult)
+    compileResults = compileResults.concat(parameterCompileResult);
+  return compileResults;
+};
+var mergeArtifactsOutput = (sourceFile) => (tableRows) => {
+  const artifactsOutput = tableRows.reduce(
+    (acc, row) => row.artifact === COMPILE_ERR_MSG ? acc : `${acc}${row.artifact}
+`,
+    ""
+  );
+  return [{
+    contract: sourceFile,
+    artifact: artifactsOutput
+  }];
+};
+var compile = (parsedArgs) => {
+  const sourceFile = parsedArgs.sourceFile;
+  let p;
+  if (isStorageListFile(sourceFile))
+    p = compileExprs(parsedArgs, sourceFile, "storage");
+  else if (isParameterListFile(sourceFile))
+    p = compileExprs(parsedArgs, sourceFile, "parameter");
+  else if (isContractFile(sourceFile))
+    p = compileContractWithStorageAndParameter(parsedArgs, sourceFile);
+  else {
+    return sendAsyncErr2(
+      `${sourceFile} doesn't have a valid LIGO extension ('.ligo', '.religo', '.mligo' or '.jsligo')`
+    );
+  }
+  return p.then(sendJsonRes).catch((err) => sendErr2(err, false));
+};
+var compile_default = compile;
+
+// compile-all.ts
+import { sendErr as sendErr3, sendJsonRes as sendJsonRes2 } from "@taqueria/node-sdk";
+import glob from "fast-glob";
+import { readFile as readFile2 } from "fs/promises";
+import { join as join3 } from "path";
+var isMainContract = (parsedArgs, contactFilename) => readFile2(getInputFilenameAbsPath(parsedArgs, contactFilename), "utf8").then((data) => /(const|let|function)\s+main/.test(data));
+var compileAll = async (parsedArgs) => {
+  let p = [];
+  const contractFilenames = await glob(
+    ["**/*.ligo", "**/*.religo", "**/*.mligo", "**/*.jsligo"],
+    { cwd: join3(parsedArgs.config.projectDir, parsedArgs.config.contractsDir ?? "contracts"), absolute: false }
+  );
+  for (const filename of contractFilenames) {
+    if (await isMainContract(parsedArgs, filename)) {
+      p.push(compileContractWithStorageAndParameter(parsedArgs, filename));
+    }
+  }
+  return Promise.all(p).then((tables) => tables.flat()).then(sendJsonRes2).catch((err) => sendErr3(err, false));
+};
+var compile_all_default = compileAll;
+
+// ligo.ts
+import { getArch as getArch2, sendAsyncErr as sendAsyncErr3, sendRes, spawnCmd } from "@taqueria/node-sdk";
+var getArbitraryLigoCmd = (parsedArgs, userArgs) => {
+  const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
+  if (!projectDir)
+    throw `No project directory provided`;
+  const binary = "docker";
+  const baseArgs = ["run", "--rm", "-v", `${projectDir}:/project`, "-w", "/project", getLigoDockerImage()];
+  const processedUserArgs = userArgs.split(" ").map((arg) => arg.startsWith("\\-") ? arg.substring(1) : arg).filter(
+    (arg) => arg
+  );
+  const args = baseArgs.concat(processedUserArgs);
+  const envVars = { "DOCKER_DEFAULT_PLATFORM": "linux/amd64" };
+  return [
+    [binary, ...args].join(" "),
+    envVars
+  ];
+};
+var runArbitraryLigoCmd = (parsedArgs, cmd) => getArch2().then(() => getArbitraryLigoCmd(parsedArgs, cmd)).then(([cmd2, envVars]) => spawnCmd(cmd2, envVars)).then(
+  (code) => code !== null && code === 0 ? `Command "${cmd}" ran successfully by LIGO` : `Command "${cmd}" failed. Please check your command`
+).catch((err) => sendAsyncErr3(`An internal error has occurred: ${err.message}`));
+var ligo = (parsedArgs) => {
+  const args = parsedArgs.command;
+  return runArbitraryLigoCmd(parsedArgs, args).then(sendRes).catch((err) => sendAsyncErr3(err, false));
+};
+var ligo_default = ligo;
+
+// test.ts
+import { execCmd as execCmd2, getArch as getArch3, sendAsyncErr as sendAsyncErr4, sendJsonRes as sendJsonRes3, sendWarn as sendWarn2 } from "@taqueria/node-sdk";
+var getTestContractCmd = (parsedArgs, sourceFile) => {
+  const projectDir = process.env.PROJECT_DIR ?? parsedArgs.projectDir;
+  if (!projectDir)
+    throw `No project directory provided`;
+  const baseCmd = `DOCKER_DEFAULT_PLATFORM=linux/amd64 docker run --rm -v "${projectDir}":/project -w /project -u $(id -u):$(id -g) ${getLigoDockerImage()} run test`;
+  const inputFile = getInputFilenameRelPath(parsedArgs, sourceFile);
+  const cmd = `${baseCmd} ${inputFile}`;
+  return cmd;
+};
+var testContract = (parsedArgs, sourceFile) => getArch3().then(() => getTestContractCmd(parsedArgs, sourceFile)).then(execCmd2).then(({ stdout, stderr }) => {
+  if (stderr.length > 0)
+    sendWarn2(stderr);
+  const result = "\u{1F389} All tests passed \u{1F389}";
+  return {
+    contract: sourceFile,
+    testResults: stdout.length > 0 ? `${stdout}
+${result}` : result
+  };
+}).catch((err) => {
+  emitExternalError(err, sourceFile);
+  return {
+    contract: sourceFile,
+    testResults: "Some tests failed :("
+  };
+});
+var test = (parsedArgs) => {
+  const sourceFile = parsedArgs.sourceFile;
+  if (!sourceFile)
+    return sendAsyncErr4(`No source file provided`);
+  return testContract(parsedArgs, sourceFile).then((result) => [result]).then(sendJsonRes3).catch(
+    (err) => sendAsyncErr4(err, false)
+  );
+};
+var test_default = test;
+
+// main.ts
+var main = (parsedArgs) => {
+  const unsafeOpts = parsedArgs;
+  switch (unsafeOpts.task) {
+    case "ligo":
+      return ligo_default(unsafeOpts);
+    case "compile":
+      return compile_default(unsafeOpts);
+    case "compile-all":
+      return compile_all_default(unsafeOpts);
+    case "test":
+      return test_default(parsedArgs);
+    case "get-image":
+      return sendAsyncRes(getLigoDockerImage());
+    default:
+      return sendAsyncErr5(`${unsafeOpts.task} is not an understood task by the LIGO plugin`);
+  }
+};
+var main_default = main;
+
+// index.ts
+Plugin.create((i18n) => ({
+  schema: "1.0",
+  version: "0.1",
+  alias: "ligo",
+  tasks: [
+    Task.create({
+      task: "ligo",
+      command: "ligo",
+      description: "This task allows you to run arbitrary LIGO native commands. Note that they might not benefit from the abstractions provided by Taqueria",
+      options: [
+        Option.create({
+          shortFlag: "c",
+          flag: "command",
+          type: "string",
+          description: "The command to be passed to the underlying LIGO binary, wrapped in quotes",
+          required: true
+        })
+      ],
+      handler: "proxy",
+      encoding: "none"
+    }),
+    Task.create({
+      task: "compile",
+      command: "compile <sourceFile>",
+      aliases: ["c", "compile-ligo"],
+      description: "Compile a smart contract written in a LIGO syntax to Michelson code, along with its associated storage/parameter list files if they are found",
+      options: [
+        Option.create({
+          flag: "json",
+          boolean: true,
+          description: "Emit JSON-encoded Michelson"
+        })
+      ],
+      handler: "proxy",
+      encoding: "json"
+    }),
+    Task.create({
+      task: "compile-all",
+      command: "compile-all",
+      description: "Compile all main smart contracts written in a LIGO syntax to Michelson code, along with their associated storage/parameter list files if they are found",
+      options: [
+        Option.create({
+          flag: "json",
+          boolean: true,
+          description: "Emit JSON-encoded Michelson"
+        })
+      ],
+      handler: "proxy",
+      encoding: "json"
+    }),
+    Task.create({
+      task: "test",
+      command: "test <sourceFile>",
+      description: "Test a smart contract written in LIGO",
+      handler: "proxy",
+      encoding: "json"
+    }),
+    Task.create({
+      task: "get-image",
+      command: "get-image",
+      description: "Gets the name of the image to be used",
+      handler: "proxy",
+      hidden: true
+    })
+  ],
+  templates: [
+    Template.create({
+      template: "contract",
+      command: "contract <sourceFileName>",
+      description: "Create a LIGO contract with boilerplate code",
+      positionals: [
+        PositionalArg.create({
+          placeholder: "sourceFileName",
+          type: "string",
+          description: "The name of the LIGO contract to generate"
+        })
+      ],
+      options: [
+        Option.create({
+          shortFlag: "s",
+          flag: "syntax",
+          type: "string",
+          description: "The syntax used in the contract"
+        })
+      ],
+      handler: createContract_default
+    })
+  ],
+  proxy: main_default
+}), process.argv);
+//# sourceMappingURL=index.mjs.map