polkamarkets-js 1.0.1 → 3.1.0

package/src/models/PredictionMarketV3Contract.js

@@ -0,0 +1,233 @@
+const predictionV3 = require("../interfaces").predictionV3;
+const PredictionMarketV2Contract = require("./PredictionMarketV2Contract");
+const PredictionMarketV3QuerierContract = require("./PredictionMarketV3QuerierContract");
+
+const Numbers = require('../utils/Numbers');
+
+class PredictionMarketV3Contract extends PredictionMarketV2Contract {
+  constructor(params) {
+    super({ abi: predictionV3, ...params });
+    this.contractName = 'predictionMarketV3';
+    if (params.defaultDecimals) {
+      this.defaultDecimals = params.defaultDecimals;
+    }
+    if (params.querierContractAddress) {
+      this.querier = new PredictionMarketV3QuerierContract({
+        ...this.params,
+        contractAddress: params.querierContractAddress
+      });
+    }
+  }
+
+  async mintAndCreateMarket ({
+    value,
+    name,
+    description = '',
+    image,
+    duration,
+    oracleAddress,
+    outcomes,
+    category,
+    token,
+    odds = [],
+    fee = 0,
+    treasuryFee = 0,
+    treasury = '0x0000000000000000000000000000000000000000',
+    realitioAddress,
+    realitioTimeout,
+    PM3ManagerAddress
+  }) {
+    const desc = await this.prepareCreateMarketDescription({
+      value,
+      name,
+      description,
+      image,
+      duration,
+      oracleAddress,
+      outcomes,
+      category,
+      token,
+      odds,
+      fee,
+      treasuryFee,
+      treasury,
+    });
+
+    return await this.__sendTx(this.getContract().methods.mintAndCreateMarket({
+      ...desc,
+      realitio: realitioAddress,
+      realitioTimeout,
+      manager: PM3ManagerAddress
+    }));
+  };
+
+  async createMarket ({
+    value,
+    name,
+    description = '',
+    image,
+    duration,
+    oracleAddress,
+    outcomes,
+    category,
+    token,
+    odds = [],
+    fee = 0,
+    treasuryFee = 0,
+    treasury = '0x0000000000000000000000000000000000000000',
+    realitioAddress,
+    realitioTimeout,
+    PM3ManagerAddress
+  }) {
+    const desc = await this.prepareCreateMarketDescription({
+      value,
+      name,
+      description,
+      image,
+      duration,
+      oracleAddress,
+      outcomes,
+      category,
+      token,
+      odds,
+      fee,
+      treasuryFee,
+      treasury,
+    });
+
+    return await this.__sendTx(this.getContract().methods.createMarket({
+      ...desc,
+      realitio: realitioAddress,
+      realitioTimeout,
+      manager: PM3ManagerAddress
+    }));
+  };
+
+  async createMarketWithETH ({
+    value,
+    name,
+    description = '',
+    image,
+    duration,
+    oracleAddress,
+    outcomes,
+    category,
+    odds = [],
+    fee = 0,
+    treasuryFee = 0,
+    treasury = '0x0000000000000000000000000000000000000000',
+    realitioAddress,
+    realitioTimeout,
+    PM3ManagerAddress
+  }) {
+    const token = await this.getWETHAddress();
+    const desc = await this.prepareCreateMarketDescription({
+      value,
+      name,
+      description,
+      image,
+      duration,
+      oracleAddress,
+      outcomes,
+      category,
+      token,
+      odds,
+      fee,
+      treasuryFee,
+      treasury,
+    });
+
+    return await this.__sendTx(
+        this.getContract().methods.createMarketWithETH({
+          ...desc,
+          realitio: realitioAddress,
+          realitioTimeout,
+          manager: PM3ManagerAddress
+        }),
+        false,
+        desc.value
+      );
+  };
+
+  async adminResolveMarketOutcome({marketId, outcomeId}) {
+    return await this.__sendTx(
+      this.getContract().methods.adminResolveMarketOutcome(marketId, outcomeId),
+      false,
+    );
+  };
+
+  async getPortfolio({ user }) {
+    if (!this.querier) {
+      return super.getPortfolio({ user });
+    }
+
+    let events = [];
+    try {
+      events = await this.getActions({ user });
+    } catch (err) {
+      // should be non-blocking
+    }
+
+    const userMarketsData = await this.querier.getUserAllMarketsData({ user });
+    const marketIds = Object.keys(userMarketsData).map(Number);
+    // fetching all markets decimals asynchrounously
+    const marketDecimals = await Promise.all(marketIds.map(marketId => this.getMarketDecimals({ marketId })));
+
+    const portfolio = marketIds.reduce((obj, marketId) => {
+      const marketData = userMarketsData[marketId];
+      const decimals = marketDecimals[marketIds.indexOf(marketId)];
+
+      const outcomeShares = Object.fromEntries(marketData.outcomeShares.map((item, index) => {
+        return [
+          index,
+          {
+            shares: Numbers.fromDecimalsNumber(item, decimals),
+            price: this.getAverageOutcomeBuyPrice({events, marketId, outcomeId: index})
+          }
+        ];
+      }));
+
+      const item = {
+        liquidity: {
+          shares: Numbers.fromDecimalsNumber(marketData.liquidityShares, decimals),
+          price: this.getAverageAddLiquidityPrice({events, marketId}),
+        },
+        outcomes: outcomeShares,
+        claimStatus: {
+          winningsToClaim: marketData.winningsToClaim,
+          winningsClaimed: marketData.winningsClaimed,
+          liquidityToClaim: marketData.liquidityToClaim,
+          liquidityClaimed: marketData.liquidityClaimed,
+          voidedWinningsToClaim: marketData.voidedSharesToClaim,
+          voidedWinningsClaimed: false,
+          liquidityFees: 0 // discontinued
+        }
+      };
+
+      return {
+        ...obj,
+        [marketId]: item
+      };
+    }, {});
+
+    // calculationg voidedWinningsClaimed, if there's any voidedWinningsToClaim
+    Object.keys(portfolio).map(Number).forEach(marketId => {
+      const item = portfolio[marketId];
+      if (item.claimStatus.voidedWinningsToClaim) {
+        item.claimStatus.voidedWinningsClaimed =
+          events.some(event => event.action === 'Claim Voided' && event.marketId === marketId);
+      }
+    });
+
+    return portfolio;
+  };
+
+  async adminResolveMarketOutcome({marketId, outcomeId}) {
+    return await this.__sendTx(
+      this.getContract().methods.adminResolveMarketOutcome(marketId, outcomeId),
+      false,
+    );
+  }
+}
+
+module.exports = PredictionMarketV3Contract;

