polkamarkets-js 1.0.2 → 3.1.1

package/src/utils/Contract.js

@@ -0,0 +1,120 @@
+
+class Contract {
+  constructor(web3, contract_json, address) {
+    this.web3 = web3;
+    this.json = contract_json;
+    this.abi = contract_json.abi;
+    this.address = address;
+    this.contract = new web3.eth.Contract(contract_json.abi, address);
+  }
+
+  async deploy(account, abi, byteCode, args = [], callback = () => { }) {
+    this.contract = new this.web3.eth.Contract(abi);
+    if (account) {
+      const data = this.contract.deploy({
+        data: byteCode,
+        arguments: args,
+      });
+
+      const rawTransaction = (await account.getAccount().signTransaction({
+        data: data.encodeABI(),
+        from: account.getAddress(),
+        gas: 5913388,
+      })).rawTransaction;
+
+      return await this.web3.eth.sendSignedTransaction(rawTransaction);
+    } else {
+      const accounts = await this.web3.eth.getAccounts();
+      const res = await this.__metamaskDeploy({
+        byteCode,
+        args,
+        acc: accounts[0],
+        callback,
+      });
+      this.address = res.contractAddress;
+      return res;
+    }
+  }
+
+  async __metamaskDeploy({ byteCode, args, acc, callback = () => { } }) {
+    return new Promise((resolve, reject) => {
+      try {
+        this.getContract()
+          .deploy({
+            data: byteCode,
+            arguments: args,
+          }).send({ from: acc })
+          .on('confirmation', (confirmationNumber, receipt) => {
+            callback(confirmationNumber)
+            if (confirmationNumber > 0) {
+              resolve(receipt);
+            }
+          })
+          .on('error', err => { reject(err) });
+      } catch (err) {
+        reject(err);
+      }
+    })
+  }
+
+  async use(contract_json, address) {
+    this.json = contract_json;
+    this.abi = contract_json.abi;
+    this.address = address ? address : this.address;
+    this.contract = new this.web3.eth.Contract(
+      contract_json.abi,
+      this.address
+    );
+  }
+
+  async send(account, byteCode, value = '0x0', callback = () => { }) {
+    return new Promise(async (resolve, reject) => {
+      let gasPrice;
+      try {
+        gasPrice = await this.web3.eth.getGasPrice();
+        gasPrice *= 2;
+      } catch (err) {
+        // should be non-blocking, defaulting to 10 gwei
+        gasPrice = '10000000000';
+      }
+
+      let tx = {
+        data: byteCode,
+        from: account.address,
+        to: this.address,
+        gas: 4430000,
+        gasPrice,
+        value: value ? value : '0x0'
+      }
+
+      let result = await account.signTransaction(tx);
+      this.web3.eth.sendSignedTransaction(result.rawTransaction)
+        .on('confirmation', (confirmationNumber, receipt) => {
+          callback(confirmationNumber);
+          if (confirmationNumber > 0) {
+            resolve(receipt);
+          }
+        })
+        .on('error', err => { reject(err) });
+    })
+
+  }
+
+  getContract() {
+    return this.contract;
+  }
+
+  getABI() {
+    return this.abi;
+  }
+
+  getJSON() {
+    return this.json;
+  }
+
+  getAddress() {
+    return this.address;
+  }
+}
+
+module.exports = Contract;

package/src/utils/Numbers.js

