polkamarkets-js 3.4.2 → 3.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "polkamarkets-js",
-    "version": "3.4.2",
+    "version": "3.4.3",
     "description": "",
     "main": "index.js",
     "directories": {

package/script/AddAdminToLand.s.sol

@@ -0,0 +1,29 @@
+// 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 {PredictionMarketV3Manager} from "../contracts/PredictionMarketV3Manager.sol";
+import {PredictionMarketV3_4} from "../contracts/PredictionMarketV3_4.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract AddAdminToLand is Script {
+  function run() public {
+    vm.startBroadcast();
+
+    address PREDICTION_MARKET_V3_MANAGER = address(0xBC39fa757886E8A56422Abc460b1FFfc70bbaeC6);
+    address PREDICTION_MARKET_V3 = address(0x39E66eE6b2ddaf4DEfDEd3038E0162180dbeF340);
+    address LAND_TOKEN = address(0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d);
+    address admin = address(0xAE7Bfff784EeEe7812D6527B72c77A7Ed773Ed9D);
+
+    // PredictionMarketV3_4(payable(PREDICTION_MARKET_V3)).setAllowedManager(PREDICTION_MARKET_V3_MANAGER, true);
+
+    PredictionMarketV3Manager(PREDICTION_MARKET_V3_MANAGER).addAdminToLand(
+      IERC20(LAND_TOKEN),
+      admin
+    );
+
+    vm.stopBroadcast();
+  }
+}

package/script/ClaimMerkleRoot.s.sol

@@ -0,0 +1,34 @@
+// 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 ClaimMerkleRoot is Script {
+  function run() public {
+    vm.startBroadcast();
+
+    MerkleRewardsDistributor distributor = MerkleRewardsDistributor(address(0x846BBEF1e62c211a16fD3F4Cd15C54B010D85036));
+    IERC20 token = IERC20(address(0xf74B14ecbAdC9fBb283Fb3c8ae11E186856eae6f));
+    string memory contestId = "7663c7a6-5c93-40e2-9de7-21a821d363e3";
+    uint256 index = 4;
+    address account = address(0x68FcB3Db1BA4Abb85D9f9420A110948e6459d613);
+    uint256 amount = 200000;
+    bytes32[] memory merkleProof = new bytes32[](2);
+    merkleProof[0] = bytes32(0x7c0e1af482e345503812141a5583c24adcfb9304cd8674e2d55b875e1ec27fdc);
+    merkleProof[1] = bytes32(0x995dc3a28d8b8bcf31a29435a588bfcea38841d36509f285b0ea606c0ee574bf);
+
+    distributor.claim(
+      contestId,
+      IERC20(address(token)),
+      index,
+      account,
+      amount,
+      merkleProof
+    );
+
+    vm.stopBroadcast();
+  }
+}

package/script/CreateLand.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 your contracts here
+import {PredictionMarketV3Manager} from "../contracts/PredictionMarketV3Manager.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+contract CreateLand is Script {
+    function run() public {
+
+        vm.startBroadcast();
+
+        address PREDICTION_MARKET_V3_MANAGER = address(0xBC39fa757886E8A56422Abc460b1FFfc70bbaeC6);
+        address ADMIN_TOKEN = address(0x307893b1d9F2F6AF097310Ef6E49b90bc5a2Ee3d);
+        address LAND_TOKEN = address(0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d);
+
+        // IERC20(ADMIN_TOKEN).approve(PREDICTION_MARKET_V3_MANAGER, 1000 ether);
+
+        PredictionMarketV3Manager(PREDICTION_MARKET_V3_MANAGER).createLand(
+            IERC20(LAND_TOKEN),
+            IERC20(ADMIN_TOKEN)
+        );
+
+        vm.stopBroadcast();
+    }
+}

package/script/CreateMarkets.s.sol

