ethershell 0.1.0-alpha.9 → 0.1.0-beta.0

package/src/utils/accounter.js

@@ -7,6 +7,15 @@
 
 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';
 
 /**
  * Delete account(s) by index
@@ -22,6 +31,8 @@ export function deleteByIndex(index) {
         deleteByIndexArr(index);
     } else if (typeof index === 'number') {
         _deleteBySingIndex(index);
+    } else if (index === null || index === undefined) {
+        _deleteAll();
     }
 }
 
@@ -82,6 +93,47 @@ export function detectDupWallet(privKeyArr) {
     }
 }
 
+/**
+ * Writes/Updates wallets json file
+ * @param {Array<string>} walletArr - Account array
+ * @example
+ * updateWalletJSON([{
+            index: allAccounts.length,
+            address: newAccount.address,
+            privateKey: privKeyArr,
+            type: 'user-imported',
+            contracts: []
+        }]);
+ */
+export function updateWalletJSON(walletArr) {
+    const walletObj = serializeBigInts(walletArr);
+    fs.writeFileSync(walletJSONPath, JSON.stringify(walletObj, null, 2));
+}
+
+/**
+ * Returns wallets' object from saved json file
+ * @returns {Object}
+ */
+export function getWalletJSON() {
+    return JSON.parse(fs.readFileSync(walletJSONPath));
+}
+
+export function updateAccountMemory(allAccArr) {
+    let memAccArr = [];
+    let memHDAccArr = [];
+    for(let i = 0; i < allAccArr.length; i++) {
+        if(allAccArr[i].phrase) {
+            memHDAccArr.push(allAccArr[i])
+        } else {
+            memAccArr.push(allAccArr[i]);
+        }
+    }
+    return {
+        memAccArr,
+        memHDAccArr
+    }
+}
+
 /**
  * Get information for multiple accounts (internal)
  * @private
@@ -127,13 +179,6 @@ async function _getAccountInfo(_index) {
  * @returns {void}
  */
 function _deleteBySingIndex(_index) {
-    if (_index === null || _index === undefined) {
-        // Clear all arrays
-        allAccounts.splice(0);
-        accounts.splice(0);
-        hdAccounts.splice(0);
-        return;
-    }
 
     // Find and remove from allAccounts
     const accountIndex = allAccounts.findIndex(acc => acc.index === _index);
@@ -144,6 +189,9 @@ function _deleteBySingIndex(_index) {
         for (let i = accountIndex; i < allAccounts.length; i++) {
             allAccounts[i].index = i;
         }
+
+        // Update wallet json file
+        fs.writeFileSync(walletJSONPath, JSON.stringify(allAccounts, null, 2));
         
         // Remove from accounts array if it exists there
         const regularIndex = accounts.findIndex(acc => acc.index === _index);
@@ -210,4 +258,26 @@ function _findDupWalletByArr(privKeyArr) {
         return {
             status: false
         }
+}
+
+/**
+ * Removes all accounts from storage and memory
+ * @private
+ * @returns {null}
+ */
+function _deleteAll() {
+    allAccounts.splice(0);
+    accounts.splice(0);
+    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

@@ -167,3 +167,18 @@ export function build(fullPath, selectedContracts, buildPath){
   });
 }
 
+/**
+ * Extract loadable version format from full version string
+ * @param {string} fullVersion - Full version string (e.g., "0.8.20+commit.a1b79de6.Emscripten.clang")
+ * @returns {string} Loadable version format (e.g., "v0.8.20+commit.a1b79de6")
+ * @example
+ * extractLoadableVersion("0.8.20+commit.a1b79de6.Emscripten.clang"); // Returns: "v0.8.20+commit.a1b79de6"
+ */
+export function extractLoadableVersion(fullVersion) {
+  // Match version number and commit hash from full version string
+  const match = fullVersion.match(/(\d+\.\d+\.\d+)\+commit\.([a-f0-9]+)/);
+  if (!match) {
+    throw new Error(`Unable to extract version from: ${fullVersion}`);
+  }
+  return `v${match[1]}+commit.${match[2]}`;
+}

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/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);
+    }
+}

