ethershell 0.1.1-alpha.15 → 0.1.2-beta.0

package/src/services/build.js

@@ -15,12 +15,15 @@ import {
   extractLoadableVersion 
 } from '../utils/builder.js';
 import fs from 'fs';
+import { 
+  generateAllTypes,
+} from '../utils/typeGenerator.js';
 
 /**
- * Stored compiler config path
+ * Stored config path
  * @type {string}
  */
-const compConfigPath = './localStorage/compilerConfig.json';
+export const configPath = './ethershell/config.json';
 
 /**
  * Global compiler configuration state
@@ -40,7 +43,11 @@ let compConfig = {};
  * @property {number} optimizerRuns - Number of optimizer runs
  * @property {boolean} viaIR - Whether to use IR-based code generation
  */
-export let compConfigFile = {};
+export let configFile = { 
+    providerEndpoint: '',
+    defaultWallet: {},
+    compiler: {} 
+  };
 
 /**
  * Global compiler configuration state
@@ -52,33 +59,38 @@ export let compConfigFile = {};
 let storedCompConfig;
 
 // Load config file
-if(fs.existsSync(compConfigPath)){
-  storedCompConfig = JSON.parse(fs.readFileSync(compConfigPath));
+if(fs.existsSync(configPath)){
+  storedCompConfig = JSON.parse(fs.readFileSync(configPath));
 } else {
   storedCompConfig = null;
 }
 
 // Initialize global configuration of compiler
 if(storedCompConfig){
-  compConfigFile = storedCompConfig;
-  compConfig.currentSolcInstance = await loadSolcVersion(compConfigFile.version);
-  compConfig.optimizer = compConfigFile.optimizer;
-  compConfig.viaIR = compConfigFile.viaIR;
-  compConfig.optimizerRuns = compConfigFile.optimizerRuns;
+  configFile.compiler = storedCompConfig.compiler;
+  console.info(`Compiler is loading ...`);
+  compConfig.currentSolcInstance = await loadSolcVersion(configFile.compiler.version);
+  console.info(`Loading done!`);
+  compConfig.optimizer = configFile.compiler.optimizer;
+  compConfig.viaIR = configFile.compiler.viaIR;
+  compConfig.optimizerRuns = configFile.compiler.optimizerRuns;
+  compConfig.compilePath = configFile.compiler.compilePath;
 } else {
   compConfig = {
     currentSolcInstance: solc, // default local compiler
     optimizer: false,
     viaIR: false,
-    optimizerRuns: 200
+    optimizerRuns: 200,
+    compilePath: './build'
   }
-  compConfigFile.version = extractLoadableVersion(compConfig.currentSolcInstance.version());
-  compConfigFile.optimizer = compConfig.optimizer;
-  compConfigFile.viaIR = compConfig.viaIR;
-  compConfigFile.optimizerRuns = compConfig.optimizerRuns;
+  configFile.compiler.version = extractLoadableVersion(compConfig.currentSolcInstance.version());
+  configFile.compiler.optimizer = compConfig.optimizer;
+  configFile.compiler.viaIR = compConfig.viaIR;
+  configFile.compiler.optimizerRuns = compConfig.optimizerRuns;
+  configFile.compiler.compilePath = compConfig.compilePath;
 
   // Update config file
-  fs.writeFileSync(compConfigPath, JSON.stringify(compConfigFile, null, 2));
+  fs.writeFileSync(configPath, JSON.stringify(configFile, null, 2));
 }
 
 /**
@@ -96,8 +108,8 @@ export async function updateCompiler(version){
     compConfig.currentSolcInstance = await setVersion(version, compConfig.currentSolcInstance);
 
     // Update config file
-    compConfigFile.version = extractLoadableVersion(compConfig.currentSolcInstance.version());
-    fs.writeFileSync(compConfigPath, JSON.stringify(compConfigFile, null, 2));
+    configFile.compiler.version = extractLoadableVersion(compConfig.currentSolcInstance.version());
+    fs.writeFileSync(configPath, JSON.stringify(configFile, null, 2));
   } catch(err) {
     console.error(err);
   }
@@ -141,20 +153,20 @@ export function compilerOptions(gasOptimizer, viaIR, optimizerRuns = 200) {
     compConfig.viaIR = viaIR;
     compConfig.optimizerRuns = optimizerRuns;
 
-    compConfigFile.optimizer = compConfig.optimizer;
-    compConfigFile.viaIR = compConfig.viaIR;
-    compConfigFile.optimizerRuns = compConfig.optimizerRuns;
-
     // Update config file
-    fs.writeFileSync(compConfigPath, JSON.stringify(compConfigFile, null, 2));
+    configFile.compiler.optimizer = compConfig.optimizer;
+    configFile.compiler.viaIR = compConfig.viaIR;
+    configFile.compiler.optimizerRuns = compConfig.optimizerRuns;
+    fs.writeFileSync(configPath, JSON.stringify(configFile, null, 2));
 
     // Provide user feedback
     console.log('✓ Compiler options updated:');
     console.log(`  Gas Optimizer: ${compConfig.optimizer ? 'Enabled' : 'Disabled'}`);
+    console.log(`  ViaIR: ${compConfig.viaIR ? 'Enabled' : 'Disabled'}`);
     if (compConfig.optimizer) {
         console.log(`  Optimizer Runs: ${compConfig.optimizerRuns}`);
     }
-    console.log(`  ViaIR: ${compConfig.viaIR ? 'Enabled' : 'Disabled'}`);
+
   } catch (error) {
       console.error('Error setting compiler options:', error.message);
       return null;
@@ -168,7 +180,7 @@ export function compilerOptions(gasOptimizer, viaIR, optimizerRuns = 200) {
  * const opts = getCompilerOptions();
  */
 export function getCompilerOptions() {
-  return { ...compConfig };
+  return { ...configFile.compiler };
 }
 
 /**
@@ -187,7 +199,7 @@ export function compile(fullPath, selectedContracts, buildPath){
   try{
     // Set default path if buildPath is undefined
     if(!buildPath){
-      buildPath = path.resolve('.', 'build');
+      buildPath = compConfig.compilePath;
       [buildPath].forEach(check);
     }
 
@@ -213,7 +225,22 @@ export function compile(fullPath, selectedContracts, buildPath){
       build(fullPath, selectedContracts, buildPath);
       console.log(`Contract compiled into ${path.resolve(buildPath)}`);
     }
+
+    // Generate TypeScript types
+    const typesOutputPath = path.join(buildPath, 'types');
+    generateAllTypes(buildPath, typesOutputPath);
+    console.log(`TypeScript types generated in ${path.resolve(typesOutputPath)}`);
   } catch(err){
       console.error(err);
   }
+}
+
+/**
+ * Changes the default path to generate build files there
+ * @param {string} newPath - The new path to build
+ */
+export function changeCompPath(newPath) {
+  compConfig.compilePath = newPath;
+  configFile.compiler.compilePath = compConfig.compilePath;
+  fs.writeFileSync(configPath, JSON.stringify(configFile, null, 2));
 }

