polkamarkets-js 1.0.2 → 3.1.1

package/src/models/RealitioERC20Contract.js

@@ -0,0 +1,286 @@
+const _ = require("lodash");
+
+const realitio = require("../interfaces").realitio;
+const ierc20 = require("../interfaces").ierc20;
+
+const Numbers = require("../utils/Numbers");
+const IContract = require('./IContract');
+
+const ERC20Contract = require('./ERC20Contract');
+
+/**
+ * RealitioERC20 Contract Object
+ * @constructor RealitioERC20Contract
+ * @param {Web3} web3
+ * @param {Integer} decimals
+ * @param {Address} contractAddress
+ */
+
+class RealitioERC20Contract extends IContract {
+  constructor(params) {
+    super({ abi: realitio, ...params });
+    this.contractName = 'realitio';
+  }
+
+  /**
+   * @function getTokenDecimals
+   * @description Get Token Decimals
+   * @return {Integer} decimals
+   */
+  async getTokenDecimals() {
+    try {
+      const contractAddress = await this.params.contract.getContract().methods.token().call();
+      const erc20Contract = new ERC20Contract({ ...this.params, contractAddress, abi: ierc20 });
+
+      return await erc20Contract.getDecimalsAsync();
+    } catch (err) {
+      // defaulting to 18 decimals
+      return 18;
+    }
+  }
+
+  /**
+   * @function getQuestion
+   * @description getQuestion
+   * @param {bytes32} questionId
+   * @returns {Object} question
+   */
+  async getQuestion({ questionId }) {
+    const question = await this.getContract().methods.questions(questionId).call();
+    const isFinalized = await this.getContract().methods.isFinalized(questionId).call();
+    const isClaimed = isFinalized && question.history_hash === Numbers.nullHash();
+    const decimals = await this.getTokenDecimals();
+
+    return {
+      id: questionId,
+      bond: Numbers.fromDecimalsNumber(question.bond, decimals),
+      bestAnswer: question.best_answer,
+      finalizeTs: question.finalize_ts,
+      isFinalized,
+      isClaimed,
+      isPendingArbitration: question.is_pending_arbitration,
+      arbitrator: question.arbitrator,
+    };
+  }
+
+  /**
+   * @function getQuestionBestAnswer
+   * @description getQuestionBestAnswer
+   * @param {bytes32} questionId
+   * @returns {bytes32} answerId
+   */
+  async getQuestionBestAnswer({ questionId }) {
+    return await this.getContract().methods.getBestAnswer(questionId).call();
+  }
+
+  /**
+   * @function resultForQuestion
+   * @description resultForQuestion - throws an error if question is not finalized
+   * @param {bytes32} questionId
+   * @returns {bytes32} answerId
+   */
+  async getResultForQuestion({ questionId }) {
+    return await this.getContract().methods.resultFor(questionId).call();
+  }
+
+  /**
+   * @function getQuestionBondsByAnswer
+   * @description getQuestionBondsByAnswer - throws an error if question is not finalized
+   * @param {bytes32} questionId
+   * @returns {Object} bonds
+   */
+  async getQuestionBondsByAnswer({ questionId, user }) {
+    const bonds = {};
+
+    const answers = await this.getEvents('LogNewAnswer', { question_id: questionId, user });
+
+    const decimals = await this.getTokenDecimals();
+
+    answers.forEach((answer) => {
+      const answerId = answer.returnValues.answer;
+
+      if (!bonds[answerId]) bonds[answerId] = 0;
+
+      bonds[answerId] += Numbers.fromDecimalsNumber(answer.returnValues.bond, decimals);
+    });
+
+    return bonds;
+  }
+
+  /**
+   * @function submitAnswerERC20
+   * @description Submit Answer for a Question
+   * @param {bytes32} questionId
+   * @param {bytes32} answerId
+   * @param {Integer} amount
+   */
+  async submitAnswerERC20({ questionId, answerId, amount }) {
+    const decimals = await this.getTokenDecimals();
+    let amountDecimals = Numbers.toSmartContractDecimals(amount, decimals);
+
+    return await this.__sendTx(
+      this.getContract().methods.submitAnswerERC20(
+        questionId,
+        answerId,
+        0,
+        amountDecimals
+      ),
+      false
+    );
+  }
+
+  async getMyBonds() {
+    const user = await this.getMyAccount();
+    if (!user) return {};
+
+    return await this.getUserBonds({ user });
+  }
+
+  /**
+   * @function getMyBonds
+   * @description Get My Bonds
+   * @returns {Array} Outcome Shares
+   */
+  async getUserBonds({ user }) {
+    const events = await this.getEvents('LogNewAnswer', { user });
+    const claimEvents = await this.getEvents('LogClaim', { user });
+    const withdrawEvents = await this.getEvents('LogWithdraw', { user });
+    const decimals = await this.getTokenDecimals();
+
+    const lastWithdrawBlockNumber = withdrawEvents[withdrawEvents.length - 1]
+      ? withdrawEvents[withdrawEvents.length - 1].blockNumber
+      : 0;
+
+    const bonds = {};
+
+    // iterating through every answer and summing up the bonds
+    events.forEach((event) => {
+      const questionId = event.returnValues.question_id;
+
+      // initializing bond vars
+      if (!bonds[questionId]) bonds[questionId] = { total: 0, answers: {}, claimed: 0, withdrawn: false };
+      if (!bonds[questionId].answers[event.returnValues.answer]) {
+        bonds[questionId].answers[event.returnValues.answer] = 0;
+      }
+
+      const bond = Numbers.fromDecimalsNumber(event.returnValues.bond, decimals)
+
+      bonds[questionId].total += bond;
+      bonds[questionId].answers[event.returnValues.answer] += bond;
+    });
+
+    claimEvents.forEach((event) => {
+      const questionId = event.returnValues.question_id;
+
+      const amount = Numbers.fromDecimalsNumber(event.returnValues.amount, decimals);
+
+      bonds[questionId].claimed += amount;
+
+      // withdraw occurred after claim, marking as withdrawn
+      if (lastWithdrawBlockNumber >= event.blockNumber) bonds[questionId].withdrawn = true;
+    });
+
+    return bonds;
+  }
+
+  async getMyActions() {
+    const user = await this.getMyAccount();
+    if (!user) return [];
+
+    return await this.getUserActions({ user });
+  }
+
+  /**
+   * @function getMyActions
+   * @description Get My Actions
+   * @returns {Array} Actions
+   */
+  async getUserActions({ user }) {
+    const events = await this.getEvents('LogNewAnswer', { user });
+    const decimals = await this.getTokenDecimals();
+
+    return events.map(event => {
+      return {
+        action: 'Bond',
+        questionId: event.returnValues.question_id,
+        answerId: event.returnValues.answer,
+        value: Numbers.fromDecimalsNumber(event.returnValues.bond, decimals),
+        timestamp: Numbers.fromBigNumberToInteger(event.returnValues.ts, 18),
+        transactionHash: event.transactionHash
+      }
+    })
+  }
+
+  async getMyQuestions() {
+    const user = await this.getMyAccount();
+    if (!user) return [];
+
+    return await this.getUserQuestions({ user });
+  }
+
+  /**
+   * @function getMyQuestions
+   * @description Get My Questions
+   * @returns {Array} Questions
+   */
+  async getUserQuestions({ user }) {
+    const events = await this.getEvents('LogNewAnswer', { user });
+    const logQuestionEvents = await this.getEvents('LogNewQuestion');
+
+    // getting unique question ids
+    const questionIds = events.map(event => event.returnValues.question_id).filter((value, index, self) => self.indexOf(value) === index);
+    const questions = logQuestionEvents.filter(event => questionIds.includes(event.returnValues.question_id));
+
+    return questions.map(event => {
+      return {
+        questionId: event.returnValues.question_id,
+        question: event.returnValues.question,
+        transactionHash: event.transactionHash
+      }
+    });
+  }
+
+  /**
+   * @function claimWinnings
+   * @description claimWinnings
+   * @param {bytes32} questionId
+   */
+  async claimWinningsAndWithdraw({ questionId }) {
+    const question = await this.getQuestion({ questionId });
+
+    // assuring question state is finalized
+    if (!question.isFinalized) return false;
+
+    if (question.isClaimed) {
+      // question already claimed, only performing a withdraw action
+      return await this.__sendTx(
+        this.getContract().methods.withdraw(),
+        false
+      );
+    }
+
+    const events = await this.getEvents('LogNewAnswer', { question_id: questionId });
+
+    const historyHashes = events.map((event) => event.returnValues.history_hash).slice(0, -1).reverse();
+    // adding an empty hash to the history hashes
+    historyHashes.push(Numbers.nullHash());
+
+    const addrs = events.map((event) => event.returnValues.user).reverse();
+    const bonds = events.map((event) => event.returnValues.bond).reverse();
+    const answers = events.map((event) => event.returnValues.answer).reverse();
+
+    return await this.__sendTx(
+      this.getContract().methods.claimMultipleAndWithdrawBalance(
+        [questionId],
+        [historyHashes.length],
+        historyHashes,
+        addrs,
+        bonds,
+        answers
+      ),
+      false
+    );
+  }
+}
+
+module.exports = RealitioERC20Contract;