package/src/utils/typeGenerator.js

@@ -0,0 +1,247 @@
+/**
+ * @fileoverview TypeScript type generation from Solidity ABIs
+ * @description Generates type-safe TypeScript interfaces and classes
+ * from compiled Solidity contracts for use in TypeScript projects
+ * @module typeGenerator
+ */
+
+import path from 'path';
+import fs from 'fs';
+
+/**
+ * Generate TypeScript types from contract ABI
+ * @param {string} contractName - Name of the contract
+ * @param {Array} abi - Contract ABI array
+ * @param {string} outputPath - Output directory for types
+ * @returns {string} Path to generated type file
+ */
+export function generateContractTypes(contractName, abi, outputPath) {
+  try {
+    // Ensure output directory exists
+    if (!fs.existsSync(outputPath)) {
+      fs.mkdirSync(outputPath, { recursive: true });
+    }
+
+    // Generate TypeScript interfaces
+    const interfaces = generateInterfaces(contractName, abi);
+    const typePath = path.join(outputPath, `${contractName}.ts`);
+    
+    fs.writeFileSync(typePath, interfaces);
+    
+    return typePath;
+  } catch (error) {
+    console.error(`Error generating types for ${contractName}:`, error.message);
+    throw error;
+  }
+}
+
+/**
+ * Generate all TypeScript types from build artifacts
+ * @param {string} buildPath - Path to build directory with ABIs
+ * @param {string} typesOutputPath - Output directory for TypeScript types
+ * @returns {Array} Array of generated type file paths
+ */
+export function generateAllTypes(buildPath, typesOutputPath = './src/types') {
+  try {
+    const abisPath = path.join(buildPath, 'abis');
+    
+    if (!fs.existsSync(abisPath)) {
+      throw new Error(`ABIs directory not found at ${abisPath}`);
+    }
+
+    const abiFiles = fs.readdirSync(abisPath).filter(f => f.endsWith('.abi.json'));
+    const generatedFiles = [];
+
+    abiFiles.forEach(file => {
+      const contractName = file.replace('.abi.json', '');
+      const abiPath = path.join(abisPath, file);
+      const abi = JSON.parse(fs.readFileSync(abiPath, 'utf8'));
+      
+      const typePath = generateContractTypes(contractName, abi, typesOutputPath);
+      generatedFiles.push(typePath);
+    });
+
+    // Generate index.ts for barrel export
+    generateIndexFile(typesOutputPath, abiFiles);
+
+    return generatedFiles;
+  } catch (error) {
+    console.error('Error generating types:', error.message);
+    throw error;
+  }
+}
+
+/**
+ * Generate TypeScript interface from ABI
+ * @private
+ */
+function generateInterfaces(contractName, abi) {
+  const functions = abi.filter(item => item.type === 'function');
+  const events = abi.filter(item => item.type === 'event');
+  const structs = extractStructTypes(abi);
+
+  let typescript = `/**
+ * Auto-generated types for ${contractName} contract
+ * Generated from ABI
+ */
+
+// ============= TYPES =============
+${generateStructTypes(structs)}
+
+// ============= FUNCTION INPUTS =============
+${generateFunctionTypes(functions, 'input')}
+
+// ============= FUNCTION OUTPUTS =============
+${generateFunctionTypes(functions, 'output')}
+
+// ============= EVENT TYPES =============
+${generateEventTypes(events)}
+
+// ============= CONTRACT INTERFACE =============
+export interface I${contractName} {
+${generateContractMethods(functions)}
+}
+
+// ============= ABI EXPORT =============
+export const ${contractName}ABI = ${JSON.stringify(abi, null, 2)} as const;
+`;
+
+  return typescript;
+}
+
+/**
+ * Generate TypeScript types for function inputs/outputs
+ * @private
+ */
+function generateFunctionTypes(functions, direction) {
+  const lines = [];
+  
+  functions.forEach(func => {
+    const params = direction === 'input' ? func.inputs : func.outputs;
+    if (!params || params.length === 0) return;
+
+    const funcName = func.name;
+    const typeName = `${funcName.charAt(0).toUpperCase() + funcName.slice(1)}${direction === 'input' ? 'Params' : 'Result'}`;
+    
+    lines.push(`export interface ${typeName} {`);
+    params.forEach((param, idx) => {
+      const name = param.name || `param${idx}`;
+      const type = solToTsType(param.type);
+      lines.push(`  ${name}: ${type};`);
+    });
+    lines.push('}\n');
+  });
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate TypeScript types for events
+ * @private
+ */
+function generateEventTypes(events) {
+  const lines = [];
+  
+  events.forEach(event => {
+    const typeName = `${event.name}Event`;
+    lines.push(`export interface ${typeName} {`);
+    
+    event.inputs.forEach((input, idx) => {
+      const name = input.name || `param${idx}`;
+      const type = solToTsType(input.type);
+      const indexed = input.indexed ? ' // indexed' : '';
+      lines.push(`  ${name}: ${type};${indexed}`);
+    });
+    
+    lines.push('}\n');
+  });
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate contract method signatures
+ * @private
+ */
+function generateContractMethods(functions) {
+  const lines = [];
+  
+  functions.forEach(func => {
+    const inputs = func.inputs.map(inp => {
+      const type = solToTsType(inp.type);
+      return `${inp.name || 'param'}: ${type}`;
+    }).join(', ');
+    
+    let returnType = 'Promise<void>';
+    if (func.outputs && func.outputs.length > 0) {
+      if (func.outputs.length === 1) {
+        returnType = `Promise<${solToTsType(func.outputs[0].type)}>`;
+      } else {
+        returnType = `Promise<[${func.outputs.map(o => solToTsType(o.type)).join(', ')}]>`;
+      }
+    }
+
+    const stateMutability = func.stateMutability || 'nonpayable';
+    lines.push(`  ${func.name}(${inputs}): ${returnType}; // ${stateMutability}`);
+  });
+
+  return lines.join('\n');
+}
+
+/**
+ * Convert Solidity type to TypeScript type
+ * @private
+ */
+function solToTsType(solidityType) {
+  // Handle arrays
+  if (solidityType.endsWith(']')) {
+    const baseType = solidityType.replace(/\[\d*\]/g, '');
+    return `${solToTsType(baseType)}[]`;
+  }
+
+  // Handle base types
+  if (solidityType.startsWith('uint')) return 'bigint';
+  if (solidityType.startsWith('int')) return 'bigint';
+  if (solidityType.startsWith('bytes')) return 'string | Uint8Array';
+  if (solidityType === 'bool') return 'boolean';
+  if (solidityType === 'address') return 'string'; // EVM address as checksum string
+  if (solidityType === 'string') return 'string';
+  
+  // Fallback for custom types
+  return 'any';
+}
+
+/**
+ * Extract struct types from ABI
+ * @private
+ */
+function extractStructTypes(abi) {
+  // This would require more advanced parsing for tuple types
+  return [];
+}
+
+/**
+ * Generate struct type definitions
+ * @private
+ */
+function generateStructTypes(structs) {
+  if (structs.length === 0) return '// No custom structs\n';
+  
+  return structs.map(struct => `export interface ${struct.name} {\n  // struct fields\n}\n`).join('\n');
+}
+
+/**
+ * Generate barrel export index.ts
+ * @private
+ */
+function generateIndexFile(typesPath, abiFiles) {
+  const exports = abiFiles
+    .map(file => {
+      const name = file.replace('.abi.json', '');
+      return `export * from './${name}';`;
+    })
+    .join('\n');
+
+  const indexPath = path.join(typesPath, 'index.ts');
+  fs.writeFileSync(indexPath, `// Auto-generated barrel export\n${exports}\n`);
+}