polkamarkets-js 1.0.1 → 3.1.0

package/src/Application.js

@@ -0,0 +1,421 @@
+const Web3 = require("web3");
+
+const PolkamarketsSmartAccount = require("./models/PolkamarketsSmartAccount");
+
+const ERC20Contract = require("./models/index").ERC20Contract;
+const PredictionMarketContract = require("./models/index").PredictionMarketContract;
+const PredictionMarketV2Contract = require("./models/index").PredictionMarketV2Contract;
+const PredictionMarketV3Contract = require("./models/index").PredictionMarketV3Contract;
+const PredictionMarketV3ManagerContract = require("./models/index").PredictionMarketV3ManagerContract;
+const PredictionMarketV3ControllerContract = require("./models/index").PredictionMarketV3ControllerContract;
+const PredictionMarketV3FactoryContract = require("./models/index").PredictionMarketV3FactoryContract;
+const AchievementsContract = require("./models/index").AchievementsContract;
+const RealitioERC20Contract = require("./models/index").RealitioERC20Contract;
+const VotingContract = require("./models/index").VotingContract;
+const FantasyERC20Contract = require("./models/index").FantasyERC20Contract;
+const WETH9Contract = require("./models/index").WETH9Contract;
+const ArbitrationContract = require("./models/index").ArbitrationContract;
+const ArbitrationProxyContract = require("./models/index").ArbitrationProxyContract;
+
+const Account = require('./utils/Account');
+
+
+const networksEnum = Object.freeze({
+  1: "Main",
+  2: "Morden",
+  3: "Ropsten",
+  4: "Rinkeby",
+  42: "Kovan",
+});
+
+class Application {
+  constructor({
+    web3Provider,
+    web3PrivateKey,
+    web3EventsProvider,
+    gasPrice,
+    isSocialLogin = false,
+    socialLoginParams,
+    startBlock,
+    defaultDecimals
+  }) {
+    this.web3Provider = web3Provider;
+    // evm logs http source (optional)
+    this.web3EventsProvider = web3EventsProvider;
+    // fixed gas price for txs (optional)
+    this.gasPrice = gasPrice;
+    this.isSocialLogin = isSocialLogin;
+    this.startBlock = startBlock;
+    this.defaultDecimals = defaultDecimals;
+
+    if (this.isSocialLogin) {
+      this.socialLoginParams = socialLoginParams;
+    }
+
+    // IMPORTANT: this parameter should only be used for testing purposes
+    if (web3PrivateKey && !this.isSocialLogin) {
+      this.start();
+      this.login();
+      this.account = new Account(this.web3, this.web3.eth.accounts.privateKeyToAccount(web3PrivateKey));
+    }
+  }
+
+  /**********/
+  /** CORE **/
+  /**********/
+
+  /**
+   * @name start
+   * @description Start the Application
+   */
+  start() {
+    this.web3 = new Web3(new Web3.providers.HttpProvider(this.web3Provider));
+    this.web3.eth.handleRevert = true;
+    if (typeof window !== "undefined") {
+      window.web3 = this.web3;
+    }
+  }
+
+  /**
+   * @name login
+   * @description Login with Metamask or a web3 provider
+   */
+  async login(provider = null, isConnectedWallet = null) {
+    if (this.isSocialLogin) {
+      if (!this.provider) {
+        this.smartAccount = PolkamarketsSmartAccount.singleton.getInstanceIfExists()
+      }
+
+      if ((!this.smartAccount || !this.smartAccount.provider) && provider) {
+        PolkamarketsSmartAccount.singleton.clearInstance();
+        this.smartAccount = PolkamarketsSmartAccount.singleton.getInstance(provider, this.socialLoginParams.networkConfig, isConnectedWallet);
+      }
+
+      return true;
+    } else {
+      try {
+        if (typeof window === "undefined") { return false; }
+        if (window.ethereum) {
+          window.web3 = new Web3(window.ethereum);
+          this.web3 = window.web3;
+          await window.ethereum.enable();
+          return true;
+        }
+        return false;
+      } catch (err) {
+        throw err;
+      }
+    }
+  };
+
+  /**
+   * @name isLoggedIn
+   * @description Returns wether metamask account is connected to service or not
+   */
+  async isLoggedIn() {
+    if (this.isSocialLogin) {
+      return !!(this.smartAccount && this.smartAccount.provider);
+    } else {
+      try {
+        if (typeof window === "undefined" || typeof window.ethereum === "undefined") { return false; }
+        const accounts = await ethereum.request({ method: 'eth_accounts' });
+
+        return accounts.length > 0;
+      } catch (err) {
+        return false;
+      }
+    }
+  };
+
+  contractDefaultParams(contractAddress) {
+    return {
+      web3: this.web3,
+      contractAddress,
+      acc: this.account,
+      web3EventsProvider: this.web3EventsProvider,
+      gasPrice: this.gasPrice,
+      isSocialLogin: this.isSocialLogin,
+      startBlock: this.startBlock,
+      defaultDecimals: this.defaultDecimals
+    };
+  }
+
+  /*************/
+  /** GETTERS **/
+  /*************/
+
+  /**
+   * @name getPredictionMarketContract
+   * @param {Address} ContractAddress (Opt) If it is deployed
+   * @description Create a PredictionMarket Contract
+   */
+  getPredictionMarketContract({ contractAddress = null } = {}) {
+    try {
+      return new PredictionMarketContract({
+        ...this.contractDefaultParams(contractAddress)
+      });
+    } catch (err) {
+      throw err;
+    }
+  };
+
+  /**
+   * @name getPredictionMarketV2Contract
+   * @param {Address} ContractAddress (Opt) If it is deployed
+   * @description Create a PredictionMarketV2 Contract
+   */
+  getPredictionMarketV2Contract({ contractAddress = null } = {}) {
+    try {
+      return new PredictionMarketV2Contract({
+        ...this.contractDefaultParams(contractAddress)
+      });
+    } catch (err) {
+      throw err;
+    }
+  };
+
+  /**
+   * @name getPredictionMarketV3Contract
+   * @param {Address} ContractAddress (Opt) If it is deployed
+   * @description Create a PredictionMarketV3 Contract
+   */
+  getPredictionMarketV3Contract({ contractAddress = null, querierContractAddress = null } = {}) {
+    try {
+      return new PredictionMarketV3Contract({
+        ...this.contractDefaultParams(contractAddress),
+        querierContractAddress,
+      });
+    } catch (err) {
+      throw err;
+    }
+
+  };
+  /**
+   * @name getPredictionMarketV3FactoryContract
+   * @param {Address} ContractAddress (Opt) If it is deployed
+   * @description Create a PredictionMarketV3Factory Contract
+   */
+  getPredictionMarketV3FactoryContract({ contractAddress = null } = {}) {
+    try {
+      return new PredictionMarketV3FactoryContract({
+        ...this.contractDefaultParams(contractAddress)
+      });
+    } catch (err) {
+      throw err;
+    }
+  };
+
+  /**
+   * @name PredictionMarketV3ControllerContract
+   * @param {Address} ContractAddress (Opt) If it is deployed
+   * @description Create a PredictionMarketV3ControllerContract Contract
+   */
+  getPredictionMarketV3ControllerContract({ contractAddress = null } = {}) {
+    try {
+      return new PredictionMarketV3ControllerContract({
+        ...this.contractDefaultParams(contractAddress)
+      });
+    } catch (err) {
+      throw err;
+    }
+  };
+
+  /**
+   * @name getPredictionMarketV3ManagerContract
+   * @param {Address} ContractAddress (Opt) If it is deployed
+   * @description Create a PredictionMarketV3Manager Contract
+   */
+  getPredictionMarketV3ManagerContract({ contractAddress = null } = {}) {
+    try {
+      return new PredictionMarketV3ManagerContract({
+        ...this.contractDefaultParams(contractAddress)
+      });
+    } catch (err) {
+      throw err;
+    }
+  };
+
+  /**
+   * @name getAchievementsContract
+   * @param {Address} ContractAddress (Opt) If it is deployed
+   * @description Create a PredictionMarket Contract
+   */
+  getAchievementsContract({
+    contractAddress = null,
+    predictionMarketContractAddress = null,
+    realitioERC20ContractAddress = null
+  } = {}) {
+    try {
+      return new AchievementsContract({
+        ...this.contractDefaultParams(contractAddress),
+        predictionMarketContractAddress,
+        realitioERC20ContractAddress,
+      });
+    } catch (err) {
+      throw err;
+    }
+  };
+
+  /**
+   * @name getVotingContract
+   * @param {Address} ContractAddress (Opt) If it is deployed
+   * @description Create a Voting Contract
+   */
+  getVotingContract({ contractAddress = null } = {}) {
+    try {
+      return new VotingContract({
+        ...this.contractDefaultParams(contractAddress)
+      });
+    } catch (err) {
+      throw err;
+    }
+  };
+
+  /**
+   * @name getFantasyERC20Contract
+   * @param {Address} ContractAddress (Opt) If it is deployed
+   * @description Create a Fantasy ERC20 Contract
+   */
+  getFantasyERC20Contract({ contractAddress = null } = {}) {
+    try {
+      return new FantasyERC20Contract({
+        ...this.contractDefaultParams(contractAddress)
+      });
+    } catch (err) {
+      throw err;
+    }
+  };
+
+  /**
+   * @name getRealitioERC20Contract
+   * @param {Address} ContractAddress (Opt) If it is deployed
+   * @description Create a RealitioERC20 Contract
+   */
+  getRealitioERC20Contract({ contractAddress = null } = {}) {
+    try {
+      return new RealitioERC20Contract({
+        ...this.contractDefaultParams(contractAddress)
+      });
+    } catch (err) {
+      throw err;
+    }
+  };
+
+  /**
+   * @name getERC20Contract
+   * @param {Address} ContractAddress (Opt) If it is deployed
+   * @description Create a ERC20 Contract
+   */
+  getERC20Contract({ contractAddress = null }) {
+    try {
+      return new ERC20Contract({
+        ...this.contractDefaultParams(contractAddress)
+      });
+    } catch (err) {
+      throw err;
+    }
+  };
+
+  /**
+   * @name getWETH9Contract
+   * @param {Address} ContractAddress (Opt) If it is deployed
+   * @description Create a WETH9 Contract
+   */
+  getWETH9Contract({ contractAddress = null }) {
+    try {
+      return new WETH9Contract({
+        ...this.contractDefaultParams(contractAddress)
+      });
+    } catch (err) {
+      throw err;
+    }
+  };
+
+  /**
+   * @name getArbitrationContract
+   * @param {Address} ContractAddress (Opt) If it is deployed
+   * @description Create a Arbitration Contract
+   */
+  getArbitrationContract({ contractAddress = null }) {
+    try {
+      return new ArbitrationContract({
+        ...this.contractDefaultParams(contractAddress)
+      });
+    } catch (err) {
+      throw err;
+    }
+  };
+
+  /**
+   * @name getArbitrationProxyContract
+   * @param {Address} ContractAddress (Opt) If it is deployed
+   * @description Create a Arbitration Proxy Contract
+   */
+  getArbitrationProxyContract({ contractAddress = null }) {
+    try {
+      return new ArbitrationProxyContract({
+        ...this.contractDefaultParams(contractAddress)
+      });
+    } catch (err) {
+      throw err;
+    }
+  };
+
+  /***********/
+  /** UTILS **/
+  /***********/
+
+  /**
+   * @name getETHNetwork
+   * @description Access current ETH Network used
+   * @returns {String} Eth Network
+   */
+  async getETHNetwork() {
+    const netId = await this.web3.eth.net.getId();
+    const networkName = networksEnum.hasOwnProperty(netId)
+      ? networksEnum[netId]
+      : "Unknown";
+    return networkName;
+  };
+
+  /**
+   * @name getAddress
+   * @description Access current Address Being Used under Web3 Injector (ex : Metamask)
+   * @returns {Address} Address
+   */
+  async getAddress() {
+    if (this.isSocialLogin) {
+      if (this.smartAccount && this.smartAccount.provider) {
+        return await this.smartAccount.getAddress();
+      }
+      return '';
+    } else {
+      const accounts = await this.web3.eth.getAccounts();
+      return accounts[0];
+    }
+  };
+
+  /**
+   * @name getETHBalance
+   * @description Access current ETH Balance Available for the Injected Web3 Address
+   * @returns {Integer} Balance
+   */
+  async getETHBalance() {
+    const address = await this.getAddress();
+    let wei = await window.web3.eth.getBalance(address);
+    return this.web3.utils.fromWei(wei, "ether");
+  };
+
+  async socialLoginWithJWT(id, jwtToken) {
+    throw new Error("Not implemented");
+  }
+
+  async socialLoginLogout() {
+    if (this.smartAccount) {
+      PolkamarketsSmartAccount.singleton.clearInstance();
+      this.smartAccount = null;
+    }
+  }
+}
+
+module.exports = Application;

