polkamarkets-js 1.0.2 → 3.1.1

package/contracts/IPredictionMarketV3.sol

@@ -0,0 +1,207 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+interface IPredictionMarketV3 {
+  struct CreateMarketDescription {
+    uint256 value;
+    uint256 closesAt;
+    uint256 outcomes;
+    address token;
+    uint256[] distribution;
+    string question;
+    string image;
+    address arbitrator;
+    uint256 fee;
+    uint256 treasuryFee;
+    address treasury;
+    address realitio;
+    uint256 realitioTimeout;
+    address manager;
+  }
+
+  event MarketActionTx(
+    address indexed user,
+    uint8 indexed action,
+    uint256 indexed marketId,
+    uint256 outcomeId,
+    uint256 shares,
+    uint256 value,
+    uint256 timestamp
+  );
+  event MarketCreated(
+    address indexed user,
+    uint256 indexed marketId,
+    uint256 outcomes,
+    string question,
+    string image,
+    address token
+  );
+  event MarketLiquidity(uint256 indexed marketId, uint256 value, uint256 price, uint256 timestamp);
+  event MarketOutcomePrice(uint256 indexed marketId, uint256 indexed outcomeId, uint256 value, uint256 timestamp);
+  event MarketOutcomeShares(uint256 indexed marketId, uint256 timestamp, uint256[] outcomeShares, uint256 liquidity);
+  event MarketResolved(
+    address indexed user,
+    uint256 indexed marketId,
+    uint256 outcomeId,
+    uint256 timestamp,
+    bool admin
+  );
+
+  function MAX_FEE() external view returns (uint256);
+
+  function MAX_OUTCOMES() external view returns (uint256);
+
+  function MAX_UINT_256() external view returns (uint256);
+
+  function ONE() external view returns (uint256);
+
+  function WETH() external view returns (address);
+
+  function marketIndex() external view returns (uint256);
+
+  function createMarket(CreateMarketDescription memory desc) external returns (uint256);
+
+  function createMarketWithETH(CreateMarketDescription memory desc) external payable returns (uint256);
+
+  function mintAndCreateMarket(CreateMarketDescription memory desc) external returns (uint256);
+
+  function calcBuyAmount(
+    uint256 amount,
+    uint256 marketId,
+    uint256 outcomeId
+  ) external view returns (uint256);
+
+  function calcSellAmount(
+    uint256 amount,
+    uint256 marketId,
+    uint256 outcomeId
+  ) external view returns (uint256 outcomeTokenSellAmount);
+
+  function buy(
+    uint256 marketId,
+    uint256 outcomeId,
+    uint256 minOutcomeSharesToBuy,
+    uint256 value
+  ) external;
+
+  function buyWithETH(
+    uint256 marketId,
+    uint256 outcomeId,
+    uint256 minOutcomeSharesToBuy
+  ) external payable;
+
+  function sell(
+    uint256 marketId,
+    uint256 outcomeId,
+    uint256 value,
+    uint256 maxOutcomeSharesToSell
+  ) external;
+
+  function sellToETH(
+    uint256 marketId,
+    uint256 outcomeId,
+    uint256 value,
+    uint256 maxOutcomeSharesToSell
+  ) external;
+
+  function addLiquidity(uint256 marketId, uint256 value) external;
+
+  function addLiquidityWithETH(uint256 marketId) external payable;
+
+  function removeLiquidity(uint256 marketId, uint256 shares) external;
+
+  function removeLiquidityToETH(uint256 marketId, uint256 shares) external;
+
+  function resolveMarketOutcome(uint256 marketId) external returns (uint256);
+
+  function adminResolveMarketOutcome(uint256 marketId, uint256 outcomeId) external returns (uint256);
+
+  function claimWinnings(uint256 marketId) external;
+
+  function claimWinningsToETH(uint256 marketId) external;
+
+  function claimVoidedOutcomeShares(uint256 marketId, uint256 outcomeId) external;
+
+  function claimVoidedOutcomeSharesToETH(uint256 marketId, uint256 outcomeId) external;
+
+  function claimLiquidity(uint256 marketId) external;
+
+  function claimLiquidityToETH(uint256 marketId) external;
+
+  function claimFees(uint256 marketId) external;
+
+  function claimFeesToETH(uint256 marketId) external;
+
+  function getUserMarketShares(uint256 marketId, address user) external view returns (uint256, uint256[] memory);
+
+  function getUserClaimStatus(uint256 marketId, address user)
+    external
+    view
+    returns (
+      bool,
+      bool,
+      bool,
+      bool,
+      uint256
+    );
+
+  function getUserLiquidityPoolShare(uint256 marketId, address user) external view returns (uint256);
+
+  function getUserClaimableFees(uint256 marketId, address user) external view returns (uint256);
+
+  function getMarkets() external view returns (uint256[] memory);
+
+  function getMarketData(uint256 marketId)
+    external
+    view
+    returns (
+      uint8,
+      uint256,
+      uint256,
+      uint256,
+      uint256,
+      int256
+    );
+
+  function getMarketAltData(uint256 marketId)
+    external
+    view
+    returns (
+      uint256,
+      bytes32,
+      uint256,
+      address,
+      uint256,
+      address,
+      address,
+      uint256,
+      address
+    );
+
+  function getMarketQuestion(uint256 marketId) external view returns (bytes32);
+
+  function getMarketPrices(uint256 marketId) external view returns (uint256, uint256[] memory);
+
+  function getMarketShares(uint256 marketId) external view returns (uint256, uint256[] memory);
+
+  function getMarketLiquidityPrice(uint256 marketId) external view returns (uint256);
+
+  function getMarketResolvedOutcome(uint256 marketId) external view returns (int256);
+
+  function isMarketVoided(uint256 marketId) external view returns (bool);
+
+  function getMarketFee(uint256 marketId) external view returns (uint256);
+
+  function getMarketOutcomeIds(uint256 marketId) external view returns (uint256[] memory);
+
+  function getMarketOutcomePrice(uint256 marketId, uint256 outcomeId) external view returns (uint256);
+
+  function getMarketOutcomeData(uint256 marketId, uint256 outcomeId)
+    external
+    view
+    returns (
+      uint256,
+      uint256,
+      uint256
+    );
+}