@@ -0,0 +1,71 @@
+// 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 CreateMarkets is Script {
+    function run() public {
+
+        vm.startBroadcast();
+
+        address predictionMarket = address(0xb5625db4777262460589724693e6E032999FCCd5);
+        address manager = address(0x47b5E2Ef0B3e79b6f5432d983731c04855121796);
+        address arbitrator = address(0x68FcB3Db1BA4Abb85D9f9420A110948e6459d613);
+        address treasury = address(0x68FcB3Db1BA4Abb85D9f9420A110948e6459d613);
+        address distributor = address(0x68FcB3Db1BA4Abb85D9f9420A110948e6459d613);
+        uint256[] memory distribution = new uint256[](2);
+        distribution[0] = 100e6;
+        distribution[1] = 100e6;
+
+        // uint256 value = 1000000000000000000000;
+        // address token = address(0xAe86Ea629FB0454bEA8EC9Da19c1b4b3d0c9Ac41);
+        // uint256 fee = 0;
+
+        uint256 value = 1000 ether;
+        address token = address(0x49Ff827F0C8835ebd8109Cc3b51b80435ce44F09);
+        uint256 fee = 1e16;
+
+        // IERC20(token).approve(predictionMarket, 10000000 ether);
+        // PredictionMarketV3_4(payable(predictionMarket)).setAllowedManager(manager, true);
+
+        PredictionMarketV3_4(payable(predictionMarket)).createMarket(PredictionMarketV3_4.CreateMarketDescription({
+            value: value,
+            closesAt: 1765029602,
+            outcomes: 2,
+            token: IERC20(token),
+            distribution: distribution,
+            question: unicode"Will Oscar Piastri win the F1 Drivers Championship 2025?;The “Lando era” became the Oscar show—but can the rising star hold his nerve and beat Lando and Max to his first Drivers Championship?\\n\\n**Market dates:**\\n\\n- **Market Period**: From the publication date through December 6th, 2025, at 02:00 PM UTC\\n- **Market Closing:** December 6th, 2025, at 02:00 PM UTC ahead of the last race\\n- **Resolution Deadline:** This market will resolve based on the official race results published by Formula 1 after the publication of the results of the last race, or earlier if the outcome is reached. The resolution may be delayed if there are any announced investigations that could impact points-scoring positions\\n\\n**Resolution criteria:**\\n\\n- This market resolves to “Yes” if Oscar Piastri wins the Drivers Championship of Formula 1 in 2025.\\n- This market resolves to “No” if Oscar Piastri doesn’t win the Drivers Championship of Formula 1 in 2025\\n\\n**Cancellation/Invalidity details:**\\n\\nThis market will be cancelled if:\\n\\n- The 2025 Formula 1 season is cancelled or postponed indefinitely\\n- The racing format of the 2025 Formula 1 season changes significantly from the standard format\\n- No official result is declared\\n- The resolution source becomes unavailable for large period of the market period\\n\\nIn the event of cancellation, participants may claim their stakes at the market value of their open positions at the time of cancellation. This could result in a profit or a loss, depending on the price of their outstanding shares.␟\"Yes\",\"No\"␟Sports,F1;;https://www.formula1.com/en/results/2025/drivers;Formula 1␟",
+            image: unicode"␟QmWvnfTtJNLCiJTPDZwVVXq2QAt9RN5gCWCWwpxDg8GsVL,",
+            arbitrator: arbitrator,
+            buyFees: PredictionMarketV3_4.Fees({fee: fee, treasuryFee: fee, distributorFee: fee}),
+            sellFees: PredictionMarketV3_4.Fees({fee: 0, treasuryFee: 0, distributorFee: 0}),
+            treasury: treasury,
+            distributor: distributor,
+            realitioTimeout: 3600,
+            manager: IPredictionMarketV3Manager(manager)
+        }));
+
+        PredictionMarketV3_4(payable(predictionMarket)).createMarket(PredictionMarketV3_4.CreateMarketDescription({
+            value: value,
+            closesAt: 1767225542,
+            outcomes: 2,
+            token: IERC20(token),
+            distribution: distribution,
+            question: unicode"Bitcoin’s next hit: moon to $150K or dip to $50K?;**Market dates:**\\n\\n- **Market Period**: From the publication date through December 31st, 2025, at 11:59 PM UTC\\n- **Market Closing:** December 31st, 2025, at 11:59 PM UTC\\n- **Resolution Deadline:** The resolution will be determined after market closing, or earlier if the outcome is reached\\n\\n**Resolution criteria:**\\n\\n- The market resolves based on which condition is met first:\\n  - **“≥ $150K”** if the BTC/USDT price on Binance reaches or exceeds $150,000.00\\n  - **“≤ $50K”** if the BTC/USDT price on Binance drops to or below $50,000.00\\n\\n**Resolution details:**\\n\\n- The market resolves based on the Binance BTC/USDT spot price, using the 1-minute chart with the following specifications:\\n  - 1-minute timeframe (\\\"1m\\\")\\n  - \\\"Original\\\" view\\n  - \\\"Close\\\" price of each candle\\n- Only the price of BTC/USDT as quoted by Binance (spot market) will be considered\\n\\n**Cancellation (Invalidity) Conditions**\\n\\nThis market will be **canceled/invalid** if:\\n\\n- The BTC/USDT spot price on Binance doesn’t reach either one of the two options until market close.\\n- The BTC/USDT spot market on Binance is suspended or becomes unreliable\\n- The Binance platform is unavailable or experiences significant disruptions during the Market Period\\n- Any circumstance prevents reliable price tracking during the Market Period\\n\\nIn the event of cancellation, participants may claim their stakes at the market value of their open positions at the time of cancellation. This could result in a profit or a loss, depending on the price of their outstanding shares.␟\"≥ $150K\",\"≤ $50K\"␟Crypto;;https://www.binance.com/en/trade/BTC_USDT?type=spot;Binance␟",
+            image: unicode"␟QmdWFkhqiUX3XxwFBMGP749Wpx1Y44KAqqCuhpnCzap7cg,",
+            arbitrator: arbitrator,
+            buyFees: PredictionMarketV3_4.Fees({fee: fee, treasuryFee: fee, distributorFee: fee}),
+            sellFees: PredictionMarketV3_4.Fees({fee: 0, treasuryFee: 0, distributorFee: 0}),
+            treasury: treasury,
+            distributor: distributor,
+            realitioTimeout: 3600,
+            manager: IPredictionMarketV3Manager(manager)
+        }));
+
+        vm.stopBroadcast();
+    }
+}