package/src/services/config.js

@@ -1,5 +1,15 @@
-import { compConfigFile } from './build.js';
+import { configFile } from './build.js';
 
+/**
+ * Gets all fields of config file
+ */
 export function getConfigInfo() {
-    console.log(compConfigFile); 
+    console.log(configFile); 
+}
+
+/**
+ * Gets just default account of config file
+ */
+export function getDefaultAccount() {
+    console.log(configFile.defaultWallet);
 }

package/src/services/files.js

@@ -19,12 +19,13 @@ import path from 'path';
 export function deleteDirectory(dirPath){
   try {
     if(!dirPath){    
-      dirPath = path.resolve('..', 'build');
+      dirPath = path.resolve('.', 'build');
     }
     // Check if the directory exists
     if(!fs.existsSync(dirPath)){
       console.log('Path is not a directory');
-      return;    }
+      return;    
+    }
 
     // For Node.js 14.14.0+ (recommended)
     fs.rmSync(dirPath, { recursive: true, force: true });

package/src/services/network.js

@@ -6,13 +6,9 @@
  */
 
 import { ethers } from 'ethers';
-import { LocalStorage } from 'node-localstorage';
-
-/**
- * Local storage instance for persisting compiler artifacts paths
- * @type {LocalStorage}
- */
-const localStorage = new LocalStorage('./localStorage');
+import { configPath } from './build.js';
+import fs from 'fs';
+import { changeProvider } from '../utils/configFileUpdate.js';
 
 /**
  * Default JSON-RPC URL for local Ethereum node
@@ -37,13 +33,14 @@ export let provider
  * The specific RPC endpoint URL saved on storage before.
  * @type {string}
  */
-const storedUrl = localStorage.getItem('url');
+const storedUrl = JSON.parse(fs.readFileSync(configPath)).providerEndpoint;
 if(storedUrl) {
-    provider = new ethers.JsonRpcProvider(storedUrl);;
-    currentUrl = storedUrl
+    provider = new ethers.JsonRpcProvider(storedUrl);
+    currentUrl = storedUrl;
 } else {
     provider = new ethers.JsonRpcProvider(defaultUrl);
     currentUrl = defaultUrl;
+    changeProvider(currentUrl);
 }
 
 
@@ -66,7 +63,7 @@ export async function set(url){
             name: result.name,
             chainId: result.chainId
         }    
-        localStorage.setItem('url', url);
+        changeProvider(currentUrl);
         console.log(network);
     }catch(err){
         console.error(err);

package/src/services/wallet.js

@@ -15,15 +15,28 @@ import {
     detectDupWallet,
     updateWalletJSON,
     getWalletJSON,
-    updateAccountMemory
+    updateAccountMemory,
+    setDefaultAccount
  } from '../utils/accounter.js';
+ import { configPath } from './build.js';
+ import fs from 'fs';
 
 /**
  * Array containing all accounts (imported, generated, HD, and node-managed)
  * @type {Array<Object>}
  */
-export let allAccounts = [];
-allAccounts = getWalletJSON();
+export let allAccounts = getWalletJSON();
+
+// Set the default account from stored wallets
+const defWallet = JSON.parse(fs.readFileSync(configPath)).defaultWallet;
+if(defWallet.address) {
+    setDefaultAccount(defWallet);
+} else {
+    if(allAccounts && allAccounts.length > 0) {
+        setDefaultAccount(allAccounts[0]);
+    }
+}
+
 
 /**
  * Array containing only regular accounts (imported and generated)
@@ -101,6 +114,7 @@ export function addAccounts(privKeyArr) {
 
         console.log(allAccounts.slice(newFrom));
     }
+    setDefaultAccount(allAccounts[0]);
 }
 
 /**
@@ -142,6 +156,7 @@ export function addHD(phrase, count = 10) {
         }
     }
     updateWalletJSON(allAccounts);
+    setDefaultAccount(allAccounts[0]);
     console.log(`!WARNING!\n The generated accounts are NOT safe. Do NOT use them on main net!`);
     console.log(allAccounts.slice(newFrom));
 }
@@ -171,6 +186,7 @@ export function createAccounts(count = 1) {
 
     }
     updateWalletJSON(allAccounts);
+    setDefaultAccount(allAccounts[0]);
     console.log(`!WARNING!\n The generated accounts are NOT safe. Do NOT use them on main net!`);
     console.log(allAccounts.slice(newFrom));
 }
@@ -205,6 +221,7 @@ export function createHD(count = 10) {
         hdAccounts.push(newAccObj);
     }
     updateWalletJSON(allAccounts);
+    setDefaultAccount(allAccounts[0]);
     console.log(`!WARNING!\n The generated accounts are NOT safe. Do NOT use them on main net!`);
     console.log(allAccounts.slice(newFrom));
 }
@@ -362,3 +379,43 @@ export async function getWalletInfo(accPointer) {
         console.error(err);
     }
 }
+
+/**
+ * Changes the default account in config file by user
+ * @param {number | string} accPointer 
+ * @throws {Error} If input is empty or invalid
+ */
+export function changeDefaultAccount(accPointer) {
+    try {
+        if(!accPointer && accPointer != 0) {
+            throw new Error('Error: Empty input is NOT valid!');
+        }
+
+        if(typeof accPointer === 'number') {
+            const index = allAccounts.findIndex(wallet => wallet.index == accPointer);
+            setDefaultAccount(allAccounts[index]);
+        }
+
+        if(ethers.isAddress(accPointer)) {
+            const index = allAccounts.findIndex(wallet => wallet.address == accPointer);
+            setDefaultAccount(allAccounts[index]);
+        }
+
+        if(ethers.isHexString(accPointer, 32)) {
+            const newAccount = new ethers.Wallet(accPointer, provider);
+            const newAccObj = {
+                index: allAccounts.length,
+                address: newAccount.address,
+                privateKey: accPointer,
+                type: 'user-imported',
+                contracts: []
+            }
+            allAccounts.push(newAccObj);
+            accounts.push(newAccObj);
+            setDefaultAccount(newAccObj);
+        }
+    
+    } catch(err) {
+        console.error(err);
+    }
+}

package/src/utils/accounter.js

@@ -8,12 +8,14 @@
 import { allAccounts, accounts, hdAccounts } from '../services/wallet.js';
 import { provider } from '../services/network.js';
 import fs from 'fs';
+import { configFile, configPath } from '../services/build.js';
+import { serializeBigInts } from './serialize.js';
 
 /**
  * The path which in wallets json file will be saved.
  * @type {String}
  */
-const walletJSONPath = './localStorage/wallets.json';
+const walletJSONPath = './ethershell/wallets.json';
 
 /**
  * Delete account(s) by index
@@ -104,7 +106,8 @@ export function detectDupWallet(privKeyArr) {
         }]);
  */
 export function updateWalletJSON(walletArr) {
-    fs.writeFileSync(walletJSONPath, JSON.stringify(walletArr, null, 2));
+    const walletObj = serializeBigInts(walletArr);
+    fs.writeFileSync(walletJSONPath, JSON.stringify(walletObj, null, 2));
 }
 
 /**
@@ -112,7 +115,20 @@ export function updateWalletJSON(walletArr) {
  * @returns {Object}
  */
 export function getWalletJSON() {
-    return JSON.parse(fs.readFileSync(walletJSONPath));
+    if(fs.existsSync(walletJSONPath)){
+        const walletJSON = fs.readFileSync(walletJSONPath, 'utf8');
+        // Return empry array if wallet is empty
+        if(walletJSON.length === 0) {
+            return [];
+        } else {
+            return JSON.parse(fs.readFileSync(walletJSONPath));
+        }
+    } else {
+        // Generate empty wallet.json if it doesn't exist
+        const fd = fs.openSync(walletJSONPath, 'w');
+        fs.closeSync(fd);
+        return [];
+    }
 }
 
 export function updateAccountMemory(allAccArr) {
@@ -268,4 +284,13 @@ function _deleteAll() {
     hdAccounts.splice(0);
     fs.writeFileSync(walletJSONPath, JSON.stringify([], null, 2));
     return;
-}
+}
+
+/**
+ * Updates default account in config file
+ * @param {Object} account - // The given account to set as default account
+ */
+export function setDefaultAccount(account) {
+    configFile.defaultWallet = serializeBigInts(account);
+    fs.writeFileSync(configPath, JSON.stringify(configFile, null, 2));
+}

package/src/utils/builder.js

@@ -16,7 +16,7 @@ import { LocalStorage } from 'node-localstorage';
  * Local storage instance for persisting compiler artifacts paths
  * @type {LocalStorage}
  */
-const localStorage = new LocalStorage('./localStorage');
+const localStorage = new LocalStorage('./ethershell');
 
 /**
  * Load a specific version of the Solidity compiler

package/src/utils/configFileUpdate.js

@@ -0,0 +1,7 @@
+import { configFile, configPath } from '../services/build.js';
+import fs from 'fs';
+
+export function changeProvider(url) {
+    configFile.providerEndpoint = url;
+    fs.writeFileSync(configPath, JSON.stringify(configFile, null, 2));
+}

package/src/utils/contractProxy.js

@@ -0,0 +1,162 @@
+// src/utils/contractProxy.js
+import { ethers } from 'ethers';
+
+/**
+ * Creates a proxy wrapper for ethers.js Contract objects
+ * Allows dynamic sender changes and comprehensive transaction options
+ * 
+ * @param {ethers.Contract} contract - The ethers.js contract instance
+ * @param {ethers.JsonRpcProvider} provider - The blockchain provider
+ * @param {Array} allAccounts - Array of available accounts with privateKey property
+ * @returns {Proxy} Proxied contract object
+ * 
+ * @example
+ * // Call with comprehensive options
+ * await Payment.spend(amount, {
+ *   from: '0x...',
+ *   value: ethers.parseEther('1'),
+ *   gasLimit: 500000,
+ *   maxFeePerGas: ethers.parseUnits('100', 'gwei'),
+ *   maxPriorityFeePerGas: ethers.parseUnits('2', 'gwei'),
+ *   nonce: 42,
+ *   chainId: 1
+ * })
+ */
+export function createContractProxy(contract, provider, allAccounts) {
+  return new Proxy(contract, {
+    get(target, prop) {
+      // Pass through non-function properties
+      if (typeof target[prop] !== 'function') {
+        return target[prop];
+      }
+
+      // Return a wrapper for contract methods
+      return async function(...args) {
+        // Extract options from last argument if it's an object with custom properties
+        const lastArg = args[args.length - 1];
+        
+        // List of all valid transaction option keys (except 'data', 'to', 'from' which are handled internally)
+        const validTxOptions = [
+          'value',
+          'nonce',
+          'gasLimit',
+          'gas', // Maps to gasLimit
+          'gasPrice',
+          'maxFeePerGas',
+          'maxPriorityFeePerGas',
+          'chainId',
+          'accessList',
+          'type',
+          'customData',
+          'from' // Special handling for signer switching
+        ];
+
+        const hasOptions = 
+          lastArg && 
+          typeof lastArg === 'object' && 
+          !Array.isArray(lastArg) &&
+          Object.keys(lastArg).some(key => validTxOptions.includes(key));
+
+        // Warn if user tries to pass 'data'
+        if (lastArg && typeof lastArg === 'object' && lastArg.data) {
+          console.warn(
+            "Warning: 'data' option is ignored. " +
+            "Function calldata is automatically encoded by ethers.js. " +
+            "Use .connect() to change the signer if needed."
+          );
+        }
+
+        const options = hasOptions ? args.pop() : null;
+
+        let method = target[prop];
+        let txOptions = {};
+
+        // Handle 'from' option - switch signer if specified
+        if (options && options.from) {
+          const account = allAccounts.find(
+            acc => acc.address?.toLowerCase() === options.from.toLowerCase()
+          );
+
+          if (!account) {
+            throw new Error(
+              `Account ${options.from} not found in registered accounts`
+            );
+          }
+
+          if (!account.privateKey) {
+            throw new Error(
+              `Account ${options.from} is a node-managed account and cannot be used with {from}`
+            );
+          }
+
+          // Create new signer with the specified account
+          const newSigner = new ethers.Wallet(account.privateKey, provider);
+          const connectedContract = target.connect(newSigner);
+          method = connectedContract[prop];
+        }
+
+        // Build transaction options object with all supported ethers.js v6 options
+        if (options) {
+          // Value (for payable functions)
+          if (options.value !== undefined) {
+            txOptions.value = options.value;
+          }
+
+          // Gas limit (handle both 'gas' and 'gasLimit')
+          if (options.gasLimit !== undefined) {
+            txOptions.gasLimit = options.gasLimit;
+          } else if (options.gas !== undefined) {
+            txOptions.gasLimit = options.gas; // Map 'gas' to 'gasLimit'
+          }
+
+          // Legacy gas price
+          if (options.gasPrice !== undefined) {
+            txOptions.gasPrice = options.gasPrice;
+          }
+
+          // EIP-1559 options
+          if (options.maxFeePerGas !== undefined) {
+            txOptions.maxFeePerGas = options.maxFeePerGas;
+          }
+
+          if (options.maxPriorityFeePerGas !== undefined) {
+            txOptions.maxPriorityFeePerGas = options.maxPriorityFeePerGas;
+          }
+
+          // Nonce for transaction ordering
+          if (options.nonce !== undefined) {
+            txOptions.nonce = options.nonce;
+          }
+
+          // Chain ID
+          if (options.chainId !== undefined) {
+            txOptions.chainId = options.chainId;
+          }
+
+          // EIP-2930 access list
+          if (options.accessList !== undefined) {
+            txOptions.accessList = options.accessList;
+          }
+
+          // Transaction type
+          if (options.type !== undefined) {
+            txOptions.type = options.type;
+          }
+
+          // Custom data (for special networks like zkSync)
+          if (options.customData !== undefined) {
+            txOptions.customData = options.customData;
+          }
+        }
+
+        // If there are transaction options, pass them as the last argument
+        if (Object.keys(txOptions).length > 0) {
+          args.push(txOptions);
+        }
+
+        // Call the method with remaining args and tx options
+        return method.apply(method, args);
+      };
+    }
+  });
+}

package/src/utils/dir.js

@@ -57,6 +57,16 @@ export function collectSolFiles(dirPath) {
  */
 export function findImports(importPath, basePath) {
   try {
+    // Handle node_modules imports (e.g., @openzeppelin/contracts/...)
+    if (importPath.startsWith('@')) {
+      const nodeModulesPath = path.resolve(process.cwd(), 'node_modules', importPath);
+      
+      if (fs.existsSync(nodeModulesPath)) {
+        const content = fs.readFileSync(nodeModulesPath, 'utf8');
+        return { contents: content };
+      }
+    }
+
     // Resolve relative to the current file's directory
     const resolvedPath = path.resolve(basePath, importPath);
     

package/src/utils/serialize.js

@@ -0,0 +1,17 @@
+export function serializeBigInts(obj) {
+    try{
+        if (Array.isArray(obj)) {
+            return obj.map(serializeBigInts);
+        } else if (obj && typeof obj === 'object') {
+            return Object.fromEntries(
+                Object.entries(obj).map(([key, value]) => [
+                    key,
+                    typeof value === 'bigint' ? value.toString() : serializeBigInts(value)
+                ])
+            );
+        }
+        return obj;
+    }catch(err){
+        console.error(err);
+    }
+}