Initilization

.deps/remix-tests/remix_accounts.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity >=0.4.22 <0.9.0;
+
+library TestsAccounts {
+    function getAccount(uint index) pure public returns (address) {
+        address[15] memory accounts;
+		accounts[0] = 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4;
+
+		accounts[1] = 0xAb8483F64d9C6d1EcF9b849Ae677dD3315835cb2;
+
+		accounts[2] = 0x4B20993Bc481177ec7E8f571ceCaE8A9e22C02db;
+
+		accounts[3] = 0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB;
+
+		accounts[4] = 0x617F2E2fD72FD9D5503197092aC168c91465E7f2;
+
+		accounts[5] = 0x17F6AD8Ef982297579C203069C1DbfFE4348c372;
+
+		accounts[6] = 0x5c6B0f7Bf3E7ce046039Bd8FABdfD3f9F5021678;
+
+		accounts[7] = 0x03C6FcED478cBbC9a4FAB34eF9f40767739D1Ff7;
+
+		accounts[8] = 0x1aE0EA34a72D944a8C7603FfB3eC30a6669E454C;
+
+		accounts[9] = 0x0A098Eda01Ce92ff4A4CCb7A4fFFb5A43EBC70DC;
+
+		accounts[10] = 0xCA35b7d915458EF540aDe6068dFe2F44E8fa733c;
+
+		accounts[11] = 0x14723A09ACff6D2A60DcdF7aA4AFf308FDDC160C;
+
+		accounts[12] = 0x4B0897b0513fdC7C541B6d9D7E929C4e5364D2dB;
+
+		accounts[13] = 0x583031D1113aD414F02576BD6afaBfb302140225;
+
+		accounts[14] = 0xdD870fA1b7C4700F2BD7f44238821C26f7392148;
+return accounts[index];
+    }
+}

.deps/remix-tests/remix_tests.sol

