polkamarkets-js 3.4.2 → 3.4.4

package/scripts/DeployContracts.s.sol

@@ -0,0 +1,94 @@
+// 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 {PredictionMarketV3_4, IWETH} from "../contracts/PredictionMarketV3_4.sol";
+import {PredictionMarketV3Manager} from "../contracts/PredictionMarketV3Manager.sol";
+import {PredictionMarketV3Querier} from "../contracts/PredictionMarketV3Querier.sol";
+import {IPredictionMarketV3Manager} from "../contracts/IPredictionMarketV3Manager.sol";
+import {IPredictionMarketV3_4} from "../contracts/IPredictionMarketV3_4.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+import {RealityETH_ERC20_v3_0} from "@reality.eth/contracts/development/contracts/RealityETH_ERC20-3.0.sol";
+import {ERC20MinterPauser} from "../contracts/ERC20MinterPauser.sol";
+import {IRealityETH_ERC20} from "../contracts/IRealityETH_ERC20.sol";
+
+contract DeployContracts is Script {
+  function run() public {
+    vm.startBroadcast();
+
+    address TOKEN = address(0x0);
+    address admin = address(0x0a70f6F09caa802D8d62dE9C7EdacE1d3b5Ca160);
+    address self = address(0x7C0F97fb24E8712E97285C7Ba7527ed6d0eb6995);
+    address WETH = address(0x0);
+    address REALITIO = address(0x0);
+    address PREDICTION_MARKET_V3_MANAGER = address(0x0);
+    address PREDICTION_MARKET_V3_QUERIER = address(0x0);
+    address payable PREDICTION_MARKET_V3_4 = payable(address(0x0));
+
+    // self transfer 0 ETH to trigger dummy transaction
+    // payable(self).transfer(0 ether);
+    // payable(self).transfer(0 ether);
+    // payable(self).transfer(0 ether);
+    // payable(self).transfer(0 ether);
+    // payable(self).transfer(0 ether);
+    // payable(self).transfer(0 ether);
+    // payable(self).transfer(0 ether);
+    // payable(self).transfer(0 ether);
+
+    // deploy PredictionMarketV3_4
+    PredictionMarketV3_4 impl = new PredictionMarketV3_4();
+    console.log("Implementation deployed at:", address(impl));
+
+    // Show initialization data for manual proxy deployment
+    bytes memory initData = abi.encodeCall(PredictionMarketV3_4.initialize, (IWETH(WETH), admin));
+    console.log("Initialization data for proxy:");
+    console.logBytes(initData);
+
+    console.log("\nFor proxy deployment, use OpenZeppelin's ERC1967Proxy:");
+    console.log("new ERC1967Proxy(", vm.toString(address(impl)), ", initData)");
+
+    ERC1967Proxy proxy = new ERC1967Proxy(
+        address(impl),
+        initData
+    );
+
+    console.log("PredictionMarketV3_4 deployed at:", address(proxy));
+    PREDICTION_MARKET_V3_4 = payable(address(proxy));
+
+    // deploy PredictionMarketV3Querier
+    PredictionMarketV3Querier querier = new PredictionMarketV3Querier(IPredictionMarketV3_4(PREDICTION_MARKET_V3_4));
+    console.log("PredictionMarketV3Querier deployed at:", address(querier));
+    PREDICTION_MARKET_V3_QUERIER = address(querier);
+
+    // deploy TOKEN
+    ERC20MinterPauser token = new ERC20MinterPauser("Myriad Cure", "MYRCURE");
+    console.log("TOKEN deployed at:", address(token));
+    TOKEN = address(token);
+    token.mint(admin, 10000000000000000000);
+
+    // deploy RealityETH_ERC20
+    RealityETH_ERC20_v3_0 realitio = new RealityETH_ERC20_v3_0();
+    console.log("RealityETH_ERC20 deployed at:", address(realitio));
+    IRealityETH_ERC20(address(realitio)).setToken(address(TOKEN));
+    REALITIO = address(realitio);
+
+    // deploy PredictionMarketV3_4Manager
+    PredictionMarketV3Manager manager = new PredictionMarketV3Manager(
+        PREDICTION_MARKET_V3_4,
+        IERC20(TOKEN),
+        1 ether,
+        address(REALITIO),
+        admin
+    );
+    console.log("PredictionMarketV3Manager deployed at:", address(manager));
+    PREDICTION_MARKET_V3_MANAGER = address(manager);
+
+    // IERC20(TOKEN).approve(PREDICTION_MARKET_V3_MANAGER, 1000 ether);
+    // PredictionMarketV3_4(PREDICTION_MARKET_V3_4).setAllowedManager(PREDICTION_MARKET_V3_MANAGER, true);
+
+    vm.stopBroadcast();
+  }
+}