package/src/models/PredictionMarketV3ControllerContract.js

@@ -0,0 +1,102 @@
+const IContract = require('./IContract');
+
+const predictionV3Controller = require("../interfaces").predictionV3Controller;
+
+const Numbers = require('../utils/Numbers');
+
+class PredictionMarketV3ControllerContract extends IContract {
+  constructor(params) {
+    super({ abi: predictionV3Controller, ...params });
+    this.contractName = 'PredictionMarketV3Controller';
+  }
+
+  async getLandById({ id }) {
+    const token = await this.getContract().methods.landTokens(id).call();
+
+    return await this.getLandByAddress({ token });
+  }
+
+  async getLandByAddress({ token }) {
+    const res = await this.getContract().methods.lands(token).call();
+    const landPermissions = await this.getContract().methods.landPermissions(token).call();
+
+    return {
+      token: res.token,
+      active: res.active,
+      realitio: res.realitio,
+      everyoneCanCreateMarkets: landPermissions.openMarketCreation
+    }
+  }
+
+  async getLandTokensLength() {
+    const index = await this.getContract().methods.landTokensLength().call();
+
+    return parseInt(index);
+  }
+
+  async isAllowedToCreateMarket({ token, user }) {
+    return await this.params.contract.getContract().methods.isAllowedToCreateMarket(token, user).call();
+  }
+
+  async isAllowedToResolveMarket({ token, user }) {
+    return await this.params.contract.getContract().methods.isAllowedToResolveMarket(token, user).call();
+  }
+
+  async isIERC20TokenSocial({ token }) {
+    return await this.params.contract.getContract().methods.isIERC20TokenSocial(token, user).call();
+  }
+
+  async isLandAdmin({ token, user }) {
+    return await this.params.contract.getContract().methods.isLandAdmin(token, user).call();
+  }
+
+  async createLand({ name, symbol, tokenAmountToClaim, tokenToAnswer, everyoneCanCreateMarkets }) {
+    const transaction = await this.__sendTx(
+      this.getContract().methods.createLand(
+        name,
+        symbol,
+        Numbers.toSmartContractDecimals(tokenAmountToClaim, 18),
+        tokenToAnswer
+      )
+    );
+
+    const token = transaction.events.LandCreated[0].returnValues.token;
+
+    // fetching land on index
+    const land = await this.getLandByAddress({ token });
+
+    if (everyoneCanCreateMarkets) {
+      await this.__sendTx(
+        this.getContract().methods.setLandEveryoneCanCreateMarkets(land.token, everyoneCanCreateMarkets)
+      );
+    }
+
+    return land;
+  };
+
+  async disableLand({ token }) {
+    return await this.__sendTx(
+      this.getContract().methods.disableLand(token)
+    );
+  }
+
+  async enableLand({ token }) {
+    return await this.__sendTx(
+      this.getContract().methods.enableLand(token)
+    );
+  }
+
+  async addAdminToLand({ token, user }) {
+    return await this.__sendTx(
+      this.getContract().methods.addAdminToLand(token, user)
+    );
+  }
+
+  async removeAdminFromLand({ token, user }) {
+    return await this.__sendTx(
+      this.getContract().methods.removeAdminFromLand(token, user)
+    );
+  }
+}
+
+module.exports = PredictionMarketV3ControllerContract;

