updated invoke chaincode function

Signed-off-by: urgetolearn <chinmayishaan2316@gmail.com>

Author: urgetolearn

extension.js

@@ -26,7 +26,7 @@ const { log } = require("console");
 let loadedConnectionProfile = null;
 
 function activate(context) {
-  const fabricDebuggerPath = "C:\\Users\\chinm\\fabric-debugger";
+  const fabricDebuggerPath = context.extensionPath;
 
   let greenButton = vscode.commands.registerCommand("myview.button1", () => {
     const platform = process.platform;
@@ -69,6 +69,118 @@ function activate(context) {
 
   context.subscriptions.push(greenButton);
   context.subscriptions.push(redButton);
+  const outputChannel = vscode.window.createOutputChannel("Chaincode Invocation");
+  let disposableExtractFunctions = vscode.commands.registerCommand('extension.extractFunctions', function () {
+    const editor = vscode.window.activeTextEditor;
+    if (!editor) {
+      vscode.window.showInformationMessage('No active editor. Open a chaincode file.');
+      return;
+    }
+    const filePath = editor.document.fileName;
+    const text = editor.document.getText();
+    let functions = [];
+
+    if (isGoChaincodeFile(filePath)) {
+      functions = extractGoFunctions(text);
+    }
+
+    const filteredFunctions = filterIntAndStringFunctions(functions);
+    const uniqueFunctions = [...new Set(filteredFunctions)];
+    storeFunctions(uniqueFunctions, context);
+
+    vscode.window.showInformationMessage(`Extracted and stored ${uniqueFunctions.length} unique functions with int or string parameters.`);
+
+    showStoredFunctions(context, outputChannel);
+  });
+
+  context.subscriptions.push(disposableExtractFunctions);
+  function isGoChaincodeFile(filePath) {
+    return filePath.toLowerCase().endsWith('.go');
+  }
+
+  function extractGoFunctions(code) {
+    const functionDetails = [];
+    const regex = /func\s*\((\w+)\s+\*SmartContract\)\s*(\w+)\s*\((.*?)\)\s*(\w*)/g;
+    let match;
+
+    while ((match = regex.exec(code)) !== null) {
+      const functionName = match[2];
+      const params = match[3];
+      functionDetails.push({ name: functionName, params });
+    }
+
+    return functionDetails;
+  }
+
+  function filterIntAndStringFunctions(functions) {
+    return functions.filter(func => /int|string/.test(func.params)).map(func => `${func.name}(${func.params})`);
+  }
+
+  function storeFunctions(functions, context) {
+    let storedFunctions = context.workspaceState.get('storedFunctions', []);
+    storedFunctions = [...new Set([...storedFunctions, ...functions])];
+    context.workspaceState.update('storedFunctions', storedFunctions);
+  }
+
+  function showStoredFunctions(context, outputChannel) {
+    const storedFunctions = context.workspaceState.get('storedFunctions', []);
+
+    vscode.window.showQuickPick(storedFunctions, {
+      placeHolder: 'Select a function to invoke',
+      canPickMany: false
+    }).then(selectedFunction => {
+      if (selectedFunction) {
+        vscode.window.showInformationMessage(`Selected: ${selectedFunction}`);
+        promptForArgumentsSequentially(selectedFunction, outputChannel);
+      }
+    });
+  }
+
+  async function promptForArgumentsSequentially(selectedFunction, outputChannel) {
+    const functionPattern = /(\w+)\((.*)\)/;
+    const match = functionPattern.exec(selectedFunction);
+
+    if (!match) {
+      vscode.window.showErrorMessage("Invalid function format.");
+      return;
+    }
+
+    const functionName = match[1];
+    const paramList = match[2].split(',').map(param => param.trim());
+
+    let argumentValues = [];
+
+    for (let param of paramList) {
+      if (/int/.test(param)) {
+        const input = await vscode.window.showInputBox({ prompt: `Enter an integer value for ${param}` });
+        const intValue = parseInt(input, 10);
+        if (isNaN(intValue)) {
+          vscode.window.showErrorMessage(`Invalid integer value for ${param}.`);
+          return;
+        }
+        argumentValues.push(intValue);
+      } else if (/string/.test(param)) {
+        const input = await vscode.window.showInputBox({ prompt: `Enter a string value for ${param}` });
+        if (!input) {
+          vscode.window.showErrorMessage(`Invalid string value for ${param}.`);
+          return;
+        }
+        argumentValues.push(`"${input}"`);
+      }
+    }
+
+    const finalArgs = argumentValues.join(', ');
+    outputChannel.show();
+    outputChannel.appendLine(`Function: ${functionName}`);
+    outputChannel.appendLine(`Arguments: ${finalArgs}`);
+
+    vscode.window.showInformationMessage(`Arguments captured. Press "Invoke" to execute the command.`, "Invoke").then(selection => {
+      if (selection === "Invoke") {
+        invokeChaincode(functionName, argumentValues);
+      }
+    });
+  }
+
   const hyperledgerProvider = new fabricsamples();
   const treeViewProviderFabric = new TreeViewProvider(
     "fabric-network",
@@ -702,7 +814,6 @@ function activate(context) {
     })
   );
 
-
   context.subscriptions.push(
     vscode.debug.registerDebugAdapterDescriptorFactory(
       "delve",
@@ -862,6 +973,66 @@ function activate(context) {
       }
     }
   }
+  async function invokeChaincode(functionName, args) {
+    try {
+      const walletPath = path.join(os.homedir(), "wallets");
+      const wallet = await Wallets.newFileSystemWallet(walletPath);
+
+      
+      if (!loadedConnectionProfile) {
+        vscode.window.showErrorMessage("No connection profile loaded.");
+        return;
+      }
+
+      const identities = await wallet.list();
+      if (!identities.length) {
+        vscode.window.showErrorMessage("No identities found in the wallet.");
+        return;
+      }
+
+      const identityName = identities[0]; 
+      const gateway = new Gateway();
+
+      await gateway.connect(loadedConnectionProfile, {
+        wallet,
+        identity: identityName,
+        discovery: { enabled: true, asLocalhost: false },
+      });
+
+      
+      const channelName = Object.keys(loadedConnectionProfile.channels || {})[0];
+      if (!channelName) {
+        vscode.window.showErrorMessage("No channel found in the connection profile.");
+        return;
+      }
+
+      const chaincodes =
+        loadedConnectionProfile.channels[channelName]?.chaincodes || [];
+      if (!chaincodes.length) {
+        vscode.window.showErrorMessage(
+          `No chaincodes found for channel "${channelName}".`
+        );
+        return;
+      }
+
+      const chaincodeName = chaincodes[0]; 
+      const network = await gateway.getNetwork(channelName);
+      const contract = network.getContract(chaincodeName);
+
+      
+      const result = await contract.submitTransaction(functionName, ...args);
+      vscode.window.showInformationMessage(
+        `Transaction invoked successfully. Result: ${result.toString()}`
+      );
+      console.log("Transaction result:", result.toString());
+
+      
+      await gateway.disconnect();
+    } catch (error) {
+      vscode.window.showErrorMessage(`Error invoking chaincode: ${error.message}`);
+      console.error("Error invoking chaincode:", error);
+    }
+  }
 }
 
 function extractNetworkDetails(profile) {
@@ -968,6 +1139,7 @@ function extractWalletDetails(walletData) {
       console.warn("Missing required wallet data fields:");
     }
   }
+
   return null;
 }
 

package.json

@@ -197,7 +197,7 @@
     "commands": [
       {
         "command": "extension.extractFunctions",
-        "title": "Debug-Chaincode ▶"
+        "title": "Invoke-Chaincode ▶"
       },
       {
         "command": "myview.button1",