package/scripts/DeployMerkleRewardsDistributor.s.sol

@@ -0,0 +1,27 @@
+// 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 {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
+
+contract DeployMerkleRewardsDistributor is Script {
+  function run() public {
+    vm.startBroadcast();
+
+    address admin = address(0xAE7Bfff784EeEe7812D6527B72c77A7Ed773Ed9D);
+
+    // it's a proxy
+    address implementation = address(new MerkleRewardsDistributor());
+    bytes memory initData = abi.encodeCall(MerkleRewardsDistributor.initialize, (admin));
+    console.log("Initialization data for proxy:");
+    console.logBytes(initData);
+
+    ERC1967Proxy proxy = new ERC1967Proxy(implementation, initData);
+    MerkleRewardsDistributor distributor = MerkleRewardsDistributor(address(proxy));
+    console.log("MerkleRewardsDistributor deployed at:", address(distributor));
+
+    vm.stopBroadcast();
+  }
+}

package/scripts/DeployToken.s.sol

@@ -0,0 +1,17 @@
+// 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 DeployToken is Script {
+  function run() public {
+    vm.startBroadcast();
+
+    ERC20MinterPauser token = new ERC20MinterPauser("Myriad Cure", "MYRCURE");
+    console.log("Token deployed at:", address(token));
+
+    vm.stopBroadcast();
+  }
+}

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(0x54eC4711c4a429D7b0466dd169079f276a868462);
+    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

@@ -17,6 +17,7 @@ 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 MerkleRewardsDistributorContract = require("./models/index").MerkleRewardsDistributorContract;
 
 const DualProvider = require("./utils/DualProvider");
 const Account = require('./utils/Account');
