polkamarkets-js 1.0.1 → 3.1.0

package/src/models/ArbitrationContract.js

@@ -0,0 +1,69 @@
+const arbitration = require("../interfaces").arbitration;
+const Numbers = require("../utils/Numbers");
+const IContract = require('./IContract');
+
+/**
+ * Arbitration Contract Object
+ * @constructor ArbitrationContract
+ * @param {Web3} web3
+ * @param {Integer} decimals
+ * @param {Address} contractAddress
+ */
+
+class ArbitrationContract extends IContract {
+  constructor(params) {
+    super({ abi: arbitration, ...params });
+    this.contractName = 'arbitration';
+  }
+
+  /**
+   * @function getDisputeFee
+   * @description get cost of applying for arbitration
+   * @param {bytes32} questionId
+   * @return {Integer} decimals
+   */
+  async getDisputeFee({ questionId }) {
+    const fee = await this.params.contract.getContract().methods.getDisputeFee(questionId).call();
+
+    return Numbers.fromDecimalsNumber(fee, 18);
+  }
+
+  async getArbitrationDisputeId({ questionId }) {
+    const allEvents = await this.getEvents('ArbitrationCreated');
+    const questionEvents = allEvents.filter(event => event.returnValues._questionID === questionId);
+
+    if (questionEvents.length === 0) return null;
+
+    return Number(questionEvents[0].returnValues._disputeID);
+  }
+
+  async getArbitrationRequests({ questionId }) {
+    const allEvents = await this.getEvents('ArbitrationRequested');
+    const questionEvents = allEvents.filter(event => event.returnValues._questionID === questionId);
+
+    return questionEvents.map(event => ({
+      questionId: event.returnValues._questionID,
+      requester: event.returnValues._requester,
+      maxPrevious: Numbers.fromDecimalsNumber(event.returnValues._maxPrevious, 18)
+    }));
+  }
+
+  /**
+   * @function requestArbitration
+   * @description apply for arbitration
+   * @param {bytes32} questionId
+   * @param {Integer} maxPrevious
+   */
+  async requestArbitration({ questionId, bond }) {
+    const fee = await this.params.contract.getContract().methods.getDisputeFee(questionId).call();
+    const maxPrevious = Numbers.toSmartContractDecimals(bond, 18);
+
+    return await this.__sendTx(
+      this.getContract().methods.requestArbitration(questionId, maxPrevious),
+      false,
+      fee
+    );
+  }
+}
+
+module.exports = ArbitrationContract;

package/src/models/ArbitrationProxyContract.js

@@ -0,0 +1,32 @@
+const arbitrationProxy = require("../interfaces").arbitrationProxy;
+const Numbers = require("../utils/Numbers");
+const IContract = require('./IContract');
+
+/**
+ * ArbitrationProxy Contract Object
+ * @constructor ArbitrationProxyContract
+ * @param {Web3} web3
+ * @param {Integer} decimals
+ * @param {Address} contractAddress
+ */
+
+class ArbitrationProxyContract extends IContract {
+  constructor(params) {
+    super({ abi: arbitrationProxy, ...params });
+    this.contractName = 'arbitrationProxy';
+  }
+
+  async getArbitrationRequestsRejected({ questionId }) {
+    const allEvents = await this.getEvents('RequestRejected');
+    const questionEvents = allEvents.filter(event => event.returnValues._questionID === questionId);
+
+    return questionEvents.map(event => ({
+      questionId: event.returnValues._questionID,
+      requester: event.returnValues._requester,
+      maxPrevious: Numbers.fromDecimalsNumber(event.returnValues._maxPrevious, 18),
+      reason: event.returnValues._reason
+    }));
+  }
+}
+
+module.exports = ArbitrationProxyContract;

package/src/models/ERC20Contract.js

