ethershell 0.1.6-beta.0 → 0.2.0-beta.0

package/bin/cli.js

@@ -36,7 +36,7 @@ import {
     changeDefaultAccount
     } from '../src/services/wallet.js';
 
-import { deploy, add } from '../src/services/addContracts.js';
+import { deploy, add, restore } from '../src/services/addContracts.js';
 import { getContracts } from '../src/services/contracts.js';
 import { getConfigInfo, getDefaultAccount } from '../src/services/configSync.js';
 
@@ -97,3 +97,4 @@ r.context.addContract = add;
 
 // Contract
 r.context.contracts = getContracts;
+r.context.restoreContract = restore;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ethershell",
   "license": "MIT",
-  "version": "0.1.6-beta.0",
+  "version": "0.2.0-beta.0",
   "description": "Interactive JavaScript console for Ethereum smart contract management",
   "author": "Alireza Kiakojouri (alirezaethdev@gmail.com)",
   "repository": {

package/src/services/addContracts.js

@@ -17,6 +17,10 @@ import { LocalStorage } from 'node-localstorage';
 import { r } from '../../bin/cli.js';
 import { createContractProxy } from '../utils/contractProxy.js';
 import { eventOf } from '../utils/event.js';
+import {
+    updateContractJSON,
+    getContractJSON
+} from '../utils/contractLister.js';
 
 /**
  * Local storage instance for persisting contract metadata
@@ -28,7 +32,29 @@ const localStorage = new LocalStorage('./ethershell');
  * Map of all deployed and added contracts
  * @type {Map<string, ethers.Contract>}
  */
-export const contracts = new Map();
+export const contracts = getContractJSON();
+
+/**
+ * Instantiate stored contracts to interact with the shell
+ */
+export async function restore() {
+    if(contracts) {
+        console.info(`Stored contracts instantiating ...`);
+        const contractsLength = contracts.length;
+        for(let i = 0; i < contractsLength; i++) {
+            await _add(
+                contracts[i].name,
+                contracts[i].address,
+                configFile.defaultWallet.index,
+                contracts[i].abiPath
+            );
+        }
+        console.info(`All stored contracts instantiated!`);
+    } else {
+        return `The storage is empty!`;
+    }
+}
+
 
 /**
  * Deploy a new smart contract to the blockchain
@@ -92,13 +118,13 @@ export async function deploy(contractName, args, accIndex, chain, abiLoc, byteco
 
         allAccounts[accIndex].contracts.push(contSpec);
 
-        // Extend contract object
-        deployTx.index = Array.from(contracts.values()).length;
-        deployTx.name = contractName;
-        deployTx.chain = connectedChain.name;
-        deployTx.chainId = connectedChain.chainId;
-        deployTx.deployType = 'ethershell-deployed',
-        deployTx.provider = currentProvider;
+        // Decorate contract instance with metadata
+        deployTx._contractIndex = contracts.length;
+        deployTx._contractName = contractName;
+        deployTx._contractChain = connectedChain.name;
+        deployTx._contractChainId = connectedChain.chainId;
+        deployTx._contractDeployType = 'ethershell-deployed',
+        deployTx._contractProvider = currentProvider;
 
         //////////////////////////////////
 
@@ -110,16 +136,31 @@ export async function deploy(contractName, args, accIndex, chain, abiLoc, byteco
         // Wrap the contract instace with proxy
         const proxiedContract = createContractProxy(contractInstance, currentProvider, allAccounts);
 
-        proxiedContract.index = Array.from(contracts.values()).length;
-        proxiedContract.name = contractName;
-        proxiedContract.chain = connectedChain.name;
-        proxiedContract.chainId = connectedChain.chainId;
-        proxiedContract.deployType = 'ethershell-deployed';
-        proxiedContract.provider = currentProvider;
+        proxiedContract._contractIndex = contracts.length;
+        proxiedContract._contractName = contractName;
+        proxiedContract._contractChain = connectedChain.name;
+        proxiedContract._contractChainId = connectedChain.chainId;
+        proxiedContract._contractDeployType = 'ethershell-deployed';
+        proxiedContract._contractProvider = currentProvider;
+        proxiedContract._contractABIPath = abiPath;
 
         // Add to REPL context with proxy
         r.context[contractName] = proxiedContract;
-        contracts.set(contractName, proxiedContract);
+
+        const contracToStore = {
+            index: proxiedContract._contractIndex,
+            name: proxiedContract._contractName,
+            address: proxiedContract.target,
+            chain: proxiedContract._contractChain,
+            chainId: proxiedContract._contractChainId,
+            deployType: proxiedContract._contractDeployType,
+            balance: await proxiedContract.provider.getBalance(proxiedContract.target),
+            abiPath: proxiedContract._contractABIPath
+        }
+        contracts.push(contracToStore);
+
+        // Update contracts.json
+        updateContractJSON(contracts);
 
         ////////////////////////////////////////////
 
@@ -131,12 +172,12 @@ export async function deploy(contractName, args, accIndex, chain, abiLoc, byteco
         const tx1 = await provider.getTransactionReceipt(deployHash);
         const eventValues = eventOf(contractInstance, tx1);
 
-        // Extend transaction object
-        tx.ethershellIndex = deployTx.index;
+        // Decorate transaction object with metadata
+        tx.ethershellIndex = deployTx._contractIndex;
         tx.address = deployTx.target;
-        tx.name = deployTx.name;
-        tx.chain = deployTx.chain;
-        tx.deployType = deployTx.deployType;
+        tx.name = deployTx._contractName;
+        tx.chain = deployTx._contractChain;
+        tx.deployType = deployTx._contractDeployType;
 
         if(eventValues) {
             tx.eventValues = eventValues;
@@ -163,77 +204,112 @@ export async function deploy(contractName, args, accIndex, chain, abiLoc, byteco
  */
 export async function add(contractName, contractAddr, accIndex, abiLoc, chain) {
     try {
-        let currentProvider;
-        let connectedChain;
-        let wallet;
-
-        if(!contractAddr) {
-            throw new Error('Contract address may not be null or undefined!');
-        }
-
-        if(chain) {
-            currentProvider = new ethers.JsonRpcProvider(chain);
-        } else {
-            currentProvider = provider;
-        }
-
-        if(!accIndex && accIndex !== 0) {
-            accIndex = configFile.defaultWallet.index;
+        const result = await _add(contractName, contractAddr, accIndex, abiLoc, chain);
+        
+        // Decorate contract object
+        const contracToStore = {
+            index: result.index,
+            name: result.name,
+            address: result.address,
+            chain: result.chain,
+            chainId: result.chainId,
+            deployType: result.deployType,
+            balance: await result.provider.getBalance(result.address),
+            abiPath: abiLoc
         }
+        // Update contracts array
+        contracts.push(contracToStore);
 
-        wallet = new ethers.Wallet(allAccounts[accIndex].privateKey, currentProvider);
-        connectedChain = await currentProvider.getNetwork();
+        // Update contracts.json
+        updateContractJSON(contracts);
 
-        const abiPath = abiLoc || localStorage.getItem(`${contractName}_abi`);
-        const abi  = JSON.parse(fs.readFileSync(abiPath, 'utf8'));
-
-        const newContract = new ethers.Contract(contractAddr, abi, wallet);
-
-        // Create contract proxy
-        // Wrap the contract instace with proxy
-        const proxiedContract = createContractProxy(newContract, currentProvider, allAccounts);
+        return result;
+    } catch(err) {
+        console.error(err);
+    }
+}
 
-        proxiedContract.index = Array.from(contracts.values()).length;
-        proxiedContract.name = contractName;
-        proxiedContract.chain = connectedChain.name;
-        proxiedContract.chainId = connectedChain.chainId;
-        proxiedContract.deployType = 'ethershell-deployed';
-        proxiedContract.provider = currentProvider;
+async function _add(contractName, contractAddr, accIndex, abiLoc, chain) {
+    let currentProvider;
+    let connectedChain;
+    let wallet;
 
-        // Add to REPL context with proxy
-        r.context[contractName] = proxiedContract;
-        contracts.set(contractName, proxiedContract);
+    if(!contractAddr) {
+        throw new Error('Contract address may not be null or undefined!');
+    }
 
-        // Update deployer contract list
-        const contSpec = {
-            address: newContract.target,
-            deployedOn: connectedChain.name,
-            chainId: connectedChain.chainId
-        }
+    if(chain) {
+        currentProvider = new ethers.JsonRpcProvider(chain);
+    } else {
+        currentProvider = provider;
+    }
 
-        allAccounts[accIndex].contracts.push(contSpec);
+    if(!accIndex && accIndex !== 0) {
+        accIndex = configFile.defaultWallet.index;
+    }
 
-        // Extend contract object
-        newContract.index = Array.from(contracts.values()).length;
-        newContract.name = contractName;
-        newContract.chain = connectedChain.name;
-        newContract.chainId = connectedChain.chainId;
-        newContract.deployType = 'pre-deployed',
-        newContract.provider = currentProvider;
-
-        // Add result
-        const result = {
-            index: newContract.index,
-            name: newContract.name,
-            address: newContract.target,
-            chain: newContract.chain,
-            chainId: newContract.chainId,
-            deployType: newContract.deployType,
-            provider: newContract.provider
-        }
+    wallet = new ethers.Wallet(allAccounts[accIndex].privateKey, currentProvider);
+    connectedChain = await currentProvider.getNetwork();
+
+    const abiPath = abiLoc || localStorage.getItem(`${contractName}_abi`);
+    const abi  = JSON.parse(fs.readFileSync(abiPath, 'utf8'));
+
+    const newContract = new ethers.Contract(contractAddr, abi, wallet);
+
+    // Create contract proxy
+    // Wrap the contract instace with proxy
+    const proxiedContract = createContractProxy(newContract, currentProvider, allAccounts);
+
+    proxiedContract._contractIndex = contracts.length;
+    proxiedContract._contractName = contractName;
+    proxiedContract._contractChain = connectedChain.name;
+    proxiedContract._contractChainId = connectedChain.chainId;
+    proxiedContract._contractDeployType = 'ethershell-deployed';
+    proxiedContract._contractProvider = currentProvider;
+    proxiedContract._contractABIPath = abiPath;
+
+    // Add to REPL context with proxy
+    r.context[contractName] = proxiedContract;
+    
+    // const contracToStore = {
+    //     index: proxiedContract._contractIndex,
+    //     name: proxiedContract._contractName,
+    //     address: proxiedContract.target,
+    //     chain: proxiedContract._contractChain,
+    //     chainId: proxiedContract._contractChainId,
+    //     deployType: proxiedContract._contractDeployType,
+    //     balance: await proxiedContract.provider.getBalance(proxiedContract.target),
+    //     abiPath: proxiedContract._contractABIPath
+    // }
+    // contracts.push(contracToStore);
+
+    // Update deployer contract list
+    const contSpec = {
+        address: newContract.target,
+        deployedOn: connectedChain.name,
+        chainId: connectedChain.chainId
+    }
 
-        return result;
-    } catch(err) {
-        console.error(err);
+    allAccounts[accIndex].contracts.push(contSpec);
+
+    // Decorate contract instance with metadata
+    newContract._contractIndex = contracts.length + 1;
+    newContract._contractName = contractName;
+    newContract._contractChain = connectedChain.name;
+    newContract._contractChainId = connectedChain.chainId;
+    newContract._contractDeployType = 'pre-deployed',
+    newContract._contractProvider = currentProvider;
+
+    // Add result
+    const result = {
+        index: newContract._contractIndex,
+        name: newContract._contractName,
+        address: newContract.target,
+        chain: newContract._contractChain,
+        chainId: newContract._contractChainId,
+        deployType: newContract._contractDeployType,
+        provider: newContract._contractProvider
     }
+
+    return result;
 }

package/src/services/configSync.js

@@ -1,11 +1,12 @@
 import { 
     loadSolcVersion, 
-    extractLoadableVersion 
+    extractLoadableVersion
 } from '../utils/builder.js';
 import { allAccounts } from './wallet.js';
 import { serializeBigInts } from '../utils/serialize.js';
 import fs from 'fs';
 import { ethers } from 'ethers';
+import solc from 'solc';
 
 // Sync Config Memory with Storage Config:
 /**
@@ -98,7 +99,8 @@ if(storedUrl) {
 
 // 3) Set Compiler to Memory:
 // Initialize global configuration of compiler
-if(storedCompConfig){
+// if(storedCompConfig){
+if(false){
   configFile.compiler = storedCompConfig.compiler;
   console.info(`Compiler is loading ...`);
   compConfig.currentSolcInstance = await loadSolcVersion(configFile.compiler.version);

package/src/utils/contractLister.js

@@ -6,6 +6,14 @@
  */
 
 import { contracts } from '../services/addContracts.js';
+import fs from 'fs';
+import { serializeBigInts } from './serialize.js'
+import { provider } from '../services/configSync.js';
+
+/**
+ * 
+ */
+const contractJSONPath = './ethershell/contracts.json';
 
 /**
  * Get array of all contracts with their information
@@ -20,18 +28,54 @@ import { contracts } from '../services/addContracts.js';
 export async function getContArr() {
     let contractsArray = [];
 
-    for (const x of contracts.values()) {
-        let contract = {
+    for (const x of contracts) {
+        const balance = await provider.getBalance(x.address);
+
+        contractsArray.push({
             index: x.index,
             name: x.name,
-            address: x.target,
+            address: x.address,
             chain: x.chain,
             chainId: x.chainId,
             deployType: x.deployType,
-            balance: await x.provider.getBalance(x.target)
-        }
-        contractsArray.push(contract);
+            balance,
+            abiPath: x.abiPath
+        });
     }
 
     return contractsArray;
+}
+
+/**
+ * Writes/Updates contracts json file
+ * @param {Array<string>} contractArr - Contract array
+ * @example
+ * updateContractJSON([{
+                ...
+        }]);
+ */
+export function updateContractJSON(contractArr) {
+    const contractObj = serializeBigInts(contractArr);
+    fs.writeFileSync(contractJSONPath, JSON.stringify(contractObj, null, 2));
+}
+
+/**
+ * Returns pre-added/deployed contracts' objects from saved json file
+ * @returns {Object}
+ */
+export function getContractJSON(){
+    if(fs.existsSync(contractJSONPath)){
+        const contractJSON = fs.readFileSync(contractJSONPath, 'utf8');
+        // Return empty array if contratcs.json is empty
+        if(contractJSON.length === 0) {
+            return [];
+        } else {
+            return JSON.parse(fs.readFileSync(contractJSONPath));
+        }
+    } else {
+        // Generate empty contracts.json if it doesn't exist
+        const fd = fs.openSync(contractJSONPath, 'w');
+        fs.closeSync(fd);
+        return [];
+    }
 }