package/src/interfaces/index.js

@@ -0,0 +1,19 @@
+let index = {
+  achievements: require("../../build/contracts/Achievements.json"),
+  arbitration: require("../../build/contracts/RealitioForeignArbitrationProxyWithAppeals.json"),
+  arbitrationProxy: require("../../build/contracts/RealitioHomeArbitrationProxy.json"),
+  fantasyerc20: require("../../build/contracts/FantasyERC20.json"),
+  ierc20: require("../../build/contracts/ERC20PresetMinterPauser.json"),
+  prediction: require("../../build/contracts/PredictionMarket.json"),
+  predictionV2: require("../../build/contracts/PredictionMarketV2.json"),
+  predictionV3: require("../../build/contracts/PredictionMarketV3.json"),
+  predictionV3Manager: require("../../build/contracts/PredictionMarketV3Manager.json"),
+  predictionV3Controller: require("../../build/contracts/PredictionMarketV3Controller.json"),
+  predictionMarketV3Factory: require("../../build/contracts/PredictionMarketV3Factory.json"),
+  predictionV3Querier: require("../../build/contracts/PredictionMarketV3Querier.json"),
+  realitio: require("../../build/contracts/RealitioERC20.json"),
+  voting: require("../../build/contracts/Voting.json"),
+  weth: require("../../build/contracts/WETH9.json"),
+};
+
+module.exports = index;