package/script/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/script/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/script/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/script/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/script/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/script/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/script/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/script/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/script/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/script/copy-abis.js

@@ -0,0 +1,57 @@
+const fs = require('fs');
+const path = require('path');
+
+const outDir = path.join(__dirname, '../out');
+const abisDir = path.join(__dirname, '../abis');
+
+// Ensure abis directory exists
+if (!fs.existsSync(abisDir)) {
+  fs.mkdirSync(abisDir, { recursive: true });
+}
+
+// Copy ABIs from out/ to abis/
+function copyAbis() {
+  if (!fs.existsSync(outDir)) {
+    console.log('❌ /out directory not found. Run "forge build" first.');
+    process.exit(1);
+  }
+
+  const contracts = fs.readdirSync(outDir);
+  let copiedCount = 0;
+
+  contracts.forEach(contract => {
+    if (contract.endsWith('.sol')) {
+      const contractDir = path.join(outDir, contract);
+
+      if (fs.statSync(contractDir).isDirectory()) {
+        const contractFiles = fs.readdirSync(contractDir);
+
+        contractFiles.forEach(file => {
+          if (file.endsWith('.json')) {
+            try {
+              const sourcePath = path.join(contractDir, file);
+              const destPath = path.join(abisDir, file);
+
+                            const contractData = JSON.parse(fs.readFileSync(sourcePath, 'utf8'));
+
+              // Extract only ABI (minified)
+              const abiData = {
+                abi: contractData.abi || []
+              };
+
+              fs.writeFileSync(destPath, JSON.stringify(abiData));
+              copiedCount++;
+              console.log(`✅ Copied ${file}`);
+            } catch (error) {
+              console.log(`⚠️  Failed to copy ${file}:`, error.message);
+            }
+          }
+        });
+      }
+    }
+  });
+
+  console.log(`\n🎉 Successfully copied ${copiedCount} contract ABIs to /abis directory`);
+}
+
+copyAbis();

package/src/Application.js

@@ -37,6 +37,7 @@ class Application {
     web3EventsProvider,
     gasPrice,
     isSocialLogin = false,
+    useGaslessTransactions,
     socialLoginParams,
     startBlock,
     defaultDecimals,
@@ -48,6 +49,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 +94,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 +103,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 +167,7 @@ class Application {
       web3EventsProvider: this.web3EventsProvider,
       gasPrice: this.gasPrice,
       isSocialLogin: this.isSocialLogin,
+      useGaslessTransactions: this.useGaslessTransactions,
       startBlock: this.startBlock,
       defaultDecimals: this.defaultDecimals
     };

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) {

package/src/models/PolkamarketsSmartAccount.js

@@ -6,6 +6,11 @@ const { createPublicClient, http } = require('viem');
 const { signerToSimpleSmartAccount } = require('permissionless/accounts');
 
 class PolkamarketsSmartAccount {
+  networkConfig = null;
+  provider = null;
+  isConnectedWallet = null;
+  thirdwebAccount = null;
+  smartAccount = null;
 
   static PIMLICO_FACTORY_ADDRESS = '0x9406Cc6185a346906296840746125a0E44976454';
   static THIRDWEB_FACTORY_ADDRESS = '0x85e23b94e7F5E9cC1fF78BCe78cfb15B81f0DF00';
@@ -65,12 +70,30 @@ class PolkamarketsSmartAccount {
     return { isConnectedWallet: false, address: null, signer: null };
   }
 
+  getThirdwebAccount() {
+    if (this.thirdwebAccount) {
+      return this.thirdwebAccount;
+    }
+
+    // For backward compatibility, check if provider is already a thirdweb account
+    if (this.provider && typeof this.provider.sendTransaction === "function") {
+      return this.provider;
+    }
+
+    return null;
+  }
+
   async getAddress() {
     const { isConnectedWallet, address } = await this.providerIsConnectedWallet();
     if (isConnectedWallet) {
       return address;
     }
 
+    // Check if we have a stored thirdweb account (for agw support)
+    if (this.thirdwebAccount && this.thirdwebAccount.address) {
+      return this.thirdwebAccount.address;
+    }
+
     if (this.networkConfig.useThirdWeb && this.networkConfig.isZkSync) {
       if (this.provider.address) {
         return this.provider.address;