polkamarkets-js 3.2.0 → 3.3.1

package/scripts/DeployUSDT.s.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.26;
+
+import {Script} from "forge-std/Script.sol";
+import {ERC20MinterPauser} from "../contracts/ERC20MinterPauser.sol";
+
+contract USDT is ERC20MinterPauser {
+  constructor(string memory _name, string memory _symbol) ERC20MinterPauser(_name, _symbol) {}
+
+  function decimals() public pure override returns (uint8) {
+    return 18;
+  }
+}
+
+
+contract DeployUSDT is Script {
+  function run() public {
+    vm.startBroadcast();
+
+    new USDT("Tether USD", "USDT");
+
+    vm.stopBroadcast();
+  }
+}

package/scripts/MintTokens.s.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.26;
+
+import {Script} from "forge-std/Script.sol";
+import {console} from "forge-std/console.sol";
+import {ERC20MinterPauser} from "../contracts/ERC20MinterPauser.sol";
+
+contract MintTokens is Script {
+  function run() public {
+    vm.startBroadcast();
+
+    address token = address(0x49Ff827F0C8835ebd8109Cc3b51b80435ce44F09);
+    address user = address(0x68FcB3Db1BA4Abb85D9f9420A110948e6459d613);
+    uint256 amount = 1000000000000000000000000;
+
+    ERC20MinterPauser(token).mint(user, amount);
+    console.log("Tokens minted to:", user);
+
+    vm.stopBroadcast();
+  }
+}

package/scripts/PublishMerkleRoot.s.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.26;
+
+import {Script} from "forge-std/Script.sol";
+import {console} from "forge-std/console.sol";
+import {MerkleRewardsDistributor} from "../contracts/MerkleRewardsDistributor.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract PublishMerkleRoot is Script {
+  function run() public {
+    vm.startBroadcast();
+
+    MerkleRewardsDistributor distributor = MerkleRewardsDistributor(address(0x846BBEF1e62c211a16fD3F4Cd15C54B010D85036));
+    IERC20 token = IERC20(address(0xf74B14ecbAdC9fBb283Fb3c8ae11E186856eae6f));
+    bytes32 root = bytes32(0x07b1c91af93eaf54d8cf1644d632ddee695267f4044167b88842e90be3e4878e);
+    string memory contestId = "55d2ca19-fee9-4320-a7c6-aea620ba7588";
+
+    string[5] memory contestIds = [
+      "8c8f733c-ecca-4a8b-8ce9-a1208f04de2a",
+      "4f29b3d5-097a-404c-9014-9e5ba7cb38a0",
+      "1577b57f-e763-4d07-8c58-56d36a49563e",
+      "9fbcd4d2-3fb3-4c0b-9fcd-82e7604d1673",
+      "b72746ec-8046-4ae5-9a34-92270ab6c3f7"
+    ];
+
+    bytes32[5] memory roots = [
+      bytes32(0x29512536af9410dc44a47a16eeff9e65ebb3e05fd5c8369c2dfa59a5bee9e2ac),
+      bytes32(0x66af758212a3c1ee876654b4e354908f57caf337178f3895dcc059e2b507ee83),
+      bytes32(0x8d022151e97cfb76f08c309f24d13bea76d1f2d7d81c38f46c49d1584912f988),
+      bytes32(0x1936d0d67853de21b9f4bd6f369c545e77b63c98596e95d61306f1ac1c0848f9),
+      bytes32(0xe84504014594f44045abdb598af6253ac00d41f3da59002dcaa7fd4d3acaaf40)
+    ];
+
+    for (uint256 i = 0; i < contestIds.length; i++) {
+      distributor.publishRoot(
+        contestIds[i],
+        IERC20(address(token)),
+        roots[i]
+      );
+    }
+
+    // distributor.publishRoot(
+    //   contestId,
+    //   IERC20(address(token)),
+    //   root
+    // );
+
+    vm.stopBroadcast();
+  }
+}