package/src/models/VotingContract.js

@@ -0,0 +1,182 @@
+// const _ =  require("lodash");
+// const moment = require("moment");
+
+const voting = require("../interfaces").voting;
+
+const Numbers = require("../utils/Numbers");
+const IContract = require('./IContract');
+
+const actions = {
+  0: 'Upvote',
+  1: 'Remove Upvote',
+  2: 'Downvote',
+  3: 'Remove Downvote',
+}
+
+/**
+ * Voting Contract Object
+ * @constructor VotingContract
+ * @param {Web3} web3
+ * @param {Integer} decimals
+ * @param {Address} contractAddress
+ */
+
+class VotingContract extends IContract {
+  constructor(params) {
+    super({ abi: voting, ...params });
+    this.contractName = 'voting';
+  }
+
+  /* Get Functions */
+  /**
+   * @function getMinimumRequiredBalance
+   * @description Returns minimum required ERC20 balance to vote
+   * @returns {Integer} requiredBalance
+   */
+  async getMinimumRequiredBalance() {
+    const requiredBalance = await this.params.contract
+      .getContract()
+      .methods
+      .requiredBalance()
+      .call();
+
+    return Numbers.fromDecimalsNumber(requiredBalance, 18)
+  }
+
+  /**
+   * @function getItemVotes
+   * @description Get Item Total upvotes and downvotes
+   * @param {Integer} itemId
+   * @returns {Integer} upvotes
+   * @returns {Integer} downvotes
+   */
+  async getItemVotes({ itemId }) {
+    let res = await this.params.contract
+      .getContract()
+      .methods
+      .getItemVotes(itemId)
+      .call();
+
+    return {
+      upvotes: Number(res[0]),
+      downvotes: Number(res[1]),
+    }
+  }
+
+  /**
+   * @function hasUserVotedItem
+   * @description Get info if user has voted the item
+   * @param {Integer} itemId
+   * @param {Address} user
+   * @returns {Boolean} upvoted
+   * @returns {Boolean} downvoted
+   */
+  async hasUserVotedItem({ user, itemId }) {
+    let res = await this.params.contract
+      .getContract()
+      .methods
+      .hasUserVotedItem(user, itemId)
+      .call();
+
+    return {
+      upvoted: res[0],
+      downvoted: res[1],
+    }
+  }
+
+  /**
+   * @function getUserActions
+   * @description Get user voting actions
+   * @param {Address} user
+   * @returns {Array} Voted Actions
+   */
+  async getUserActions({ user }) {
+    const events = await this.getEvents('ItemVoteAction', { user });
+
+    return events.map(event => {
+      return {
+        action: actions[Numbers.fromBigNumberToInteger(event.returnValues.action, 18)],
+        itemId: Numbers.fromBigNumberToInteger(event.returnValues.itemId, 18),
+        timestamp: Numbers.fromBigNumberToInteger(event.returnValues.timestamp, 18),
+        transactionHash: event.transactionHash,
+      }
+    });
+  }
+
+  /**
+   * @function getUserVotes
+   * @description Get user voting status for every item he has voted
+   * @param {Address} user
+   * @returns {Object} Voting status
+   */
+  async getUserVotes({ user }) {
+    const events = await this.getEvents('ItemVoteAction', { user });
+
+    const eventMap = new Map();
+
+    // go through all events and get the latest event per each item
+    events.forEach(event => {
+      eventMap.set(
+        Numbers.fromBigNumberToInteger(event.returnValues.itemId, 18),
+        actions[Numbers.fromBigNumberToInteger(event.returnValues.action, 18)]
+      );
+    });
+
+    const userVotes = {};
+    [...eventMap].forEach(([itemId, action]) => userVotes[itemId] = {
+      upvoted: action === actions[0],
+      downvoted: action === actions[2],
+    });
+
+    return userVotes;
+  }
+
+  /* POST User Functions */
+
+  /**
+   * @function upvoteItem
+   * @description Upvote an item
+   * @param {Integer} itemId
+   */
+  async upvoteItem({ itemId }) {
+    return await this.__sendTx(
+      this.getContract().methods.upvoteItem(itemId)
+    );
+  };
+
+  /**
+   * @function downvoteItem
+   * @description Downvote an item
+   * @param {Integer} itemId
+   */
+  async downvoteItem({ itemId }) {
+    return await this.__sendTx(
+      this.getContract().methods.downvoteItem(itemId)
+    );
+  };
+
+
+  /**
+   * @function removeUpvoteItem
+   * @description Remove Upvote from an item
+   * @param {Integer} itemId
+   */
+  async removeUpvoteItem({ itemId }) {
+    return await this.__sendTx(
+      this.getContract().methods.removeUpvoteItem(itemId)
+    );
+  };
+
+  /**
+   * @function removeDownvoteItem
+   * @description Remove Downvote from an item
+   * @param {Integer} itemId
+   */
+  async removeDownvoteItem({ itemId }) {
+    return await this.__sendTx(
+      this.getContract().methods.removeDownvoteItem(itemId)
+    );
+  };
+}
+
+module.exports = VotingContract;