@@ -0,0 +1,225 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity >=0.4.22 <0.9.0;
+
+library Assert {
+
+  event AssertionEvent(
+    bool passed,
+    string message,
+    string methodName
+  );
+
+  event AssertionEventUint(
+    bool passed,
+    string message,
+    string methodName,
+    uint256 returned,
+    uint256 expected
+  );
+
+  event AssertionEventInt(
+    bool passed,
+    string message,
+    string methodName,
+    int256 returned,
+    int256 expected
+  );
+
+  event AssertionEventBool(
+    bool passed,
+    string message,
+    string methodName,
+    bool returned,
+    bool expected
+  );
+
+  event AssertionEventAddress(
+    bool passed,
+    string message,
+    string methodName,
+    address returned,
+    address expected
+  );
+
+  event AssertionEventBytes32(
+    bool passed,
+    string message,
+    string methodName,
+    bytes32 returned,
+    bytes32 expected
+  );
+
+  event AssertionEventString(
+    bool passed,
+    string message,
+    string methodName,
+    string returned,
+    string expected
+  );
+
+  event AssertionEventUintInt(
+    bool passed,
+    string message,
+    string methodName,
+    uint256 returned,
+    int256 expected
+  );
+
+  event AssertionEventIntUint(
+    bool passed,
+    string message,
+    string methodName,
+    int256 returned,
+    uint256 expected
+  );
+
+  function ok(bool a, string memory message) public returns (bool result) {
+    result = a;
+    emit AssertionEvent(result, message, "ok");
+  }
+
+  function equal(uint256 a, uint256 b, string memory message) public returns (bool result) {
+    result = (a == b);
+    emit AssertionEventUint(result, message, "equal", a, b);
+  }
+
+  function equal(int256 a, int256 b, string memory message) public returns (bool result) {
+    result = (a == b);
+    emit AssertionEventInt(result, message, "equal", a, b);
+  }
+
+  function equal(bool a, bool b, string memory message) public returns (bool result) {
+    result = (a == b);
+    emit AssertionEventBool(result, message, "equal", a, b);
+  }
+
+  // TODO: only for certain versions of solc
+  //function equal(fixed a, fixed b, string message) public returns (bool result) {
+  //  result = (a == b);
+  //  emit AssertionEvent(result, message);
+  //}
+
+  // TODO: only for certain versions of solc
+  //function equal(ufixed a, ufixed b, string message) public returns (bool result) {
+  //  result = (a == b);
+  //  emit AssertionEvent(result, message);
+  //}
+
+  function equal(address a, address b, string memory message) public returns (bool result) {
+    result = (a == b);
+    emit AssertionEventAddress(result, message, "equal", a, b);
+  }
+
+  function equal(bytes32 a, bytes32 b, string memory message) public returns (bool result) {
+    result = (a == b);
+    emit AssertionEventBytes32(result, message, "equal", a, b);
+  }
+
+  function equal(string memory a, string memory b, string memory message) public returns (bool result) {
+     result = (keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b)));
+     emit AssertionEventString(result, message, "equal", a, b);
+  }
+
+  function notEqual(uint256 a, uint256 b, string memory message) public returns (bool result) {
+    result = (a != b);
+    emit AssertionEventUint(result, message, "notEqual", a, b);
+  }
+
+  function notEqual(int256 a, int256 b, string memory message) public returns (bool result) {
+    result = (a != b);
+    emit AssertionEventInt(result, message, "notEqual", a, b);
+  }
+
+  function notEqual(bool a, bool b, string memory message) public returns (bool result) {
+    result = (a != b);
+    emit AssertionEventBool(result, message, "notEqual", a, b);
+  }
+
+  // TODO: only for certain versions of solc
+  //function notEqual(fixed a, fixed b, string message) public returns (bool result) {
+  //  result = (a != b);
+  //  emit AssertionEvent(result, message);
+  //}
+
+  // TODO: only for certain versions of solc
+  //function notEqual(ufixed a, ufixed b, string message) public returns (bool result) {
+  //  result = (a != b);
+  //  emit AssertionEvent(result, message);
+  //}
+
+  function notEqual(address a, address b, string memory message) public returns (bool result) {
+    result = (a != b);
+    emit AssertionEventAddress(result, message, "notEqual", a, b);
+  }
+
+  function notEqual(bytes32 a, bytes32 b, string memory message) public returns (bool result) {
+    result = (a != b);
+    emit AssertionEventBytes32(result, message, "notEqual", a, b);
+  }
+
+  function notEqual(string memory a, string memory b, string memory message) public returns (bool result) {
+    result = (keccak256(abi.encodePacked(a)) != keccak256(abi.encodePacked(b)));
+    emit AssertionEventString(result, message, "notEqual", a, b);
+  }
+
+  /*----------------- Greater than --------------------*/
+  function greaterThan(uint256 a, uint256 b, string memory message) public returns (bool result) {
+    result = (a > b);
+    emit AssertionEventUint(result, message, "greaterThan", a, b);
+  }
+
+  function greaterThan(int256 a, int256 b, string memory message) public returns (bool result) {
+    result = (a > b);
+    emit AssertionEventInt(result, message, "greaterThan", a, b);
+  }
+  // TODO: safely compare between uint and int
+  function greaterThan(uint256 a, int256 b, string memory message) public returns (bool result) {
+    if(b < int(0)) {
+      // int is negative uint "a" always greater
+      result = true;
+    } else {
+      result = (a > uint(b));
+    }
+    emit AssertionEventUintInt(result, message, "greaterThan", a, b);
+  }
+  function greaterThan(int256 a, uint256 b, string memory message) public returns (bool result) {
+    if(a < int(0)) {
+      // int is negative uint "b" always greater
+      result = false;
+    } else {
+      result = (uint(a) > b);
+    }
+    emit AssertionEventIntUint(result, message, "greaterThan", a, b);
+  }
+  /*----------------- Lesser than --------------------*/
+  function lesserThan(uint256 a, uint256 b, string memory message) public returns (bool result) {
+    result = (a < b);
+    emit AssertionEventUint(result, message, "lesserThan", a, b);
+  }
+
+  function lesserThan(int256 a, int256 b, string memory message) public returns (bool result) {
+    result = (a < b);
+    emit AssertionEventInt(result, message, "lesserThan", a, b);
+  }
+  // TODO: safely compare between uint and int
+  function lesserThan(uint256 a, int256 b, string memory message) public returns (bool result) {
+    if(b < int(0)) {
+      // int is negative int "b" always lesser
+      result = false;
+    } else {
+      result = (a < uint(b));
+    }
+    emit AssertionEventUintInt(result, message, "lesserThan", a, b);
+  }
+
+  function lesserThan(int256 a, uint256 b, string memory message) public returns (bool result) {
+    if(a < int(0)) {
+      // int is negative int "a" always lesser
+      result = true;
+    } else {
+      result = (uint(a) < b);
+    }
+    emit AssertionEventIntUint(result, message, "lesserThan", a, b);
+  }
+}