@@ -0,0 +1,94 @@
+const moment = require('moment');
+
+Number.prototype.noExponents = function () {
+  var data = String(this).split(/[eE]/)
+  if (data.length == 1) return data[0]
+
+  var z = '',
+    sign = this < 0 ? '-' : '',
+    str = data[0].replace('.', ''),
+    mag = Number(data[1]) + 1
+
+  if (mag < 0) {
+    z = sign + '0.'
+    while (mag++) z += '0'
+    return z + str.replace(/^\-/, '')
+  }
+  mag -= str.length
+  while (mag--) z += '0'
+  return str + z
+}
+
+class numbers {
+  constructor() {}
+
+  fromDayMonthYear(date) {
+    let mom = moment().dayOfYear(date.day)
+    mom.set('hour', date.hour)
+    mom.set('year', date.year)
+    return mom.format('ddd, hA')
+  }
+
+  fromHex(hex){
+    return hex.toString();
+  }
+
+  toFloat(number) {
+    return parseFloat(parseFloat(number).toFixed(2))
+  }
+
+  timeToSmartContractTime(time) {
+    return parseInt(new Date(time).getTime() / 1000)
+  }
+
+  toDate(date) {
+    let mom = moment().dayOfYear(date.day)
+    mom.set('hour', date.hour)
+    mom.set('year', date.year)
+    return mom.unix()
+  }
+
+  toSmartContractDecimals(value, decimals) {
+    let numberWithNoExponents = new Number((Number(value) * 10 ** decimals).toFixed(0)).noExponents();
+    return numberWithNoExponents;
+  }
+
+  fromBigNumberToInteger(value, decimals = 18) {
+    return Math.round((value / Math.pow(10, decimals)) * 1000000000000000000);
+  }
+
+  fromDecimals(value, decimals) {
+      return  Number(parseFloat(value / 10 ** decimals).toPrecision(decimals)).noExponents();
+  }
+
+  fromDecimalsNumber(value, decimals) {
+      const number = Number(parseFloat(value / 10 ** decimals).toPrecision(decimals)).noExponents();
+      return Number(number);
+  }
+
+  fromExponential(x) {
+    if (Math.abs(x) < 1.0) {
+      var e = parseInt(x.toString().split('e-')[1])
+      if (e) {
+        x *= Math.pow(10, e - 1)
+        x = '0.' + new Array(e).join('0') + x.toString().substring(2)
+      }
+    } else {
+      var e = parseInt(x.toString().split('+')[1])
+      if (e > 20) {
+        e -= 20
+        x /= Math.pow(10, e)
+        x += new Array(e + 1).join('0')
+      }
+    }
+    return x
+  }
+
+  nullHash() {
+    return '0x0000000000000000000000000000000000000000000000000000000000000000';
+  }
+}
+
+let Numbers = new numbers()
+
+module.exports = Numbers;

package/tests/fantasyERC20Contract.js

