genlayer 0.12.4 → 0.12.5

package/dist/index.js

@@ -9624,7 +9624,7 @@ var version3;
 var init_version2 = __esm({
   "node_modules/viem/_esm/errors/version.js"() {
     "use strict";
-    version3 = "2.23.5";
+    version3 = "2.23.6";
   }
 });
 
@@ -16853,7 +16853,7 @@ var init_call = __esm({
 import { program } from "commander";
 
 // package.json
-var version = "0.12.4";
+var version = "0.12.5";
 var package_default = {
   name: "genlayer",
   version,
@@ -16893,6 +16893,7 @@ var package_default = {
   devDependencies: {
     "@release-it/conventional-changelog": "^10.0.0",
     "@types/dockerode": "^3.3.31",
+    "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "^9.0.7",
     "@types/node": "^22.0.0",
     "@types/sinon": "^17.0.3",
@@ -16901,7 +16902,7 @@ var package_default = {
     "@typescript-eslint/parser": "^8.0.0",
     "@vitest/coverage-v8": "^2.1.4",
     "cross-env": "^7.0.3",
-    esbuild: "^0.25.0",
+    esbuild: ">=0.25.0",
     eslint: "^9.0.0",
     "eslint-config-prettier": "^10.0.0",
     "eslint-import-resolver-typescript": "^3.6.1",
@@ -16918,7 +16919,8 @@ var package_default = {
     dockerode: "^4.0.2",
     dotenv: "^16.4.5",
     ethers: "^6.13.4",
-    "genlayer-js": "^0.6.0",
+    "fs-extra": "^11.3.0",
+    "genlayer-js": "^0.9.0",
     inquirer: "^12.0.0",
     "node-fetch": "^3.0.0",
     open: "^10.1.0",
@@ -16942,7 +16944,7 @@ var CLI_DESCRIPTION = "GenLayer CLI is a development environment for the GenLaye
 import inquirer2 from "inquirer";
 
 // src/lib/config/simulator.ts
-var localnetCompatibleVersion = "v0.42.0";
+var localnetCompatibleVersion = "v0.51.0";
 var DEFAULT_JSON_RPC_URL = "http://localhost:4000/api";
 var CONTAINERS_NAME_PREFIX = "/genlayer-";
 var IMAGES_NAME_PREFIX = "yeagerai";
@@ -16966,7 +16968,7 @@ var STARTING_TIMEOUT_ATTEMPTS = 120;
 var AI_PROVIDERS_CONFIG = {
   ollama: {
     name: "Ollama",
-    hint: "(This will download and run a local instance of Llama 3)",
+    hint: "(By default, this will download and run a local instance of Llama 3)",
     cliOptionValue: "ollama"
   },
   openai: {
@@ -19806,34 +19808,34 @@ var BaseAction = class extends ConfigFileManager {
   log(message, data) {
     console.log(source_default.white(`
 ${message}`));
-    if (data) console.log(this.formatOutput(data));
+    if (data !== void 0) console.log(this.formatOutput(data));
   }
   logSuccess(message, data) {
     console.log(source_default.green(`
 \u2714 ${message}`));
-    if (data) console.log(source_default.green(this.formatOutput(data)));
+    if (data !== void 0) console.log(source_default.green(this.formatOutput(data)));
   }
   logInfo(message, data) {
     console.log(source_default.blue(`
 \u2139 ${message}`));
-    if (data) console.log(source_default.blue(this.formatOutput(data)));
+    if (data !== void 0) console.log(source_default.blue(this.formatOutput(data)));
   }
   logWarning(message, data) {
     console.log(source_default.yellow(`
 \u26A0 ${message}`));
-    if (data) console.log(source_default.yellow(this.formatOutput(data)));
+    if (data !== void 0) console.log(source_default.yellow(this.formatOutput(data)));
   }
   logError(message, error) {
     console.error(source_default.red(`
 \u2716 ${message}`));
-    if (error) console.error(source_default.red(this.formatOutput(error)));
+    if (error !== void 0) console.error(source_default.red(this.formatOutput(error)));
   }
   startSpinner(message) {
     this.spinner.text = source_default.blue(`${message}`);
     this.spinner.start();
   }
   succeedSpinner(message, data) {
-    if (data) this.log("Result:", data);
+    if (data !== void 0) this.log("Result:", data);
     this.spinner.succeed(source_default.green(message));
   }
   failSpinner(message, error) {
@@ -20726,7 +20728,6 @@ var InitAction = class extends BaseAction {
       const llmProvidersAnswer = await inquirer2.prompt(llmQuestions);
       const selectedLlmProviders = llmProvidersAnswer.selectedLlmProviders;
       let defaultOllamaModel = this.getConfig().defaultOllamaModel;
-      AI_PROVIDERS_CONFIG.ollama.hint = `(This will download and run a local instance of ${defaultOllamaModel})`;
       const aiProvidersEnvVars = {};
       const configurableAiProviders = selectedLlmProviders.filter(
         (provider) => AI_PROVIDERS_CONFIG[provider].envVar
@@ -20954,6 +20955,7 @@ function initializeKeygenCommands(program2) {
 
 // src/commands/contracts/deploy.ts
 import fs9 from "fs";
+import path4 from "path";
 
 // node_modules/genlayer-js/dist/chunk-MLKGABMK.js
 var __defProp2 = Object.defineProperty;
@@ -27894,15 +27896,16 @@ init_encodeFunctionData();
 init_toHex();
 init_fromHex();
 
-// node_modules/genlayer-js/dist/chunk-O3T2C57T.js
+// node_modules/genlayer-js/dist/chunk-WEXFFND6.js
 var chains_exports = {};
 __export2(chains_exports, {
+  localnet: () => localnet,
   simulator: () => simulator
 });
 var SIMULATOR_JSON_RPC_URL = "http://127.0.0.1:4000/api";
-var simulator = defineChain({
+var localnet = defineChain({
   id: 61999,
-  name: "GenLayer Simulator",
+  name: "Genlayer Localnet",
   rpcUrls: {
     default: {
       http: [SIMULATOR_JSON_RPC_URL]
@@ -27924,8 +27927,33 @@ var simulator = defineChain({
   defaultNumberOfInitialValidators: 5,
   defaultConsensusMaxRotations: 3
 });
+var SIMULATOR_JSON_RPC_URL2 = "http://127.0.0.1:4000/api";
+var simulator = defineChain({
+  id: 61999,
+  name: "GenLayer Simulator",
+  rpcUrls: {
+    default: {
+      http: [SIMULATOR_JSON_RPC_URL2]
+    }
+  },
+  nativeCurrency: {
+    name: "GEN Token",
+    symbol: "GEN",
+    decimals: 18
+  },
+  blockExplorers: {
+    default: {
+      name: "GenLayer Explorer",
+      url: SIMULATOR_JSON_RPC_URL2
+    }
+  },
+  testnet: true,
+  consensusMainContract: null,
+  defaultNumberOfInitialValidators: 5,
+  defaultConsensusMaxRotations: 3
+});
 
-// node_modules/genlayer-js/dist/chunk-2EJVFGKU.js
+// node_modules/genlayer-js/dist/chunk-K72OSU5N.js
 var CalldataAddress = class {
   constructor(addr) {
     __publicField(this, "bytes");
@@ -27935,6 +27963,17 @@ var CalldataAddress = class {
     this.bytes = addr;
   }
 };
+var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
+  TransactionStatus2["PENDING"] = "PENDING";
+  TransactionStatus2["CANCELED"] = "CANCELED";
+  TransactionStatus2["PROPOSING"] = "PROPOSING";
+  TransactionStatus2["COMMITTING"] = "COMMITTING";
+  TransactionStatus2["REVEALING"] = "REVEALING";
+  TransactionStatus2["ACCEPTED"] = "ACCEPTED";
+  TransactionStatus2["FINALIZED"] = "FINALIZED";
+  TransactionStatus2["UNDETERMINED"] = "UNDETERMINED";
+  return TransactionStatus2;
+})(TransactionStatus || {});
 
 // node_modules/viem/_esm/accounts/generatePrivateKey.js
 init_secp256k1();
@@ -28080,8 +28119,8 @@ function privateKeyToAccount(privateKey, options = {}) {
 function accountActions(client) {
   return {
     fundAccount: async ({ address, amount }) => {
-      if (client.chain?.id !== simulator.id) {
-        throw new Error("Client is not connected to the simulator");
+      if (client.chain?.id !== localnet.id) {
+        throw new Error("Client is not connected to the localnet");
       }
       return client.request({
         method: "sim_fundAccount",
@@ -28488,18 +28527,18 @@ var overrideContractActions = (client) => {
     return decode2(resultBinary);
   };
   client.writeContract = async (args) => {
-    const { account, address, functionName, args: callArgs, kwargs, value = 0n, leaderOnly = false } = args;
+    const { account, address, functionName, args: callArgs, kwargs, value = 0n, leaderOnly = false, consensusMaxRotations = client.chain.defaultConsensusMaxRotations } = args;
     const data = [encode4(makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
     const serializedData = serialize(data);
-    return _sendTransaction(address, serializedData, account || client.account, value);
+    return _sendTransaction(address, serializedData, account || client.account, consensusMaxRotations, value);
   };
   client.deployContract = async (args) => {
-    const { account, code, args: constructorArgs, kwargs, leaderOnly = false } = args;
+    const { account, code, args: constructorArgs, kwargs, leaderOnly = false, consensusMaxRotations = client.chain.defaultConsensusMaxRotations } = args;
     const data = [code, encode4(makeCalldataObject(void 0, constructorArgs, kwargs)), leaderOnly];
     const serializedData = serialize(data);
-    return _sendTransaction(zeroAddress, serializedData, account || client.account);
+    return _sendTransaction(zeroAddress, serializedData, account || client.account, consensusMaxRotations);
   };
-  const _sendTransaction = async (recipient, data, senderAccount, value) => {
+  const _sendTransaction = async (recipient, data, senderAccount, consensusMaxRotations, value) => {
     if (!senderAccount) {
       throw new Error(
         "No account set. Configure the client with an account or pass an account to this function."
@@ -28517,7 +28556,7 @@ var overrideContractActions = (client) => {
         senderAccount.address,
         recipient,
         client.chain.defaultNumberOfInitialValidators,
-        client.chain.defaultConsensusMaxRotations,
+        consensusMaxRotations,
         data
       ]
     });
@@ -28557,6 +28596,51 @@ var transactionsConfig = {
 async function sleep2(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
+var abi_exports = {};
+__export2(abi_exports, {
+  calldata: () => calldata,
+  transactions: () => transactions
+});
+var calldata = calldata_exports;
+var transactions = transactions_exports;
+function b64ToArray(b64) {
+  return Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
+}
+function calldataToUserFriendlyJson(cd) {
+  return {
+    raw: Array.from(cd),
+    readable: calldata.toString(calldata.decode(cd))
+  };
+}
+var RESULT_CODES = /* @__PURE__ */ new Map([
+  [0, "return"],
+  [1, "rollback"],
+  [2, "contract_error"],
+  [3, "error"],
+  [4, "none"],
+  [5, "no_leaders"]
+]);
+function resultToUserFriendlyJson(cd64) {
+  const raw = b64ToArray(cd64);
+  const code = RESULT_CODES.get(raw[0]);
+  let status;
+  let payload = null;
+  if (code === void 0) {
+    status = "<unknown>";
+  } else {
+    status = code;
+    if ([1, 2].includes(raw[0])) {
+      payload = new TextDecoder("utf-8").decode(raw.slice(1));
+    } else if (raw[0] == 0) {
+      payload = calldataToUserFriendlyJson(raw.slice(1));
+    }
+  }
+  return {
+    raw: cd64,
+    status,
+    payload
+  };
+}
 var transactionActions = (client) => ({
   waitForTransactionReceipt: async ({
     hash: hash2,
@@ -28569,7 +28653,7 @@ var transactionActions = (client) => ({
       throw new Error("Transaction not found");
     }
     if (transaction.status === status || status === "ACCEPTED" && transaction.status === "FINALIZED") {
-      return transaction;
+      return _decodeTransaction(transaction);
     }
     if (retries === 0) {
       throw new Error("Transaction status is not " + status);
@@ -28583,6 +28667,137 @@ var transactionActions = (client) => ({
     });
   }
 });
+var _decodeTransaction = (tx) => {
+  if (!tx.data) return tx;
+  try {
+    const leaderReceipt = tx.consensus_data?.leader_receipt;
+    if (leaderReceipt) {
+      if (leaderReceipt.result) {
+        leaderReceipt.result = resultToUserFriendlyJson(leaderReceipt.result);
+      }
+      if (leaderReceipt.calldata) {
+        leaderReceipt.calldata = {
+          base64: leaderReceipt.calldata,
+          ...calldataToUserFriendlyJson(b64ToArray(leaderReceipt.calldata))
+        };
+      }
+      if (leaderReceipt.eq_outputs) {
+        leaderReceipt.eq_outputs = Object.fromEntries(
+          Object.entries(leaderReceipt.eq_outputs).map(([key, value]) => {
+            const decodedValue = new TextDecoder().decode(b64ToArray(String(value)));
+            return [key, resultToUserFriendlyJson(decodedValue)];
+          })
+        );
+      }
+    }
+    if (tx.data.calldata) {
+      tx.data.calldata = {
+        base64: tx.data.calldata,
+        ...calldataToUserFriendlyJson(b64ToArray(tx.data.calldata))
+      };
+    }
+  } catch (e2) {
+    console.error("Error decoding transaction:", e2);
+  }
+  return tx;
+};
+var snapID = {
+  local: "local:http://localhost:8081",
+  npm: "npm:genlayer-wallet-plugin"
+};
+var networks = {
+  localnet
+};
+var connect = async (client, network = "localnet", snapSource = "npm") => {
+  if (!window.ethereum) {
+    throw new Error("MetaMask is not installed.");
+  }
+  if (network === "testnet" || network === "mainnet") {
+    throw new Error(`${network} is not available yet. Please use localnet.`);
+  }
+  const selectedNetwork = networks[network];
+  if (!selectedNetwork) {
+    throw new Error(`Network configuration for '${network}' is not available.`);
+  }
+  const chainIdHex = `0x${selectedNetwork.id.toString(16)}`;
+  const chainParams = {
+    chainId: chainIdHex,
+    chainName: selectedNetwork.name,
+    rpcUrls: selectedNetwork.rpcUrls.default.http,
+    nativeCurrency: selectedNetwork.nativeCurrency,
+    blockExplorerUrls: [selectedNetwork.blockExplorers?.default.url]
+  };
+  const currentChainId = await window.ethereum.request({ method: "eth_chainId" });
+  if (currentChainId !== chainIdHex) {
+    await window.ethereum.request({
+      method: "wallet_addEthereumChain",
+      params: [chainParams]
+    });
+    await window.ethereum.request({
+      method: "wallet_switchEthereumChain",
+      params: [{ chainId: chainIdHex }]
+    });
+  }
+  const id = snapSource === "local" ? snapID.local : snapID.npm;
+  const installedSnaps = await window.ethereum.request({ method: "wallet_getSnaps" });
+  const isGenLayerSnapInstalled = Object.values(installedSnaps).some(
+    (snap) => snap.id === id
+  );
+  if (!isGenLayerSnapInstalled) {
+    await window.ethereum.request({
+      method: "wallet_requestSnaps",
+      params: {
+        [id]: {}
+      }
+    });
+  }
+  client.chain = selectedNetwork;
+};
+var metamaskClient = async (snapSource = "npm") => {
+  if (typeof window === "undefined" || !window.ethereum) {
+    throw new Error("MetaMask is not installed.");
+  }
+  const isFlask = async () => {
+    try {
+      const clientVersion = await window.ethereum?.request({
+        method: "web3_clientVersion"
+      });
+      return clientVersion?.includes("flask");
+    } catch (error) {
+      console.error("Error detecting Flask:", error);
+      return false;
+    }
+  };
+  const installedSnaps = async () => {
+    try {
+      return await window.ethereum?.request({
+        method: "wallet_getSnaps"
+      });
+    } catch (error) {
+      console.error("Error getting installed snaps:", error);
+      return {};
+    }
+  };
+  const isGenLayerSnapInstalled = async () => {
+    const id = snapSource === "local" ? snapID.local : snapID.npm;
+    const snaps = await installedSnaps();
+    return Object.values(snaps).some((snap) => snap.id === id);
+  };
+  const flaskDetected = await isFlask();
+  const snapsList = await installedSnaps();
+  const genLayerSnapInstalled = await isGenLayerSnapInstalled();
+  return {
+    isFlask: flaskDetected,
+    installedSnaps: snapsList,
+    isGenLayerSnapInstalled: genLayerSnapInstalled
+  };
+};
+function walletActions2(client) {
+  return {
+    connect: (network, snapSource) => connect(client, network, snapSource),
+    metamaskClient: (snapSource = "npm") => metamaskClient(snapSource)
+  };
+}
 function chainActions(client) {
   return {
     initializeConsensusSmartContract: async (forceReset = false) => {
@@ -28612,8 +28827,8 @@ function chainActions(client) {
     }
   };
 }
-var createClient2 = (config = { chain: simulator }) => {
-  const chainConfig = config.chain || simulator;
+var createClient2 = (config = { chain: localnet }) => {
+  const chainConfig = config.chain || localnet;
   if (config.endpoint) {
     chainConfig.rpcUrls.default.http = [config.endpoint];
   }
@@ -28657,7 +28872,7 @@ var createClient2 = (config = { chain: simulator }) => {
     chain: chainConfig,
     transport: custom(customTransport),
     ...config.account ? { account: config.account } : {}
-  }).extend(publicActions).extend(walletActions).extend((client) => accountActions(client)).extend((client) => transactionActions(client)).extend((client) => contractActions(client)).extend((client) => chainActions(client));
+  }).extend(publicActions).extend(walletActions).extend((client) => accountActions(client)).extend((client) => transactionActions(client)).extend((client) => contractActions(client)).extend((client) => chainActions(client)).extend((client) => walletActions2(client));
   baseClient.initializeConsensusSmartContract().catch((error) => {
     console.error("Failed to initialize consensus smart contract:", error);
   });
@@ -28669,13 +28884,6 @@ var createAccount = (accountPrivateKey) => {
   const account = privateKeyToAccount(privateKey);
   return account;
 };
-var abi_exports = {};
-__export2(abi_exports, {
-  calldata: () => calldata,
-  transactions: () => transactions
-});
-var calldata = calldata_exports;
-var transactions = transactions_exports;
 
 // src/lib/accounts/getPrivateKey.ts
 import fs8 from "fs";
@@ -28695,9 +28903,13 @@ function getPrivateKey() {
 }
 
 // src/commands/contracts/deploy.ts
-var DeployAction = class {
+import { pathToFileURL } from "url";
+import { buildSync } from "esbuild";
+var DeployAction = class extends BaseAction {
   constructor() {
+    super();
     __publicField(this, "genlayerClient");
+    __publicField(this, "deployDir", path4.resolve(process.cwd(), "deploy"));
     this.genlayerClient = createClient2({
       chain: simulator,
       endpoint: process.env.VITE_JSON_RPC_SERVER_URL,
@@ -28710,41 +28922,113 @@ var DeployAction = class {
     }
     return fs9.readFileSync(contractPath, "utf-8");
   }
-  async deploy(options) {
-    const argsUsed = options.args && options.args.length > 0;
-    const kwargsUsed = options.kwargs && options.kwargs.trim() !== "";
-    if (argsUsed && kwargsUsed) {
-      throw new Error("Invalid usage: Please specify either `args` or `kwargs`, but not both.");
+  async executeTsScript(filePath) {
+    const outFile = filePath.replace(/\.ts$/, ".compiled.js");
+    this.startSpinner(`Transpiling TypeScript file: ${filePath}`);
+    try {
+      buildSync({
+        entryPoints: [filePath],
+        outfile: outFile,
+        bundle: false,
+        platform: "node",
+        format: "esm",
+        target: "es2020",
+        sourcemap: false
+      });
+      await this.executeJsScript(filePath, outFile);
+    } catch (error) {
+      this.failSpinner(`Error executing: ${filePath}`, error);
+    } finally {
+      fs9.unlinkSync(outFile);
+    }
+  }
+  async executeJsScript(filePath, transpiledFilePath) {
+    this.startSpinner(`Executing file: ${filePath}`);
+    try {
+      const module = await import(pathToFileURL(transpiledFilePath || filePath).href);
+      if (!module.default || typeof module.default !== "function") {
+        this.failSpinner(`No "default" function found in: ${filePath}`);
+        return;
+      }
+      await module.default(this.genlayerClient);
+      this.succeedSpinner(`Successfully executed: ${filePath}`);
+    } catch (error) {
+      this.failSpinner(`Error executing: ${filePath}`, error);
     }
-    if (!options.contract) {
-      console.error("No contract specified for deployment.");
+  }
+  async deployScripts() {
+    this.startSpinner("Searching for deploy scripts...");
+    if (!fs9.existsSync(this.deployDir)) {
+      this.failSpinner("No deploy folder found.");
       return;
     }
-    const contractCode = this.readContractCode(options.contract);
-    if (!contractCode) {
-      console.error("Contract code is empty.");
+    const files = fs9.readdirSync(this.deployDir).filter((file) => file.endsWith(".ts") || file.endsWith(".js")).sort((a, b) => {
+      const numA = parseInt(a.split("_")[0]);
+      const numB = parseInt(b.split("_")[0]);
+      if (!isNaN(numA) && !isNaN(numB)) return numA - numB;
+      if (!isNaN(numA)) return -1;
+      if (!isNaN(numB)) return 1;
+      return a.localeCompare(b);
+    });
+    if (files.length === 0) {
+      this.failSpinner("No deploy scripts found.");
       return;
     }
-    const leaderOnly = false;
-    let deployParams = { code: contractCode, args: options.args, leaderOnly };
-    console.log("Starting contract deployment...");
-    console.log("Deployment Parameters:", deployParams);
+    this.setSpinnerText(`Found ${files.length} deploy scripts. Executing...`);
+    for (const file of files) {
+      const filePath = path4.resolve(this.deployDir, file);
+      this.setSpinnerText(`Executing script: ${filePath}`);
+      try {
+        if (file.endsWith(".ts")) {
+          await this.executeTsScript(filePath);
+        } else {
+          await this.executeJsScript(filePath);
+        }
+      } catch (error) {
+        this.failSpinner(`Error executing script: ${filePath}`, error);
+      }
+    }
+  }
+  async deploy(options) {
     try {
+      this.startSpinner("Setting up the deployment environment...");
+      await this.genlayerClient.initializeConsensusSmartContract();
+      if (!options.contract) {
+        this.failSpinner("No contract specified for deployment.");
+        return;
+      }
+      this.setSpinnerText("Reading contract code...");
+      const contractCode = this.readContractCode(options.contract);
+      if (!contractCode) {
+        this.failSpinner("Contract code is empty.");
+        return;
+      }
+      const leaderOnly = false;
+      const deployParams = { code: contractCode, args: options.args, leaderOnly };
+      this.setSpinnerText("Starting contract deployment...");
+      this.log("Deployment Parameters:", deployParams);
       const hash2 = await this.genlayerClient.deployContract(deployParams);
-      const result = await this.genlayerClient.waitForTransactionReceipt({ hash: hash2, retries: 15, interval: 2e3 });
-      console.log("Contract deployed successfully.");
-      console.log("Transaction Hash:", hash2);
-      console.log("Contract Address:", result.data?.contract_address);
+      const result = await this.genlayerClient.waitForTransactionReceipt({
+        hash: hash2,
+        retries: 15,
+        interval: 2e3,
+        status: TransactionStatus.ACCEPTED
+      });
+      this.log("Deployment Receipt:", result);
+      this.succeedSpinner("Contract deployed successfully.", {
+        "Transaction Hash": hash2,
+        "Contract Address": result.data?.contract_address
+      });
     } catch (error) {
-      console.error("Error deploying contract:", error);
-      throw new Error("Contract deployment failed.");
+      this.failSpinner("Error deploying contract", error);
     }
   }
 };
 
 // src/commands/contracts/call.ts
-var CallAction = class {
+var CallAction = class extends BaseAction {
   constructor() {
+    super();
     __publicField(this, "genlayerClient");
     this.genlayerClient = createClient2({
       chain: simulator,
@@ -28757,23 +29041,18 @@ var CallAction = class {
     method,
     args
   }) {
-    console.log(`Calling method ${method} on contract at ${contractAddress}...`);
+    this.startSpinner(`Calling method ${method} on contract at ${contractAddress}...`);
     const contractSchema = await this.genlayerClient.getContractSchema(contractAddress);
     if (!contractSchema.methods.hasOwnProperty(method)) {
-      console.error(`method ${method} not found.`);
-      process.exit(1);
+      this.failSpinner(`method ${method} not found.`);
+      return;
     }
     const readonly = contractSchema.methods[method].readonly;
-    try {
-      if (readonly) {
-        await this.executeRead(contractAddress, method, args);
-      } else {
-        await this.executeWrite(contractAddress, method, args);
-      }
-    } catch (error) {
-      console.error("Error calling contract method:", error);
-      throw error;
+    if (readonly) {
+      await this.executeRead(contractAddress, method, args);
+      return;
     }
+    await this.executeWrite(contractAddress, method, args);
   }
   async executeRead(contractAddress, method, args) {
     try {
@@ -28782,10 +29061,9 @@ var CallAction = class {
         functionName: method,
         args
       });
-      console.log("Read result:", result);
+      this.succeedSpinner("Read operation successfully executed", result);
     } catch (error) {
-      console.error("Error during read operation:", error);
-      throw error;
+      this.failSpinner("Error during read operation", error);
     }
   }
   async executeWrite(contractAddress, method, args) {
@@ -28801,22 +29079,31 @@ var CallAction = class {
         retries: 15,
         interval: 2e3
       });
-      console.log("Write transaction hash:", hash2);
-      console.log("Result:", result);
+      this.log("Write transaction hash:", hash2);
+      this.succeedSpinner("Write operation successfully executed", result);
     } catch (error) {
-      console.error("Error during write operation:", error);
-      throw error;
+      this.failSpinner("Error during write operation", error);
     }
   }
 };
 
 // src/commands/contracts/index.ts
+function parseArg(value, previous = []) {
+  if (value === "true") return [...previous, true];
+  if (value === "false") return [...previous, false];
+  if (!isNaN(Number(value))) return [...previous, Number(value)];
+  return [...previous, value];
+}
 function initializeContractsCommands(program2) {
-  program2.command("deploy").description("Deploy intelligent contracts").option("--contract <contractPath>", "Path to the smart contract to deploy").option("--args <args...>", "Positional arguments for the contract (space-separated, use quotes for multi-word arguments)", []).action(async (options) => {
+  program2.command("deploy").description("Deploy intelligent contracts").option("--contract <contractPath>", "Path to the smart contract to deploy").option("--args <args...>", "Positional arguments for the contract (space-separated, use quotes for multi-word arguments)", parseArg, []).action(async (options) => {
     const deployer = new DeployAction();
-    await deployer.deploy(options);
+    if (options.contract) {
+      await deployer.deploy(options);
+    } else {
+      await deployer.deployScripts();
+    }
   });
-  program2.command("call <contractAddress> <method>").description("Call a contract method").option("--args <args...>", "Positional arguments for the method (space-separated, use quotes for multi-word arguments)", []).action(async (contractAddress, method, options) => {
+  program2.command("call <contractAddress> <method>").description("Call a contract method").option("--args <args...>", "Positional arguments for the method (space-separated, use quotes for multi-word arguments)", parseArg, []).action(async (contractAddress, method, options) => {
     const caller = new CallAction();
     await caller.call({ contractAddress, method, ...options });
   });
@@ -29134,6 +29421,44 @@ function initializeUpdateCommands(program2) {
   return program2;
 }
 
+// src/commands/scaffold/new.ts
+import fs10 from "fs-extra";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var NewAction = class extends BaseAction {
+  constructor() {
+    super();
+    __publicField(this, "templatePath");
+    const __filename = fileURLToPath3(import.meta.url);
+    const basePath = path5.resolve(path5.dirname(__filename), "..");
+    this.templatePath = path5.join(basePath, "templates", "default");
+  }
+  async createProject(projectName, options) {
+    const targetPath = path5.resolve(options.path, projectName);
+    if (fs10.existsSync(targetPath) && !options.overwrite) {
+      return this.failSpinner(
+        `Project directory "${targetPath}" already exists. Use --overwrite to replace it.`
+      );
+    }
+    this.startSpinner(`Creating new GenLayer project: ${projectName}`);
+    try {
+      fs10.copySync(this.templatePath, targetPath);
+      this.succeedSpinner(`Project "${projectName}" created successfully at ${targetPath}`);
+    } catch (error) {
+      this.failSpinner(`Error creating project "${projectName}"`, error);
+    }
+  }
+};
+
+// src/commands/scaffold/index.ts
+function initializeScaffoldCommands(program2) {
+  program2.command("new <projectName>").description("Create a new GenLayer project using the default template").option("--path <directory>", "Specify the directory for the new project", ".").option("--overwrite", "Overwrite existing directory if it exists", false).action(async (projectName, options) => {
+    const newProjectAction = new NewAction();
+    await newProjectAction.createProject(projectName, options);
+  });
+  return program2;
+}
+
 // src/index.ts
 function initializeCLI() {
   program.version(version).description(CLI_DESCRIPTION);
@@ -29143,6 +29468,7 @@ function initializeCLI() {
   initializeConfigCommands(program);
   initializeUpdateCommands(program);
   initializeValidatorCommands(program);
+  initializeScaffoldCommands(program);
   program.parse(process.argv);
 }
 initializeCLI();