@@ -0,0 +1,156 @@
+const ierc20 = require("../interfaces").ierc20;
+const Numbers = require("../utils/Numbers");
+const IContract = require('./IContract');
+
+class ERC20Contract extends IContract {
+  constructor(params, abi) {
+    super({...params, abi: params.abi || ierc20});
+    this.contractName = 'erc20';
+  }
+
+  async __assert() {
+    await super.__assert();
+    this.params.decimals = await this.getDecimalsAsync();
+  }
+
+  async transferTokenAmount({ toAddress, tokenAmount }) {
+    let amountWithDecimals = Numbers.toSmartContractDecimals(
+      tokenAmount,
+      this.getDecimals()
+    );
+    return await this.__sendTx(
+      this.getContract()
+        .methods.transfer(toAddress, amountWithDecimals)
+    );
+  }
+
+  async getTokenAmount(address) {
+    return Numbers.fromDecimals(
+      await this.getContract().methods.balanceOf(address).call(),
+      this.getDecimals()
+    );
+  }
+
+  async totalSupply() {
+    return Numbers.fromDecimals(await this.getContract().methods.totalSupply().call(), this.getDecimals());
+  }
+
+  getABI() {
+    return this.params.contract;
+  }
+
+  getDecimals() {
+    return this.params.decimals;
+  }
+
+  async getDecimalsAsync() {
+    return await this.getContract().methods.decimals().call();
+  }
+
+  async balanceOf({ address }) {
+    const decimals = this.getDecimals() || (await this.getDecimalsAsync());
+    return Numbers.fromDecimalsNumber(await this.getContract().methods.balanceOf(address).call(), decimals);
+  }
+
+  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() || (await this.getDecimalsAsync())
+      );
+      let res = await this.__sendTx(
+        this.getContract().methods.approve(address, amountWithDecimals),
+        null,
+        null,
+        callback
+      );
+      return res;
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async burn({ amount }) {
+    try {
+      let amountWithDecimals = Numbers.toSmartContractDecimals(
+        amount,
+        this.getDecimals()
+      );
+      let res = await this.__sendTx(
+        this.getContract().methods.burn(amountWithDecimals),
+        false,
+      );
+      return res;
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async mint({ address, amount }) {
+    try {
+      let amountWithDecimals = Numbers.toSmartContractDecimals(
+        amount,
+        this.getDecimals()
+      );
+      let res = await this.__sendTx(
+        this.getContract().methods.mint(address, amountWithDecimals),
+        false,
+      );
+      return res;
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  async burnEvents({ address }) {
+    const events = await this.getEvents(
+      'Transfer',
+      { from: address, to: '0x0000000000000000000000000000000000000000' }
+    )
+
+    // attaching block timestamp to event
+    return await Promise.all(events.map(async (event) => {
+      const block = await this.getBlock(event.blockNumber);
+
+      return {
+        ...event,
+        timestamp: block.timestamp
+      };
+    }));
+  }
+
+  async name() {
+    return await this.getContract().methods.name().call();
+  }
+
+  async symbol() {
+    return await this.getContract().methods.symbol().call();
+  }
+
+  async paused() {
+    return await this.getContract().methods.paused().call();
+  }
+
+  async getTokenInfo() {
+    return {
+      name: await this.name(),
+      address: this.getAddress(),
+      ticker: await this.symbol(),
+      decimals: await this.getDecimalsAsync(),
+    };
+  }
+}
+
+module.exports = ERC20Contract;

package/src/models/FantasyERC20Contract.js

@@ -0,0 +1,92 @@
+const fantasyerc20 = require("../interfaces").fantasyerc20;
+const ERC20Contract = require("./ERC20Contract");
+
+const Numbers = require("../utils/Numbers");
+
+/**
+ * Fantasy ERC20 Contract Object
+ * @constructor FantasyERC20Contract
+ * @param {Web3} web3
+ * @param {Integer} decimals
+ * @param {Address} contractAddress
+ */
+
+class FantasyERC20Contract extends ERC20Contract {
+  constructor(params) {
+    super({ abi: fantasyerc20, ...params });
+    this.contractName = 'erc20';
+  }
+
+  /* Get Functions */
+  /**
+   * @function hasUserClaimedTokens
+   * @description Returns if the user has already claimed the tokens
+   * @returns {Boolean} claimedTokens
+   */
+  async hasUserClaimedTokens({ address }) {
+    return await this.params.contract
+      .getContract()
+      .methods
+      .hasUserClaimedTokens(address)
+      .call();
+  }
+
+  /**
+   * @function tokenAmountToClaim
+   * @description Returns the amount of tokens to claim
+   * @returns {Integer} tokenAmountToClaim
+   *
+   */
+  async tokenAmountToClaim() {
+    const tokenAmountToClaim = Numbers.fromDecimalsNumber(
+      await this.params.contract
+        .getContract()
+        .methods
+        .tokenAmountToClaim()
+        .call(),
+      this.getDecimals()
+    );
+
+    return tokenAmountToClaim;
+  }
+
+  /* POST User Functions */
+
+  /**
+   * @function claimTokens
+   * @description Claim tokens for sender
+   */
+  async claimTokens() {
+    return await this.__sendTx(
+      this.getContract().methods.claimTokens()
+    );
+  };
+
+  /**
+   * @function claimAndApproveTokens
+   * @description Claim and approve tokens for sender
+   */
+  async claimAndApproveTokens() {
+    return await this.__sendTx(
+      this.getContract().methods.claimAndApproveTokens()
+    );
+  };
+
+  /**
+   * @function resetBalance
+   * @description Reset user's balance to tokenAmountToClaim
+   */
+  async resetBalance() {
+    const address = await this.getMyAccount();
+    if (!address) return false;
+
+    const tokenAmountToClaim = await this.tokenAmountToClaim();
+    const balance = await this.getTokenAmount(address);
+
+    const amountToBurn = balance - tokenAmountToClaim > 0 ? balance - tokenAmountToClaim : 0;
+
+    return await this.burn({ amount: amountToBurn });
+  };
+}
+
+module.exports = FantasyERC20Contract;