@@ -0,0 +1,225 @@
+
+
+import { expect } from 'chai';
+
+import { mochaAsync } from './utils';
+import { Application } from '..';
+const Numbers = require("../src/utils/Numbers");
+
+context('FantasyERC20 Contract', async () => {
+  require('dotenv').config();
+
+  const TOKEN_AMOUNT_TO_CLAIM = '10000';
+
+
+  const USER1_ADDRESS = process.env.TEST_USER1_ADDRESS;
+  const USER1_PRIVATE_KEY = process.env.TEST_USER1_PRIVATE_KEY;
+  const USER2_ADDRESS = process.env.TEST_USER2_ADDRESS;
+  const USER2_PRIVATE_KEY = process.env.TEST_USER2_PRIVATE_KEY;
+  const TOKEN_MANAGER_ADDRESS = process.env.TEST_USER3_ADDRESS;
+  const TOKEN_MANAGER_PRIVATE_KEY = process.env.TEST_USER3_PRIVATE_KEY;
+
+  let app;
+  let fantasyERC20ContractAddress;
+
+  let user1FantasyERC20Contract;
+  let user2FantasyERC20Contract2;
+  let tokenManagerfantasyERC20Contract;
+
+  context('Contract Deployment', async () => {
+    it('should start the Application', mochaAsync(async () => {
+      app = new Application({
+        web3Provider: process.env.WEB3_PROVIDER,
+        web3PrivateKey: USER1_PRIVATE_KEY,
+      });
+
+      expect(app).to.not.equal(null);
+    }));
+
+    it('should deploy FantasyERC20 Contract', mochaAsync(async () => {
+      // Create Contract
+      user1FantasyERC20Contract = app.getFantasyERC20Contract({});
+      // Deploy
+      await user1FantasyERC20Contract.deploy({
+        params: [
+          'Fantasy',
+          'FNTS',
+          Numbers.toSmartContractDecimals(TOKEN_AMOUNT_TO_CLAIM, 18),
+          TOKEN_MANAGER_ADDRESS,
+          '0x0000000000000000000000000000000000000000',
+          '0x0000000000000000000000000000000000000000'
+        ]
+      });
+
+      fantasyERC20ContractAddress = user1FantasyERC20Contract.getAddress();
+
+      expect(fantasyERC20ContractAddress).to.not.equal(null);
+    }));
+  });
+
+  context('Claim Tokens', async () => {
+    it('should claim tokens for address', mochaAsync(async () => {
+
+      app = new Application({
+        web3Provider: process.env.WEB3_PROVIDER,
+        web3PrivateKey: USER2_PRIVATE_KEY,
+      });
+
+      user2FantasyERC20Contract2 = app.getFantasyERC20Contract({ contractAddress: fantasyERC20ContractAddress });
+      await user2FantasyERC20Contract2.__init__();
+
+      let user2HasClaimedTokens;
+      let user2TokenAmount;
+      let totalSupply;
+      let isApproved;
+
+      // check if address hasn't claimed tokens
+      user2HasClaimedTokens = await user2FantasyERC20Contract2.hasUserClaimedTokens({ address: USER2_ADDRESS });
+      expect(user2HasClaimedTokens).to.equal(false);
+
+      user2TokenAmount = await user2FantasyERC20Contract2.getTokenAmount(USER2_ADDRESS);
+      expect(user2TokenAmount).to.equal('0');
+
+      totalSupply = await user2FantasyERC20Contract2.totalSupply();
+      expect(totalSupply).to.equal('0');
+
+      isApproved = await user2FantasyERC20Contract2.isApproved({ address: USER2_ADDRESS, amount: TOKEN_AMOUNT_TO_CLAIM, spenderAddress: TOKEN_MANAGER_ADDRESS });
+      expect(isApproved).to.equal(false);
+
+      // claim tokens
+      const res = await user2FantasyERC20Contract2.claimAndApproveTokens();
+      expect(res.status).to.equal(true);
+
+      // check if address hasn't claimed tokens
+      user2HasClaimedTokens = await user2FantasyERC20Contract2.hasUserClaimedTokens({ address: USER2_ADDRESS });
+      expect(user2HasClaimedTokens).to.equal(true);
+
+      user2TokenAmount = await user2FantasyERC20Contract2.getTokenAmount(USER2_ADDRESS);
+      expect(user2TokenAmount).to.equal(
+        TOKEN_AMOUNT_TO_CLAIM
+      );
+
+      totalSupply = await user2FantasyERC20Contract2.totalSupply();
+      expect(totalSupply).to.equal(TOKEN_AMOUNT_TO_CLAIM);
+
+      isApproved = await user2FantasyERC20Contract2.isApproved({ address: USER2_ADDRESS, amount: TOKEN_AMOUNT_TO_CLAIM, spenderAddress: TOKEN_MANAGER_ADDRESS });
+      expect(isApproved).to.equal(true);
+    }));
+
+    it('should not claim tokens for address that has already claimed tokens', mochaAsync(async () => {
+      let user2HasClaimedTokens;
+      let user2TokenAmount;
+
+      // check if address has already claimed tokens
+      user2HasClaimedTokens = await user2FantasyERC20Contract2.hasUserClaimedTokens({ address: USER2_ADDRESS });
+      expect(user2HasClaimedTokens).to.equal(true);
+
+      user2TokenAmount = await user2FantasyERC20Contract2.getTokenAmount(USER2_ADDRESS);
+      expect(user2TokenAmount).to.equal(TOKEN_AMOUNT_TO_CLAIM);
+
+      // claim tokens
+      let res;
+      try {
+        res = await user2FantasyERC20Contract2.claimAndApproveTokens();
+      } catch (error) {
+        res = { status: false };
+      }
+
+      expect(res.status).to.equal(false);
+      // TODO: check if error is correct
+      // expect(res.reason).to.equal('FantasyERC20: address already claimed the tokens');
+
+      user2HasClaimedTokens = await user2FantasyERC20Contract2.hasUserClaimedTokens({ address: USER2_ADDRESS });
+      expect(user2HasClaimedTokens).to.equal(true);
+
+      user2TokenAmount = await user2FantasyERC20Contract2.getTokenAmount(USER2_ADDRESS);
+      expect(user2TokenAmount).to.equal(TOKEN_AMOUNT_TO_CLAIM);
+
+    }));
+  });
+
+  context('Transfer Tokens', async () => {
+    it('should allow to transfer tokens between an address and the token manager', mochaAsync(async () => {
+      // transfer from address to token manager
+      const tokenAmountToTransfer = 500;
+      let user2TokenAmount;
+      let managerTokenAmount;
+
+      user2TokenAmount = await user2FantasyERC20Contract2.getTokenAmount(USER2_ADDRESS);
+      expect(user2TokenAmount).to.equal(TOKEN_AMOUNT_TO_CLAIM);
+
+      managerTokenAmount = await user2FantasyERC20Contract2.getTokenAmount(TOKEN_MANAGER_ADDRESS);
+      expect(managerTokenAmount).to.equal('0');
+
+      let res = await user2FantasyERC20Contract2.transferTokenAmount({
+        toAddress: TOKEN_MANAGER_ADDRESS,
+        tokenAmount: tokenAmountToTransfer,
+      });
+
+      expect(res.status).to.equal(true);
+
+      user2TokenAmount = await user2FantasyERC20Contract2.getTokenAmount(USER2_ADDRESS);
+      expect(parseFloat(user2TokenAmount).toFixed(0)).to.equal((TOKEN_AMOUNT_TO_CLAIM - tokenAmountToTransfer).toFixed(0));
+
+      managerTokenAmount = await user2FantasyERC20Contract2.getTokenAmount(TOKEN_MANAGER_ADDRESS);
+      expect(managerTokenAmount).to.equal(tokenAmountToTransfer.toFixed(0));
+
+      // transfer back from manager to address
+      app = new Application({
+        web3Provider: process.env.WEB3_PROVIDER,
+        web3PrivateKey: TOKEN_MANAGER_PRIVATE_KEY,
+      });
+
+      tokenManagerfantasyERC20Contract = app.getFantasyERC20Contract({ contractAddress: fantasyERC20ContractAddress });
+      await tokenManagerfantasyERC20Contract.__init__();
+
+      res = await tokenManagerfantasyERC20Contract.transferTokenAmount({
+        toAddress: USER2_ADDRESS,
+        tokenAmount: tokenAmountToTransfer,
+      });
+
+      expect(res.status).to.equal(true);
+
+      user2TokenAmount = await tokenManagerfantasyERC20Contract.getTokenAmount(USER2_ADDRESS);
+      expect(user2TokenAmount).to.equal(TOKEN_AMOUNT_TO_CLAIM);
+
+      managerTokenAmount = await tokenManagerfantasyERC20Contract.getTokenAmount(TOKEN_MANAGER_ADDRESS);
+      expect(managerTokenAmount).to.equal('0');
+
+    }));
+
+    it('should not allow to transfer tokens between 2 addresses that are not the token manager', mochaAsync(async () => {
+
+      const tokenAmountToTransfer = 500;
+      let user1TokenAmount;
+      let user2TokenAmount;
+
+      user2TokenAmount = await user2FantasyERC20Contract2.getTokenAmount(USER2_ADDRESS);
+      expect(user2TokenAmount).to.equal(TOKEN_AMOUNT_TO_CLAIM);
+
+      user1TokenAmount = await user2FantasyERC20Contract2.getTokenAmount(USER1_ADDRESS);
+      expect(user1TokenAmount).to.equal('0');
+
+      let res;
+
+      try {
+        res = await user2FantasyERC20Contract2.transferTokenAmount({
+          toAddress: USER1_ADDRESS,
+          tokenAmount: tokenAmountToTransfer,
+        });
+      } catch (error) {
+        res = { status: false };
+      }
+
+      expect(res.status).to.equal(false);
+      // TODO: check if error is correct
+      // expect(res.reason).to.equal('FantasyERC20: token transfer not allowed between the addresses');
+
+      user2TokenAmount = await user2FantasyERC20Contract2.getTokenAmount(USER2_ADDRESS);
+      expect(parseFloat(user2TokenAmount).toFixed(0)).to.equal(TOKEN_AMOUNT_TO_CLAIM);
+
+      user1TokenAmount = await user2FantasyERC20Contract2.getTokenAmount(USER1_ADDRESS);
+      expect(user1TokenAmount).to.equal('0');
+    }));
+  });
+});

package/tests/index.js

@@ -0,0 +1,10 @@
+context('Unit Tests', () => {
+  require('./predictionMarketContract');
+  require('./predictionMarketV2Contract');
+  require('./predictionMarketV3Contract');
+  require('./predictionMarketV3ManagerContract');
+  require('./predictionMarketV3ControllerContract');
+  require('./predictionMarketV3FactoryContract');
+  require('./fantasyERC20Contract');
+  require('./votingContract');
+});