package/contracts/IPredictionMarketV3Factory.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IPredictionMarketV3Factory {
+  function isPMControllerAdmin(address controllerAddress, address user) external view returns (bool);
+
+  function isPMControllerActive(address controllerAddress) external view returns (bool);
+}

package/contracts/IPredictionMarketV3Manager.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IPredictionMarketV3Manager {
+  function isAllowedToCreateMarket(IERC20 token, address user) external view returns (bool);
+
+  function isAllowedToResolveMarket(IERC20 token, address user) external view returns (bool);
+
+  function isIERC20TokenSocial(IERC20 token) external view returns (bool);
+}

package/contracts/IRealityETH_ERC20.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: GPL-3.0-only
+// Based on https://github.com/RealityETH/reality-eth-monorepo/blob/main/packages/contracts/development/contracts/IRealityETH_ERC20.sol
+
+pragma solidity ^0.8.18;
+
+interface IRealityETH_ERC20 {
+     event LogAnswerReveal (bytes32 indexed question_id, address indexed user, bytes32 indexed answer_hash, bytes32 answer, uint256 nonce, uint256 bond);
+     event LogCancelArbitration (bytes32 indexed question_id);
+     event LogClaim (bytes32 indexed question_id, address indexed user, uint256 amount);
+     event LogFinalize (bytes32 indexed question_id, bytes32 indexed answer);
+     event LogFundAnswerBounty (bytes32 indexed question_id, uint256 bounty_added, uint256 bounty, address indexed user);
+     event LogMinimumBond (bytes32 indexed question_id, uint256 min_bond);
+     event LogNewAnswer (bytes32 answer, bytes32 indexed question_id, bytes32 history_hash, address indexed user, uint256 bond, uint256 ts, bool is_commitment);
+     event LogNewQuestion (bytes32 indexed question_id, address indexed user, uint256 template_id, string question, bytes32 indexed content_hash, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 nonce, uint256 created);
+     event LogNewTemplate (uint256 indexed template_id, address indexed user, string question_text);
+     event LogNotifyOfArbitrationRequest (bytes32 indexed question_id, address indexed user);
+     event LogReopenQuestion (bytes32 indexed question_id, bytes32 indexed reopened_question_id);
+     event LogSetQuestionFee (address arbitrator, uint256 amount);
+
+     function askQuestion (uint256 template_id, string calldata question, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 nonce) external returns (bytes32);
+     function askQuestionERC20 (uint256 template_id, string calldata question, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 nonce, uint256 tokens) external returns (bytes32);
+     function askQuestionWithMinBondERC20 (uint256 template_id, string calldata question, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 nonce, uint256 min_bond, uint256 tokens) external returns (bytes32);
+     function assignWinnerAndSubmitAnswerByArbitrator (bytes32 question_id, bytes32 answer, address payee_if_wrong, bytes32 last_history_hash, bytes32 last_answer_or_commitment_id, address last_answerer) external;
+     function cancelArbitration (bytes32 question_id) external;
+     function claimMultipleAndWithdrawBalance (bytes32[] calldata question_ids, uint256[] calldata lengths, bytes32[] calldata hist_hashes, address[] calldata addrs, uint256[] calldata bonds, bytes32[] calldata answers) external;
+     function claimWinnings (bytes32 question_id, bytes32[] calldata history_hashes, address[] calldata addrs, uint256[] calldata bonds, bytes32[] calldata answers) external;
+     function createTemplate (string calldata content) external returns (uint256);
+     function createTemplateAndAskQuestion (string calldata content, string calldata question, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 nonce) external returns (bytes32);
+     function fundAnswerBountyERC20 (bytes32 question_id, uint256 tokens) external;
+     function notifyOfArbitrationRequest (bytes32 question_id, address requester, uint256 max_previous) external;
+     function reopenQuestionERC20 (uint256 template_id, string calldata question, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 nonce, uint256 min_bond, bytes32 reopens_question_id, uint256 tokens) external returns (bytes32);
+     function setQuestionFee (uint256 fee) external;
+     function setToken (address _token) external;
+     function submitAnswerByArbitrator (bytes32 question_id, bytes32 answer, address answerer) external;
+     function submitAnswerCommitmentERC20 (bytes32 question_id, bytes32 answer_hash, uint256 max_previous, address _answerer, uint256 tokens) external;
+     function submitAnswerERC20 (bytes32 question_id, bytes32 answer, uint256 max_previous, uint256 tokens) external;
+     function submitAnswerForERC20 (bytes32 question_id, bytes32 answer, uint256 max_previous, address answerer, uint256 tokens) external;
+     function submitAnswerReveal (bytes32 question_id, bytes32 answer, uint256 nonce, uint256 bond) external;
+     function arbitrator_question_fees (address) external view returns (uint256);
+     function commitments (bytes32) external view returns (uint32 reveal_ts, bool is_revealed, bytes32 revealed_answer);
+     function getArbitrator (bytes32 question_id) external view returns (address);
+     function getBestAnswer (bytes32 question_id) external view returns (bytes32);
+     function getBond (bytes32 question_id) external view returns (uint256);
+     function getBounty (bytes32 question_id) external view returns (uint256);
+     function getContentHash (bytes32 question_id) external view returns (bytes32);
+     function getFinalAnswer (bytes32 question_id) external view returns (bytes32);
+     function getFinalAnswerIfMatches (bytes32 question_id, bytes32 content_hash, address arbitrator, uint32 min_timeout, uint256 min_bond) external view returns (bytes32);
+     function getFinalizeTS (bytes32 question_id) external view returns (uint32);
+     function getHistoryHash (bytes32 question_id) external view returns (bytes32);
+     function getMinBond (bytes32 question_id) external view returns (uint256);
+     function getOpeningTS (bytes32 question_id) external view returns (uint32);
+     function getTimeout (bytes32 question_id) external view returns (uint32);
+     function isFinalized (bytes32 question_id) external view returns (bool);
+     function isPendingArbitration (bytes32 question_id) external view returns (bool);
+     function isSettledTooSoon (bytes32 question_id) external view returns (bool);
+     function question_claims (bytes32) external view returns (address payee, uint256 last_bond, uint256 queued_funds);
+     function questions (bytes32) external view returns (bytes32 content_hash, address arbitrator, uint32 opening_ts, uint32 timeout, uint32 finalize_ts, bool is_pending_arbitration, uint256 bounty, bytes32 best_answer, bytes32 history_hash, uint256 bond, uint256 min_bond);
+     function reopened_questions (bytes32) external view returns (bytes32);
+     function reopener_questions (bytes32) external view returns (bool);
+     function resultFor (bytes32 question_id) external view returns (bytes32);
+     function resultForOnceSettled (bytes32 question_id) external view returns (bytes32);
+     function template_hashes (uint256) external view returns (bytes32);
+     function templates (uint256) external view returns (uint256);
+}