package/src/models/AchievementsContract.js

@@ -0,0 +1,217 @@
+const achievements = require("../interfaces").achievements;
+
+const Numbers = require("../utils/Numbers");
+const IContract = require('./IContract');
+const PredictionMarketContract = require('./PredictionMarketContract');
+const RealitioERC20Contract = require('./RealitioERC20Contract');
+
+const axios = require('axios');
+
+const actions = {
+  0: 'Buy',
+  1: 'Add Liquidity',
+  2: 'Bond',
+  3: 'Claim Winnings',
+  4: 'Create Market',
+}
+
+/**
+ * PredictionMarket Contract Object
+ * @constructor PredictionMarketContract
+ * @param {Web3} web3
+ * @param {Integer} decimals
+ * @param {Address} contractAddress
+ */
+
+class AchievementsContract extends IContract {
+  constructor(params) {
+    super({ abi: achievements, ...params });
+    this.contractName = 'achievements';
+  }
+
+  async getUserStats({ user }) {
+    await this.initializePredictionMarketContract();
+    await this.initializeRealitioERC20Contract();
+
+    const portfolio = await this.predictionMarket.getPortfolio({ user });
+    // fetching unique buy actions per market
+    const buyMarkets = Object.keys(portfolio).filter(marketId => {
+      return portfolio[marketId].outcomes[0].shares > 0 || portfolio[marketId].outcomes[1].shares > 0
+    });
+    // fetching unique liquidity actions per market
+    const liquidityMarkets = Object.keys(portfolio).filter(marketId => portfolio[marketId].liquidity.shares > 0);
+    // fetching unique claim winnings actions per market
+    const winningsMarkets = Object.keys(portfolio).filter(marketId => portfolio[marketId].claimStatus.winningsClaimed);
+
+    // fetching create market actions
+    const createMarketEvents = await this.predictionMarket.getEvents('MarketCreated', { user });
+
+    // fetching unique bonds actions per market
+    const bondsEvents = await this.realitioERC20.getEvents('LogNewAnswer', { user });
+    const bondsQuestions = bondsEvents.map(e => e.returnValues.question_id).filter((x, i, a) => a.indexOf(x) == i);
+    let bondsMarkets = [];
+
+    if (bondsQuestions.length > 0) {
+      // filtering by bonds placed in PredictionMarket contract
+      // TODO: optimize this
+      const allMarketIds = await this.predictionMarket.getMarkets();
+      const allMarketQuestions = await Promise.all(allMarketIds.map(async marketId => {
+        const questionId = await this.predictionMarket.getMarketQuestionId({ marketId });
+        return questionId;
+      }));
+
+      const marketQuestions = bondsQuestions.filter(questionId => allMarketQuestions.includes(questionId));
+      bondsMarkets = marketQuestions.map(questionId => allMarketQuestions.indexOf(questionId));
+    }
+
+    // returning stats mapped by action id
+    return {
+      0: { markets: buyMarkets, occurrences: buyMarkets.length },
+      1: { markets: liquidityMarkets, occurrences: liquidityMarkets.length },
+      2: { markets: bondsMarkets, occurrences: bondsMarkets.length },
+      3: { markets: winningsMarkets, occurrences: winningsMarkets.length },
+      4: { markets: createMarketEvents.map(e => e.returnValues.marketId), occurrences: createMarketEvents.length },
+    }
+  }
+
+  async getAchievementIds() {
+    const achievementIndex = await this.getContract().methods.achievementIndex().call();
+
+    return [...Array(parseInt(achievementIndex)).keys()];
+  }
+
+  async getAchievement({ achievementId }) {
+    const achievement = await this.getContract().methods.achievements(achievementId).call();
+
+    return {
+      action: actions[Numbers.fromBigNumberToInteger(achievement[0], 18)],
+      actionId: Numbers.fromBigNumberToInteger(achievement[0], 18),
+      occurrences: Numbers.fromBigNumberToInteger(achievement[1], 18)
+    };
+  }
+
+  async getUserAchievements({ user }) {
+    const achievementIds = await this.getAchievementIds();
+    const userStats = await this.getUserStats({ user });
+    let userTokens;
+    try {
+      userTokens = await this.getUserTokens({ user });
+    } catch (err) {
+      // should be non-blocking
+    }
+
+    return await achievementIds.reduce(async (obj, achievementId) => {
+      const achievement = await this.getAchievement({ achievementId });
+      const canClaim = userStats[achievement.actionId].occurrences >= achievement.occurrences;
+      const claimed = canClaim && (await this.getContract().methods.hasUserClaimedAchievement(user, achievementId).call());
+      const token = userTokens && userTokens.find(token => token.achievementId == achievementId);
+
+      const status = {
+        canClaim,
+        claimed,
+        token
+      }
+
+      return await {
+        ...(await obj),
+        [achievementId]: status,
+      };
+    }, {});
+  }
+
+  async getUserTokens({ user }) {
+    const tokenCount = await this.getContract().methods.balanceOf(user).call();
+    const tokens = [];
+
+    for (let i = 0; i < tokenCount; i++) {
+      const tokenIndex = await this.getContract().methods.tokenOfOwnerByIndex(user, i).call();
+      const tokenAchievement = await this.getContract().methods.tokens(tokenIndex).call();
+      const tokenURI = await this.getContract().methods.tokenURI(tokenIndex).call();
+      const { data } = await axios.get(tokenURI);
+
+      tokens.push({
+        id: tokenIndex,
+        achievementId: tokenAchievement,
+        uri: tokenURI,
+        data
+      });
+    }
+
+    return tokens;
+  }
+
+  async claimAchievement({ achievementId }) {
+    const user = await this.getMyAccount();
+    if (!user) return false;
+
+    const achievement = await this.getAchievement({ achievementId });
+    const userStats = await this.getUserStats({ user });
+
+    // user not eligible to claim
+    if (userStats[achievement.actionId].occurrences < achievement.occurrences) return false;
+
+    if (achievement.actionId == 2) {
+      const marketIds = userStats[achievement.actionId].markets.slice(0, achievement.occurrences);
+      const lengths = [];
+      const hhashes = [];
+      const addrs = [];
+      const bonds = [];
+      const answers = [];
+
+      for (const marketId of marketIds) {
+        const questionId = await this.predictionMarket.getMarketQuestionId({ marketId });
+        const events = await this.realitioERC20.getEvents('LogNewAnswer', { question_id: questionId });
+
+        hhashes.push(...events.map((event) => event.returnValues.history_hash).slice(0, -1).reverse());
+        // adding an empty hash to the history hashes
+        hhashes.push(Numbers.nullHash());
+
+        addrs.push(...events.map((event) => event.returnValues.user).reverse());
+        bonds.push(...events.map((event) => event.returnValues.bond).reverse());
+        answers.push(...events.map((event) => event.returnValues.answer).reverse());
+        lengths.push(events.length);
+      }
+
+      return await this.__sendTx(
+        this.getContract().methods.claimAchievement(
+          achievementId,
+          marketIds,
+          lengths,
+          hhashes,
+          addrs,
+          bonds,
+          answers
+        ),
+        false
+      );
+    } else {
+      return await this.__sendTx(
+        this.getContract().methods.claimAchievement(
+          achievementId,
+          userStats[achievement.actionId].markets.slice(0, achievement.occurrences)
+        ),
+        false,
+      );
+    }
+  }
+
+  async initializePredictionMarketContract() {
+    // predictionMarket already initialized
+    if (this.predictionMarket) return;
+
+    const contractAddress = await this.getContract().methods.predictionMarket().call();
+
+    this.predictionMarket = new PredictionMarketContract({ ...this.params, contractAddress });
+  }
+
+  async initializeRealitioERC20Contract() {
+    // predictionMarket already initialized
+    if (this.realitioERC20) return;
+
+    const contractAddress = await this.getContract().methods.realitioERC20().call();
+
+    this.realitioERC20 = new RealitioERC20Contract({ ...this.params, contractAddress });
+  }
+}
+
+module.exports = AchievementsContract;