polkamarkets-js 1.0.2 → 3.1.1

package/tests/votingContract.js

@@ -0,0 +1,490 @@
+
+
+import { expect } from 'chai';
+
+import { mochaAsync } from './utils';
+import { Application } from '..';
+
+context('Voting Contract', async () => {
+  require('dotenv').config();
+
+  let app;
+  let votingContract;
+  let ERC20Contract;
+
+  context('Contract Deployment', async () => {
+    it('should start the Application', mochaAsync(async () => {
+      app = new Application({
+        web3Provider: process.env.WEB3_PROVIDER,
+        web3PrivateKey: process.env.WEB3_PRIVATE_KEY,
+      });
+
+      expect(app).to.not.equal(null);
+    }));
+
+    it('should deploy Voting Contract', mochaAsync(async () => {
+      // Create Contract
+      votingContract = app.getVotingContract({});
+      ERC20Contract = app.getERC20Contract({});
+      // // Deploy
+      await ERC20Contract.deploy({ params: ['Polkamarkets', 'POLK'] });
+
+      const ERC20ContractAddress = ERC20Contract.getAddress();
+
+      await votingContract.deploy({
+        params: [
+          ERC20ContractAddress,
+          0
+        ]
+      });
+      const votingContractAddress = votingContract.getAddress();
+
+      expect(votingContractAddress).to.not.equal(null);
+    }));
+  });
+
+  context('Voting Items', async () => {
+    it('should upvote an Item', mochaAsync(async () => {
+      let itemId = 0;
+
+      // chek if there are no votes
+      let itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(0);
+      expect(itemVotes.downvotes).to.equal(0);
+
+      const user = await votingContract.getMyAccount();
+
+      let userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(false);
+      expect(userVoted.downvoted).to.equal(false);
+
+      const res = await votingContract.upvoteItem({
+        itemId,
+      });
+
+      expect(res.status).to.equal(true);
+
+      itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(1);
+      expect(itemVotes.downvotes).to.equal(0);
+
+
+      userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(true);
+      expect(userVoted.downvoted).to.equal(false);
+
+      // Validate User Votes
+      const userVotes = await votingContract.getUserVotes({ user });
+      expect(Object.keys(userVotes).length).to.equal(1);
+      expect(userVotes[0].upvoted).to.equal(true);
+      expect(userVotes[0].downvoted).to.equal(false);
+    }));
+
+    it('should downvote an Item', mochaAsync(async () => {
+      let itemId = 1;
+
+      // chek if there are no votes
+      let itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(0);
+      expect(itemVotes.downvotes).to.equal(0);
+
+      const user = await votingContract.getMyAccount();
+
+      let userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(false);
+      expect(userVoted.downvoted).to.equal(false);
+
+      const res = await votingContract.downvoteItem({
+        itemId,
+      });
+
+      expect(res.status).to.equal(true);
+
+      itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(0);
+      expect(itemVotes.downvotes).to.equal(1);
+
+      userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(false);
+      expect(userVoted.downvoted).to.equal(true);
+
+      // Validate User Votes
+      const userVotes = await votingContract.getUserVotes({ user });
+      expect(Object.keys(userVotes).length).to.equal(2);
+      expect(userVotes[0].upvoted).to.equal(true);
+      expect(userVotes[0].downvoted).to.equal(false);
+      expect(userVotes[1].upvoted).to.equal(false);
+      expect(userVotes[1].downvoted).to.equal(true);
+    }));
+
+    it('should upvote an Item when there is already a downvote', mochaAsync(async () => {
+      let itemId = 1;
+
+      // check first if user has a downvote
+      let itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(0);
+      expect(itemVotes.downvotes).to.equal(1);
+
+      const user = await votingContract.getMyAccount();
+
+      let userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(false);
+      expect(userVoted.downvoted).to.equal(true);
+
+
+      const res = await votingContract.upvoteItem({
+        itemId,
+      });
+
+      expect(res.status).to.equal(true);
+
+      itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(1);
+      expect(itemVotes.downvotes).to.equal(0);
+
+
+      userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(true);
+      expect(userVoted.downvoted).to.equal(false);
+
+      // Validate User Votes
+      const userVotes = await votingContract.getUserVotes({ user });
+      expect(Object.keys(userVotes).length).to.equal(2);
+      expect(userVotes[0].upvoted).to.equal(true);
+      expect(userVotes[0].downvoted).to.equal(false);
+      expect(userVotes[1].upvoted).to.equal(true);
+      expect(userVotes[1].downvoted).to.equal(false);
+    }));
+
+    it('should downvote an Item when there is already an upvote', mochaAsync(async () => {
+      let itemId = 0;
+
+      // check first if user has an upvote
+      let itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(1);
+      expect(itemVotes.downvotes).to.equal(0);
+
+      const user = await votingContract.getMyAccount();
+
+      let userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(true);
+      expect(userVoted.downvoted).to.equal(false);
+
+
+      const res = await votingContract.downvoteItem({
+        itemId,
+      });
+
+      expect(res.status).to.equal(true);
+
+      itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(0);
+      expect(itemVotes.downvotes).to.equal(1);
+
+
+      userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(false);
+      expect(userVoted.downvoted).to.equal(true);
+
+      // Validate User Votes
+      const userVotes = await votingContract.getUserVotes({ user });
+      expect(Object.keys(userVotes).length).to.equal(2);
+      expect(userVotes[0].upvoted).to.equal(false);
+      expect(userVotes[0].downvoted).to.equal(true);
+      expect(userVotes[1].upvoted).to.equal(true);
+      expect(userVotes[1].downvoted).to.equal(false);
+    }));
+
+    it('should not allow to upvote an already upvoted item', mochaAsync(async () => {
+      let itemId = 1;
+
+      // check first if user has an upvote
+      let itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(1);
+      expect(itemVotes.downvotes).to.equal(0);
+
+      const user = await votingContract.getMyAccount();
+
+      let userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(true);
+      expect(userVoted.downvoted).to.equal(false);
+
+      let res
+      try {
+        res = await votingContract.upvoteItem({
+          itemId,
+        });
+      } catch (error) {
+        res = { status: false };
+      }
+
+      expect(res.status).to.equal(false);
+
+      itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(1);
+      expect(itemVotes.downvotes).to.equal(0);
+
+
+      userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(true);
+      expect(userVoted.downvoted).to.equal(false);
+
+      // Validate User Votes
+      const userVotes = await votingContract.getUserVotes({ user });
+      expect(Object.keys(userVotes).length).to.equal(2);
+      expect(userVotes[0].upvoted).to.equal(false);
+      expect(userVotes[0].downvoted).to.equal(true);
+      expect(userVotes[1].upvoted).to.equal(true);
+      expect(userVotes[1].downvoted).to.equal(false);
+    }));
+
+    it('should not allow to downvote an already downvoted item', mochaAsync(async () => {
+      let itemId = 0;
+
+      // check first if user has a downvote
+      let itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(0);
+      expect(itemVotes.downvotes).to.equal(1);
+
+      const user = await votingContract.getMyAccount();
+
+      let userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(false);
+      expect(userVoted.downvoted).to.equal(true);
+
+      let res
+      try {
+        res = await votingContract.downvoteItem({
+          itemId,
+        });
+      } catch (error) {
+        res = { status: false };
+      }
+
+      expect(res.status).to.equal(false);
+
+      itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(0);
+      expect(itemVotes.downvotes).to.equal(1);
+
+
+      userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(false);
+      expect(userVoted.downvoted).to.equal(true);
+
+      // Validate User Votes
+      const userVotes = await votingContract.getUserVotes({ user });
+      expect(Object.keys(userVotes).length).to.equal(2);
+      expect(userVotes[0].upvoted).to.equal(false);
+      expect(userVotes[0].downvoted).to.equal(true);
+      expect(userVotes[1].upvoted).to.equal(true);
+      expect(userVotes[1].downvoted).to.equal(false);
+    }));
+
+    it('should allow to remove upvote of an already upvoted item', mochaAsync(async () => {
+      let itemId = 1;
+
+      // check first if user has an upvote
+      let itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(1);
+      expect(itemVotes.downvotes).to.equal(0);
+
+      const user = await votingContract.getMyAccount();
+
+      let userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(true);
+      expect(userVoted.downvoted).to.equal(false);
+
+
+      const res = await votingContract.removeUpvoteItem({
+        itemId,
+      });
+
+      expect(res.status).to.equal(true);
+
+      itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(0);
+      expect(itemVotes.downvotes).to.equal(0);
+
+
+      userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(false);
+      expect(userVoted.downvoted).to.equal(false);
+
+      // Validate User Votes
+      const userVotes = await votingContract.getUserVotes({ user });
+      expect(Object.keys(userVotes).length).to.equal(2);
+      expect(userVotes[0].upvoted).to.equal(false);
+      expect(userVotes[0].downvoted).to.equal(true);
+      expect(userVotes[1].upvoted).to.equal(false);
+      expect(userVotes[1].downvoted).to.equal(false);
+    }));
+
+    it('should allow to remove downvote of an already downvoted item', mochaAsync(async () => {
+      let itemId = 0;
+
+      // check first if user has a downvote
+      let itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(0);
+      expect(itemVotes.downvotes).to.equal(1);
+
+      const user = await votingContract.getMyAccount();
+
+      let userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(false);
+      expect(userVoted.downvoted).to.equal(true);
+
+
+      const res = await votingContract.removeDownvoteItem({
+        itemId,
+      });
+
+      expect(res.status).to.equal(true);
+
+      itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(0);
+      expect(itemVotes.downvotes).to.equal(0);
+
+
+      userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(false);
+      expect(userVoted.downvoted).to.equal(false);
+
+      // Validate User Votes
+      const userVotes = await votingContract.getUserVotes({ user });
+      expect(Object.keys(userVotes).length).to.equal(2);
+      expect(userVotes[0].upvoted).to.equal(false);
+      expect(userVotes[0].downvoted).to.equal(false);
+      expect(userVotes[1].upvoted).to.equal(false);
+      expect(userVotes[1].downvoted).to.equal(false);
+    }));
+
+    it('should not allow to remove upvote of an item not upvoted', mochaAsync(async () => {
+      let itemId = 1;
+
+      // check first if user does not have an upvote
+      let itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(0);
+      expect(itemVotes.downvotes).to.equal(0);
+
+      const user = await votingContract.getMyAccount();
+
+      let userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(false);
+      expect(userVoted.downvoted).to.equal(false);
+
+
+      let res
+      try {
+        res = await votingContract.removeUpvoteItem({
+          itemId,
+        });
+      } catch (error) {
+        res = { status: false };
+      }
+
+      expect(res.status).to.equal(false);
+
+      itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(0);
+      expect(itemVotes.downvotes).to.equal(0);
+
+
+      userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(false);
+      expect(userVoted.downvoted).to.equal(false);
+
+      // Validate User Votes
+      const userVotes = await votingContract.getUserVotes({ user });
+      expect(Object.keys(userVotes).length).to.equal(2);
+      expect(userVotes[0].upvoted).to.equal(false);
+      expect(userVotes[0].downvoted).to.equal(false);
+      expect(userVotes[1].upvoted).to.equal(false);
+      expect(userVotes[1].downvoted).to.equal(false);
+    }));
+
+    it('should not allow to remove downvote of an item not downvoted', mochaAsync(async () => {
+      let itemId = 0;
+
+      // check first if user does not have a downvote
+      let itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(0);
+      expect(itemVotes.downvotes).to.equal(0);
+
+      const user = await votingContract.getMyAccount();
+
+      let userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(false);
+      expect(userVoted.downvoted).to.equal(false);
+
+
+      let res
+      try {
+        res = await votingContract.removeDownvoteItem({
+          itemId,
+        });
+      } catch (error) {
+        res = { status: false };
+      }
+
+      expect(res.status).to.equal(false);
+
+      itemVotes = await votingContract.getItemVotes({ itemId });
+
+      expect(itemVotes.upvotes).to.equal(0);
+      expect(itemVotes.downvotes).to.equal(0);
+
+
+      userVoted = await votingContract.hasUserVotedItem({ itemId, user });
+
+      expect(userVoted.upvoted).to.equal(false);
+      expect(userVoted.downvoted).to.equal(false);
+
+      // Validate User Votes
+      const userVotes = await votingContract.getUserVotes({ user });
+      expect(Object.keys(userVotes).length).to.equal(2);
+      expect(userVotes[0].upvoted).to.equal(false);
+      expect(userVotes[0].downvoted).to.equal(false);
+      expect(userVotes[1].upvoted).to.equal(false);
+      expect(userVotes[1].downvoted).to.equal(false);
+    }));
+  });
+});