package/scripts/ResolveMarket.s.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.26;
+
+import {Script} from "forge-std/Script.sol";
+import {console} from "forge-std/console.sol";
+import {PredictionMarketV3_4} from "../contracts/PredictionMarketV3_4.sol";
+import {IPredictionMarketV3Manager} from "../contracts/IPredictionMarketV3Manager.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract ResolveMarket is Script {
+  function run() public {
+    vm.startBroadcast();
+
+    address predictionMarket = address(0x289E3908ECDc3c8CcceC5b6801E758549846Ab19);
+    uint256 marketId = 5;
+    uint256 outcomeId = 0;
+
+    PredictionMarketV3_4(payable(predictionMarket)).adminResolveMarketOutcome(
+      marketId,
+      outcomeId
+    );
+  }
+}

package/scripts/TradeMarket.s.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.26;
+
+import {Script} from "forge-std/Script.sol";
+import {console} from "forge-std/console.sol";
+import {PredictionMarketV3_4} from "../contracts/PredictionMarketV3_4.sol";
+import {IPredictionMarketV3Manager} from "../contracts/IPredictionMarketV3Manager.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract TradeMarket is Script {
+  function run() public {
+    vm.startBroadcast();
+
+    address predictionMarket = address(0x289E3908ECDc3c8CcceC5b6801E758549846Ab19);
+    uint256 marketId = 4;
+    uint256 outcomeId = 0;
+    uint256 minOutcomeSharesToBuy = 1;
+    uint256 amount = 1000000;
+
+    // PredictionMarketV3_4(payable(predictionMarket)).buy(
+    //     marketId,
+    //     outcomeId,
+    //     minOutcomeSharesToBuy,
+    //     amount
+    // );
+    PredictionMarketV3_4(payable(predictionMarket)).addLiquidity(marketId, amount, 0);
+  }
+}

package/scripts/UpdateMarket.s.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.26;
+
+import {Script} from "forge-std/Script.sol";
+import {console} from "forge-std/console.sol";
+// Import your contracts here
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {PredictionMarketV3_3, IWETH} from "../contracts/PredictionMarketV3_3.sol";
+import {IPredictionMarketV3Manager} from "../contracts/IPredictionMarketV3Manager.sol";
+import {PredictionMarketV3Manager, FantasyERC20} from "../contracts/PredictionMarketV3Manager.sol";
+import {IRealityETH_ERC20} from "../contracts/IRealityETH_ERC20.sol";
+
+contract UpdateMarket is Script {
+    function run() public {
+
+        vm.startBroadcast();
+
+        address payable PREDICTION_MARKET_V3_3 = payable(address(0x3e0F5F8F5Fb043aBFA475C0308417Bf72c463289));
+        address PREDICTION_MARKET_V3_MANAGER = address(0x68dDc91CCC06e63d74905D901A30edEA7C77EebE);
+
+        PredictionMarketV3_3.MarketState state = PredictionMarketV3_3(PREDICTION_MARKET_V3_3).getMarketState(486);
+        console2.log("state: ", state);
+
+        PredictionMarketV3_3.MarketUpdateDescription memory description = PredictionMarketV3_3.MarketUpdateDescription({
+            closesAtTimestamp: 1762066800,
+            balance: 456538064447348172635074428,
+            liquidity: 120000000000000000000000000,
+            sharesAvailable: 1272835104225672313766121101,
+            state: PredictionMarketV3_3.MarketState.open,
+            resolution: PredictionMarketV3_3.MarketResolution({
+                resolved: false,
+                realitio: IRealityETH_ERC20(0x71D76Ff3C2729071B2c52A667197d9f715029F2c),
+                outcomeId: 115792089237316195423570985008687907853269984665640564039457584007913129639935,
+                questionId: 0x21d6c6c195572d82a7d0a7ba677251dfd3839b21e09df9b39ae36ec99fa6744d,
+                realitioTimeout: 3600
+            }),
+            feesPoolWeight: 0,
+            feesTreasury: address(0xBc30e9765Dc8c735206c76DE96d369754eBbcc1f),
+            feesDistributor: address(0xBc30e9765Dc8c735206c76DE96d369754eBbcc1f),
+            buyFees: PredictionMarketV3_3.Fees({fee: 0, treasuryFee: 0, distributorFee: 0}),
+            sellFees: PredictionMarketV3_3.Fees({fee: 0, treasuryFee: 0, distributorFee: 0}),
+            outcomeCount: 5,
+            token: IERC20(0x0b07cf011B6e2b7E0803b892d97f751659940F23),
+            manager: IPredictionMarketV3Manager(0x2EbD002d755bdFadb9e5549aA00a80bd7fa408AE),
+            creator: address(0xBc30e9765Dc8c735206c76DE96d369754eBbcc1f),
+            paused: false
+        });
+
+        PredictionMarketV3_3(PREDICTION_MARKET_V3_3).updateMarket(486, description);
+        PredictionMarketV3_3(PREDICTION_MARKET_V3_3).updateMarketResolution(486, description);
+
+        state = PredictionMarketV3_3(PREDICTION_MARKET_V3_3).getMarketState(486);
+        console2.log("new state: ", state);
+    }
+}