package/src/models/WETH9Contract.js

@@ -0,0 +1,92 @@
+const weth = require("../interfaces").weth;
+const Numbers = require("../utils/Numbers");
+const IContract = require('./IContract');
+
+class WETH9Contract extends IContract {
+  constructor(params) {
+    super({ abi: weth, ...params });
+    this.contractName = 'weth';
+  }
+
+  getDecimals() {
+    return 18;
+  }
+
+  async totalSupply() {
+    return Numbers.fromDecimals(await this.getContract().methods.totalSupply().call(), this.getDecimals());
+  }
+
+  async balanceOf({ address }) {
+    return Numbers.fromDecimalsNumber(await this.getContract().methods.balanceOf(address).call(), this.getDecimals());
+  }
+
+  async isApproved({ address, amount, spenderAddress }) {
+    try {
+      let approvedAmount = Numbers.fromDecimals(
+        await this.getContract().methods.allowance(address, spenderAddress).call(),
+        this.getDecimals()
+      );
+      return (approvedAmount >= amount);
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async approve({ address, amount, callback }) {
+    try {
+      let amountWithDecimals = Numbers.toSmartContractDecimals(
+        amount,
+        this.getDecimals()
+      );
+      let res = await this.__sendTx(
+        this.getContract()
+          .methods.approve(address, amountWithDecimals),
+        null,
+        null,
+        callback
+      );
+      return res;
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async deposit({ amount, callback }) {
+    try {
+      let amountWithDecimals = Numbers.toSmartContractDecimals(
+        amount,
+        this.getDecimals()
+      );
+      let res = await this.__sendTx(
+        this.getContract().methods.deposit(),
+        false,
+        amountWithDecimals,
+        callback
+      );
+      return res;
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async withdraw({ amount, callback }) {
+    try {
+      let amountWithDecimals = Numbers.toSmartContractDecimals(
+        amount,
+        this.getDecimals()
+      );
+      let res = await this.__sendTx(
+        this.getContract()
+          .methods.withdraw(amountWithDecimals),
+        null,
+        null,
+        callback
+      );
+      return res;
+    } catch (err) {
+      throw err;
+    }
+  }
+}
+
+module.exports = WETH9Contract;

package/src/models/index.js

@@ -0,0 +1,33 @@
+const ERC20Contract = require('./ERC20Contract');
+const PredictionMarketContract = require('./PredictionMarketContract');
+const PredictionMarketV2Contract = require('./PredictionMarketV2Contract');
+const PredictionMarketV3Contract = require('./PredictionMarketV3Contract');
+const PredictionMarketV3ManagerContract = require('./PredictionMarketV3ManagerContract');
+const PredictionMarketV3ControllerContract = require('./PredictionMarketV3ControllerContract');
+const PredictionMarketV3FactoryContract = require('./PredictionMarketV3FactoryContract');
+const PredictionMarketV3QuerierContract = require('./PredictionMarketV3QuerierContract');
+const AchievementsContract = require('./AchievementsContract');
+const RealitioERC20Contract = require('./RealitioERC20Contract');
+const VotingContract = require('./VotingContract');
+const FantasyERC20Contract = require('./FantasyERC20Contract');
+const WETH9Contract = require('./WETH9Contract');
+const ArbitrationContract = require('./ArbitrationContract');
+const ArbitrationProxyContract = require('./ArbitrationProxyContract');
+
+module.exports = {
+  ERC20Contract,
+  PredictionMarketContract,
+  PredictionMarketV2Contract,
+  PredictionMarketV3Contract,
+  PredictionMarketV3ManagerContract,
+  PredictionMarketV3QuerierContract,
+  AchievementsContract,
+  RealitioERC20Contract,
+  VotingContract,
+  FantasyERC20Contract,
+  WETH9Contract,
+  ArbitrationContract,
+  ArbitrationProxyContract,
+  PredictionMarketV3FactoryContract,
+  PredictionMarketV3ControllerContract
+}

package/src/utils/Account.js

@@ -0,0 +1,40 @@
+class Account {
+
+  constructor(web3, account) {
+    this.web3 = web3;
+    this.account = account;
+  }
+
+
+  async getBalance() {
+    let wei = await this.web3.eth.getBalance(this.getAddress());
+    return this.web3.utils.fromWei(wei, 'ether')
+  }
+
+  getAddress() {
+    return this.account.address;
+  }
+
+  getPrivateKey() {
+    return this.account.privateKey;
+  }
+
+  getAccount() {
+    return this.account
+  }
+
+  async sendEther(amount, address, data = null) {
+    let tx = {
+      data: data,
+      from: this.getAddress(),
+      to: address,
+      gas: 443000,
+      value: amount
+    };
+    let result = await this.account.signTransaction(tx);
+    let transaction = await this.web3.eth.sendSignedTransaction(result.rawTransaction);
+    return transaction;
+  }
+}
+
+module.exports = Account;