package/src/models/PredictionMarketV3FactoryContract.js

@@ -0,0 +1,96 @@
+const IContract = require('./IContract');
+
+const predictionMarketFactory = require("../interfaces").predictionMarketV3Factory;
+
+const Numbers = require('../utils/Numbers');
+
+class PredictionMarketV3FactoryContract extends IContract {
+  constructor(params) {
+    super({ abi: predictionMarketFactory, ...params });
+    this.contractName = 'PredictionMarketFactory';
+  }
+
+  async getPMControllerById({ id }) {
+    const controllerAddress = await this.getPMControllerAddressById({ id });
+
+    return await this.getPMControllerByAddress({ controllerAddress });
+  }
+
+  async getPMControllerAddressById({ id }) {
+    return this.getContract().methods.controllersAddresses(id).call();
+  }
+
+  async getPMControllerByAddress({ controllerAddress }) {
+    const res = await this.getContract().methods.controllers(controllerAddress).call();
+
+    return {
+      active: res.active,
+      lockAmount: Numbers.fromDecimalsNumber(res.lockAmount, 18),
+      lockUser: res.lockUser,
+    }
+  }
+
+  async getControllersLength() {
+    const index = await this.getContract().methods.controllersLength().call();
+
+    return parseInt(index);
+  }
+
+  async isPMControllerAdmin({ controllerAddress, user }) {
+    return await this.params.contract.getContract().methods.isPMControllerAdmin(controllerAddress, user).call();
+  }
+
+  async lockAmount() {
+    const amount = await this.params.contract.getContract().methods.lockAmount().call();
+    // TODO: fetch ERC20 decimals
+    return Numbers.fromDecimalsNumber(amount, 18);
+  }
+
+  async updateLockAmount({ amount }) {
+    return await this.__sendTx(
+      this.getContract().methods.updateLockAmount(Numbers.toSmartContractDecimals(amount, 18))
+    );
+  }
+
+  async createPMController({
+    PMV3,
+  }) {
+    return await this.__sendTx(
+      this.getContract().methods.createPMController(
+        PMV3,
+      )
+    );
+  };
+
+  async disablePMController({ controllerAddress }) {
+    return await this.__sendTx(
+      this.getContract().methods.disablePMController(controllerAddress)
+    );
+  }
+
+  async enablePMController({ controllerAddress }) {
+    return await this.__sendTx(
+      this.getContract().methods.enablePMController(controllerAddress)
+    );
+  }
+
+  async unlockOffsetFromPMController({ controllerAddress }) {
+    return await this.__sendTx(
+      this.getContract().methods.unlockOffsetFromPMController(controllerAddress)
+    );
+  }
+
+  async addAdminToPMController({ controllerAddress, user }) {
+    return await this.__sendTx(
+      this.getContract().methods.addAdminToPMController(controllerAddress, user)
+    );
+  }
+
+  async removeAdminFromPMController({ controllerAddress, user }) {
+    return await this.__sendTx(
+      this.getContract().methods.removeAdminFromPMController(controllerAddress, user)
+    );
+  }
+}
+
+module.exports = PredictionMarketV3FactoryContract;

package/src/models/PredictionMarketV3ManagerContract.js