package/tooling/docs/jsdoc.json

@@ -0,0 +1,6 @@
+{
+    "plugins": ["node_modules/babel-core",  "node_modules/babel-register"],
+    "babel": {
+      "presets": [ "es2015" ]
+    }
+  }

package/truffle-config.js

@@ -0,0 +1,134 @@
+require('dotenv').config()
+const HDWalletProvider = require("@truffle/hdwallet-provider");
+const mnemonic = process.env.TRUFFLE_MNEMONIC;
+const ETHERSCAN_API_KEY = process.env.ETHERSCAN_API_KEY;
+const POLYGONSCAN_API_KEY = process.env.POLYGONSCAN_API_KEY;
+const GNOSIS_API_KEY = process.env.GNOSIS_API_KEY;
+const CELO_API_KEY = process.env.CELO_API_KEY;
+const INFURA_API_KEY = process.env.INFURA_API_KEY;
+const ARBITRUM_API_KEY = process.env.ARBITRUM_API_KEY;
+
+module.exports = {
+  networks: {
+    development: {
+      host: "127.0.0.1",
+      port: 8545,
+      network_id: "*", // Match any network id
+      gasLimit: 10000000,
+      gas: 10000000
+    },
+    live: {
+      provider: new HDWalletProvider(mnemonic, "https://mainnet.infura.io/v3/" + INFURA_API_KEY),
+      network_id: 1,
+      gasPrice: 100000000000,
+      websockets: true
+    },
+    chiado: {
+      provider: function () {
+        return new HDWalletProvider(mnemonic, "https://rpc.chiadochain.net")
+      },
+      network_id: 10200,
+      gas: 5000000,
+      gasPrice: 10000000
+    },
+    gnosis: {
+      provider: function () {
+        return new HDWalletProvider(mnemonic, "https://rpc.gnosischain.com")
+      },
+      network_id: 100,
+      gas: 5000000,
+      gasPrice: 10000000000
+    },
+    alfajores: {
+      provider: function () {
+        return new HDWalletProvider(
+          mnemonic,
+          "https://alfajores-forno.celo-testnet.org/")
+      },
+      network_id: 44787,
+      gas: 5000000,
+      gasPrice: 10000000000
+    },
+    celo: {
+      provider: function () {
+        return new HDWalletProvider(
+          mnemonic,
+          "https://forno.celo.org")
+      },
+      network_id: 42220,
+      gas: 5000000,
+      gasPrice: 10000000000
+    },
+    moonriver: {
+      provider: new HDWalletProvider(mnemonic, "https://rpc.api.moonriver.moonbeam.network/"),
+      network_id: 1285
+    },
+    moonbeam: {
+      provider: new HDWalletProvider(mnemonic, "https://rpc.api.moonbeam.network"),
+      network_id: 1284
+    },
+    polygon: {
+      provider: new HDWalletProvider(mnemonic, "https://polygon-rpc.com"),
+      network_id: "137",
+      gasPrice: 200000000000,
+      skipDryRun: true,
+      networkCheckTimeout: 10000,
+      timeoutBlocks: 200,
+      gas: 25000000,
+    },
+    arbitrum: {
+      provider: new HDWalletProvider(mnemonic, "https://arb1.arbitrum.io/rpc"),
+      network_id: 42161,
+      gasPrice: 200000000,
+      skipDryRun: true,
+      networkCheckTimeout: 10000,
+      timeoutBlocks: 200,
+      gas: 25000000,
+    },
+    arbitrum_sepolia: {
+      provider: new HDWalletProvider(mnemonic, "https://sepolia-rollup.arbitrum.io/rpc"),
+      network_id: 421614,
+      gasPrice: 200000000,
+      skipDryRun: true,
+      networkCheckTimeout: 10000,
+      timeoutBlocks: 200,
+      gas: 25000000,
+      verify: {
+        apiUrl: 'https://api-sepolia.arbiscan.io/api',
+        apiKey: ARBITRUM_API_KEY,
+        explorerUrl: 'https://sepolia.arbiscan.io/address',
+      },
+    },
+  },
+  // Configure your compilers
+  compilers: {
+    solc: {
+      version: "0.8.18",    // Fetch exact version from solc-bin (default: truffle's version)
+      // docker: true,        // Use "0.5.1" you've installed locally with docker (default: false)
+      // settings: {          // See the solidity docs for advice about optimization and evmVersion
+      //  optimizer: {
+      //    enabled: false,
+      //    runs: 200
+      //  },
+      //  evmVersion: "byzantium"
+      // }
+      settings: {
+        optimizer: {
+          enabled: true,
+          runs: 200
+        }
+      }
+    }
+  },
+  plugins: [
+    'truffle-contract-size',
+    'truffle-plugin-verify'
+  ],
+  api_keys: {
+    etherscan: ETHERSCAN_API_KEY,
+    polygonscan: POLYGONSCAN_API_KEY,
+    gnosisscan: GNOSIS_API_KEY,
+    celoscan: CELO_API_KEY,
+    arbiscan: ARBITRUM_API_KEY,
+  }
+};