.github/workflows/cicd_v1.yml

@@ -0,0 +1,20 @@
+name: Quality Gate
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    types: [opened, synchronize, reopened]
+jobs:
+  sonarcloud:
+    name: SonarCloud
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
+      - name: SonarCloud Scan
+        uses: SonarSource/sonarcloud-github-action@master
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}  # Needed to get PR information, if any
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

.gitignore

@@ -0,0 +1,14 @@
+old
+artifacts
+node_modules
+node_modules
+.env
+coverage
+coverage.json
+typechain
+typechain-types
+
+# Hardhat files
+cache
+artifacts
+

.prettierrc.json

@@ -0,0 +1,38 @@
+{
+    "overrides": [
+        {
+            "files": "*.sol",
+            "options": {
+                "printWidth": 80,
+                "tabWidth": 4,
+                "useTabs": false,
+                "singleQuote": false,
+                "bracketSpacing": false
+            }
+        },
+        {
+            "files": "*.yml",
+            "options": {}
+        },
+        {
+            "files": "*.yaml",
+            "options": {}
+        },
+        {
+            "files": "*.toml",
+            "options": {}
+        },
+        {
+            "files": "*.json",
+            "options": {}
+        },
+        {
+            "files": "*.js",
+            "options": {}
+        },
+        {
+            "files": "*.ts",
+            "options": {}
+        }
+    ]
+}

.solcover.js

@@ -0,0 +1,3 @@
+module.exports = {
+    configureYulOptimizer: true,
+  };

Readme.md

@@ -1,3 +1,33 @@
 # Contracts 
 
 is the smart contracts repository of echotrade
+
+REMIX DEFAULT WORKSPACE
+
+Remix default workspace is present when:
+i. Remix loads for the very first time 
+ii. A new workspace is created with 'Default' template
+iii. There are no files existing in the File Explorer
+
+This workspace contains 3 directories:
+
+1. 'contracts': Holds three contracts with increasing levels of complexity.
+2. 'scripts': Contains four typescript files to deploy a contract. It is explained below.
+3. 'tests': Contains one Solidity test file for 'Ballot' contract & one JS test file for 'Storage' contract.
+
+SCRIPTS
+
+The 'scripts' folder has four typescript files which help to deploy the 'Storage' contract using 'web3.js' and 'ethers.js' libraries.
+
+For the deployment of any other contract, just update the contract's name from 'Storage' to the desired contract and provide constructor arguments accordingly 
+in the file `deploy_with_ethers.ts` or  `deploy_with_web3.ts`
+
+In the 'tests' folder there is a script containing Mocha-Chai unit tests for 'Storage' contract.
+
+To run a script, right click on file name in the file explorer and click 'Run'. Remember, Solidity file must already be compiled.
+Output from script will appear in remix terminal.
+
+Please note, require/import is supported in a limited manner for Remix supported modules.
+For now, modules supported by Remix are ethers, web3, swarmgw, chai, multihashes, remix and hardhat only for hardhat.ethers object/plugin.
+For unsupported modules, an error like this will be thrown: '<module_name> module require is not supported by Remix IDE' will be shown.
+