@@ -37,6 +38,7 @@ class Application {
     web3EventsProvider,
     gasPrice,
     isSocialLogin = false,
+    useGaslessTransactions,
     socialLoginParams,
     startBlock,
     defaultDecimals,
@@ -48,6 +50,8 @@ class Application {
     // fixed gas price for txs (optional)
     this.gasPrice = gasPrice;
     this.isSocialLogin = isSocialLogin;
+    // If useGaslessTransactions is not explicitly set, default to true when isSocialLogin is true, otherwise false (backwards compatibility)
+    this.useGaslessTransactions = useGaslessTransactions !== undefined ? useGaslessTransactions : isSocialLogin;
     this.startBlock = startBlock;
     this.defaultDecimals = defaultDecimals;
     // use DualProvider to separate read (HttpProvider) and write (window.ethereum) operations
@@ -91,6 +95,8 @@ class Application {
   /**
    * @name login
    * @description Login with Metamask or a web3 provider
+   * @param {Object} provider
+   * @param {Boolean} isConnectedWallet
    */
   async login(provider = null, isConnectedWallet = null) {
     if (this.isSocialLogin) {
@@ -98,9 +104,14 @@ class Application {
         this.smartAccount = PolkamarketsSmartAccount.singleton.getInstanceIfExists()
       }
 
-      if ((!this.smartAccount || !this.smartAccount.provider) && provider) {
+      if (provider) {
         PolkamarketsSmartAccount.singleton.clearInstance();
         this.smartAccount = PolkamarketsSmartAccount.singleton.getInstance(provider, this.socialLoginParams.networkConfig, isConnectedWallet);
+
+        // Store thirdweb account reference if provider has sendTransaction method
+        if (typeof provider.sendTransaction === 'function') {
+          this.smartAccount.thirdwebAccount = provider;
+        }
       }
 
       return true;
@@ -157,6 +168,7 @@ class Application {
       web3EventsProvider: this.web3EventsProvider,
       gasPrice: this.gasPrice,
       isSocialLogin: this.isSocialLogin,
+      useGaslessTransactions: this.useGaslessTransactions,
       startBlock: this.startBlock,
       defaultDecimals: this.defaultDecimals
     };
@@ -401,6 +413,21 @@ class Application {
     }
   };
 
+  /**
+   * @name getMerkleRewardsDistributorContract
+   * @param {Address} ContractAddress (Opt) If it is deployed
+   * @description Create a Merkle Rewards Distributor Contract
+   */
+  getMerkleRewardsDistributorContract({ contractAddress = null }) {
+    try {
+      return new MerkleRewardsDistributorContract({
+        ...this.contractDefaultParams(contractAddress)
+      });
+    } catch (err) {
+      throw err;
+    }
+  }
+
   /***********/
   /** UTILS **/
   /***********/

package/src/interfaces/index.js

@@ -15,6 +15,7 @@ let index = {
   predictionMarketV3Factory: require("../../abis/PredictionMarketV3Factory.json"),
   predictionV3Querier: require("../../abis/PredictionMarketV3Querier.json"),
   realitio: require("../../abis/RealitioERC20.json"),
+  merkleRewardsDistributor: require("../../abis/MerkleRewardsDistributor.json"),
   voting: require("../../abis/Voting.json"),
   weth: require("../../abis/WETH9.json"),
 };

package/src/models/IContract.js

@@ -34,6 +34,7 @@ class IContract {
     web3EventsProvider,
     gasPrice,
     isSocialLogin = false,
+    useGaslessTransactions,
     startBlock
   }) {
     try {
@@ -58,6 +59,8 @@ class IContract {
         gasPrice,
         contract: new Contract(web3, abi, contractAddress),
         isSocialLogin,
+        // (For backwards compatibility) If useGaslessTransactions is not explicitly set, default to true when isSocialLogin is true, otherwise false
+        useGaslessTransactions: useGaslessTransactions !== undefined ? useGaslessTransactions : isSocialLogin,
         startBlock,
       };
     } catch (err) {
@@ -590,6 +593,30 @@ class IContract {
     return receipt;
   }
 
+  async useThirdWebWithUserPaidGas(tx, networkConfig, smartAccount) {
+    const client = createThirdwebClient({ clientId: networkConfig.thirdWebClientId });
+    const chain = defineChain(networkConfig.chainId);
+
+    if (!smartAccount || typeof smartAccount.sendTransaction !== 'function') {
+      throw new Error('Invalid account provided - expected thirdweb Account object with sendTransaction method');
+    }
+
+    const res = await smartAccount.sendTransaction({
+      to: tx.to,
+      data: tx.data,
+      gas: BigInt(500000),
+      chain: chain,
+    });
+
+    const receipt = await waitForReceipt({
+      client,
+      chain,
+      transactionHash: res.transactionHash,
+    });
+
+    return receipt;
+  }
+
   async sendGaslessTransactions(f) {
     const smartAccount = PolkamarketsSmartAccount.singleton.getInstance();
     const networkConfig = smartAccount.networkConfig;
@@ -799,9 +826,68 @@ class IContract {
     return transformedEvents;
   }
 
+  async sendSocialLoginGasTransactions(f) {
+    const smartAccount = PolkamarketsSmartAccount.singleton.getInstance();
+    const networkConfig = smartAccount.networkConfig;
+
+    const { isConnectedWallet, signer } = await smartAccount.providerIsConnectedWallet();
+
+    const methodName = f._method.name;
+
+    const contractInterface = new ethers.utils.Interface(this.params.abi.abi);
+    const methodCallData = contractInterface.encodeFunctionData(methodName, f.arguments);
+
+    const tx = {
+      to: this.params.contractAddress,
+      data: methodCallData,
+    };
+
+    try {
+      let receipt;
+
+      if (isConnectedWallet) {
+        const txResponse = await signer.sendTransaction({ ...tx, gasLimit: 210000 });
+        receipt = await txResponse.wait();
+      } else {
+        if (networkConfig.useThirdWeb) {
+          const thirdwebAccount = smartAccount.getThirdwebAccount();
+          if (!thirdwebAccount) {
+            throw new Error('ThirdWeb account not found. Make sure you passed the thirdweb account when calling login()');
+          }
+          receipt = await this.useThirdWebWithUserPaidGas(tx, networkConfig, thirdwebAccount);
+        } else {
+          throw new Error('User-paid transactions are only supported with ThirdWeb configuration');
+        }
+      }
+
+      console.log('receipt:', receipt.status, receipt.transactionHash);
+
+      if (receipt.logs) {
+        const events = receipt.logs.map(log => {
+          try {
+            const event = contractInterface.parseLog(log);
+            return event;
+          } catch (error) {
+            return null;
+          }
+        });
+        receipt.events = this.convertEtherEventsToWeb3Events(events);
+      }
+
+      return receipt;
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+  }
+
   async __sendTx(f, call = false, value, callback = () => { }) {
     if (this.params.isSocialLogin && !call) {
-      return await this.sendGaslessTransactions(f);
+      if (this.params.useGaslessTransactions) {
+        return await this.sendGaslessTransactions(f);
+      } else {
+        return await this.sendSocialLoginGasTransactions(f);
+      }
     } else {
       var res;
       if (!this.acc && !call) {
@@ -1052,6 +1138,20 @@ class IContract {
   async getBlock(blockNumber) {
     return await this.params.web3.eth.getBlock(blockNumber);
   }
+
+  async soliditySha3(args) {
+    return this.params.web3.utils.soliditySha3(...args)
+  }
+
+  async signMessage(message) {
+    if (this.acc) {
+      return await this.acc.account.sign(message);
+    } else {
+      // TODO need to test with forntend
+      // return await this.params.web3.eth.sign(message, await this.getMyAccount());
+      return await this.params.web3.eth.personal.sign(message, await this.getMyAccount());
+    }
+  }
 }
 
 module.exports = IContract;

package/src/models/MerkleRewardsDistributorContract.js

@@ -0,0 +1,107 @@
+// const _ =  require("lodash");
+
+const merkleRewardsDistributor = require("../interfaces").merkleRewardsDistributor;
+
+const Numbers = require("../utils/Numbers");
+const IContract = require('./IContract');
+
+class MerkleRewardsDistributorContract extends IContract {
+  constructor(params) {
+    super({ abi: merkleRewardsDistributor, ...params });
+    this.contractName = 'merkleRewardsDistributor';
+  }
+
+  // ----- Views -----
+  async getRoot({ contestId, tokenAddress }) {
+    return await this.params.contract
+      .getContract()
+      .methods
+      .getRoot(contestId, tokenAddress)
+      .call();
+  }
+
+  async isClaimed({ contestId, tokenAddress, index }) {
+    return await this.params.contract
+      .getContract()
+      .methods
+      .isClaimed(contestId, tokenAddress, index)
+      .call();
+  }
+
+  async isClaimedMany({ contestIds, tokenAddresses, indices }) {
+    return await this.params.contract
+      .getContract()
+      .methods
+      .isClaimedMany(contestIds, tokenAddresses, indices)
+      .call();
+  }
+
+  async isAdmin({ user }) {
+    return await this.params.contract
+      .getContract()
+      .methods
+      .isAdmin(user)
+      .call();
+  }
+
+  async getClaims({ user, tokenAddress, index }) {
+    return await this.getEvents(
+      'Claim',
+      {
+        user,
+        tokenAddress,
+        index
+      }
+    );
+  }
+
+  // ----- Admin -----
+  async publishRoot({ contestId, tokenAddress, root }) {
+    return await this.__sendTx(
+      this.getContract().methods.publishRoot(contestId, tokenAddress, root)
+    );
+  }
+
+  async addAdmin({ user }) {
+    return await this.__sendTx(
+      this.getContract().methods.addAdmin(user)
+    );
+  }
+
+  async removeAdmin({ user }) {
+    return await this.__sendTx(
+      this.getContract().methods.removeAdmin(user)
+    );
+  }
+
+  async withdraw({ tokenAddress, amount }) {
+    const amountDecimals = Numbers.toSmartContractDecimals(amount, 18);
+    return await this.__sendTx(
+      this.getContract().methods.withdraw(tokenAddress, amountDecimals)
+    );
+  }
+
+  // ----- Claims -----
+  async claim({ contestId, tokenAddress, index, user, amount, proof }) {
+    const amountDecimals = Numbers.toSmartContractDecimals(amount, 18);
+    return await this.__sendTx(
+      this.getContract().methods.claim(contestId, tokenAddress, index, user, amountDecimals, proof)
+    );
+  }
+
+  async claimMany({ entries }) {
+    // entries: array of { contestId, tokenAddress, index, user, amount, proof }
+    const contestIds = entries.map(e => e.contestId);
+    const tokens = entries.map(e => e.tokenAddress);
+    const indices = entries.map(e => e.index);
+    const users = entries.map(e => e.user);
+    const amounts = entries.map(e => Numbers.toSmartContractDecimals(e.amount, 18));
+    const proofs = entries.map(e => e.proof);
+
+    return await this.__sendTx(
+      this.getContract().methods.claimMany(contestIds, tokens, indices, users, amounts, proofs)
+    );
+  }
+}
+
+module.exports = MerkleRewardsDistributorContract;