package/src/Application.js

@@ -196,11 +196,12 @@ class Application {
    * @param {Address} ContractAddress (Opt) If it is deployed
    * @description Create a PredictionMarketV3 Contract
    */
-  getPredictionMarketV3PlusContract({ contractAddress = null, querierContractAddress = null } = {}) {
+  getPredictionMarketV3PlusContract({ contractAddress = null, querierContractAddress = null, contractVersion = null } = {}) {
     try {
       return new PredictionMarketV3PlusContract({
         ...this.contractDefaultParams(contractAddress),
         querierContractAddress,
+        contractVersion,
       });
     } catch (err) {
       throw err;

package/src/interfaces/index.js

@@ -7,6 +7,8 @@ let index = {
   prediction: require("../../abis/PredictionMarket.json"),
   predictionV2: require("../../abis/PredictionMarketV2.json"),
   predictionV3: require("../../abis/PredictionMarketV3.json"),
+  predictionV3_2: require("../../abis/PredictionMarketV3_2.json"),
+  predictionV3_3: require("../../abis/PredictionMarketV3_3.json"),
   predictionV3Plus: require("../../abis/PredictionMarketV3_4.json"),
   predictionV3Manager: require("../../abis/PredictionMarketV3Manager.json"),
   predictionV3Controller: require("../../abis/PredictionMarketV3Controller.json"),

package/src/models/PredictionMarketV3Contract.js

@@ -1,6 +1,7 @@
 const predictionV3 = require("../interfaces").predictionV3;
 const PredictionMarketV2Contract = require("./PredictionMarketV2Contract");
 const PredictionMarketV3QuerierContract = require("./PredictionMarketV3QuerierContract");
+const _ = require('lodash');
 
 const Numbers = require('../utils/Numbers');
 
@@ -217,6 +218,8 @@ class PredictionMarketV3Contract extends PredictionMarketV2Contract {
         ];
       }));
 
+      const liquidityFeesClaimed = _.sumBy(_.filter(events, { action: 'Claim Fees' }), 'value');
+
       const item = {
         liquidity: {
           shares: Numbers.fromDecimalsNumber(marketData.liquidityShares, decimals),
@@ -230,7 +233,8 @@ class PredictionMarketV3Contract extends PredictionMarketV2Contract {
           liquidityClaimed: marketData.liquidityClaimed,
           voidedWinningsToClaim: marketData.voidedSharesToClaim,
           voidedWinningsClaimed: false,
-          liquidityFees: 0 // discontinued
+          liquidityFees: 0, // discontinued
+          liquidityFeesClaimed
         }
       };
 

package/src/models/PredictionMarketV3PlusContract.js

@@ -1,4 +1,6 @@
-const predictionV3 = require("../interfaces").predictionV3Plus;
+const predictionV3_2 = require("../interfaces").predictionV3_2;
+const predictionV3_3 = require("../interfaces").predictionV3_3;
+const predictionV3Plus = require("../interfaces").predictionV3Plus;
 const PredictionMarketV3Contract = require("./PredictionMarketV3Contract");
 const PredictionMarketV3QuerierContract = require("./PredictionMarketV3QuerierContract");
 
@@ -8,7 +10,11 @@ const realitioLib = require('@reality.eth/reality-eth-lib/formatters/question');
 
 class PredictionMarketV3PlusContract extends PredictionMarketV3Contract {
   constructor(params) {
-    super({ abi: predictionV3, ...params });
+    let abi = predictionV3Plus;
+    if (params.contractVersion && params.contractVersion < 3.4) {
+      abi = params.contractVersion === 3.3 ? predictionV3_3 : predictionV3_2;
+    }
+    super({ abi, ...params });
     this.contractName = 'predictionMarketV3';
     if (params.defaultDecimals) {
       this.defaultDecimals = params.defaultDecimals;
@@ -19,6 +25,9 @@ class PredictionMarketV3PlusContract extends PredictionMarketV3Contract {
         contractAddress: params.querierContractAddress
       });
     }
+    if (params.contractVersion) {
+      this.contractVersion = params.contractVersion;
+    }
     this.marketDecimals = {};
   }
 
@@ -205,6 +214,34 @@ class PredictionMarketV3PlusContract extends PredictionMarketV3Contract {
       this.getContract().methods.referralSell(marketId, outcomeId, valueToWei, maxOutcomeSharesToSell, code),
     );
   };
+
+  async addLiquidity({marketId, value, wrapped = false, minSharesIn = null}) {
+    if (!this.contractVersion || this.contractVersion < 3.4) {
+      return super.addLiquidity({marketId, value, wrapped});
+    }
+
+    const decimals = await this.getMarketDecimals({marketId});
+    const valueToWei = Numbers.toSmartContractDecimals(value, decimals);
+    const minSharesInToWei = minSharesIn === null ? 0 : Numbers.toSmartContractDecimals(minSharesIn, decimals);
+
+    return await this.__sendTx(
+      this.getContract().methods.addLiquidity(marketId, valueToWei, minSharesInToWei)
+    );
+  };
+
+  async removeLiquidity({marketId, shares, wrapped = false, minValueOut = null}) {
+    if (!this.contractVersion || this.contractVersion < 3.4) {
+      return super.removeLiquidity({marketId, shares, wrapped});
+    }
+
+    const decimals = await this.getMarketDecimals({marketId});
+    const sharesToWei = Numbers.toSmartContractDecimals(shares, decimals);
+    const minValueOutToWei = minValueOut === null ? 0 : Numbers.toSmartContractDecimals(minValueOut, decimals);
+
+    return await this.__sendTx(
+      this.getContract().methods.removeLiquidity(marketId, sharesToWei, minValueOutToWei)
+    );
+  }
 }
 
 module.exports = PredictionMarketV3PlusContract;

package/test/UpdateTest.t.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.0;
+
+import "forge-std/console2.sol";
+import "../contracts/PredictionMarketV3_3.sol";
+
+import {Test} from "forge-std/Test.sol";
+import {console} from "forge-std/console.sol";
+
+// forge test --match-contract POC -vvvvv --fork-url $RPC_URL --fork-block-number 13292408 --zksync
+contract UpdateTest is Test {
+    function test_POC() public {
+        address predictionMarketV3 = 0x3e0F5F8F5Fb043aBFA475C0308417Bf72c463289;
+        address admin = 0x0a70f6F09caa802D8d62dE9C7EdacE1d3b5Ca160;
+
+        vm.startPrank(admin);
+
+        address payable PREDICTION_MARKET_V3_3 = payable(address(0x3e0F5F8F5Fb043aBFA475C0308417Bf72c463289));
+
+        (PredictionMarketV3_3.MarketState state, uint256 closesAt, uint256 liquidity, uint256 balance, uint256 sharesAvailable, int256 resolvedOutcomeId) = PredictionMarketV3_3(payable(predictionMarketV3)).getMarketData(486);
+        console.log("state: ", uint256(state));
+
+        PredictionMarketV3_3.MarketUpdateDescription memory description = PredictionMarketV3_3.MarketUpdateDescription({
+            closesAtTimestamp: 1762066800,
+            balance: 456538064447348172635074428,
+            liquidity: 120000000000000000000000000,
+            sharesAvailable: 1272835104225672313766121101,
+            state: PredictionMarketV3_3.MarketState.open,
+            resolution: PredictionMarketV3_3.MarketResolution({
+                resolved: false,
+                realitio: IRealityETH_ERC20(0x71D76Ff3C2729071B2c52A667197d9f715029F2c),
+                outcomeId: 115792089237316195423570985008687907853269984665640564039457584007913129639935,
+                questionId: 0x21d6c6c195572d82a7d0a7ba677251dfd3839b21e09df9b39ae36ec99fa6744d,
+                realitioTimeout: 3600
+            }),
+            feesPoolWeight: 0,
+            feesTreasury: address(0xBc30e9765Dc8c735206c76DE96d369754eBbcc1f),
+            feesDistributor: address(0xBc30e9765Dc8c735206c76DE96d369754eBbcc1f),
+            buyFees: PredictionMarketV3_3.Fees({fee: 0, treasuryFee: 0, distributorFee: 0}),
+            sellFees: PredictionMarketV3_3.Fees({fee: 0, treasuryFee: 0, distributorFee: 0}),
+            outcomeCount: 5,
+            token: IERC20(0x0b07cf011B6e2b7E0803b892d97f751659940F23),
+            manager: IPredictionMarketV3Manager(0x2EbD002d755bdFadb9e5549aA00a80bd7fa408AE),
+            creator: address(0xBc30e9765Dc8c735206c76DE96d369754eBbcc1f),
+            paused: false
+        });
+
+        PredictionMarketV3_3(PREDICTION_MARKET_V3_3).updateMarket(486, description);
+        PredictionMarketV3_3(PREDICTION_MARKET_V3_3).updateMarketResolution(486, description);
+
+        (state, closesAt, liquidity, balance, sharesAvailable, resolvedOutcomeId) = PredictionMarketV3_3(PREDICTION_MARKET_V3_3).getMarketData(486);
+        console2.log("new state: ", uint256(state));
+
+    }
+}

package/test/WhaleTest.t.sol

@@ -0,0 +1,188 @@
+// SPDX-License-Identifier: GPL-2.0
+pragma solidity ^0.8.0;
+
+import "forge-std/console2.sol";
+
+import {Test} from "forge-std/Test.sol";
+import {ERC20, IERC20} from "openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
+
+// forge test --match-contract POC -vvvvv --fork-url $RPC_URL --fork-block-number 13292408 --zksync
+contract WhaleTest is Test {
+    function test_POC() public {
+        address predictionMarketV3 = 0x39E66eE6b2ddaf4DEfDEd3038E0162180dbeF340;
+        address predictionMarketV3Manager = 0xDeFb36c47754D2e37d44b8b8C647D4D643e03bAd;
+        address usdc = 0x176211869cA2b568f2A7D4EE941E073a821EE1ff;
+        address admin = 0x7836D709E750F6A2D6ff9362457028e8Cd901EB3;
+        address whale = 0x374D7860c4f2f604De0191298dD393703Cce84f3;
+
+        vm.deal(address(this), 200000e6); // Small eth amount needed to trick contract accounting, 0.000000000001 eth would be enough to steal 10_000 usdc
+
+        // take usdc from the whale
+        vm.startPrank(whale);
+        IERC20(usdc).transfer(admin, 250000e6);
+        vm.stopPrank();
+
+        console2.log("admin's usdc balance at the start: ", IERC20(usdc).balanceOf(admin));
+
+
+        vm.startPrank(admin);
+        uint256[] memory distribution = new uint256[](2);
+        distribution[0] = 100e6;
+        distribution[1] = 100e6;
+
+        IERC20(usdc).approve(predictionMarketV3, type(uint256).max);
+
+
+        uint256 marketId = PredictionMarketV3(predictionMarketV3).createMarket(CreateMarketDescription({
+            value: 10_000e6,
+            closesAt: uint32(block.timestamp + 3600),
+            outcomes: 2,
+            token: IERC20(usdc),
+            distribution: distribution,
+            question: "test",
+            image: "test",
+            arbitrator: address(this),
+            buyFees: Fees({fee: 1e16, treasuryFee: 0, distributorFee: 0}),
+            sellFees: Fees({fee: 0, treasuryFee: 0, distributorFee: 0}),
+            treasury: address(0),
+            distributor: address(0),
+            realitioTimeout: 3600,
+            manager: IPredictionMarketV3Manager(predictionMarketV3Manager)
+        }));
+
+        for (uint256 i = 0; i < 100; i++) {
+          PredictionMarketV3(predictionMarketV3).buy(marketId, 0, 0, 1000e6);
+          PredictionMarketV3(predictionMarketV3).buy(marketId, 1, 0, 1000e6);
+        }
+
+        (uint256 liquidity, uint256[] memory outcomes) = PredictionMarketV3(predictionMarketV3).getUserMarketShares(marketId, admin);
+        console2.log("liquidity: ", liquidity);
+        console2.log("outcome 0: ", outcomes[0]);
+        console2.log("outcome 1: ", outcomes[1]);
+
+        vm.stopPrank();
+
+        console2.log("admin's usdc balance at the end: ", IERC20(usdc).balanceOf(admin));
+    }
+}
+
+interface IPredictionMarketV3Manager {
+    function getERC20RealitioAddress(IERC20 token) external view returns (address);
+    function isAllowedToCreateMarket(address, address) external view returns (bool);
+    function askQuestionERC20(uint256 template_id, string calldata question, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 nonce, uint256 tokens) external returns (bytes32);
+}
+
+contract Manager is IPredictionMarketV3Manager {
+    function getERC20RealitioAddress(IERC20 token) external view returns (address) {
+        return address(this);
+    }
+
+    function isAllowedToCreateMarket(address, address) external view returns (bool) {
+        return true;
+    }
+
+    function askQuestionERC20 (uint256 template_id, string calldata question, address arbitrator, uint32 timeout, uint32 opening_ts, uint256 nonce, uint256 tokens) external returns (bytes32) {
+        return bytes32(uint256(1));
+    }
+
+}
+
+interface PredictionMarketV3 {
+    function buy(uint256 marketId, uint256 outcomeId, uint256 minOutcomeSharesToBuy, uint256 value) external;
+    function sell(uint256 marketId, uint256 outcomeId, uint256 value, uint256 maxOutcomeSharesToSell) external ;
+    function createMarket(CreateMarketDescription calldata desc) external returns (uint256);
+    function getUserMarketShares(uint256 marketId, address user) external view returns (uint256 liquidity, uint256[] memory outcomes);
+}
+
+
+  enum MarketState {
+    open,
+    closed,
+    resolved
+  }
+  enum MarketAction {
+    buy,
+    sell,
+    addLiquidity,
+    removeLiquidity,
+    claimWinnings,
+    claimLiquidity,
+    claimFees,
+    claimVoided
+  }
+
+
+  struct Market {
+    // market details
+    uint256 closesAtTimestamp;
+    uint256 balance; // total stake
+    uint256 liquidity; // stake held
+    uint256 sharesAvailable; // shares held (all outcomes)
+    mapping(address => uint256) liquidityShares;
+    mapping(address => bool) liquidityClaims; // wether user has claimed liquidity earnings
+    MarketState state; // resolution variables
+    MarketResolution resolution; // fees
+    MarketFees fees;
+    // market outcomes
+    uint256 outcomeCount;
+    mapping(uint256 => MarketOutcome) outcomes;
+    IERC20 token; // ERC20 token market will use for trading
+    IPredictionMarketV3Manager manager; // manager contract
+    address creator; // market creator
+    bool paused; // market paused, no trading allowed
+  }
+
+  struct Fees {
+    uint256 fee; // fee % taken from every transaction
+    uint256 treasuryFee; // fee % taken from every transaction to a treasury address
+    uint256 distributorFee; // fee % taken from every transaction to a distributor address
+  }
+
+  struct MarketFees {
+    uint256 poolWeight; // internal var used to ensure pro-rate fee distribution
+    mapping(address => uint256) claimed;
+    address treasury; // address to send treasury fees to
+    address distributor; // fee % taken from every transaction to a treasury address
+    Fees buyFees; // fees for buy transactions
+    Fees sellFees; // fees for sell transactions
+  }
+
+  struct MarketResolution {
+    bool resolved;
+    address realitio;
+    uint256 outcomeId;
+    bytes32 questionId; // realitio questionId
+    // realitio
+    uint256 realitioTimeout;
+  }
+
+  struct MarketOutcome {
+    uint256 marketId;
+    uint256 id;
+    Shares shares;
+  }
+
+  struct Shares {
+    uint256 total; // number of shares
+    uint256 available; // available shares
+    mapping(address => uint256) holders;
+    mapping(address => bool) claims; // wether user has claimed winnings
+    mapping(address => bool) voidedClaims; // wether user has claimed voided market shares
+  }
+
+  struct CreateMarketDescription {
+    uint256 value;
+    uint32 closesAt;
+    uint256 outcomes;
+    IERC20 token;
+    uint256[] distribution;
+    string question;
+    string image;
+    address arbitrator;
+    Fees buyFees;
+    Fees sellFees;
+    address treasury;
+    address distributor;
+    uint32 realitioTimeout;
+    IPredictionMarketV3Manager manager;
+  }