package/contracts/LandFactory.sol

@@ -0,0 +1,248 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.18;
+
+import "./FantasyERC20.sol";
+import "./RealityETH_ERC20_Factory.sol";
+
+// openzeppelin ownable contract import
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
+
+abstract contract LandFactory is Ownable, ReentrancyGuard {
+  struct Land {
+    FantasyERC20 token;
+    bool active;
+    mapping(address => bool) admins;
+    uint256 lockAmount;
+    address lockUser;
+    IRealityETH_IERC20 realitio;
+  }
+
+  address public PMV3; // PredictionMarketV3 contract
+  IERC20 public token; // Governance IERC20
+  uint256 public lockAmount; // amount necessary to lock to create a land
+  RealityETH_ERC20_Factory public realitioFactory;
+
+  mapping(address => Land) public lands;
+  address[] public landTokens;
+  uint256 public landTokensLength;
+  mapping(address => bool) public fantasyTokens;
+
+  event LandCreated(address indexed user, address indexed token, address indexed tokenToAnswer, uint256 amountLocked);
+
+  event LandDisabled(address indexed user, address indexed token, uint256 amountUnlocked);
+
+  event LandEnabled(address indexed user, address indexed token, uint256 amountLocked);
+
+  event LandOffsetUnlocked(address indexed user, address indexed token, uint256 amountUnlocked);
+
+  event LandAdminAdded(address indexed user, address indexed token, address indexed admin);
+
+  event LandAdminRemoved(address indexed user, address indexed token, address indexed admin);
+
+  // lockAmount is the amount of tokens that the user needs to lock to create a land
+  // by locking the amount the factory will create a fantasyERC20 token and store it in the contract
+  // the user will be the admin of the land
+  function createLand(
+    string memory name,
+    string memory symbol,
+    uint256 tokenAmountToClaim,
+    IERC20 tokenToAnswer
+  ) external virtual returns (FantasyERC20) {
+    return _createLand(name, symbol, tokenAmountToClaim, tokenToAnswer, address(0), address(0));
+  }
+
+  function createLand(FantasyERC20 landToken, IERC20 tokenToAnswer) external virtual returns (FantasyERC20) {
+    return _createLand(landToken, tokenToAnswer);
+  }
+
+  function _createLand(
+    string memory name,
+    string memory symbol,
+    uint256 tokenAmountToClaim,
+    IERC20 tokenToAnswer,
+    address PMV3Factory,
+    address PMV3Controller
+  ) internal returns (FantasyERC20) {
+    // create a new fantasyERC20 token
+    FantasyERC20 landToken = new FantasyERC20(
+      name,
+      symbol,
+      tokenAmountToClaim,
+      address(PMV3),
+      PMV3Factory,
+      PMV3Controller
+    );
+
+    // adding minting privileges to the PMV3 contract
+    landToken.grantRole(keccak256("MINTER_ROLE"), address(PMV3));
+    // adding minting privileges to the msg.sender
+    landToken.grantRole(keccak256("MINTER_ROLE"), msg.sender);
+
+    fantasyTokens[address(landToken)] = true;
+
+    return _createLand(landToken, tokenToAnswer);
+  }
+
+  function _createLand(FantasyERC20 landToken, IERC20 tokenToAnswer) internal returns (FantasyERC20) {
+    // checking if land with same token was already created
+    require(!lands[address(landToken)].active, "Land already exists");
+
+    if (lockAmount > 0) {
+      // transfer the lockAmount to the contract
+      require(token.balanceOf(msg.sender) >= lockAmount, "Not enough tokens to lock");
+      token.transferFrom(msg.sender, address(this), lockAmount);
+    }
+    require(address(tokenToAnswer) != address(0), "Token to answer cannot be 0 address");
+
+    // store the new token in the contract
+    Land storage land = lands[address(landToken)];
+    land.token = landToken;
+    land.active = true;
+    land.admins[msg.sender] = true;
+    land.lockAmount = lockAmount;
+    land.lockUser = msg.sender;
+    landTokens.push(address(landToken));
+    landTokensLength++;
+
+    // creating the realityETH_ERC20 contract
+    if (realitioFactory.deployments(address(tokenToAnswer)) == address(0)) {
+      realitioFactory.createInstance(address(tokenToAnswer));
+    }
+    land.realitio = IRealityETH_IERC20(realitioFactory.deployments(address(tokenToAnswer)));
+
+    emit LandCreated(msg.sender, address(landToken), address(tokenToAnswer), lockAmount);
+
+    return landToken;
+  }
+
+  function disableLand(IERC20 landToken) external virtual {
+    Land storage land = lands[address(landToken)];
+
+    require(land.active, "Land is not active");
+    require(isLandAdmin(landToken, msg.sender), "Not admin of the land");
+
+    uint256 amountToUnlock = land.lockAmount;
+
+    if (amountToUnlock > 0) {
+      token.transfer(land.lockUser, amountToUnlock);
+    }
+
+    // disable the land
+    land.active = false;
+    land.lockAmount = 0;
+    land.lockUser = address(0);
+
+    if (fantasyTokens[address(landToken)]) {
+      // pausing token
+      land.token.pause();
+    }
+
+    emit LandDisabled(msg.sender, address(landToken), amountToUnlock);
+  }
+
+  function enableLand(IERC20 landToken) external virtual {
+    Land storage land = lands[address(landToken)];
+
+    require(!land.active, "Land is already active");
+    require(isLandAdmin(landToken, msg.sender), "Not admin of the land");
+
+    uint256 amountToLock = lockAmount > land.lockAmount ? lockAmount - land.lockAmount : 0;
+
+    // transfer the lockAmount to the contract
+    if (amountToLock > 0) {
+      token.transferFrom(msg.sender, address(this), amountToLock);
+    }
+
+    // enable the land
+    land.active = true;
+    land.lockAmount = land.lockAmount + amountToLock;
+    land.lockUser = msg.sender;
+
+    if (fantasyTokens[address(landToken)]) {
+      // unpausing token
+      land.token.unpause();
+    }
+
+    emit LandEnabled(msg.sender, address(landToken), amountToLock);
+  }
+
+  function unlockOffsetFromLand(IERC20 landToken) external virtual {
+    Land storage land = lands[address(landToken)];
+
+    require(land.active, "Land is not active");
+    require(isLandAdmin(landToken, msg.sender), "Not admin of the land");
+
+    uint256 amountToUnlock = land.lockAmount > lockAmount ? land.lockAmount - lockAmount : 0;
+
+    if (amountToUnlock > 0) {
+      token.transfer(msg.sender, amountToUnlock);
+      land.lockAmount = land.lockAmount - amountToUnlock;
+    }
+
+    emit LandOffsetUnlocked(msg.sender, address(landToken), amountToUnlock);
+  }
+
+  function updateLockAmount(uint256 newLockAmount) external onlyOwner {
+    require(newLockAmount > 0, "Lock amount must be greater than 0");
+    require(newLockAmount != lockAmount, "Lock amount is the same");
+
+    lockAmount = newLockAmount;
+  }
+
+  function addAdminToLand(IERC20 landToken, address admin) external virtual {
+    Land storage land = lands[address(landToken)];
+
+    require(land.active, "Land does not exist");
+    require(isLandAdmin(landToken, msg.sender), "Not admin of the land");
+
+    // adding minting privileges to the admin
+    if (fantasyTokens[address(landToken)]) {
+      land.token.grantRole(keccak256("MINTER_ROLE"), admin);
+    }
+
+    land.admins[admin] = true;
+
+    emit LandAdminAdded(msg.sender, address(landToken), admin);
+  }
+
+  function removeAdminFromLand(IERC20 landToken, address admin) external virtual {
+    Land storage land = lands[address(landToken)];
+
+    require(land.active, "Land does not exist");
+    require(isLandAdmin(landToken, msg.sender), "Not admin of the land");
+
+    // removing minting privileges from the admin
+    if (fantasyTokens[address(landToken)]) {
+      land.token.revokeRole(keccak256("MINTER_ROLE"), admin);
+    }
+
+    land.admins[admin] = false;
+
+    emit LandAdminRemoved(msg.sender, address(landToken), admin);
+  }
+
+  function isAllowedToCreateMarket(IERC20 marketToken, address user) public view virtual returns (bool) {
+    Land storage land = lands[address(marketToken)];
+
+    return land.active && land.admins[user];
+  }
+
+  function isAllowedToResolveMarket(IERC20 marketToken, address user) external view virtual returns (bool) {
+    Land storage land = lands[address(marketToken)];
+
+    return land.active && land.admins[user];
+  }
+
+  function isIERC20TokenSocial(IERC20 marketToken) external view virtual returns (bool) {
+    Land storage land = lands[address(marketToken)];
+
+    return land.active;
+  }
+
+  function isLandAdmin(IERC20 marketToken, address user) public view virtual returns (bool) {
+    Land storage land = lands[address(marketToken)];
+
+    return land.admins[user];
+  }
+}

package/contracts/Migrations.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.5.1;
+
+contract Migrations {
+  address public owner;
+  uint256 public lastCompletedMigration;
+
+  modifier restricted() {
+    if (msg.sender == owner) _;
+  }
+
+  constructor() public {
+    owner = msg.sender;
+  }
+
+  function setCompleted(uint256 completed) public restricted {
+    lastCompletedMigration = completed;
+  }
+
+  function upgrade(address newAddress) public restricted {
+    Migrations upgraded = Migrations(newAddress);
+    upgraded.setCompleted(lastCompletedMigration);
+  }
+}