@@ -0,0 +1,111 @@
+const IContract = require('./IContract');
+
+const predictionV3Manager = require("../interfaces").predictionV3Manager;
+
+const Numbers = require('../utils/Numbers');
+
+class PredictionMarketV3ManagerContract extends IContract {
+  constructor(params) {
+    super({ abi: predictionV3Manager, ...params });
+    this.contractName = 'PredictionMarketV3Manager';
+  }
+
+  async getLandById({ id }) {
+    const token = await this.getContract().methods.landTokens(id).call();
+
+    return await this.getLandByAddress({ token });
+  }
+
+  async getLandByAddress({ token }) {
+    const res = await this.getContract().methods.lands(token).call();
+
+    return {
+      token: res.token,
+      active: res.active,
+      lockAmount: Numbers.fromDecimalsNumber(res.lockAmount, 18),
+      lockUser: res.lockUser,
+      realitio: res.realitio,
+    }
+  }
+
+  async getLandTokensLength() {
+    const index = await this.getContract().methods.landTokensLength().call();
+
+    return parseInt(index);
+  }
+
+  async isAllowedToCreateMarket({ token, user }) {
+    return await this.params.contract.getContract().methods.isAllowedToCreateMarket(token, user).call();
+  }
+
+  async isAllowedToResolveMarket({ token, user }) {
+    return await this.params.contract.getContract().methods.isAllowedToResolveMarket(token, user).call();
+  }
+
+  async isIERC20TokenSocial({ token }) {
+    return await this.params.contract.getContract().methods.isIERC20TokenSocial(token, user).call();
+  }
+
+  async isLandAdmin({ token, user }) {
+    return await this.params.contract.getContract().methods.isLandAdmin(token, user).call();
+  }
+
+  async lockAmount() {
+    const amount = await this.params.contract.getContract().methods.lockAmount().call();
+    // TODO: fetch ERC20 decimals
+    return Numbers.fromDecimalsNumber(amount, 18);
+  }
+
+  async lockToken() {
+    return await this.params.contract.getContract().methods.token().call();
+  }
+
+  async updateLockAmount({ amount }) {
+    return await this.__sendTx(
+      this.getContract().methods.updateLockAmount(Numbers.toSmartContractDecimals(amount, 18))
+    );
+  }
+
+  async createLand({ name, symbol, tokenAmountToClaim, tokenToAnswer }) {
+    return await this.__sendTx(
+      this.getContract().methods.createLand(
+        name,
+        symbol,
+        Numbers.toSmartContractDecimals(tokenAmountToClaim, 18),
+        tokenToAnswer
+      )
+    );
+  };
+
+  async disableLand({ token }) {
+    return await this.__sendTx(
+      this.getContract().methods.disableLand(token)
+    );
+  }
+
+  async enableLand({ token }) {
+    return await this.__sendTx(
+      this.getContract().methods.enableLand(token)
+    );
+  }
+
+  async unlockOffsetFromLand({ token }) {
+    return await this.__sendTx(
+      this.getContract().methods.unlockOffsetFromLand(token)
+    );
+  }
+
+  async addAdminToLand({ token, user }) {
+    return await this.__sendTx(
+      this.getContract().methods.addAdminToLand(token, user)
+    );
+  }
+
+  async removeAdminFromLand({ token, user }) {
+    return await this.__sendTx(
+      this.getContract().methods.removeAdminFromLand(token, user)
+    );
+  }
+}
+
+module.exports = PredictionMarketV3ManagerContract;

package/src/models/PredictionMarketV3QuerierContract.js

@@ -0,0 +1,24 @@
+const IContract = require('./IContract');
+
+const predictionV3Querier = require("../interfaces").predictionV3Querier;
+
+class PredictionMarketV3QuerierContract extends IContract {
+  constructor(params) {
+    super({ ...params, abi: predictionV3Querier });
+    this.contractName = 'PredictionMarketV3Querier';
+  }
+
+  async getUserMarketsData({ user, marketId }) {
+    return await this.params.contract.getContract().methods.getUserMarketData(user, marketId).call();
+  }
+
+  async getUserMarketsData({ user, marketIds }) {
+    return await this.params.contract.getContract().methods.getUserMarketsData(user, marketIds).call();
+  }
+
+  async getUserAllMarketsData({ user }) {
+    return await this.params.contract.getContract().methods.getUserAllMarketsData(user).call();
+  }
+}
+
+module.exports = PredictionMarketV3QuerierContract;