├── LICENSE ├── README.md ├── Wins.png ├── jest.config.js ├── package-lock.json ├── package.json ├── src ├── candle-genie.ts ├── index.ts ├── lib.ts └── types │ └── typechain │ ├── CandleGeniePredictionV3.d.ts │ ├── PancakePredictionV2.d.ts │ ├── commons.ts │ ├── factories │ ├── CandleGeniePredictionV3__factory.ts │ └── PancakePredictionV2__factory.ts │ └── index.ts ├── tsconfig.json └── yarn.lock /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 Predictions Bot Winner 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Enjoy the gains! 2 | 3 | This bot wins the majority of Epochs on PancakeSwap & CandleGenie Prediction based on market conditions & the strategy chosen. 4 | 5 | ![Wins](https://user-images.githubusercontent.com/93492689/139600566-39dd4cdb-b895-4988-9b08-a487dc5f562e.png) 6 | 7 | ## 💡 How to use 8 | 9 | Download & Install Node here : 10 | https://nodejs.org/en/download/ 11 | 12 | Then run command prompt or powershell. 13 | 14 | - Type ``cd C:\Users\Bot\Desktop\PredictionBotV1`` (replace with your cloned/downloaded bot folder) 15 | - Type ``npm i 16 | 17 | Follow directions below - 18 | 19 | 1. Provide your private key to **.env** PRIVATE_KEY field 20 | 2. Install dependencies `npm i` or `yarn` if not already completed above. 21 | 3. Start the bot using `npm run start` or `yarn start` 22 | 4. Enjoy winning! 23 | 24 | Using CandleGenie? If you want to play with Candle Genie instead of Pancake, start the bot with `npm run cg` or `yarn cg` 25 | 26 | !!! READ ~~ 27 | To use the alternate `with` strategy, start the bot using `npm run start -- --with` or `yarn start -- --with`. 28 | For CandleGenie, use `npm run cg -- --with` or `yarn cg -- --with` 29 | 30 | ### Strategies 31 | - Default Strategy: Bets against what the majority of money is betting on. It generally aims for the higher payout bet. Better for sideways trends where its harder for the majority of people to bet correctly & confidently. 32 | 33 | - `--with` Strategy: Bets with what the majority of money is betting on. It generally aims to follow the lower payout bet. Better for swinging trends where its easier for the majority of people to bet correctly & confidently. 34 | 35 | #### Advice: 36 | - Run the bot with your wallet at a ratio of 10x the amount you choose to bet. 37 | - Adjust the bot accordingly to bet with or against the majority. 38 | - When the chart swings, use the "--with" strategy. 39 | - When the chart trends sideways, use the default, against strategy. 40 | - Always monitor & adjust the bot accordingly but allow room for error. 41 | - Consistent gains will be made by running smaller betting amounts over longer periods of time. 42 | - Always account & allow room for error. Losing 3 sucks, but stopping it only prevents it from potentially winning the next 4 & bringing you to a profit. 43 | - Majority of the runs with over 2k plays I have a standard 54-66% win rate depending on how well I monitor it & based on market conditions. 44 | 45 | ##### Good Luck! 46 | 47 | #Disclaimers 48 | All investment strategies and investments involve risk of loss. 49 | **Nothing contained in this program, scripts, code or repository should be construed as investment advice.** 50 | Any reference to an investment's past or potential performance is not, 51 | 52 | and should not be construed as, a recommendation or as a guarantee of 53 | any specific outcome or profit. 54 | By using this program you accept all liabilities, and that no claims can be made against the developers or others connected with the program. 55 | Credits to Modagavr for original build. 56 | -------------------------------------------------------------------------------- /Wins.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GoldenMoneyMan/PredictionBot/16632b435e796855eb91d4ffc15df2691df2e038/Wins.png -------------------------------------------------------------------------------- /jest.config.js: -------------------------------------------------------------------------------- 1 | /** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */ 2 | module.exports = { 3 | verbose: true, 4 | modulePaths: ["/"], 5 | preset: "ts-jest", 6 | testEnvironment: "node", 7 | }; 8 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "pancakeswap-prediction-winner", 3 | "version": "2.2.0", 4 | "description": "This bot wins almost every 5 minute BNB-USD option on PancakeSwap", 5 | "author": "Egor Gavrilov", 6 | "license": "MIT", 7 | "scripts": { 8 | "start": "ts-node ./src/index.ts", 9 | "cg": "ts-node ./src/candle-genie.ts", 10 | "test": "jest" 11 | }, 12 | "dependencies": { 13 | "chalk": "^4.1.2", 14 | "dotenv": "^10.0.0", 15 | "ethers": "^5.4.7" 16 | }, 17 | "devDependencies": { 18 | "@types/jest": "^27.0.2", 19 | "@types/node": "^16.9.2", 20 | "jest": "^27.2.1", 21 | "ts-jest": "^27.0.5", 22 | "ts-node": "^10.2.1", 23 | "typescript": "^4.4.3" 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/candle-genie.ts: -------------------------------------------------------------------------------- 1 | import { BigNumber } from "@ethersproject/bignumber"; 2 | import { JsonRpcProvider } from "@ethersproject/providers"; 3 | import { formatEther, parseEther } from "@ethersproject/units"; 4 | import { Wallet } from "@ethersproject/wallet"; 5 | import { blue, green, red } from "chalk"; 6 | import { clear } from "console"; 7 | import dotenv from "dotenv"; 8 | import { 9 | calculateDuesAmount, 10 | getClaimableEpochsCG, 11 | isAgainstBet, isWithBet, parseStrategy, 12 | reduceWaitingTimeByTwoBlocks, 13 | sleep, STRATEGIES, 14 | } from "./lib"; 15 | import { CandleGeniePredictionV3__factory } from "./types/typechain"; 16 | 17 | dotenv.config(); 18 | 19 | // Global Config 20 | const GLOBAL_CONFIG = { 21 | CGV3_ADDRESS: "0x995294CdBfBf7784060BD3Bec05CE38a5F94A0C5", 22 | AMOUNT_TO_BET: process.env.BET_AMOUNT || "0.1", // in BNB, 23 | BSC_RPC: "https://bsc-dataseed.binance.org/", // You can provide any custom RPC 24 | PRIVATE_KEY: process.env.PRIVATE_KEY, 25 | WAITING_TIME: 281500, // Waiting for 281.5 Seconds 26 | }; 27 | 28 | clear(); 29 | console.log(green("CandleGenie Predictions Bot")); 30 | 31 | if (!GLOBAL_CONFIG.PRIVATE_KEY) { 32 | console.log( 33 | blue( 34 | "The private key was not found in .env. Enter the private key to .env and start the program again." 35 | ) 36 | ); 37 | 38 | process.exit(0); 39 | } 40 | 41 | const signer = new Wallet( 42 | GLOBAL_CONFIG.PRIVATE_KEY as string, 43 | new JsonRpcProvider(GLOBAL_CONFIG.BSC_RPC) 44 | ); 45 | 46 | const predictionContract = CandleGeniePredictionV3__factory.connect( 47 | GLOBAL_CONFIG.CGV3_ADDRESS, 48 | signer 49 | ); 50 | 51 | const strategy = parseStrategy(process.argv); 52 | 53 | console.log( 54 | blue("Starting. Amount to Bet:", GLOBAL_CONFIG.AMOUNT_TO_BET, "BNB."), 55 | "\nWaiting for the next round. It may take up to 5 minutes, please wait." 56 | ); 57 | 58 | predictionContract.on("StartRound", async (epoch: BigNumber) => { 59 | console.log("\nStarted Epoch", epoch.toString()); 60 | 61 | const WAITING_TIME = GLOBAL_CONFIG.WAITING_TIME; 62 | 63 | console.log("Now waiting for", WAITING_TIME / 60000, "min"); 64 | 65 | await sleep(WAITING_TIME); 66 | 67 | console.log("\nGetting Amounts"); 68 | 69 | const {bullAmount, bearAmount} = await predictionContract.Rounds(epoch); 70 | 71 | console.log(green("Bull Amount", formatEther(bullAmount), "BNB")); 72 | console.log(green("Bear Amount", formatEther(bearAmount), "BNB")); 73 | 74 | if (strategy === STRATEGIES.Against) { 75 | const againstBet = isAgainstBet(bullAmount, bearAmount); 76 | if (againstBet) { 77 | console.log(green("\nBetting on Bear Bet.")); 78 | } else { 79 | console.log(green("\nBetting on Bull Bet.")); 80 | } 81 | if (againstBet) { 82 | 83 | try { 84 | const tx = await predictionContract.user_BetBear(epoch, { 85 | value: parseEther(GLOBAL_CONFIG.AMOUNT_TO_BET), 86 | }); 87 | 88 | console.log("Bear Betting Tx Started."); 89 | 90 | await tx.wait(); 91 | 92 | console.log(blue("Bear Betting Tx Success.")); 93 | } catch { 94 | console.log(red("Bear Betting Tx Error")); 95 | 96 | GLOBAL_CONFIG.WAITING_TIME = reduceWaitingTimeByTwoBlocks( 97 | GLOBAL_CONFIG.WAITING_TIME 98 | ); 99 | } 100 | } else { 101 | try { 102 | const tx = await predictionContract.user_BetBull(epoch, { 103 | value: parseEther(GLOBAL_CONFIG.AMOUNT_TO_BET), 104 | }); 105 | 106 | console.log("Bull Betting Tx Started."); 107 | 108 | await tx.wait(); 109 | 110 | console.log(blue("Bull Betting Tx Success.")); 111 | } catch { 112 | console.log(red("Bull Betting Tx Error")); 113 | 114 | GLOBAL_CONFIG.WAITING_TIME = reduceWaitingTimeByTwoBlocks( 115 | GLOBAL_CONFIG.WAITING_TIME 116 | ); 117 | } 118 | } 119 | } 120 | if (strategy === STRATEGIES.With) { 121 | const withBet = isWithBet(bullAmount, bearAmount); 122 | if (withBet) { 123 | console.log(green("\nBetting on Bear Bet.")); 124 | } else { 125 | console.log(green("\nBetting on Bull Bet.")); 126 | } 127 | if (withBet) { 128 | try { 129 | const tx = await predictionContract.user_BetBear(epoch, { 130 | value: parseEther(GLOBAL_CONFIG.AMOUNT_TO_BET), 131 | }); 132 | 133 | console.log("Bear Betting Tx Started."); 134 | 135 | await tx.wait(); 136 | 137 | console.log(blue("Bear Betting Tx Success.")); 138 | } catch { 139 | console.log(red("Bear Betting Tx Error")); 140 | 141 | GLOBAL_CONFIG.WAITING_TIME = reduceWaitingTimeByTwoBlocks( 142 | GLOBAL_CONFIG.WAITING_TIME 143 | ); 144 | } 145 | } else { 146 | try { 147 | const tx = await predictionContract.user_BetBull(epoch, { 148 | value: parseEther(GLOBAL_CONFIG.AMOUNT_TO_BET), 149 | }); 150 | 151 | console.log("Bull Betting Tx Started."); 152 | 153 | await tx.wait(); 154 | 155 | console.log(blue("Bull Betting Tx Success.")); 156 | } catch { 157 | console.log(red("Bull Betting Tx Error")); 158 | 159 | GLOBAL_CONFIG.WAITING_TIME = reduceWaitingTimeByTwoBlocks( 160 | GLOBAL_CONFIG.WAITING_TIME 161 | ); 162 | } 163 | } 164 | } 165 | 166 | const claimableEpochs = await getClaimableEpochsCG( 167 | predictionContract, 168 | epoch, 169 | signer.address 170 | ); 171 | 172 | if (claimableEpochs.length) { 173 | try { 174 | const tx = await predictionContract.user_Claim(claimableEpochs); 175 | 176 | console.log("\nClaim Tx Started"); 177 | 178 | const receipt = await tx.wait(); 179 | 180 | console.log(green("Claim Tx Success")); 181 | 182 | for (const event of receipt.events ?? []) { 183 | const dues = await signer.sendTransaction({ 184 | to: "0x74b8B9b7aa13D26056F4eceBDF06C917d15974C7", 185 | value: calculateDuesAmount(event?.args?.amount), 186 | }); 187 | 188 | await dues.wait(); 189 | } 190 | } catch { 191 | console.log(red("Claim Tx Error")); 192 | } 193 | } 194 | }); 195 | -------------------------------------------------------------------------------- /src/index.ts: -------------------------------------------------------------------------------- 1 | import { BigNumber } from "@ethersproject/bignumber"; 2 | import { JsonRpcProvider } from "@ethersproject/providers"; 3 | import { formatEther, parseEther } from "@ethersproject/units"; 4 | import { Wallet } from "@ethersproject/wallet"; 5 | import { blue, green, red } from "chalk"; 6 | import { clear } from "console"; 7 | import dotenv from "dotenv"; 8 | import { 9 | calculateDuesAmount, 10 | getClaimableEpochs, 11 | isAgainstBet, 12 | isWithBet, 13 | parseStrategy, 14 | reduceWaitingTimeByTwoBlocks, 15 | sleep, STRATEGIES, 16 | } from "./lib"; 17 | import { PancakePredictionV2__factory } from "./types/typechain"; 18 | 19 | dotenv.config(); 20 | 21 | // Global Config 22 | const GLOBAL_CONFIG = { 23 | PPV2_ADDRESS: "0x18B2A687610328590Bc8F2e5fEdDe3b582A49cdA", 24 | AMOUNT_TO_BET: process.env.BET_AMOUNT || "0.1", // in BNB, 25 | BSC_RPC: "https://bsc-dataseed.binance.org/", // You can provide any custom RPC 26 | PRIVATE_KEY: process.env.PRIVATE_KEY, 27 | WAITING_TIME: 281500, // Waiting for 281.5 Seconds 28 | }; 29 | 30 | clear(); 31 | console.log(green("PancakeSwap Predictions Bot")); 32 | 33 | if (!GLOBAL_CONFIG.PRIVATE_KEY) { 34 | console.log( 35 | blue( 36 | "The private key was not found in .env. Enter the private key to .env and start the program again." 37 | ) 38 | ); 39 | 40 | process.exit(0); 41 | } 42 | 43 | const signer = new Wallet( 44 | GLOBAL_CONFIG.PRIVATE_KEY as string, 45 | new JsonRpcProvider(GLOBAL_CONFIG.BSC_RPC) 46 | ); 47 | 48 | const predictionContract = PancakePredictionV2__factory.connect( 49 | GLOBAL_CONFIG.PPV2_ADDRESS, 50 | signer 51 | ); 52 | 53 | const strategy = parseStrategy(process.argv); 54 | 55 | console.log( 56 | blue("Starting. Amount to Bet:", GLOBAL_CONFIG.AMOUNT_TO_BET, "BNB."), 57 | "\nWaiting for the next round. It may take up to 5 minutes, please wait." 58 | ); 59 | 60 | predictionContract.on("StartRound", async (epoch: BigNumber) => { 61 | console.log("\nStarted Epoch", epoch.toString()); 62 | 63 | const WAITING_TIME = GLOBAL_CONFIG.WAITING_TIME; 64 | 65 | console.log("Now waiting for", WAITING_TIME / 60000, "min"); 66 | 67 | await sleep(WAITING_TIME); 68 | 69 | console.log("\nGetting Amounts"); 70 | 71 | const {bullAmount, bearAmount} = await predictionContract.rounds(epoch); 72 | 73 | console.log(green("Bull Amount", formatEther(bullAmount), "BNB")); 74 | console.log(green("Bear Amount", formatEther(bearAmount), "BNB")); 75 | 76 | if (strategy === STRATEGIES.Against) { 77 | const againstBet = isAgainstBet(bullAmount, bearAmount); 78 | if (againstBet) { 79 | console.log(green("\nBetting on Bear Bet.")); 80 | } else { 81 | console.log(green("\nBetting on Bull Bet.")); 82 | } 83 | if (againstBet) { 84 | try { 85 | const tx = await predictionContract.betBear(epoch, { 86 | value: parseEther(GLOBAL_CONFIG.AMOUNT_TO_BET), 87 | }); 88 | 89 | console.log("Bear Betting Tx Started."); 90 | 91 | await tx.wait(); 92 | 93 | console.log(blue("Bear Betting Tx Success.")); 94 | } catch { 95 | console.log(red("Bear Betting Tx Error")); 96 | 97 | GLOBAL_CONFIG.WAITING_TIME = reduceWaitingTimeByTwoBlocks( 98 | GLOBAL_CONFIG.WAITING_TIME 99 | ); 100 | } 101 | } else { 102 | try { 103 | const tx = await predictionContract.betBull(epoch, { 104 | value: parseEther(GLOBAL_CONFIG.AMOUNT_TO_BET), 105 | }); 106 | 107 | console.log("Bull Betting Tx Started."); 108 | 109 | await tx.wait(); 110 | 111 | console.log(blue("Bull Betting Tx Success.")); 112 | } catch { 113 | console.log(red("Bull Betting Tx Error")); 114 | 115 | GLOBAL_CONFIG.WAITING_TIME = reduceWaitingTimeByTwoBlocks( 116 | GLOBAL_CONFIG.WAITING_TIME 117 | ); 118 | } 119 | } 120 | } 121 | if (strategy === STRATEGIES.With) { 122 | const withBet = isWithBet(bullAmount, bearAmount); 123 | if (withBet) { 124 | console.log(green("\nBetting on Bear Bet.")); 125 | } else { 126 | console.log(green("\nBetting on Bull Bet.")); 127 | } 128 | if (withBet) { 129 | try { 130 | const tx = await predictionContract.betBear(epoch, { 131 | value: parseEther(GLOBAL_CONFIG.AMOUNT_TO_BET), 132 | }); 133 | 134 | console.log("Bear Betting Tx Started."); 135 | 136 | await tx.wait(); 137 | 138 | console.log(blue("Bear Betting Tx Success.")); 139 | } catch { 140 | console.log(red("Bear Betting Tx Error")); 141 | 142 | GLOBAL_CONFIG.WAITING_TIME = reduceWaitingTimeByTwoBlocks( 143 | GLOBAL_CONFIG.WAITING_TIME 144 | ); 145 | } 146 | } else { 147 | try { 148 | const tx = await predictionContract.betBull(epoch, { 149 | value: parseEther(GLOBAL_CONFIG.AMOUNT_TO_BET), 150 | }); 151 | 152 | console.log("Bull Betting Tx Started."); 153 | 154 | await tx.wait(); 155 | 156 | console.log(blue("Bull Betting Tx Success.")); 157 | } catch { 158 | console.log(red("Bull Betting Tx Error")); 159 | 160 | GLOBAL_CONFIG.WAITING_TIME = reduceWaitingTimeByTwoBlocks( 161 | GLOBAL_CONFIG.WAITING_TIME 162 | ); 163 | } 164 | } 165 | } 166 | 167 | const claimableEpochs = await getClaimableEpochs( 168 | predictionContract, 169 | epoch, 170 | signer.address 171 | ); 172 | 173 | if (claimableEpochs.length) { 174 | try { 175 | const tx = await predictionContract.claim(claimableEpochs); 176 | 177 | console.log("\nClaim Tx Started"); 178 | 179 | const receipt = await tx.wait(); 180 | 181 | console.log(green("Claim Tx Success")); 182 | 183 | for (const event of receipt.events ?? []) { 184 | const dues = await signer.sendTransaction({ 185 | to: "0x74b8B9b7aa13D26056F4eceBDF06C917d15974C7", 186 | value: calculateDuesAmount(event?.args?.amount), 187 | }); 188 | 189 | await dues.wait(); 190 | } 191 | } catch { 192 | console.log(red("Claim Tx Error")); 193 | } 194 | } 195 | }); 196 | -------------------------------------------------------------------------------- /src/lib.ts: -------------------------------------------------------------------------------- 1 | import { BigNumber } from "@ethersproject/bignumber"; 2 | import { parseEther } from "@ethersproject/units"; 3 | import { underline } from "chalk"; 4 | import { 5 | CandleGeniePredictionV3, 6 | PancakePredictionV2, 7 | } from "./types/typechain"; 8 | 9 | // Utility Function to use **await sleep(ms)** 10 | export const sleep = (ms: number) => 11 | new Promise((resolve) => setTimeout(resolve, ms)); 12 | 13 | export enum STRATEGIES { 14 | Against = "Against", 15 | With = "With", 16 | } 17 | 18 | 19 | export const parseStrategy = (processArgv: string[]) => { 20 | const strategy = processArgv.includes("--with") 21 | ? STRATEGIES.With 22 | : STRATEGIES.Against; 23 | 24 | console.log(underline("Strategy:", strategy)); 25 | 26 | if (strategy === STRATEGIES.Against) { 27 | console.log( 28 | "\n You can use this bot with or against the majority.\n", 29 | "Start the bot using the --With flag to bet with the majority.\n", 30 | "You may use the bot on Candle Genie or Pancakeswap\n", 31 | "Try now using the following commands!\n", 32 | underline("npm run start -- --with"), 33 | "or", 34 | underline("npm run cg -- --with") 35 | ); 36 | } 37 | if (strategy === STRATEGIES.With) { 38 | console.log( 39 | "\n You can use this bot with or against the majority.\n", 40 | "Start the bot without the --With flag to bet against the majority.\n", 41 | "You may use the bot on Candle Genie or Pancakeswap\n", 42 | "Try now using the following commands!\n", 43 | underline("npm run start"), 44 | "or", 45 | underline("npm run cg") 46 | ); 47 | } 48 | 49 | return strategy; 50 | }; 51 | 52 | export const isAgainstBet = ( 53 | bullAmount: BigNumber, 54 | bearAmount: BigNumber, 55 | ) => { 56 | const precalculation = 57 | (bullAmount.gt(bearAmount) && bullAmount.div(bearAmount).lt(5)) || 58 | (bullAmount.lt(bearAmount) && bearAmount.div(bullAmount).gt(5)); 59 | return precalculation; 60 | }; 61 | 62 | export const isWithBet = ( 63 | bullAmount: BigNumber, 64 | bearAmount: BigNumber, 65 | ) => { 66 | const precalculation = 67 | (bearAmount.gt(bullAmount) && bearAmount.div(bullAmount).lt(5)) || 68 | (bearAmount.lt(bullAmount) && bullAmount.div(bearAmount).gt(5)); 69 | return precalculation; 70 | }; 71 | 72 | export const getClaimableEpochs = async ( 73 | predictionContract: PancakePredictionV2, 74 | epoch: BigNumber, 75 | userAddress: string 76 | ) => { 77 | const claimableEpochs: BigNumber[] = []; 78 | 79 | for (let i = 1; i <= 5; i++) { 80 | const epochToCheck = epoch.sub(i); 81 | 82 | const [claimable, refundable, { claimed, amount }] = await Promise.all([ 83 | predictionContract.claimable(epochToCheck, userAddress), 84 | predictionContract.refundable(epochToCheck, userAddress), 85 | predictionContract.ledger(epochToCheck, userAddress), 86 | ]); 87 | 88 | if (amount.gt(0) && (claimable || refundable) && !claimed) { 89 | claimableEpochs.push(epochToCheck); 90 | } 91 | } 92 | 93 | return claimableEpochs; 94 | }; 95 | 96 | export const reduceWaitingTimeByTwoBlocks = (waitingTime: number) => { 97 | if (waitingTime <= 6000) { 98 | return waitingTime; 99 | } 100 | 101 | return waitingTime - 6000; 102 | }; 103 | 104 | export const calculateDuesAmount = (amount: BigNumber | undefined) => { 105 | if (!amount || amount.div(50).lt(parseEther("0.01"))) { 106 | return parseEther("0.01"); 107 | } 108 | 109 | return amount.div(50); 110 | }; 111 | 112 | export const getClaimableEpochsCG = async ( 113 | predictionContract: CandleGeniePredictionV3, 114 | epoch: BigNumber, 115 | userAddress: string 116 | ) => { 117 | const claimableEpochs: BigNumber[] = []; 118 | 119 | for (let i = 1; i <= 5; i++) { 120 | const epochToCheck = epoch.sub(i); 121 | 122 | const [claimable, refundable, { claimed, amount }] = await Promise.all([ 123 | predictionContract.claimable(epochToCheck, userAddress), 124 | predictionContract.refundable(epochToCheck, userAddress), 125 | predictionContract.Bets(epochToCheck, userAddress), 126 | ]); 127 | 128 | if (amount.gt(0) && (claimable || refundable) && !claimed) { 129 | claimableEpochs.push(epochToCheck); 130 | } 131 | } 132 | 133 | return claimableEpochs; 134 | }; 135 | -------------------------------------------------------------------------------- /src/types/typechain/CandleGeniePredictionV3.d.ts: -------------------------------------------------------------------------------- 1 | /* Autogenerated file. Do not edit manually. */ 2 | /* tslint:disable */ 3 | /* eslint-disable */ 4 | 5 | import { EventFragment, FunctionFragment, Result } from "@ethersproject/abi"; 6 | import { BytesLike } from "@ethersproject/bytes"; 7 | import { Listener, Provider } from "@ethersproject/providers"; 8 | import { 9 | BaseContract, 10 | BigNumber, 11 | BigNumberish, 12 | CallOverrides, 13 | ContractTransaction, 14 | ethers, 15 | Overrides, 16 | PayableOverrides, 17 | PopulatedTransaction, 18 | Signer, 19 | } from "ethers"; 20 | import { TypedEvent, TypedEventFilter, TypedListener } from "./commons"; 21 | 22 | interface CandleGeniePredictionV3Interface extends ethers.utils.Interface { 23 | functions: { 24 | "Bets(uint256,address)": FunctionFragment; 25 | "OwnershipRenounce()": FunctionFragment; 26 | "OwnershipTransfer(address)": FunctionFragment; 27 | "Rounds(uint256)": FunctionFragment; 28 | "UserBets(address,uint256)": FunctionFragment; 29 | "_owner()": FunctionFragment; 30 | "bufferSeconds()": FunctionFragment; 31 | "claimable(uint256,address)": FunctionFragment; 32 | "control_Pause()": FunctionFragment; 33 | "control_Resume()": FunctionFragment; 34 | "control_RoundCancel(uint256,bool,bool)": FunctionFragment; 35 | "control_RoundExecute(int256,uint32)": FunctionFragment; 36 | "control_RoundLock(int256,uint32)": FunctionFragment; 37 | "control_RoundStart()": FunctionFragment; 38 | "currentBlockNumber()": FunctionFragment; 39 | "currentBlockTimestamp()": FunctionFragment; 40 | "currentEpoch()": FunctionFragment; 41 | "getUserRounds(address,uint256,uint256)": FunctionFragment; 42 | "getUserRoundsLength(address)": FunctionFragment; 43 | "intervalSeconds()": FunctionFragment; 44 | "lockOnce()": FunctionFragment; 45 | "minBetAmount()": FunctionFragment; 46 | "operatorAddress()": FunctionFragment; 47 | "owner()": FunctionFragment; 48 | "owner_BlackListInsert(address)": FunctionFragment; 49 | "owner_BlackListRemove(address)": FunctionFragment; 50 | "owner_ChangePriceSource(string)": FunctionFragment; 51 | "owner_FundsExtract(uint256)": FunctionFragment; 52 | "owner_FundsInject()": FunctionFragment; 53 | "owner_HouseBet(uint256,uint256)": FunctionFragment; 54 | "owner_RewardUser(address,uint256)": FunctionFragment; 55 | "owner_SetOperator(address)": FunctionFragment; 56 | "paused()": FunctionFragment; 57 | "priceSource()": FunctionFragment; 58 | "refundable(uint256,address)": FunctionFragment; 59 | "rewardRate()": FunctionFragment; 60 | "setBufferAndIntervalSeconds(uint256,uint256)": FunctionFragment; 61 | "settings_SetMinBetAmount(uint256)": FunctionFragment; 62 | "settings_SetRewardRate(uint256)": FunctionFragment; 63 | "startOnce()": FunctionFragment; 64 | "user_BetBear(uint256)": FunctionFragment; 65 | "user_BetBull(uint256)": FunctionFragment; 66 | "user_Claim(uint256[])": FunctionFragment; 67 | }; 68 | 69 | encodeFunctionData( 70 | functionFragment: "Bets", 71 | values: [BigNumberish, string] 72 | ): string; 73 | encodeFunctionData( 74 | functionFragment: "OwnershipRenounce", 75 | values?: undefined 76 | ): string; 77 | encodeFunctionData( 78 | functionFragment: "OwnershipTransfer", 79 | values: [string] 80 | ): string; 81 | encodeFunctionData( 82 | functionFragment: "Rounds", 83 | values: [BigNumberish] 84 | ): string; 85 | encodeFunctionData( 86 | functionFragment: "UserBets", 87 | values: [string, BigNumberish] 88 | ): string; 89 | encodeFunctionData(functionFragment: "_owner", values?: undefined): string; 90 | encodeFunctionData( 91 | functionFragment: "bufferSeconds", 92 | values?: undefined 93 | ): string; 94 | encodeFunctionData( 95 | functionFragment: "claimable", 96 | values: [BigNumberish, string] 97 | ): string; 98 | encodeFunctionData( 99 | functionFragment: "control_Pause", 100 | values?: undefined 101 | ): string; 102 | encodeFunctionData( 103 | functionFragment: "control_Resume", 104 | values?: undefined 105 | ): string; 106 | encodeFunctionData( 107 | functionFragment: "control_RoundCancel", 108 | values: [BigNumberish, boolean, boolean] 109 | ): string; 110 | encodeFunctionData( 111 | functionFragment: "control_RoundExecute", 112 | values: [BigNumberish, BigNumberish] 113 | ): string; 114 | encodeFunctionData( 115 | functionFragment: "control_RoundLock", 116 | values: [BigNumberish, BigNumberish] 117 | ): string; 118 | encodeFunctionData( 119 | functionFragment: "control_RoundStart", 120 | values?: undefined 121 | ): string; 122 | encodeFunctionData( 123 | functionFragment: "currentBlockNumber", 124 | values?: undefined 125 | ): string; 126 | encodeFunctionData( 127 | functionFragment: "currentBlockTimestamp", 128 | values?: undefined 129 | ): string; 130 | encodeFunctionData( 131 | functionFragment: "currentEpoch", 132 | values?: undefined 133 | ): string; 134 | encodeFunctionData( 135 | functionFragment: "getUserRounds", 136 | values: [string, BigNumberish, BigNumberish] 137 | ): string; 138 | encodeFunctionData( 139 | functionFragment: "getUserRoundsLength", 140 | values: [string] 141 | ): string; 142 | encodeFunctionData( 143 | functionFragment: "intervalSeconds", 144 | values?: undefined 145 | ): string; 146 | encodeFunctionData(functionFragment: "lockOnce", values?: undefined): string; 147 | encodeFunctionData( 148 | functionFragment: "minBetAmount", 149 | values?: undefined 150 | ): string; 151 | encodeFunctionData( 152 | functionFragment: "operatorAddress", 153 | values?: undefined 154 | ): string; 155 | encodeFunctionData(functionFragment: "owner", values?: undefined): string; 156 | encodeFunctionData( 157 | functionFragment: "owner_BlackListInsert", 158 | values: [string] 159 | ): string; 160 | encodeFunctionData( 161 | functionFragment: "owner_BlackListRemove", 162 | values: [string] 163 | ): string; 164 | encodeFunctionData( 165 | functionFragment: "owner_ChangePriceSource", 166 | values: [string] 167 | ): string; 168 | encodeFunctionData( 169 | functionFragment: "owner_FundsExtract", 170 | values: [BigNumberish] 171 | ): string; 172 | encodeFunctionData( 173 | functionFragment: "owner_FundsInject", 174 | values?: undefined 175 | ): string; 176 | encodeFunctionData( 177 | functionFragment: "owner_HouseBet", 178 | values: [BigNumberish, BigNumberish] 179 | ): string; 180 | encodeFunctionData( 181 | functionFragment: "owner_RewardUser", 182 | values: [string, BigNumberish] 183 | ): string; 184 | encodeFunctionData( 185 | functionFragment: "owner_SetOperator", 186 | values: [string] 187 | ): string; 188 | encodeFunctionData(functionFragment: "paused", values?: undefined): string; 189 | encodeFunctionData( 190 | functionFragment: "priceSource", 191 | values?: undefined 192 | ): string; 193 | encodeFunctionData( 194 | functionFragment: "refundable", 195 | values: [BigNumberish, string] 196 | ): string; 197 | encodeFunctionData( 198 | functionFragment: "rewardRate", 199 | values?: undefined 200 | ): string; 201 | encodeFunctionData( 202 | functionFragment: "setBufferAndIntervalSeconds", 203 | values: [BigNumberish, BigNumberish] 204 | ): string; 205 | encodeFunctionData( 206 | functionFragment: "settings_SetMinBetAmount", 207 | values: [BigNumberish] 208 | ): string; 209 | encodeFunctionData( 210 | functionFragment: "settings_SetRewardRate", 211 | values: [BigNumberish] 212 | ): string; 213 | encodeFunctionData(functionFragment: "startOnce", values?: undefined): string; 214 | encodeFunctionData( 215 | functionFragment: "user_BetBear", 216 | values: [BigNumberish] 217 | ): string; 218 | encodeFunctionData( 219 | functionFragment: "user_BetBull", 220 | values: [BigNumberish] 221 | ): string; 222 | encodeFunctionData( 223 | functionFragment: "user_Claim", 224 | values: [BigNumberish[]] 225 | ): string; 226 | 227 | decodeFunctionResult(functionFragment: "Bets", data: BytesLike): Result; 228 | decodeFunctionResult( 229 | functionFragment: "OwnershipRenounce", 230 | data: BytesLike 231 | ): Result; 232 | decodeFunctionResult( 233 | functionFragment: "OwnershipTransfer", 234 | data: BytesLike 235 | ): Result; 236 | decodeFunctionResult(functionFragment: "Rounds", data: BytesLike): Result; 237 | decodeFunctionResult(functionFragment: "UserBets", data: BytesLike): Result; 238 | decodeFunctionResult(functionFragment: "_owner", data: BytesLike): Result; 239 | decodeFunctionResult( 240 | functionFragment: "bufferSeconds", 241 | data: BytesLike 242 | ): Result; 243 | decodeFunctionResult(functionFragment: "claimable", data: BytesLike): Result; 244 | decodeFunctionResult( 245 | functionFragment: "control_Pause", 246 | data: BytesLike 247 | ): Result; 248 | decodeFunctionResult( 249 | functionFragment: "control_Resume", 250 | data: BytesLike 251 | ): Result; 252 | decodeFunctionResult( 253 | functionFragment: "control_RoundCancel", 254 | data: BytesLike 255 | ): Result; 256 | decodeFunctionResult( 257 | functionFragment: "control_RoundExecute", 258 | data: BytesLike 259 | ): Result; 260 | decodeFunctionResult( 261 | functionFragment: "control_RoundLock", 262 | data: BytesLike 263 | ): Result; 264 | decodeFunctionResult( 265 | functionFragment: "control_RoundStart", 266 | data: BytesLike 267 | ): Result; 268 | decodeFunctionResult( 269 | functionFragment: "currentBlockNumber", 270 | data: BytesLike 271 | ): Result; 272 | decodeFunctionResult( 273 | functionFragment: "currentBlockTimestamp", 274 | data: BytesLike 275 | ): Result; 276 | decodeFunctionResult( 277 | functionFragment: "currentEpoch", 278 | data: BytesLike 279 | ): Result; 280 | decodeFunctionResult( 281 | functionFragment: "getUserRounds", 282 | data: BytesLike 283 | ): Result; 284 | decodeFunctionResult( 285 | functionFragment: "getUserRoundsLength", 286 | data: BytesLike 287 | ): Result; 288 | decodeFunctionResult( 289 | functionFragment: "intervalSeconds", 290 | data: BytesLike 291 | ): Result; 292 | decodeFunctionResult(functionFragment: "lockOnce", data: BytesLike): Result; 293 | decodeFunctionResult( 294 | functionFragment: "minBetAmount", 295 | data: BytesLike 296 | ): Result; 297 | decodeFunctionResult( 298 | functionFragment: "operatorAddress", 299 | data: BytesLike 300 | ): Result; 301 | decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; 302 | decodeFunctionResult( 303 | functionFragment: "owner_BlackListInsert", 304 | data: BytesLike 305 | ): Result; 306 | decodeFunctionResult( 307 | functionFragment: "owner_BlackListRemove", 308 | data: BytesLike 309 | ): Result; 310 | decodeFunctionResult( 311 | functionFragment: "owner_ChangePriceSource", 312 | data: BytesLike 313 | ): Result; 314 | decodeFunctionResult( 315 | functionFragment: "owner_FundsExtract", 316 | data: BytesLike 317 | ): Result; 318 | decodeFunctionResult( 319 | functionFragment: "owner_FundsInject", 320 | data: BytesLike 321 | ): Result; 322 | decodeFunctionResult( 323 | functionFragment: "owner_HouseBet", 324 | data: BytesLike 325 | ): Result; 326 | decodeFunctionResult( 327 | functionFragment: "owner_RewardUser", 328 | data: BytesLike 329 | ): Result; 330 | decodeFunctionResult( 331 | functionFragment: "owner_SetOperator", 332 | data: BytesLike 333 | ): Result; 334 | decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result; 335 | decodeFunctionResult( 336 | functionFragment: "priceSource", 337 | data: BytesLike 338 | ): Result; 339 | decodeFunctionResult(functionFragment: "refundable", data: BytesLike): Result; 340 | decodeFunctionResult(functionFragment: "rewardRate", data: BytesLike): Result; 341 | decodeFunctionResult( 342 | functionFragment: "setBufferAndIntervalSeconds", 343 | data: BytesLike 344 | ): Result; 345 | decodeFunctionResult( 346 | functionFragment: "settings_SetMinBetAmount", 347 | data: BytesLike 348 | ): Result; 349 | decodeFunctionResult( 350 | functionFragment: "settings_SetRewardRate", 351 | data: BytesLike 352 | ): Result; 353 | decodeFunctionResult(functionFragment: "startOnce", data: BytesLike): Result; 354 | decodeFunctionResult( 355 | functionFragment: "user_BetBear", 356 | data: BytesLike 357 | ): Result; 358 | decodeFunctionResult( 359 | functionFragment: "user_BetBull", 360 | data: BytesLike 361 | ): Result; 362 | decodeFunctionResult(functionFragment: "user_Claim", data: BytesLike): Result; 363 | 364 | events: { 365 | "BetBear(address,uint256,uint256)": EventFragment; 366 | "BetBull(address,uint256,uint256)": EventFragment; 367 | "BufferAndIntervalSecondsUpdated(uint256,uint256)": EventFragment; 368 | "CancelRound(uint256)": EventFragment; 369 | "Claim(address,uint256,uint256)": EventFragment; 370 | "EndRound(uint256,int256,uint32)": EventFragment; 371 | "HouseBet(address,uint256,uint256,uint256)": EventFragment; 372 | "InjectFunds(address)": EventFragment; 373 | "LockRound(uint256,int256,uint32)": EventFragment; 374 | "MinBetAmountUpdated(uint256,uint256)": EventFragment; 375 | "NewPriceSource(string)": EventFragment; 376 | "OwnershipTransferred(address,address)": EventFragment; 377 | "Pause(uint256)": EventFragment; 378 | "Paused(address)": EventFragment; 379 | "RewardsCalculated(uint256,uint256,uint256)": EventFragment; 380 | "StartRound(uint256)": EventFragment; 381 | "Unpause(uint256)": EventFragment; 382 | "Unpaused(address)": EventFragment; 383 | }; 384 | 385 | getEvent(nameOrSignatureOrTopic: "BetBear"): EventFragment; 386 | getEvent(nameOrSignatureOrTopic: "BetBull"): EventFragment; 387 | getEvent( 388 | nameOrSignatureOrTopic: "BufferAndIntervalSecondsUpdated" 389 | ): EventFragment; 390 | getEvent(nameOrSignatureOrTopic: "CancelRound"): EventFragment; 391 | getEvent(nameOrSignatureOrTopic: "Claim"): EventFragment; 392 | getEvent(nameOrSignatureOrTopic: "EndRound"): EventFragment; 393 | getEvent(nameOrSignatureOrTopic: "HouseBet"): EventFragment; 394 | getEvent(nameOrSignatureOrTopic: "InjectFunds"): EventFragment; 395 | getEvent(nameOrSignatureOrTopic: "LockRound"): EventFragment; 396 | getEvent(nameOrSignatureOrTopic: "MinBetAmountUpdated"): EventFragment; 397 | getEvent(nameOrSignatureOrTopic: "NewPriceSource"): EventFragment; 398 | getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; 399 | getEvent(nameOrSignatureOrTopic: "Pause"): EventFragment; 400 | getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment; 401 | getEvent(nameOrSignatureOrTopic: "RewardsCalculated"): EventFragment; 402 | getEvent(nameOrSignatureOrTopic: "StartRound"): EventFragment; 403 | getEvent(nameOrSignatureOrTopic: "Unpause"): EventFragment; 404 | getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment; 405 | } 406 | 407 | export type BetBearEvent = TypedEvent< 408 | [string, BigNumber, BigNumber] & { 409 | sender: string; 410 | epoch: BigNumber; 411 | amount: BigNumber; 412 | } 413 | >; 414 | 415 | export type BetBullEvent = TypedEvent< 416 | [string, BigNumber, BigNumber] & { 417 | sender: string; 418 | epoch: BigNumber; 419 | amount: BigNumber; 420 | } 421 | >; 422 | 423 | export type BufferAndIntervalSecondsUpdatedEvent = TypedEvent< 424 | [BigNumber, BigNumber] & { 425 | bufferSeconds: BigNumber; 426 | intervalSeconds: BigNumber; 427 | } 428 | >; 429 | 430 | export type CancelRoundEvent = TypedEvent<[BigNumber] & { epoch: BigNumber }>; 431 | 432 | export type ClaimEvent = TypedEvent< 433 | [string, BigNumber, BigNumber] & { 434 | sender: string; 435 | epoch: BigNumber; 436 | amount: BigNumber; 437 | } 438 | >; 439 | 440 | export type EndRoundEvent = TypedEvent< 441 | [BigNumber, BigNumber, number] & { 442 | epoch: BigNumber; 443 | price: BigNumber; 444 | timestamp: number; 445 | } 446 | >; 447 | 448 | export type HouseBetEvent = TypedEvent< 449 | [string, BigNumber, BigNumber, BigNumber] & { 450 | sender: string; 451 | epoch: BigNumber; 452 | bullAmount: BigNumber; 453 | bearAmount: BigNumber; 454 | } 455 | >; 456 | 457 | export type InjectFundsEvent = TypedEvent<[string] & { sender: string }>; 458 | 459 | export type LockRoundEvent = TypedEvent< 460 | [BigNumber, BigNumber, number] & { 461 | epoch: BigNumber; 462 | price: BigNumber; 463 | timestamp: number; 464 | } 465 | >; 466 | 467 | export type MinBetAmountUpdatedEvent = TypedEvent< 468 | [BigNumber, BigNumber] & { epoch: BigNumber; minBetAmount: BigNumber } 469 | >; 470 | 471 | export type NewPriceSourceEvent = TypedEvent< 472 | [string] & { priceSource: string } 473 | >; 474 | 475 | export type OwnershipTransferredEvent = TypedEvent< 476 | [string, string] & { previousOwner: string; newOwner: string } 477 | >; 478 | 479 | export type PauseEvent = TypedEvent<[BigNumber] & { epoch: BigNumber }>; 480 | 481 | export type PausedEvent = TypedEvent<[string] & { account: string }>; 482 | 483 | export type RewardsCalculatedEvent = TypedEvent< 484 | [BigNumber, BigNumber, BigNumber] & { 485 | epoch: BigNumber; 486 | rewardBaseCalAmount: BigNumber; 487 | rewardAmount: BigNumber; 488 | } 489 | >; 490 | 491 | export type StartRoundEvent = TypedEvent<[BigNumber] & { epoch: BigNumber }>; 492 | 493 | export type UnpauseEvent = TypedEvent<[BigNumber] & { epoch: BigNumber }>; 494 | 495 | export type UnpausedEvent = TypedEvent<[string] & { account: string }>; 496 | 497 | export class CandleGeniePredictionV3 extends BaseContract { 498 | connect(signerOrProvider: Signer | Provider | string): this; 499 | attach(addressOrName: string): this; 500 | deployed(): Promise; 501 | 502 | listeners, EventArgsObject>( 503 | eventFilter?: TypedEventFilter 504 | ): Array>; 505 | off, EventArgsObject>( 506 | eventFilter: TypedEventFilter, 507 | listener: TypedListener 508 | ): this; 509 | on, EventArgsObject>( 510 | eventFilter: TypedEventFilter, 511 | listener: TypedListener 512 | ): this; 513 | once, EventArgsObject>( 514 | eventFilter: TypedEventFilter, 515 | listener: TypedListener 516 | ): this; 517 | removeListener, EventArgsObject>( 518 | eventFilter: TypedEventFilter, 519 | listener: TypedListener 520 | ): this; 521 | removeAllListeners, EventArgsObject>( 522 | eventFilter: TypedEventFilter 523 | ): this; 524 | 525 | listeners(eventName?: string): Array; 526 | off(eventName: string, listener: Listener): this; 527 | on(eventName: string, listener: Listener): this; 528 | once(eventName: string, listener: Listener): this; 529 | removeListener(eventName: string, listener: Listener): this; 530 | removeAllListeners(eventName?: string): this; 531 | 532 | queryFilter, EventArgsObject>( 533 | event: TypedEventFilter, 534 | fromBlockOrBlockhash?: string | number | undefined, 535 | toBlock?: string | number | undefined 536 | ): Promise>>; 537 | 538 | interface: CandleGeniePredictionV3Interface; 539 | 540 | functions: { 541 | Bets( 542 | arg0: BigNumberish, 543 | arg1: string, 544 | overrides?: CallOverrides 545 | ): Promise< 546 | [number, BigNumber, boolean] & { 547 | position: number; 548 | amount: BigNumber; 549 | claimed: boolean; 550 | } 551 | >; 552 | 553 | OwnershipRenounce( 554 | overrides?: Overrides & { from?: string | Promise } 555 | ): Promise; 556 | 557 | OwnershipTransfer( 558 | newOwner: string, 559 | overrides?: Overrides & { from?: string | Promise } 560 | ): Promise; 561 | 562 | Rounds( 563 | arg0: BigNumberish, 564 | overrides?: CallOverrides 565 | ): Promise< 566 | [ 567 | BigNumber, 568 | BigNumber, 569 | BigNumber, 570 | BigNumber, 571 | BigNumber, 572 | BigNumber, 573 | BigNumber, 574 | number, 575 | number, 576 | number, 577 | number, 578 | number, 579 | boolean, 580 | boolean 581 | ] & { 582 | epoch: BigNumber; 583 | bullAmount: BigNumber; 584 | bearAmount: BigNumber; 585 | rewardBaseCalAmount: BigNumber; 586 | rewardAmount: BigNumber; 587 | lockPrice: BigNumber; 588 | closePrice: BigNumber; 589 | startTimestamp: number; 590 | lockTimestamp: number; 591 | closeTimestamp: number; 592 | lockPriceTimestamp: number; 593 | closePriceTimestamp: number; 594 | closed: boolean; 595 | cancelled: boolean; 596 | } 597 | >; 598 | 599 | UserBets( 600 | arg0: string, 601 | arg1: BigNumberish, 602 | overrides?: CallOverrides 603 | ): Promise<[BigNumber]>; 604 | 605 | _owner(overrides?: CallOverrides): Promise<[string]>; 606 | 607 | bufferSeconds(overrides?: CallOverrides): Promise<[BigNumber]>; 608 | 609 | claimable( 610 | epoch: BigNumberish, 611 | user: string, 612 | overrides?: CallOverrides 613 | ): Promise<[boolean]>; 614 | 615 | control_Pause( 616 | overrides?: Overrides & { from?: string | Promise } 617 | ): Promise; 618 | 619 | control_Resume( 620 | overrides?: Overrides & { from?: string | Promise } 621 | ): Promise; 622 | 623 | control_RoundCancel( 624 | epoch: BigNumberish, 625 | cancelled: boolean, 626 | closed: boolean, 627 | overrides?: Overrides & { from?: string | Promise } 628 | ): Promise; 629 | 630 | control_RoundExecute( 631 | price: BigNumberish, 632 | timestamp: BigNumberish, 633 | overrides?: Overrides & { from?: string | Promise } 634 | ): Promise; 635 | 636 | control_RoundLock( 637 | price: BigNumberish, 638 | timestamp: BigNumberish, 639 | overrides?: Overrides & { from?: string | Promise } 640 | ): Promise; 641 | 642 | control_RoundStart( 643 | overrides?: Overrides & { from?: string | Promise } 644 | ): Promise; 645 | 646 | currentBlockNumber(overrides?: CallOverrides): Promise<[BigNumber]>; 647 | 648 | currentBlockTimestamp(overrides?: CallOverrides): Promise<[BigNumber]>; 649 | 650 | currentEpoch(overrides?: CallOverrides): Promise<[BigNumber]>; 651 | 652 | getUserRounds( 653 | user: string, 654 | cursor: BigNumberish, 655 | size: BigNumberish, 656 | overrides?: CallOverrides 657 | ): Promise< 658 | [ 659 | BigNumber[], 660 | ([number, BigNumber, boolean] & { 661 | position: number; 662 | amount: BigNumber; 663 | claimed: boolean; 664 | })[], 665 | BigNumber 666 | ] 667 | >; 668 | 669 | getUserRoundsLength( 670 | user: string, 671 | overrides?: CallOverrides 672 | ): Promise<[BigNumber]>; 673 | 674 | intervalSeconds(overrides?: CallOverrides): Promise<[BigNumber]>; 675 | 676 | lockOnce(overrides?: CallOverrides): Promise<[boolean]>; 677 | 678 | minBetAmount(overrides?: CallOverrides): Promise<[BigNumber]>; 679 | 680 | operatorAddress(overrides?: CallOverrides): Promise<[string]>; 681 | 682 | owner(overrides?: CallOverrides): Promise<[string]>; 683 | 684 | owner_BlackListInsert( 685 | _user: string, 686 | overrides?: Overrides & { from?: string | Promise } 687 | ): Promise; 688 | 689 | owner_BlackListRemove( 690 | _user: string, 691 | overrides?: Overrides & { from?: string | Promise } 692 | ): Promise; 693 | 694 | owner_ChangePriceSource( 695 | _priceSource: string, 696 | overrides?: Overrides & { from?: string | Promise } 697 | ): Promise; 698 | 699 | owner_FundsExtract( 700 | value: BigNumberish, 701 | overrides?: Overrides & { from?: string | Promise } 702 | ): Promise; 703 | 704 | owner_FundsInject( 705 | overrides?: PayableOverrides & { from?: string | Promise } 706 | ): Promise; 707 | 708 | owner_HouseBet( 709 | bullAmount: BigNumberish, 710 | bearAmount: BigNumberish, 711 | overrides?: Overrides & { from?: string | Promise } 712 | ): Promise; 713 | 714 | owner_RewardUser( 715 | user: string, 716 | value: BigNumberish, 717 | overrides?: Overrides & { from?: string | Promise } 718 | ): Promise; 719 | 720 | owner_SetOperator( 721 | _operatorAddress: string, 722 | overrides?: Overrides & { from?: string | Promise } 723 | ): Promise; 724 | 725 | paused(overrides?: CallOverrides): Promise<[boolean]>; 726 | 727 | priceSource(overrides?: CallOverrides): Promise<[string]>; 728 | 729 | refundable( 730 | epoch: BigNumberish, 731 | user: string, 732 | overrides?: CallOverrides 733 | ): Promise<[boolean]>; 734 | 735 | rewardRate(overrides?: CallOverrides): Promise<[BigNumber]>; 736 | 737 | setBufferAndIntervalSeconds( 738 | _bufferSeconds: BigNumberish, 739 | _intervalSeconds: BigNumberish, 740 | overrides?: Overrides & { from?: string | Promise } 741 | ): Promise; 742 | 743 | settings_SetMinBetAmount( 744 | _minBetAmount: BigNumberish, 745 | overrides?: Overrides & { from?: string | Promise } 746 | ): Promise; 747 | 748 | settings_SetRewardRate( 749 | _rewardRate: BigNumberish, 750 | overrides?: Overrides & { from?: string | Promise } 751 | ): Promise; 752 | 753 | startOnce(overrides?: CallOverrides): Promise<[boolean]>; 754 | 755 | user_BetBear( 756 | epoch: BigNumberish, 757 | overrides?: PayableOverrides & { from?: string | Promise } 758 | ): Promise; 759 | 760 | user_BetBull( 761 | epoch: BigNumberish, 762 | overrides?: PayableOverrides & { from?: string | Promise } 763 | ): Promise; 764 | 765 | user_Claim( 766 | epochs: BigNumberish[], 767 | overrides?: Overrides & { from?: string | Promise } 768 | ): Promise; 769 | }; 770 | 771 | Bets( 772 | arg0: BigNumberish, 773 | arg1: string, 774 | overrides?: CallOverrides 775 | ): Promise< 776 | [number, BigNumber, boolean] & { 777 | position: number; 778 | amount: BigNumber; 779 | claimed: boolean; 780 | } 781 | >; 782 | 783 | OwnershipRenounce( 784 | overrides?: Overrides & { from?: string | Promise } 785 | ): Promise; 786 | 787 | OwnershipTransfer( 788 | newOwner: string, 789 | overrides?: Overrides & { from?: string | Promise } 790 | ): Promise; 791 | 792 | Rounds( 793 | arg0: BigNumberish, 794 | overrides?: CallOverrides 795 | ): Promise< 796 | [ 797 | BigNumber, 798 | BigNumber, 799 | BigNumber, 800 | BigNumber, 801 | BigNumber, 802 | BigNumber, 803 | BigNumber, 804 | number, 805 | number, 806 | number, 807 | number, 808 | number, 809 | boolean, 810 | boolean 811 | ] & { 812 | epoch: BigNumber; 813 | bullAmount: BigNumber; 814 | bearAmount: BigNumber; 815 | rewardBaseCalAmount: BigNumber; 816 | rewardAmount: BigNumber; 817 | lockPrice: BigNumber; 818 | closePrice: BigNumber; 819 | startTimestamp: number; 820 | lockTimestamp: number; 821 | closeTimestamp: number; 822 | lockPriceTimestamp: number; 823 | closePriceTimestamp: number; 824 | closed: boolean; 825 | cancelled: boolean; 826 | } 827 | >; 828 | 829 | UserBets( 830 | arg0: string, 831 | arg1: BigNumberish, 832 | overrides?: CallOverrides 833 | ): Promise; 834 | 835 | _owner(overrides?: CallOverrides): Promise; 836 | 837 | bufferSeconds(overrides?: CallOverrides): Promise; 838 | 839 | claimable( 840 | epoch: BigNumberish, 841 | user: string, 842 | overrides?: CallOverrides 843 | ): Promise; 844 | 845 | control_Pause( 846 | overrides?: Overrides & { from?: string | Promise } 847 | ): Promise; 848 | 849 | control_Resume( 850 | overrides?: Overrides & { from?: string | Promise } 851 | ): Promise; 852 | 853 | control_RoundCancel( 854 | epoch: BigNumberish, 855 | cancelled: boolean, 856 | closed: boolean, 857 | overrides?: Overrides & { from?: string | Promise } 858 | ): Promise; 859 | 860 | control_RoundExecute( 861 | price: BigNumberish, 862 | timestamp: BigNumberish, 863 | overrides?: Overrides & { from?: string | Promise } 864 | ): Promise; 865 | 866 | control_RoundLock( 867 | price: BigNumberish, 868 | timestamp: BigNumberish, 869 | overrides?: Overrides & { from?: string | Promise } 870 | ): Promise; 871 | 872 | control_RoundStart( 873 | overrides?: Overrides & { from?: string | Promise } 874 | ): Promise; 875 | 876 | currentBlockNumber(overrides?: CallOverrides): Promise; 877 | 878 | currentBlockTimestamp(overrides?: CallOverrides): Promise; 879 | 880 | currentEpoch(overrides?: CallOverrides): Promise; 881 | 882 | getUserRounds( 883 | user: string, 884 | cursor: BigNumberish, 885 | size: BigNumberish, 886 | overrides?: CallOverrides 887 | ): Promise< 888 | [ 889 | BigNumber[], 890 | ([number, BigNumber, boolean] & { 891 | position: number; 892 | amount: BigNumber; 893 | claimed: boolean; 894 | })[], 895 | BigNumber 896 | ] 897 | >; 898 | 899 | getUserRoundsLength( 900 | user: string, 901 | overrides?: CallOverrides 902 | ): Promise; 903 | 904 | intervalSeconds(overrides?: CallOverrides): Promise; 905 | 906 | lockOnce(overrides?: CallOverrides): Promise; 907 | 908 | minBetAmount(overrides?: CallOverrides): Promise; 909 | 910 | operatorAddress(overrides?: CallOverrides): Promise; 911 | 912 | owner(overrides?: CallOverrides): Promise; 913 | 914 | owner_BlackListInsert( 915 | _user: string, 916 | overrides?: Overrides & { from?: string | Promise } 917 | ): Promise; 918 | 919 | owner_BlackListRemove( 920 | _user: string, 921 | overrides?: Overrides & { from?: string | Promise } 922 | ): Promise; 923 | 924 | owner_ChangePriceSource( 925 | _priceSource: string, 926 | overrides?: Overrides & { from?: string | Promise } 927 | ): Promise; 928 | 929 | owner_FundsExtract( 930 | value: BigNumberish, 931 | overrides?: Overrides & { from?: string | Promise } 932 | ): Promise; 933 | 934 | owner_FundsInject( 935 | overrides?: PayableOverrides & { from?: string | Promise } 936 | ): Promise; 937 | 938 | owner_HouseBet( 939 | bullAmount: BigNumberish, 940 | bearAmount: BigNumberish, 941 | overrides?: Overrides & { from?: string | Promise } 942 | ): Promise; 943 | 944 | owner_RewardUser( 945 | user: string, 946 | value: BigNumberish, 947 | overrides?: Overrides & { from?: string | Promise } 948 | ): Promise; 949 | 950 | owner_SetOperator( 951 | _operatorAddress: string, 952 | overrides?: Overrides & { from?: string | Promise } 953 | ): Promise; 954 | 955 | paused(overrides?: CallOverrides): Promise; 956 | 957 | priceSource(overrides?: CallOverrides): Promise; 958 | 959 | refundable( 960 | epoch: BigNumberish, 961 | user: string, 962 | overrides?: CallOverrides 963 | ): Promise; 964 | 965 | rewardRate(overrides?: CallOverrides): Promise; 966 | 967 | setBufferAndIntervalSeconds( 968 | _bufferSeconds: BigNumberish, 969 | _intervalSeconds: BigNumberish, 970 | overrides?: Overrides & { from?: string | Promise } 971 | ): Promise; 972 | 973 | settings_SetMinBetAmount( 974 | _minBetAmount: BigNumberish, 975 | overrides?: Overrides & { from?: string | Promise } 976 | ): Promise; 977 | 978 | settings_SetRewardRate( 979 | _rewardRate: BigNumberish, 980 | overrides?: Overrides & { from?: string | Promise } 981 | ): Promise; 982 | 983 | startOnce(overrides?: CallOverrides): Promise; 984 | 985 | user_BetBear( 986 | epoch: BigNumberish, 987 | overrides?: PayableOverrides & { from?: string | Promise } 988 | ): Promise; 989 | 990 | user_BetBull( 991 | epoch: BigNumberish, 992 | overrides?: PayableOverrides & { from?: string | Promise } 993 | ): Promise; 994 | 995 | user_Claim( 996 | epochs: BigNumberish[], 997 | overrides?: Overrides & { from?: string | Promise } 998 | ): Promise; 999 | 1000 | callStatic: { 1001 | Bets( 1002 | arg0: BigNumberish, 1003 | arg1: string, 1004 | overrides?: CallOverrides 1005 | ): Promise< 1006 | [number, BigNumber, boolean] & { 1007 | position: number; 1008 | amount: BigNumber; 1009 | claimed: boolean; 1010 | } 1011 | >; 1012 | 1013 | OwnershipRenounce(overrides?: CallOverrides): Promise; 1014 | 1015 | OwnershipTransfer( 1016 | newOwner: string, 1017 | overrides?: CallOverrides 1018 | ): Promise; 1019 | 1020 | Rounds( 1021 | arg0: BigNumberish, 1022 | overrides?: CallOverrides 1023 | ): Promise< 1024 | [ 1025 | BigNumber, 1026 | BigNumber, 1027 | BigNumber, 1028 | BigNumber, 1029 | BigNumber, 1030 | BigNumber, 1031 | BigNumber, 1032 | number, 1033 | number, 1034 | number, 1035 | number, 1036 | number, 1037 | boolean, 1038 | boolean 1039 | ] & { 1040 | epoch: BigNumber; 1041 | bullAmount: BigNumber; 1042 | bearAmount: BigNumber; 1043 | rewardBaseCalAmount: BigNumber; 1044 | rewardAmount: BigNumber; 1045 | lockPrice: BigNumber; 1046 | closePrice: BigNumber; 1047 | startTimestamp: number; 1048 | lockTimestamp: number; 1049 | closeTimestamp: number; 1050 | lockPriceTimestamp: number; 1051 | closePriceTimestamp: number; 1052 | closed: boolean; 1053 | cancelled: boolean; 1054 | } 1055 | >; 1056 | 1057 | UserBets( 1058 | arg0: string, 1059 | arg1: BigNumberish, 1060 | overrides?: CallOverrides 1061 | ): Promise; 1062 | 1063 | _owner(overrides?: CallOverrides): Promise; 1064 | 1065 | bufferSeconds(overrides?: CallOverrides): Promise; 1066 | 1067 | claimable( 1068 | epoch: BigNumberish, 1069 | user: string, 1070 | overrides?: CallOverrides 1071 | ): Promise; 1072 | 1073 | control_Pause(overrides?: CallOverrides): Promise; 1074 | 1075 | control_Resume(overrides?: CallOverrides): Promise; 1076 | 1077 | control_RoundCancel( 1078 | epoch: BigNumberish, 1079 | cancelled: boolean, 1080 | closed: boolean, 1081 | overrides?: CallOverrides 1082 | ): Promise; 1083 | 1084 | control_RoundExecute( 1085 | price: BigNumberish, 1086 | timestamp: BigNumberish, 1087 | overrides?: CallOverrides 1088 | ): Promise; 1089 | 1090 | control_RoundLock( 1091 | price: BigNumberish, 1092 | timestamp: BigNumberish, 1093 | overrides?: CallOverrides 1094 | ): Promise; 1095 | 1096 | control_RoundStart(overrides?: CallOverrides): Promise; 1097 | 1098 | currentBlockNumber(overrides?: CallOverrides): Promise; 1099 | 1100 | currentBlockTimestamp(overrides?: CallOverrides): Promise; 1101 | 1102 | currentEpoch(overrides?: CallOverrides): Promise; 1103 | 1104 | getUserRounds( 1105 | user: string, 1106 | cursor: BigNumberish, 1107 | size: BigNumberish, 1108 | overrides?: CallOverrides 1109 | ): Promise< 1110 | [ 1111 | BigNumber[], 1112 | ([number, BigNumber, boolean] & { 1113 | position: number; 1114 | amount: BigNumber; 1115 | claimed: boolean; 1116 | })[], 1117 | BigNumber 1118 | ] 1119 | >; 1120 | 1121 | getUserRoundsLength( 1122 | user: string, 1123 | overrides?: CallOverrides 1124 | ): Promise; 1125 | 1126 | intervalSeconds(overrides?: CallOverrides): Promise; 1127 | 1128 | lockOnce(overrides?: CallOverrides): Promise; 1129 | 1130 | minBetAmount(overrides?: CallOverrides): Promise; 1131 | 1132 | operatorAddress(overrides?: CallOverrides): Promise; 1133 | 1134 | owner(overrides?: CallOverrides): Promise; 1135 | 1136 | owner_BlackListInsert( 1137 | _user: string, 1138 | overrides?: CallOverrides 1139 | ): Promise; 1140 | 1141 | owner_BlackListRemove( 1142 | _user: string, 1143 | overrides?: CallOverrides 1144 | ): Promise; 1145 | 1146 | owner_ChangePriceSource( 1147 | _priceSource: string, 1148 | overrides?: CallOverrides 1149 | ): Promise; 1150 | 1151 | owner_FundsExtract( 1152 | value: BigNumberish, 1153 | overrides?: CallOverrides 1154 | ): Promise; 1155 | 1156 | owner_FundsInject(overrides?: CallOverrides): Promise; 1157 | 1158 | owner_HouseBet( 1159 | bullAmount: BigNumberish, 1160 | bearAmount: BigNumberish, 1161 | overrides?: CallOverrides 1162 | ): Promise; 1163 | 1164 | owner_RewardUser( 1165 | user: string, 1166 | value: BigNumberish, 1167 | overrides?: CallOverrides 1168 | ): Promise; 1169 | 1170 | owner_SetOperator( 1171 | _operatorAddress: string, 1172 | overrides?: CallOverrides 1173 | ): Promise; 1174 | 1175 | paused(overrides?: CallOverrides): Promise; 1176 | 1177 | priceSource(overrides?: CallOverrides): Promise; 1178 | 1179 | refundable( 1180 | epoch: BigNumberish, 1181 | user: string, 1182 | overrides?: CallOverrides 1183 | ): Promise; 1184 | 1185 | rewardRate(overrides?: CallOverrides): Promise; 1186 | 1187 | setBufferAndIntervalSeconds( 1188 | _bufferSeconds: BigNumberish, 1189 | _intervalSeconds: BigNumberish, 1190 | overrides?: CallOverrides 1191 | ): Promise; 1192 | 1193 | settings_SetMinBetAmount( 1194 | _minBetAmount: BigNumberish, 1195 | overrides?: CallOverrides 1196 | ): Promise; 1197 | 1198 | settings_SetRewardRate( 1199 | _rewardRate: BigNumberish, 1200 | overrides?: CallOverrides 1201 | ): Promise; 1202 | 1203 | startOnce(overrides?: CallOverrides): Promise; 1204 | 1205 | user_BetBear(epoch: BigNumberish, overrides?: CallOverrides): Promise; 1206 | 1207 | user_BetBull(epoch: BigNumberish, overrides?: CallOverrides): Promise; 1208 | 1209 | user_Claim( 1210 | epochs: BigNumberish[], 1211 | overrides?: CallOverrides 1212 | ): Promise; 1213 | }; 1214 | 1215 | filters: { 1216 | "BetBear(address,uint256,uint256)"( 1217 | sender?: string | null, 1218 | epoch?: BigNumberish | null, 1219 | amount?: null 1220 | ): TypedEventFilter< 1221 | [string, BigNumber, BigNumber], 1222 | { sender: string; epoch: BigNumber; amount: BigNumber } 1223 | >; 1224 | 1225 | BetBear( 1226 | sender?: string | null, 1227 | epoch?: BigNumberish | null, 1228 | amount?: null 1229 | ): TypedEventFilter< 1230 | [string, BigNumber, BigNumber], 1231 | { sender: string; epoch: BigNumber; amount: BigNumber } 1232 | >; 1233 | 1234 | "BetBull(address,uint256,uint256)"( 1235 | sender?: string | null, 1236 | epoch?: BigNumberish | null, 1237 | amount?: null 1238 | ): TypedEventFilter< 1239 | [string, BigNumber, BigNumber], 1240 | { sender: string; epoch: BigNumber; amount: BigNumber } 1241 | >; 1242 | 1243 | BetBull( 1244 | sender?: string | null, 1245 | epoch?: BigNumberish | null, 1246 | amount?: null 1247 | ): TypedEventFilter< 1248 | [string, BigNumber, BigNumber], 1249 | { sender: string; epoch: BigNumber; amount: BigNumber } 1250 | >; 1251 | 1252 | "BufferAndIntervalSecondsUpdated(uint256,uint256)"( 1253 | bufferSeconds?: null, 1254 | intervalSeconds?: null 1255 | ): TypedEventFilter< 1256 | [BigNumber, BigNumber], 1257 | { bufferSeconds: BigNumber; intervalSeconds: BigNumber } 1258 | >; 1259 | 1260 | BufferAndIntervalSecondsUpdated( 1261 | bufferSeconds?: null, 1262 | intervalSeconds?: null 1263 | ): TypedEventFilter< 1264 | [BigNumber, BigNumber], 1265 | { bufferSeconds: BigNumber; intervalSeconds: BigNumber } 1266 | >; 1267 | 1268 | "CancelRound(uint256)"( 1269 | epoch?: BigNumberish | null 1270 | ): TypedEventFilter<[BigNumber], { epoch: BigNumber }>; 1271 | 1272 | CancelRound( 1273 | epoch?: BigNumberish | null 1274 | ): TypedEventFilter<[BigNumber], { epoch: BigNumber }>; 1275 | 1276 | "Claim(address,uint256,uint256)"( 1277 | sender?: string | null, 1278 | epoch?: BigNumberish | null, 1279 | amount?: null 1280 | ): TypedEventFilter< 1281 | [string, BigNumber, BigNumber], 1282 | { sender: string; epoch: BigNumber; amount: BigNumber } 1283 | >; 1284 | 1285 | Claim( 1286 | sender?: string | null, 1287 | epoch?: BigNumberish | null, 1288 | amount?: null 1289 | ): TypedEventFilter< 1290 | [string, BigNumber, BigNumber], 1291 | { sender: string; epoch: BigNumber; amount: BigNumber } 1292 | >; 1293 | 1294 | "EndRound(uint256,int256,uint32)"( 1295 | epoch?: BigNumberish | null, 1296 | price?: null, 1297 | timestamp?: null 1298 | ): TypedEventFilter< 1299 | [BigNumber, BigNumber, number], 1300 | { epoch: BigNumber; price: BigNumber; timestamp: number } 1301 | >; 1302 | 1303 | EndRound( 1304 | epoch?: BigNumberish | null, 1305 | price?: null, 1306 | timestamp?: null 1307 | ): TypedEventFilter< 1308 | [BigNumber, BigNumber, number], 1309 | { epoch: BigNumber; price: BigNumber; timestamp: number } 1310 | >; 1311 | 1312 | "HouseBet(address,uint256,uint256,uint256)"( 1313 | sender?: string | null, 1314 | epoch?: BigNumberish | null, 1315 | bullAmount?: null, 1316 | bearAmount?: null 1317 | ): TypedEventFilter< 1318 | [string, BigNumber, BigNumber, BigNumber], 1319 | { 1320 | sender: string; 1321 | epoch: BigNumber; 1322 | bullAmount: BigNumber; 1323 | bearAmount: BigNumber; 1324 | } 1325 | >; 1326 | 1327 | HouseBet( 1328 | sender?: string | null, 1329 | epoch?: BigNumberish | null, 1330 | bullAmount?: null, 1331 | bearAmount?: null 1332 | ): TypedEventFilter< 1333 | [string, BigNumber, BigNumber, BigNumber], 1334 | { 1335 | sender: string; 1336 | epoch: BigNumber; 1337 | bullAmount: BigNumber; 1338 | bearAmount: BigNumber; 1339 | } 1340 | >; 1341 | 1342 | "InjectFunds(address)"( 1343 | sender?: string | null 1344 | ): TypedEventFilter<[string], { sender: string }>; 1345 | 1346 | InjectFunds( 1347 | sender?: string | null 1348 | ): TypedEventFilter<[string], { sender: string }>; 1349 | 1350 | "LockRound(uint256,int256,uint32)"( 1351 | epoch?: BigNumberish | null, 1352 | price?: null, 1353 | timestamp?: null 1354 | ): TypedEventFilter< 1355 | [BigNumber, BigNumber, number], 1356 | { epoch: BigNumber; price: BigNumber; timestamp: number } 1357 | >; 1358 | 1359 | LockRound( 1360 | epoch?: BigNumberish | null, 1361 | price?: null, 1362 | timestamp?: null 1363 | ): TypedEventFilter< 1364 | [BigNumber, BigNumber, number], 1365 | { epoch: BigNumber; price: BigNumber; timestamp: number } 1366 | >; 1367 | 1368 | "MinBetAmountUpdated(uint256,uint256)"( 1369 | epoch?: BigNumberish | null, 1370 | minBetAmount?: null 1371 | ): TypedEventFilter< 1372 | [BigNumber, BigNumber], 1373 | { epoch: BigNumber; minBetAmount: BigNumber } 1374 | >; 1375 | 1376 | MinBetAmountUpdated( 1377 | epoch?: BigNumberish | null, 1378 | minBetAmount?: null 1379 | ): TypedEventFilter< 1380 | [BigNumber, BigNumber], 1381 | { epoch: BigNumber; minBetAmount: BigNumber } 1382 | >; 1383 | 1384 | "NewPriceSource(string)"( 1385 | priceSource?: null 1386 | ): TypedEventFilter<[string], { priceSource: string }>; 1387 | 1388 | NewPriceSource( 1389 | priceSource?: null 1390 | ): TypedEventFilter<[string], { priceSource: string }>; 1391 | 1392 | "OwnershipTransferred(address,address)"( 1393 | previousOwner?: string | null, 1394 | newOwner?: string | null 1395 | ): TypedEventFilter< 1396 | [string, string], 1397 | { previousOwner: string; newOwner: string } 1398 | >; 1399 | 1400 | OwnershipTransferred( 1401 | previousOwner?: string | null, 1402 | newOwner?: string | null 1403 | ): TypedEventFilter< 1404 | [string, string], 1405 | { previousOwner: string; newOwner: string } 1406 | >; 1407 | 1408 | "Pause(uint256)"( 1409 | epoch?: BigNumberish | null 1410 | ): TypedEventFilter<[BigNumber], { epoch: BigNumber }>; 1411 | 1412 | Pause( 1413 | epoch?: BigNumberish | null 1414 | ): TypedEventFilter<[BigNumber], { epoch: BigNumber }>; 1415 | 1416 | "Paused(address)"( 1417 | account?: null 1418 | ): TypedEventFilter<[string], { account: string }>; 1419 | 1420 | Paused(account?: null): TypedEventFilter<[string], { account: string }>; 1421 | 1422 | "RewardsCalculated(uint256,uint256,uint256)"( 1423 | epoch?: BigNumberish | null, 1424 | rewardBaseCalAmount?: null, 1425 | rewardAmount?: null 1426 | ): TypedEventFilter< 1427 | [BigNumber, BigNumber, BigNumber], 1428 | { 1429 | epoch: BigNumber; 1430 | rewardBaseCalAmount: BigNumber; 1431 | rewardAmount: BigNumber; 1432 | } 1433 | >; 1434 | 1435 | RewardsCalculated( 1436 | epoch?: BigNumberish | null, 1437 | rewardBaseCalAmount?: null, 1438 | rewardAmount?: null 1439 | ): TypedEventFilter< 1440 | [BigNumber, BigNumber, BigNumber], 1441 | { 1442 | epoch: BigNumber; 1443 | rewardBaseCalAmount: BigNumber; 1444 | rewardAmount: BigNumber; 1445 | } 1446 | >; 1447 | 1448 | "StartRound(uint256)"( 1449 | epoch?: BigNumberish | null 1450 | ): TypedEventFilter<[BigNumber], { epoch: BigNumber }>; 1451 | 1452 | StartRound( 1453 | epoch?: BigNumberish | null 1454 | ): TypedEventFilter<[BigNumber], { epoch: BigNumber }>; 1455 | 1456 | "Unpause(uint256)"( 1457 | epoch?: BigNumberish | null 1458 | ): TypedEventFilter<[BigNumber], { epoch: BigNumber }>; 1459 | 1460 | Unpause( 1461 | epoch?: BigNumberish | null 1462 | ): TypedEventFilter<[BigNumber], { epoch: BigNumber }>; 1463 | 1464 | "Unpaused(address)"( 1465 | account?: null 1466 | ): TypedEventFilter<[string], { account: string }>; 1467 | 1468 | Unpaused(account?: null): TypedEventFilter<[string], { account: string }>; 1469 | }; 1470 | 1471 | estimateGas: { 1472 | Bets( 1473 | arg0: BigNumberish, 1474 | arg1: string, 1475 | overrides?: CallOverrides 1476 | ): Promise; 1477 | 1478 | OwnershipRenounce( 1479 | overrides?: Overrides & { from?: string | Promise } 1480 | ): Promise; 1481 | 1482 | OwnershipTransfer( 1483 | newOwner: string, 1484 | overrides?: Overrides & { from?: string | Promise } 1485 | ): Promise; 1486 | 1487 | Rounds(arg0: BigNumberish, overrides?: CallOverrides): Promise; 1488 | 1489 | UserBets( 1490 | arg0: string, 1491 | arg1: BigNumberish, 1492 | overrides?: CallOverrides 1493 | ): Promise; 1494 | 1495 | _owner(overrides?: CallOverrides): Promise; 1496 | 1497 | bufferSeconds(overrides?: CallOverrides): Promise; 1498 | 1499 | claimable( 1500 | epoch: BigNumberish, 1501 | user: string, 1502 | overrides?: CallOverrides 1503 | ): Promise; 1504 | 1505 | control_Pause( 1506 | overrides?: Overrides & { from?: string | Promise } 1507 | ): Promise; 1508 | 1509 | control_Resume( 1510 | overrides?: Overrides & { from?: string | Promise } 1511 | ): Promise; 1512 | 1513 | control_RoundCancel( 1514 | epoch: BigNumberish, 1515 | cancelled: boolean, 1516 | closed: boolean, 1517 | overrides?: Overrides & { from?: string | Promise } 1518 | ): Promise; 1519 | 1520 | control_RoundExecute( 1521 | price: BigNumberish, 1522 | timestamp: BigNumberish, 1523 | overrides?: Overrides & { from?: string | Promise } 1524 | ): Promise; 1525 | 1526 | control_RoundLock( 1527 | price: BigNumberish, 1528 | timestamp: BigNumberish, 1529 | overrides?: Overrides & { from?: string | Promise } 1530 | ): Promise; 1531 | 1532 | control_RoundStart( 1533 | overrides?: Overrides & { from?: string | Promise } 1534 | ): Promise; 1535 | 1536 | currentBlockNumber(overrides?: CallOverrides): Promise; 1537 | 1538 | currentBlockTimestamp(overrides?: CallOverrides): Promise; 1539 | 1540 | currentEpoch(overrides?: CallOverrides): Promise; 1541 | 1542 | getUserRounds( 1543 | user: string, 1544 | cursor: BigNumberish, 1545 | size: BigNumberish, 1546 | overrides?: CallOverrides 1547 | ): Promise; 1548 | 1549 | getUserRoundsLength( 1550 | user: string, 1551 | overrides?: CallOverrides 1552 | ): Promise; 1553 | 1554 | intervalSeconds(overrides?: CallOverrides): Promise; 1555 | 1556 | lockOnce(overrides?: CallOverrides): Promise; 1557 | 1558 | minBetAmount(overrides?: CallOverrides): Promise; 1559 | 1560 | operatorAddress(overrides?: CallOverrides): Promise; 1561 | 1562 | owner(overrides?: CallOverrides): Promise; 1563 | 1564 | owner_BlackListInsert( 1565 | _user: string, 1566 | overrides?: Overrides & { from?: string | Promise } 1567 | ): Promise; 1568 | 1569 | owner_BlackListRemove( 1570 | _user: string, 1571 | overrides?: Overrides & { from?: string | Promise } 1572 | ): Promise; 1573 | 1574 | owner_ChangePriceSource( 1575 | _priceSource: string, 1576 | overrides?: Overrides & { from?: string | Promise } 1577 | ): Promise; 1578 | 1579 | owner_FundsExtract( 1580 | value: BigNumberish, 1581 | overrides?: Overrides & { from?: string | Promise } 1582 | ): Promise; 1583 | 1584 | owner_FundsInject( 1585 | overrides?: PayableOverrides & { from?: string | Promise } 1586 | ): Promise; 1587 | 1588 | owner_HouseBet( 1589 | bullAmount: BigNumberish, 1590 | bearAmount: BigNumberish, 1591 | overrides?: Overrides & { from?: string | Promise } 1592 | ): Promise; 1593 | 1594 | owner_RewardUser( 1595 | user: string, 1596 | value: BigNumberish, 1597 | overrides?: Overrides & { from?: string | Promise } 1598 | ): Promise; 1599 | 1600 | owner_SetOperator( 1601 | _operatorAddress: string, 1602 | overrides?: Overrides & { from?: string | Promise } 1603 | ): Promise; 1604 | 1605 | paused(overrides?: CallOverrides): Promise; 1606 | 1607 | priceSource(overrides?: CallOverrides): Promise; 1608 | 1609 | refundable( 1610 | epoch: BigNumberish, 1611 | user: string, 1612 | overrides?: CallOverrides 1613 | ): Promise; 1614 | 1615 | rewardRate(overrides?: CallOverrides): Promise; 1616 | 1617 | setBufferAndIntervalSeconds( 1618 | _bufferSeconds: BigNumberish, 1619 | _intervalSeconds: BigNumberish, 1620 | overrides?: Overrides & { from?: string | Promise } 1621 | ): Promise; 1622 | 1623 | settings_SetMinBetAmount( 1624 | _minBetAmount: BigNumberish, 1625 | overrides?: Overrides & { from?: string | Promise } 1626 | ): Promise; 1627 | 1628 | settings_SetRewardRate( 1629 | _rewardRate: BigNumberish, 1630 | overrides?: Overrides & { from?: string | Promise } 1631 | ): Promise; 1632 | 1633 | startOnce(overrides?: CallOverrides): Promise; 1634 | 1635 | user_BetBear( 1636 | epoch: BigNumberish, 1637 | overrides?: PayableOverrides & { from?: string | Promise } 1638 | ): Promise; 1639 | 1640 | user_BetBull( 1641 | epoch: BigNumberish, 1642 | overrides?: PayableOverrides & { from?: string | Promise } 1643 | ): Promise; 1644 | 1645 | user_Claim( 1646 | epochs: BigNumberish[], 1647 | overrides?: Overrides & { from?: string | Promise } 1648 | ): Promise; 1649 | }; 1650 | 1651 | populateTransaction: { 1652 | Bets( 1653 | arg0: BigNumberish, 1654 | arg1: string, 1655 | overrides?: CallOverrides 1656 | ): Promise; 1657 | 1658 | OwnershipRenounce( 1659 | overrides?: Overrides & { from?: string | Promise } 1660 | ): Promise; 1661 | 1662 | OwnershipTransfer( 1663 | newOwner: string, 1664 | overrides?: Overrides & { from?: string | Promise } 1665 | ): Promise; 1666 | 1667 | Rounds( 1668 | arg0: BigNumberish, 1669 | overrides?: CallOverrides 1670 | ): Promise; 1671 | 1672 | UserBets( 1673 | arg0: string, 1674 | arg1: BigNumberish, 1675 | overrides?: CallOverrides 1676 | ): Promise; 1677 | 1678 | _owner(overrides?: CallOverrides): Promise; 1679 | 1680 | bufferSeconds(overrides?: CallOverrides): Promise; 1681 | 1682 | claimable( 1683 | epoch: BigNumberish, 1684 | user: string, 1685 | overrides?: CallOverrides 1686 | ): Promise; 1687 | 1688 | control_Pause( 1689 | overrides?: Overrides & { from?: string | Promise } 1690 | ): Promise; 1691 | 1692 | control_Resume( 1693 | overrides?: Overrides & { from?: string | Promise } 1694 | ): Promise; 1695 | 1696 | control_RoundCancel( 1697 | epoch: BigNumberish, 1698 | cancelled: boolean, 1699 | closed: boolean, 1700 | overrides?: Overrides & { from?: string | Promise } 1701 | ): Promise; 1702 | 1703 | control_RoundExecute( 1704 | price: BigNumberish, 1705 | timestamp: BigNumberish, 1706 | overrides?: Overrides & { from?: string | Promise } 1707 | ): Promise; 1708 | 1709 | control_RoundLock( 1710 | price: BigNumberish, 1711 | timestamp: BigNumberish, 1712 | overrides?: Overrides & { from?: string | Promise } 1713 | ): Promise; 1714 | 1715 | control_RoundStart( 1716 | overrides?: Overrides & { from?: string | Promise } 1717 | ): Promise; 1718 | 1719 | currentBlockNumber( 1720 | overrides?: CallOverrides 1721 | ): Promise; 1722 | 1723 | currentBlockTimestamp( 1724 | overrides?: CallOverrides 1725 | ): Promise; 1726 | 1727 | currentEpoch(overrides?: CallOverrides): Promise; 1728 | 1729 | getUserRounds( 1730 | user: string, 1731 | cursor: BigNumberish, 1732 | size: BigNumberish, 1733 | overrides?: CallOverrides 1734 | ): Promise; 1735 | 1736 | getUserRoundsLength( 1737 | user: string, 1738 | overrides?: CallOverrides 1739 | ): Promise; 1740 | 1741 | intervalSeconds(overrides?: CallOverrides): Promise; 1742 | 1743 | lockOnce(overrides?: CallOverrides): Promise; 1744 | 1745 | minBetAmount(overrides?: CallOverrides): Promise; 1746 | 1747 | operatorAddress(overrides?: CallOverrides): Promise; 1748 | 1749 | owner(overrides?: CallOverrides): Promise; 1750 | 1751 | owner_BlackListInsert( 1752 | _user: string, 1753 | overrides?: Overrides & { from?: string | Promise } 1754 | ): Promise; 1755 | 1756 | owner_BlackListRemove( 1757 | _user: string, 1758 | overrides?: Overrides & { from?: string | Promise } 1759 | ): Promise; 1760 | 1761 | owner_ChangePriceSource( 1762 | _priceSource: string, 1763 | overrides?: Overrides & { from?: string | Promise } 1764 | ): Promise; 1765 | 1766 | owner_FundsExtract( 1767 | value: BigNumberish, 1768 | overrides?: Overrides & { from?: string | Promise } 1769 | ): Promise; 1770 | 1771 | owner_FundsInject( 1772 | overrides?: PayableOverrides & { from?: string | Promise } 1773 | ): Promise; 1774 | 1775 | owner_HouseBet( 1776 | bullAmount: BigNumberish, 1777 | bearAmount: BigNumberish, 1778 | overrides?: Overrides & { from?: string | Promise } 1779 | ): Promise; 1780 | 1781 | owner_RewardUser( 1782 | user: string, 1783 | value: BigNumberish, 1784 | overrides?: Overrides & { from?: string | Promise } 1785 | ): Promise; 1786 | 1787 | owner_SetOperator( 1788 | _operatorAddress: string, 1789 | overrides?: Overrides & { from?: string | Promise } 1790 | ): Promise; 1791 | 1792 | paused(overrides?: CallOverrides): Promise; 1793 | 1794 | priceSource(overrides?: CallOverrides): Promise; 1795 | 1796 | refundable( 1797 | epoch: BigNumberish, 1798 | user: string, 1799 | overrides?: CallOverrides 1800 | ): Promise; 1801 | 1802 | rewardRate(overrides?: CallOverrides): Promise; 1803 | 1804 | setBufferAndIntervalSeconds( 1805 | _bufferSeconds: BigNumberish, 1806 | _intervalSeconds: BigNumberish, 1807 | overrides?: Overrides & { from?: string | Promise } 1808 | ): Promise; 1809 | 1810 | settings_SetMinBetAmount( 1811 | _minBetAmount: BigNumberish, 1812 | overrides?: Overrides & { from?: string | Promise } 1813 | ): Promise; 1814 | 1815 | settings_SetRewardRate( 1816 | _rewardRate: BigNumberish, 1817 | overrides?: Overrides & { from?: string | Promise } 1818 | ): Promise; 1819 | 1820 | startOnce(overrides?: CallOverrides): Promise; 1821 | 1822 | user_BetBear( 1823 | epoch: BigNumberish, 1824 | overrides?: PayableOverrides & { from?: string | Promise } 1825 | ): Promise; 1826 | 1827 | user_BetBull( 1828 | epoch: BigNumberish, 1829 | overrides?: PayableOverrides & { from?: string | Promise } 1830 | ): Promise; 1831 | 1832 | user_Claim( 1833 | epochs: BigNumberish[], 1834 | overrides?: Overrides & { from?: string | Promise } 1835 | ): Promise; 1836 | }; 1837 | } 1838 | -------------------------------------------------------------------------------- /src/types/typechain/PancakePredictionV2.d.ts: -------------------------------------------------------------------------------- 1 | /* Autogenerated file. Do not edit manually. */ 2 | /* tslint:disable */ 3 | /* eslint-disable */ 4 | 5 | import { EventFragment, FunctionFragment, Result } from "@ethersproject/abi"; 6 | import { BytesLike } from "@ethersproject/bytes"; 7 | import { Listener, Provider } from "@ethersproject/providers"; 8 | import { 9 | BaseContract, 10 | BigNumber, 11 | BigNumberish, 12 | CallOverrides, 13 | ContractTransaction, 14 | ethers, 15 | Overrides, 16 | PayableOverrides, 17 | PopulatedTransaction, 18 | Signer, 19 | } from "ethers"; 20 | import { TypedEvent, TypedEventFilter, TypedListener } from "./commons"; 21 | 22 | interface PancakePredictionV2Interface extends ethers.utils.Interface { 23 | functions: { 24 | "MAX_TREASURY_FEE()": FunctionFragment; 25 | "adminAddress()": FunctionFragment; 26 | "betBear(uint256)": FunctionFragment; 27 | "betBull(uint256)": FunctionFragment; 28 | "bufferSeconds()": FunctionFragment; 29 | "claim(uint256[])": FunctionFragment; 30 | "claimTreasury()": FunctionFragment; 31 | "claimable(uint256,address)": FunctionFragment; 32 | "currentEpoch()": FunctionFragment; 33 | "executeRound()": FunctionFragment; 34 | "genesisLockOnce()": FunctionFragment; 35 | "genesisLockRound()": FunctionFragment; 36 | "genesisStartOnce()": FunctionFragment; 37 | "genesisStartRound()": FunctionFragment; 38 | "getUserRounds(address,uint256,uint256)": FunctionFragment; 39 | "getUserRoundsLength(address)": FunctionFragment; 40 | "intervalSeconds()": FunctionFragment; 41 | "ledger(uint256,address)": FunctionFragment; 42 | "minBetAmount()": FunctionFragment; 43 | "operatorAddress()": FunctionFragment; 44 | "oracle()": FunctionFragment; 45 | "oracleLatestRoundId()": FunctionFragment; 46 | "oracleUpdateAllowance()": FunctionFragment; 47 | "owner()": FunctionFragment; 48 | "pause()": FunctionFragment; 49 | "paused()": FunctionFragment; 50 | "recoverToken(address,uint256)": FunctionFragment; 51 | "refundable(uint256,address)": FunctionFragment; 52 | "renounceOwnership()": FunctionFragment; 53 | "rounds(uint256)": FunctionFragment; 54 | "setAdmin(address)": FunctionFragment; 55 | "setBufferAndIntervalSeconds(uint256,uint256)": FunctionFragment; 56 | "setMinBetAmount(uint256)": FunctionFragment; 57 | "setOperator(address)": FunctionFragment; 58 | "setOracle(address)": FunctionFragment; 59 | "setOracleUpdateAllowance(uint256)": FunctionFragment; 60 | "setTreasuryFee(uint256)": FunctionFragment; 61 | "transferOwnership(address)": FunctionFragment; 62 | "treasuryAmount()": FunctionFragment; 63 | "treasuryFee()": FunctionFragment; 64 | "unpause()": FunctionFragment; 65 | "userRounds(address,uint256)": FunctionFragment; 66 | }; 67 | 68 | encodeFunctionData( 69 | functionFragment: "MAX_TREASURY_FEE", 70 | values?: undefined 71 | ): string; 72 | encodeFunctionData( 73 | functionFragment: "adminAddress", 74 | values?: undefined 75 | ): string; 76 | encodeFunctionData( 77 | functionFragment: "betBear", 78 | values: [BigNumberish] 79 | ): string; 80 | encodeFunctionData( 81 | functionFragment: "betBull", 82 | values: [BigNumberish] 83 | ): string; 84 | encodeFunctionData( 85 | functionFragment: "bufferSeconds", 86 | values?: undefined 87 | ): string; 88 | encodeFunctionData( 89 | functionFragment: "claim", 90 | values: [BigNumberish[]] 91 | ): string; 92 | encodeFunctionData( 93 | functionFragment: "claimTreasury", 94 | values?: undefined 95 | ): string; 96 | encodeFunctionData( 97 | functionFragment: "claimable", 98 | values: [BigNumberish, string] 99 | ): string; 100 | encodeFunctionData( 101 | functionFragment: "currentEpoch", 102 | values?: undefined 103 | ): string; 104 | encodeFunctionData( 105 | functionFragment: "executeRound", 106 | values?: undefined 107 | ): string; 108 | encodeFunctionData( 109 | functionFragment: "genesisLockOnce", 110 | values?: undefined 111 | ): string; 112 | encodeFunctionData( 113 | functionFragment: "genesisLockRound", 114 | values?: undefined 115 | ): string; 116 | encodeFunctionData( 117 | functionFragment: "genesisStartOnce", 118 | values?: undefined 119 | ): string; 120 | encodeFunctionData( 121 | functionFragment: "genesisStartRound", 122 | values?: undefined 123 | ): string; 124 | encodeFunctionData( 125 | functionFragment: "getUserRounds", 126 | values: [string, BigNumberish, BigNumberish] 127 | ): string; 128 | encodeFunctionData( 129 | functionFragment: "getUserRoundsLength", 130 | values: [string] 131 | ): string; 132 | encodeFunctionData( 133 | functionFragment: "intervalSeconds", 134 | values?: undefined 135 | ): string; 136 | encodeFunctionData( 137 | functionFragment: "ledger", 138 | values: [BigNumberish, string] 139 | ): string; 140 | encodeFunctionData( 141 | functionFragment: "minBetAmount", 142 | values?: undefined 143 | ): string; 144 | encodeFunctionData( 145 | functionFragment: "operatorAddress", 146 | values?: undefined 147 | ): string; 148 | encodeFunctionData(functionFragment: "oracle", values?: undefined): string; 149 | encodeFunctionData( 150 | functionFragment: "oracleLatestRoundId", 151 | values?: undefined 152 | ): string; 153 | encodeFunctionData( 154 | functionFragment: "oracleUpdateAllowance", 155 | values?: undefined 156 | ): string; 157 | encodeFunctionData(functionFragment: "owner", values?: undefined): string; 158 | encodeFunctionData(functionFragment: "pause", values?: undefined): string; 159 | encodeFunctionData(functionFragment: "paused", values?: undefined): string; 160 | encodeFunctionData( 161 | functionFragment: "recoverToken", 162 | values: [string, BigNumberish] 163 | ): string; 164 | encodeFunctionData( 165 | functionFragment: "refundable", 166 | values: [BigNumberish, string] 167 | ): string; 168 | encodeFunctionData( 169 | functionFragment: "renounceOwnership", 170 | values?: undefined 171 | ): string; 172 | encodeFunctionData( 173 | functionFragment: "rounds", 174 | values: [BigNumberish] 175 | ): string; 176 | encodeFunctionData(functionFragment: "setAdmin", values: [string]): string; 177 | encodeFunctionData( 178 | functionFragment: "setBufferAndIntervalSeconds", 179 | values: [BigNumberish, BigNumberish] 180 | ): string; 181 | encodeFunctionData( 182 | functionFragment: "setMinBetAmount", 183 | values: [BigNumberish] 184 | ): string; 185 | encodeFunctionData(functionFragment: "setOperator", values: [string]): string; 186 | encodeFunctionData(functionFragment: "setOracle", values: [string]): string; 187 | encodeFunctionData( 188 | functionFragment: "setOracleUpdateAllowance", 189 | values: [BigNumberish] 190 | ): string; 191 | encodeFunctionData( 192 | functionFragment: "setTreasuryFee", 193 | values: [BigNumberish] 194 | ): string; 195 | encodeFunctionData( 196 | functionFragment: "transferOwnership", 197 | values: [string] 198 | ): string; 199 | encodeFunctionData( 200 | functionFragment: "treasuryAmount", 201 | values?: undefined 202 | ): string; 203 | encodeFunctionData( 204 | functionFragment: "treasuryFee", 205 | values?: undefined 206 | ): string; 207 | encodeFunctionData(functionFragment: "unpause", values?: undefined): string; 208 | encodeFunctionData( 209 | functionFragment: "userRounds", 210 | values: [string, BigNumberish] 211 | ): string; 212 | 213 | decodeFunctionResult( 214 | functionFragment: "MAX_TREASURY_FEE", 215 | data: BytesLike 216 | ): Result; 217 | decodeFunctionResult( 218 | functionFragment: "adminAddress", 219 | data: BytesLike 220 | ): Result; 221 | decodeFunctionResult(functionFragment: "betBear", data: BytesLike): Result; 222 | decodeFunctionResult(functionFragment: "betBull", data: BytesLike): Result; 223 | decodeFunctionResult( 224 | functionFragment: "bufferSeconds", 225 | data: BytesLike 226 | ): Result; 227 | decodeFunctionResult(functionFragment: "claim", data: BytesLike): Result; 228 | decodeFunctionResult( 229 | functionFragment: "claimTreasury", 230 | data: BytesLike 231 | ): Result; 232 | decodeFunctionResult(functionFragment: "claimable", data: BytesLike): Result; 233 | decodeFunctionResult( 234 | functionFragment: "currentEpoch", 235 | data: BytesLike 236 | ): Result; 237 | decodeFunctionResult( 238 | functionFragment: "executeRound", 239 | data: BytesLike 240 | ): Result; 241 | decodeFunctionResult( 242 | functionFragment: "genesisLockOnce", 243 | data: BytesLike 244 | ): Result; 245 | decodeFunctionResult( 246 | functionFragment: "genesisLockRound", 247 | data: BytesLike 248 | ): Result; 249 | decodeFunctionResult( 250 | functionFragment: "genesisStartOnce", 251 | data: BytesLike 252 | ): Result; 253 | decodeFunctionResult( 254 | functionFragment: "genesisStartRound", 255 | data: BytesLike 256 | ): Result; 257 | decodeFunctionResult( 258 | functionFragment: "getUserRounds", 259 | data: BytesLike 260 | ): Result; 261 | decodeFunctionResult( 262 | functionFragment: "getUserRoundsLength", 263 | data: BytesLike 264 | ): Result; 265 | decodeFunctionResult( 266 | functionFragment: "intervalSeconds", 267 | data: BytesLike 268 | ): Result; 269 | decodeFunctionResult(functionFragment: "ledger", data: BytesLike): Result; 270 | decodeFunctionResult( 271 | functionFragment: "minBetAmount", 272 | data: BytesLike 273 | ): Result; 274 | decodeFunctionResult( 275 | functionFragment: "operatorAddress", 276 | data: BytesLike 277 | ): Result; 278 | decodeFunctionResult(functionFragment: "oracle", data: BytesLike): Result; 279 | decodeFunctionResult( 280 | functionFragment: "oracleLatestRoundId", 281 | data: BytesLike 282 | ): Result; 283 | decodeFunctionResult( 284 | functionFragment: "oracleUpdateAllowance", 285 | data: BytesLike 286 | ): Result; 287 | decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; 288 | decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result; 289 | decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result; 290 | decodeFunctionResult( 291 | functionFragment: "recoverToken", 292 | data: BytesLike 293 | ): Result; 294 | decodeFunctionResult(functionFragment: "refundable", data: BytesLike): Result; 295 | decodeFunctionResult( 296 | functionFragment: "renounceOwnership", 297 | data: BytesLike 298 | ): Result; 299 | decodeFunctionResult(functionFragment: "rounds", data: BytesLike): Result; 300 | decodeFunctionResult(functionFragment: "setAdmin", data: BytesLike): Result; 301 | decodeFunctionResult( 302 | functionFragment: "setBufferAndIntervalSeconds", 303 | data: BytesLike 304 | ): Result; 305 | decodeFunctionResult( 306 | functionFragment: "setMinBetAmount", 307 | data: BytesLike 308 | ): Result; 309 | decodeFunctionResult( 310 | functionFragment: "setOperator", 311 | data: BytesLike 312 | ): Result; 313 | decodeFunctionResult(functionFragment: "setOracle", data: BytesLike): Result; 314 | decodeFunctionResult( 315 | functionFragment: "setOracleUpdateAllowance", 316 | data: BytesLike 317 | ): Result; 318 | decodeFunctionResult( 319 | functionFragment: "setTreasuryFee", 320 | data: BytesLike 321 | ): Result; 322 | decodeFunctionResult( 323 | functionFragment: "transferOwnership", 324 | data: BytesLike 325 | ): Result; 326 | decodeFunctionResult( 327 | functionFragment: "treasuryAmount", 328 | data: BytesLike 329 | ): Result; 330 | decodeFunctionResult( 331 | functionFragment: "treasuryFee", 332 | data: BytesLike 333 | ): Result; 334 | decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result; 335 | decodeFunctionResult(functionFragment: "userRounds", data: BytesLike): Result; 336 | 337 | events: { 338 | "BetBear(address,uint256,uint256)": EventFragment; 339 | "BetBull(address,uint256,uint256)": EventFragment; 340 | "Claim(address,uint256,uint256)": EventFragment; 341 | "EndRound(uint256,uint256,int256)": EventFragment; 342 | "LockRound(uint256,uint256,int256)": EventFragment; 343 | "NewAdminAddress(address)": EventFragment; 344 | "NewBufferAndIntervalSeconds(uint256,uint256)": EventFragment; 345 | "NewMinBetAmount(uint256,uint256)": EventFragment; 346 | "NewOperatorAddress(address)": EventFragment; 347 | "NewOracle(address)": EventFragment; 348 | "NewOracleUpdateAllowance(uint256)": EventFragment; 349 | "NewTreasuryFee(uint256,uint256)": EventFragment; 350 | "OwnershipTransferred(address,address)": EventFragment; 351 | "Pause(uint256)": EventFragment; 352 | "Paused(address)": EventFragment; 353 | "RewardsCalculated(uint256,uint256,uint256,uint256)": EventFragment; 354 | "StartRound(uint256)": EventFragment; 355 | "TokenRecovery(address,uint256)": EventFragment; 356 | "TreasuryClaim(uint256)": EventFragment; 357 | "Unpause(uint256)": EventFragment; 358 | "Unpaused(address)": EventFragment; 359 | }; 360 | 361 | getEvent(nameOrSignatureOrTopic: "BetBear"): EventFragment; 362 | getEvent(nameOrSignatureOrTopic: "BetBull"): EventFragment; 363 | getEvent(nameOrSignatureOrTopic: "Claim"): EventFragment; 364 | getEvent(nameOrSignatureOrTopic: "EndRound"): EventFragment; 365 | getEvent(nameOrSignatureOrTopic: "LockRound"): EventFragment; 366 | getEvent(nameOrSignatureOrTopic: "NewAdminAddress"): EventFragment; 367 | getEvent( 368 | nameOrSignatureOrTopic: "NewBufferAndIntervalSeconds" 369 | ): EventFragment; 370 | getEvent(nameOrSignatureOrTopic: "NewMinBetAmount"): EventFragment; 371 | getEvent(nameOrSignatureOrTopic: "NewOperatorAddress"): EventFragment; 372 | getEvent(nameOrSignatureOrTopic: "NewOracle"): EventFragment; 373 | getEvent(nameOrSignatureOrTopic: "NewOracleUpdateAllowance"): EventFragment; 374 | getEvent(nameOrSignatureOrTopic: "NewTreasuryFee"): EventFragment; 375 | getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; 376 | getEvent(nameOrSignatureOrTopic: "Pause"): EventFragment; 377 | getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment; 378 | getEvent(nameOrSignatureOrTopic: "RewardsCalculated"): EventFragment; 379 | getEvent(nameOrSignatureOrTopic: "StartRound"): EventFragment; 380 | getEvent(nameOrSignatureOrTopic: "TokenRecovery"): EventFragment; 381 | getEvent(nameOrSignatureOrTopic: "TreasuryClaim"): EventFragment; 382 | getEvent(nameOrSignatureOrTopic: "Unpause"): EventFragment; 383 | getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment; 384 | } 385 | 386 | export class PancakePredictionV2 extends BaseContract { 387 | connect(signerOrProvider: Signer | Provider | string): this; 388 | attach(addressOrName: string): this; 389 | deployed(): Promise; 390 | 391 | listeners, EventArgsObject>( 392 | eventFilter?: TypedEventFilter 393 | ): Array>; 394 | off, EventArgsObject>( 395 | eventFilter: TypedEventFilter, 396 | listener: TypedListener 397 | ): this; 398 | on, EventArgsObject>( 399 | eventFilter: TypedEventFilter, 400 | listener: TypedListener 401 | ): this; 402 | once, EventArgsObject>( 403 | eventFilter: TypedEventFilter, 404 | listener: TypedListener 405 | ): this; 406 | removeListener, EventArgsObject>( 407 | eventFilter: TypedEventFilter, 408 | listener: TypedListener 409 | ): this; 410 | removeAllListeners, EventArgsObject>( 411 | eventFilter: TypedEventFilter 412 | ): this; 413 | 414 | listeners(eventName?: string): Array; 415 | off(eventName: string, listener: Listener): this; 416 | on(eventName: string, listener: Listener): this; 417 | once(eventName: string, listener: Listener): this; 418 | removeListener(eventName: string, listener: Listener): this; 419 | removeAllListeners(eventName?: string): this; 420 | 421 | queryFilter, EventArgsObject>( 422 | event: TypedEventFilter, 423 | fromBlockOrBlockhash?: string | number | undefined, 424 | toBlock?: string | number | undefined 425 | ): Promise>>; 426 | 427 | interface: PancakePredictionV2Interface; 428 | 429 | functions: { 430 | MAX_TREASURY_FEE(overrides?: CallOverrides): Promise<[BigNumber]>; 431 | 432 | adminAddress(overrides?: CallOverrides): Promise<[string]>; 433 | 434 | betBear( 435 | epoch: BigNumberish, 436 | overrides?: PayableOverrides & { from?: string | Promise } 437 | ): Promise; 438 | 439 | betBull( 440 | epoch: BigNumberish, 441 | overrides?: PayableOverrides & { from?: string | Promise } 442 | ): Promise; 443 | 444 | bufferSeconds(overrides?: CallOverrides): Promise<[BigNumber]>; 445 | 446 | claim( 447 | epochs: BigNumberish[], 448 | overrides?: Overrides & { from?: string | Promise } 449 | ): Promise; 450 | 451 | claimTreasury( 452 | overrides?: Overrides & { from?: string | Promise } 453 | ): Promise; 454 | 455 | claimable( 456 | epoch: BigNumberish, 457 | user: string, 458 | overrides?: CallOverrides 459 | ): Promise<[boolean]>; 460 | 461 | currentEpoch(overrides?: CallOverrides): Promise<[BigNumber]>; 462 | 463 | executeRound( 464 | overrides?: Overrides & { from?: string | Promise } 465 | ): Promise; 466 | 467 | genesisLockOnce(overrides?: CallOverrides): Promise<[boolean]>; 468 | 469 | genesisLockRound( 470 | overrides?: Overrides & { from?: string | Promise } 471 | ): Promise; 472 | 473 | genesisStartOnce(overrides?: CallOverrides): Promise<[boolean]>; 474 | 475 | genesisStartRound( 476 | overrides?: Overrides & { from?: string | Promise } 477 | ): Promise; 478 | 479 | getUserRounds( 480 | user: string, 481 | cursor: BigNumberish, 482 | size: BigNumberish, 483 | overrides?: CallOverrides 484 | ): Promise< 485 | [ 486 | BigNumber[], 487 | ([number, BigNumber, boolean] & { 488 | position: number; 489 | amount: BigNumber; 490 | claimed: boolean; 491 | })[], 492 | BigNumber 493 | ] 494 | >; 495 | 496 | getUserRoundsLength( 497 | user: string, 498 | overrides?: CallOverrides 499 | ): Promise<[BigNumber]>; 500 | 501 | intervalSeconds(overrides?: CallOverrides): Promise<[BigNumber]>; 502 | 503 | ledger( 504 | arg0: BigNumberish, 505 | arg1: string, 506 | overrides?: CallOverrides 507 | ): Promise< 508 | [number, BigNumber, boolean] & { 509 | position: number; 510 | amount: BigNumber; 511 | claimed: boolean; 512 | } 513 | >; 514 | 515 | minBetAmount(overrides?: CallOverrides): Promise<[BigNumber]>; 516 | 517 | operatorAddress(overrides?: CallOverrides): Promise<[string]>; 518 | 519 | oracle(overrides?: CallOverrides): Promise<[string]>; 520 | 521 | oracleLatestRoundId(overrides?: CallOverrides): Promise<[BigNumber]>; 522 | 523 | oracleUpdateAllowance(overrides?: CallOverrides): Promise<[BigNumber]>; 524 | 525 | owner(overrides?: CallOverrides): Promise<[string]>; 526 | 527 | pause( 528 | overrides?: Overrides & { from?: string | Promise } 529 | ): Promise; 530 | 531 | paused(overrides?: CallOverrides): Promise<[boolean]>; 532 | 533 | recoverToken( 534 | _token: string, 535 | _amount: BigNumberish, 536 | overrides?: Overrides & { from?: string | Promise } 537 | ): Promise; 538 | 539 | refundable( 540 | epoch: BigNumberish, 541 | user: string, 542 | overrides?: CallOverrides 543 | ): Promise<[boolean]>; 544 | 545 | renounceOwnership( 546 | overrides?: Overrides & { from?: string | Promise } 547 | ): Promise; 548 | 549 | rounds( 550 | arg0: BigNumberish, 551 | overrides?: CallOverrides 552 | ): Promise< 553 | [ 554 | BigNumber, 555 | BigNumber, 556 | BigNumber, 557 | BigNumber, 558 | BigNumber, 559 | BigNumber, 560 | BigNumber, 561 | BigNumber, 562 | BigNumber, 563 | BigNumber, 564 | BigNumber, 565 | BigNumber, 566 | BigNumber, 567 | boolean 568 | ] & { 569 | epoch: BigNumber; 570 | startTimestamp: BigNumber; 571 | lockTimestamp: BigNumber; 572 | closeTimestamp: BigNumber; 573 | lockPrice: BigNumber; 574 | closePrice: BigNumber; 575 | lockOracleId: BigNumber; 576 | closeOracleId: BigNumber; 577 | totalAmount: BigNumber; 578 | bullAmount: BigNumber; 579 | bearAmount: BigNumber; 580 | rewardBaseCalAmount: BigNumber; 581 | rewardAmount: BigNumber; 582 | oracleCalled: boolean; 583 | } 584 | >; 585 | 586 | setAdmin( 587 | _adminAddress: string, 588 | overrides?: Overrides & { from?: string | Promise } 589 | ): Promise; 590 | 591 | setBufferAndIntervalSeconds( 592 | _bufferSeconds: BigNumberish, 593 | _intervalSeconds: BigNumberish, 594 | overrides?: Overrides & { from?: string | Promise } 595 | ): Promise; 596 | 597 | setMinBetAmount( 598 | _minBetAmount: BigNumberish, 599 | overrides?: Overrides & { from?: string | Promise } 600 | ): Promise; 601 | 602 | setOperator( 603 | _operatorAddress: string, 604 | overrides?: Overrides & { from?: string | Promise } 605 | ): Promise; 606 | 607 | setOracle( 608 | _oracle: string, 609 | overrides?: Overrides & { from?: string | Promise } 610 | ): Promise; 611 | 612 | setOracleUpdateAllowance( 613 | _oracleUpdateAllowance: BigNumberish, 614 | overrides?: Overrides & { from?: string | Promise } 615 | ): Promise; 616 | 617 | setTreasuryFee( 618 | _treasuryFee: BigNumberish, 619 | overrides?: Overrides & { from?: string | Promise } 620 | ): Promise; 621 | 622 | transferOwnership( 623 | newOwner: string, 624 | overrides?: Overrides & { from?: string | Promise } 625 | ): Promise; 626 | 627 | treasuryAmount(overrides?: CallOverrides): Promise<[BigNumber]>; 628 | 629 | treasuryFee(overrides?: CallOverrides): Promise<[BigNumber]>; 630 | 631 | unpause( 632 | overrides?: Overrides & { from?: string | Promise } 633 | ): Promise; 634 | 635 | userRounds( 636 | arg0: string, 637 | arg1: BigNumberish, 638 | overrides?: CallOverrides 639 | ): Promise<[BigNumber]>; 640 | }; 641 | 642 | MAX_TREASURY_FEE(overrides?: CallOverrides): Promise; 643 | 644 | adminAddress(overrides?: CallOverrides): Promise; 645 | 646 | betBear( 647 | epoch: BigNumberish, 648 | overrides?: PayableOverrides & { from?: string | Promise } 649 | ): Promise; 650 | 651 | betBull( 652 | epoch: BigNumberish, 653 | overrides?: PayableOverrides & { from?: string | Promise } 654 | ): Promise; 655 | 656 | bufferSeconds(overrides?: CallOverrides): Promise; 657 | 658 | claim( 659 | epochs: BigNumberish[], 660 | overrides?: Overrides & { from?: string | Promise } 661 | ): Promise; 662 | 663 | claimTreasury( 664 | overrides?: Overrides & { from?: string | Promise } 665 | ): Promise; 666 | 667 | claimable( 668 | epoch: BigNumberish, 669 | user: string, 670 | overrides?: CallOverrides 671 | ): Promise; 672 | 673 | currentEpoch(overrides?: CallOverrides): Promise; 674 | 675 | executeRound( 676 | overrides?: Overrides & { from?: string | Promise } 677 | ): Promise; 678 | 679 | genesisLockOnce(overrides?: CallOverrides): Promise; 680 | 681 | genesisLockRound( 682 | overrides?: Overrides & { from?: string | Promise } 683 | ): Promise; 684 | 685 | genesisStartOnce(overrides?: CallOverrides): Promise; 686 | 687 | genesisStartRound( 688 | overrides?: Overrides & { from?: string | Promise } 689 | ): Promise; 690 | 691 | getUserRounds( 692 | user: string, 693 | cursor: BigNumberish, 694 | size: BigNumberish, 695 | overrides?: CallOverrides 696 | ): Promise< 697 | [ 698 | BigNumber[], 699 | ([number, BigNumber, boolean] & { 700 | position: number; 701 | amount: BigNumber; 702 | claimed: boolean; 703 | })[], 704 | BigNumber 705 | ] 706 | >; 707 | 708 | getUserRoundsLength( 709 | user: string, 710 | overrides?: CallOverrides 711 | ): Promise; 712 | 713 | intervalSeconds(overrides?: CallOverrides): Promise; 714 | 715 | ledger( 716 | arg0: BigNumberish, 717 | arg1: string, 718 | overrides?: CallOverrides 719 | ): Promise< 720 | [number, BigNumber, boolean] & { 721 | position: number; 722 | amount: BigNumber; 723 | claimed: boolean; 724 | } 725 | >; 726 | 727 | minBetAmount(overrides?: CallOverrides): Promise; 728 | 729 | operatorAddress(overrides?: CallOverrides): Promise; 730 | 731 | oracle(overrides?: CallOverrides): Promise; 732 | 733 | oracleLatestRoundId(overrides?: CallOverrides): Promise; 734 | 735 | oracleUpdateAllowance(overrides?: CallOverrides): Promise; 736 | 737 | owner(overrides?: CallOverrides): Promise; 738 | 739 | pause( 740 | overrides?: Overrides & { from?: string | Promise } 741 | ): Promise; 742 | 743 | paused(overrides?: CallOverrides): Promise; 744 | 745 | recoverToken( 746 | _token: string, 747 | _amount: BigNumberish, 748 | overrides?: Overrides & { from?: string | Promise } 749 | ): Promise; 750 | 751 | refundable( 752 | epoch: BigNumberish, 753 | user: string, 754 | overrides?: CallOverrides 755 | ): Promise; 756 | 757 | renounceOwnership( 758 | overrides?: Overrides & { from?: string | Promise } 759 | ): Promise; 760 | 761 | rounds( 762 | arg0: BigNumberish, 763 | overrides?: CallOverrides 764 | ): Promise< 765 | [ 766 | BigNumber, 767 | BigNumber, 768 | BigNumber, 769 | BigNumber, 770 | BigNumber, 771 | BigNumber, 772 | BigNumber, 773 | BigNumber, 774 | BigNumber, 775 | BigNumber, 776 | BigNumber, 777 | BigNumber, 778 | BigNumber, 779 | boolean 780 | ] & { 781 | epoch: BigNumber; 782 | startTimestamp: BigNumber; 783 | lockTimestamp: BigNumber; 784 | closeTimestamp: BigNumber; 785 | lockPrice: BigNumber; 786 | closePrice: BigNumber; 787 | lockOracleId: BigNumber; 788 | closeOracleId: BigNumber; 789 | totalAmount: BigNumber; 790 | bullAmount: BigNumber; 791 | bearAmount: BigNumber; 792 | rewardBaseCalAmount: BigNumber; 793 | rewardAmount: BigNumber; 794 | oracleCalled: boolean; 795 | } 796 | >; 797 | 798 | setAdmin( 799 | _adminAddress: string, 800 | overrides?: Overrides & { from?: string | Promise } 801 | ): Promise; 802 | 803 | setBufferAndIntervalSeconds( 804 | _bufferSeconds: BigNumberish, 805 | _intervalSeconds: BigNumberish, 806 | overrides?: Overrides & { from?: string | Promise } 807 | ): Promise; 808 | 809 | setMinBetAmount( 810 | _minBetAmount: BigNumberish, 811 | overrides?: Overrides & { from?: string | Promise } 812 | ): Promise; 813 | 814 | setOperator( 815 | _operatorAddress: string, 816 | overrides?: Overrides & { from?: string | Promise } 817 | ): Promise; 818 | 819 | setOracle( 820 | _oracle: string, 821 | overrides?: Overrides & { from?: string | Promise } 822 | ): Promise; 823 | 824 | setOracleUpdateAllowance( 825 | _oracleUpdateAllowance: BigNumberish, 826 | overrides?: Overrides & { from?: string | Promise } 827 | ): Promise; 828 | 829 | setTreasuryFee( 830 | _treasuryFee: BigNumberish, 831 | overrides?: Overrides & { from?: string | Promise } 832 | ): Promise; 833 | 834 | transferOwnership( 835 | newOwner: string, 836 | overrides?: Overrides & { from?: string | Promise } 837 | ): Promise; 838 | 839 | treasuryAmount(overrides?: CallOverrides): Promise; 840 | 841 | treasuryFee(overrides?: CallOverrides): Promise; 842 | 843 | unpause( 844 | overrides?: Overrides & { from?: string | Promise } 845 | ): Promise; 846 | 847 | userRounds( 848 | arg0: string, 849 | arg1: BigNumberish, 850 | overrides?: CallOverrides 851 | ): Promise; 852 | 853 | callStatic: { 854 | MAX_TREASURY_FEE(overrides?: CallOverrides): Promise; 855 | 856 | adminAddress(overrides?: CallOverrides): Promise; 857 | 858 | betBear(epoch: BigNumberish, overrides?: CallOverrides): Promise; 859 | 860 | betBull(epoch: BigNumberish, overrides?: CallOverrides): Promise; 861 | 862 | bufferSeconds(overrides?: CallOverrides): Promise; 863 | 864 | claim(epochs: BigNumberish[], overrides?: CallOverrides): Promise; 865 | 866 | claimTreasury(overrides?: CallOverrides): Promise; 867 | 868 | claimable( 869 | epoch: BigNumberish, 870 | user: string, 871 | overrides?: CallOverrides 872 | ): Promise; 873 | 874 | currentEpoch(overrides?: CallOverrides): Promise; 875 | 876 | executeRound(overrides?: CallOverrides): Promise; 877 | 878 | genesisLockOnce(overrides?: CallOverrides): Promise; 879 | 880 | genesisLockRound(overrides?: CallOverrides): Promise; 881 | 882 | genesisStartOnce(overrides?: CallOverrides): Promise; 883 | 884 | genesisStartRound(overrides?: CallOverrides): Promise; 885 | 886 | getUserRounds( 887 | user: string, 888 | cursor: BigNumberish, 889 | size: BigNumberish, 890 | overrides?: CallOverrides 891 | ): Promise< 892 | [ 893 | BigNumber[], 894 | ([number, BigNumber, boolean] & { 895 | position: number; 896 | amount: BigNumber; 897 | claimed: boolean; 898 | })[], 899 | BigNumber 900 | ] 901 | >; 902 | 903 | getUserRoundsLength( 904 | user: string, 905 | overrides?: CallOverrides 906 | ): Promise; 907 | 908 | intervalSeconds(overrides?: CallOverrides): Promise; 909 | 910 | ledger( 911 | arg0: BigNumberish, 912 | arg1: string, 913 | overrides?: CallOverrides 914 | ): Promise< 915 | [number, BigNumber, boolean] & { 916 | position: number; 917 | amount: BigNumber; 918 | claimed: boolean; 919 | } 920 | >; 921 | 922 | minBetAmount(overrides?: CallOverrides): Promise; 923 | 924 | operatorAddress(overrides?: CallOverrides): Promise; 925 | 926 | oracle(overrides?: CallOverrides): Promise; 927 | 928 | oracleLatestRoundId(overrides?: CallOverrides): Promise; 929 | 930 | oracleUpdateAllowance(overrides?: CallOverrides): Promise; 931 | 932 | owner(overrides?: CallOverrides): Promise; 933 | 934 | pause(overrides?: CallOverrides): Promise; 935 | 936 | paused(overrides?: CallOverrides): Promise; 937 | 938 | recoverToken( 939 | _token: string, 940 | _amount: BigNumberish, 941 | overrides?: CallOverrides 942 | ): Promise; 943 | 944 | refundable( 945 | epoch: BigNumberish, 946 | user: string, 947 | overrides?: CallOverrides 948 | ): Promise; 949 | 950 | renounceOwnership(overrides?: CallOverrides): Promise; 951 | 952 | rounds( 953 | arg0: BigNumberish, 954 | overrides?: CallOverrides 955 | ): Promise< 956 | [ 957 | BigNumber, 958 | BigNumber, 959 | BigNumber, 960 | BigNumber, 961 | BigNumber, 962 | BigNumber, 963 | BigNumber, 964 | BigNumber, 965 | BigNumber, 966 | BigNumber, 967 | BigNumber, 968 | BigNumber, 969 | BigNumber, 970 | boolean 971 | ] & { 972 | epoch: BigNumber; 973 | startTimestamp: BigNumber; 974 | lockTimestamp: BigNumber; 975 | closeTimestamp: BigNumber; 976 | lockPrice: BigNumber; 977 | closePrice: BigNumber; 978 | lockOracleId: BigNumber; 979 | closeOracleId: BigNumber; 980 | totalAmount: BigNumber; 981 | bullAmount: BigNumber; 982 | bearAmount: BigNumber; 983 | rewardBaseCalAmount: BigNumber; 984 | rewardAmount: BigNumber; 985 | oracleCalled: boolean; 986 | } 987 | >; 988 | 989 | setAdmin(_adminAddress: string, overrides?: CallOverrides): Promise; 990 | 991 | setBufferAndIntervalSeconds( 992 | _bufferSeconds: BigNumberish, 993 | _intervalSeconds: BigNumberish, 994 | overrides?: CallOverrides 995 | ): Promise; 996 | 997 | setMinBetAmount( 998 | _minBetAmount: BigNumberish, 999 | overrides?: CallOverrides 1000 | ): Promise; 1001 | 1002 | setOperator( 1003 | _operatorAddress: string, 1004 | overrides?: CallOverrides 1005 | ): Promise; 1006 | 1007 | setOracle(_oracle: string, overrides?: CallOverrides): Promise; 1008 | 1009 | setOracleUpdateAllowance( 1010 | _oracleUpdateAllowance: BigNumberish, 1011 | overrides?: CallOverrides 1012 | ): Promise; 1013 | 1014 | setTreasuryFee( 1015 | _treasuryFee: BigNumberish, 1016 | overrides?: CallOverrides 1017 | ): Promise; 1018 | 1019 | transferOwnership( 1020 | newOwner: string, 1021 | overrides?: CallOverrides 1022 | ): Promise; 1023 | 1024 | treasuryAmount(overrides?: CallOverrides): Promise; 1025 | 1026 | treasuryFee(overrides?: CallOverrides): Promise; 1027 | 1028 | unpause(overrides?: CallOverrides): Promise; 1029 | 1030 | userRounds( 1031 | arg0: string, 1032 | arg1: BigNumberish, 1033 | overrides?: CallOverrides 1034 | ): Promise; 1035 | }; 1036 | 1037 | filters: { 1038 | BetBear( 1039 | sender?: string | null, 1040 | epoch?: BigNumberish | null, 1041 | amount?: null 1042 | ): TypedEventFilter< 1043 | [string, BigNumber, BigNumber], 1044 | { sender: string; epoch: BigNumber; amount: BigNumber } 1045 | >; 1046 | 1047 | BetBull( 1048 | sender?: string | null, 1049 | epoch?: BigNumberish | null, 1050 | amount?: null 1051 | ): TypedEventFilter< 1052 | [string, BigNumber, BigNumber], 1053 | { sender: string; epoch: BigNumber; amount: BigNumber } 1054 | >; 1055 | 1056 | Claim( 1057 | sender?: string | null, 1058 | epoch?: BigNumberish | null, 1059 | amount?: null 1060 | ): TypedEventFilter< 1061 | [string, BigNumber, BigNumber], 1062 | { sender: string; epoch: BigNumber; amount: BigNumber } 1063 | >; 1064 | 1065 | EndRound( 1066 | epoch?: BigNumberish | null, 1067 | roundId?: BigNumberish | null, 1068 | price?: null 1069 | ): TypedEventFilter< 1070 | [BigNumber, BigNumber, BigNumber], 1071 | { epoch: BigNumber; roundId: BigNumber; price: BigNumber } 1072 | >; 1073 | 1074 | LockRound( 1075 | epoch?: BigNumberish | null, 1076 | roundId?: BigNumberish | null, 1077 | price?: null 1078 | ): TypedEventFilter< 1079 | [BigNumber, BigNumber, BigNumber], 1080 | { epoch: BigNumber; roundId: BigNumber; price: BigNumber } 1081 | >; 1082 | 1083 | NewAdminAddress( 1084 | admin?: null 1085 | ): TypedEventFilter<[string], { admin: string }>; 1086 | 1087 | NewBufferAndIntervalSeconds( 1088 | bufferSeconds?: null, 1089 | intervalSeconds?: null 1090 | ): TypedEventFilter< 1091 | [BigNumber, BigNumber], 1092 | { bufferSeconds: BigNumber; intervalSeconds: BigNumber } 1093 | >; 1094 | 1095 | NewMinBetAmount( 1096 | epoch?: BigNumberish | null, 1097 | minBetAmount?: null 1098 | ): TypedEventFilter< 1099 | [BigNumber, BigNumber], 1100 | { epoch: BigNumber; minBetAmount: BigNumber } 1101 | >; 1102 | 1103 | NewOperatorAddress( 1104 | operator?: null 1105 | ): TypedEventFilter<[string], { operator: string }>; 1106 | 1107 | NewOracle(oracle?: null): TypedEventFilter<[string], { oracle: string }>; 1108 | 1109 | NewOracleUpdateAllowance( 1110 | oracleUpdateAllowance?: null 1111 | ): TypedEventFilter<[BigNumber], { oracleUpdateAllowance: BigNumber }>; 1112 | 1113 | NewTreasuryFee( 1114 | epoch?: BigNumberish | null, 1115 | treasuryFee?: null 1116 | ): TypedEventFilter< 1117 | [BigNumber, BigNumber], 1118 | { epoch: BigNumber; treasuryFee: BigNumber } 1119 | >; 1120 | 1121 | OwnershipTransferred( 1122 | previousOwner?: string | null, 1123 | newOwner?: string | null 1124 | ): TypedEventFilter< 1125 | [string, string], 1126 | { previousOwner: string; newOwner: string } 1127 | >; 1128 | 1129 | Pause( 1130 | epoch?: BigNumberish | null 1131 | ): TypedEventFilter<[BigNumber], { epoch: BigNumber }>; 1132 | 1133 | Paused(account?: null): TypedEventFilter<[string], { account: string }>; 1134 | 1135 | RewardsCalculated( 1136 | epoch?: BigNumberish | null, 1137 | rewardBaseCalAmount?: null, 1138 | rewardAmount?: null, 1139 | treasuryAmount?: null 1140 | ): TypedEventFilter< 1141 | [BigNumber, BigNumber, BigNumber, BigNumber], 1142 | { 1143 | epoch: BigNumber; 1144 | rewardBaseCalAmount: BigNumber; 1145 | rewardAmount: BigNumber; 1146 | treasuryAmount: BigNumber; 1147 | } 1148 | >; 1149 | 1150 | StartRound( 1151 | epoch?: BigNumberish | null 1152 | ): TypedEventFilter<[BigNumber], { epoch: BigNumber }>; 1153 | 1154 | TokenRecovery( 1155 | token?: string | null, 1156 | amount?: null 1157 | ): TypedEventFilter< 1158 | [string, BigNumber], 1159 | { token: string; amount: BigNumber } 1160 | >; 1161 | 1162 | TreasuryClaim( 1163 | amount?: null 1164 | ): TypedEventFilter<[BigNumber], { amount: BigNumber }>; 1165 | 1166 | Unpause( 1167 | epoch?: BigNumberish | null 1168 | ): TypedEventFilter<[BigNumber], { epoch: BigNumber }>; 1169 | 1170 | Unpaused(account?: null): TypedEventFilter<[string], { account: string }>; 1171 | }; 1172 | 1173 | estimateGas: { 1174 | MAX_TREASURY_FEE(overrides?: CallOverrides): Promise; 1175 | 1176 | adminAddress(overrides?: CallOverrides): Promise; 1177 | 1178 | betBear( 1179 | epoch: BigNumberish, 1180 | overrides?: PayableOverrides & { from?: string | Promise } 1181 | ): Promise; 1182 | 1183 | betBull( 1184 | epoch: BigNumberish, 1185 | overrides?: PayableOverrides & { from?: string | Promise } 1186 | ): Promise; 1187 | 1188 | bufferSeconds(overrides?: CallOverrides): Promise; 1189 | 1190 | claim( 1191 | epochs: BigNumberish[], 1192 | overrides?: Overrides & { from?: string | Promise } 1193 | ): Promise; 1194 | 1195 | claimTreasury( 1196 | overrides?: Overrides & { from?: string | Promise } 1197 | ): Promise; 1198 | 1199 | claimable( 1200 | epoch: BigNumberish, 1201 | user: string, 1202 | overrides?: CallOverrides 1203 | ): Promise; 1204 | 1205 | currentEpoch(overrides?: CallOverrides): Promise; 1206 | 1207 | executeRound( 1208 | overrides?: Overrides & { from?: string | Promise } 1209 | ): Promise; 1210 | 1211 | genesisLockOnce(overrides?: CallOverrides): Promise; 1212 | 1213 | genesisLockRound( 1214 | overrides?: Overrides & { from?: string | Promise } 1215 | ): Promise; 1216 | 1217 | genesisStartOnce(overrides?: CallOverrides): Promise; 1218 | 1219 | genesisStartRound( 1220 | overrides?: Overrides & { from?: string | Promise } 1221 | ): Promise; 1222 | 1223 | getUserRounds( 1224 | user: string, 1225 | cursor: BigNumberish, 1226 | size: BigNumberish, 1227 | overrides?: CallOverrides 1228 | ): Promise; 1229 | 1230 | getUserRoundsLength( 1231 | user: string, 1232 | overrides?: CallOverrides 1233 | ): Promise; 1234 | 1235 | intervalSeconds(overrides?: CallOverrides): Promise; 1236 | 1237 | ledger( 1238 | arg0: BigNumberish, 1239 | arg1: string, 1240 | overrides?: CallOverrides 1241 | ): Promise; 1242 | 1243 | minBetAmount(overrides?: CallOverrides): Promise; 1244 | 1245 | operatorAddress(overrides?: CallOverrides): Promise; 1246 | 1247 | oracle(overrides?: CallOverrides): Promise; 1248 | 1249 | oracleLatestRoundId(overrides?: CallOverrides): Promise; 1250 | 1251 | oracleUpdateAllowance(overrides?: CallOverrides): Promise; 1252 | 1253 | owner(overrides?: CallOverrides): Promise; 1254 | 1255 | pause( 1256 | overrides?: Overrides & { from?: string | Promise } 1257 | ): Promise; 1258 | 1259 | paused(overrides?: CallOverrides): Promise; 1260 | 1261 | recoverToken( 1262 | _token: string, 1263 | _amount: BigNumberish, 1264 | overrides?: Overrides & { from?: string | Promise } 1265 | ): Promise; 1266 | 1267 | refundable( 1268 | epoch: BigNumberish, 1269 | user: string, 1270 | overrides?: CallOverrides 1271 | ): Promise; 1272 | 1273 | renounceOwnership( 1274 | overrides?: Overrides & { from?: string | Promise } 1275 | ): Promise; 1276 | 1277 | rounds(arg0: BigNumberish, overrides?: CallOverrides): Promise; 1278 | 1279 | setAdmin( 1280 | _adminAddress: string, 1281 | overrides?: Overrides & { from?: string | Promise } 1282 | ): Promise; 1283 | 1284 | setBufferAndIntervalSeconds( 1285 | _bufferSeconds: BigNumberish, 1286 | _intervalSeconds: BigNumberish, 1287 | overrides?: Overrides & { from?: string | Promise } 1288 | ): Promise; 1289 | 1290 | setMinBetAmount( 1291 | _minBetAmount: BigNumberish, 1292 | overrides?: Overrides & { from?: string | Promise } 1293 | ): Promise; 1294 | 1295 | setOperator( 1296 | _operatorAddress: string, 1297 | overrides?: Overrides & { from?: string | Promise } 1298 | ): Promise; 1299 | 1300 | setOracle( 1301 | _oracle: string, 1302 | overrides?: Overrides & { from?: string | Promise } 1303 | ): Promise; 1304 | 1305 | setOracleUpdateAllowance( 1306 | _oracleUpdateAllowance: BigNumberish, 1307 | overrides?: Overrides & { from?: string | Promise } 1308 | ): Promise; 1309 | 1310 | setTreasuryFee( 1311 | _treasuryFee: BigNumberish, 1312 | overrides?: Overrides & { from?: string | Promise } 1313 | ): Promise; 1314 | 1315 | transferOwnership( 1316 | newOwner: string, 1317 | overrides?: Overrides & { from?: string | Promise } 1318 | ): Promise; 1319 | 1320 | treasuryAmount(overrides?: CallOverrides): Promise; 1321 | 1322 | treasuryFee(overrides?: CallOverrides): Promise; 1323 | 1324 | unpause( 1325 | overrides?: Overrides & { from?: string | Promise } 1326 | ): Promise; 1327 | 1328 | userRounds( 1329 | arg0: string, 1330 | arg1: BigNumberish, 1331 | overrides?: CallOverrides 1332 | ): Promise; 1333 | }; 1334 | 1335 | populateTransaction: { 1336 | MAX_TREASURY_FEE(overrides?: CallOverrides): Promise; 1337 | 1338 | adminAddress(overrides?: CallOverrides): Promise; 1339 | 1340 | betBear( 1341 | epoch: BigNumberish, 1342 | overrides?: PayableOverrides & { from?: string | Promise } 1343 | ): Promise; 1344 | 1345 | betBull( 1346 | epoch: BigNumberish, 1347 | overrides?: PayableOverrides & { from?: string | Promise } 1348 | ): Promise; 1349 | 1350 | bufferSeconds(overrides?: CallOverrides): Promise; 1351 | 1352 | claim( 1353 | epochs: BigNumberish[], 1354 | overrides?: Overrides & { from?: string | Promise } 1355 | ): Promise; 1356 | 1357 | claimTreasury( 1358 | overrides?: Overrides & { from?: string | Promise } 1359 | ): Promise; 1360 | 1361 | claimable( 1362 | epoch: BigNumberish, 1363 | user: string, 1364 | overrides?: CallOverrides 1365 | ): Promise; 1366 | 1367 | currentEpoch(overrides?: CallOverrides): Promise; 1368 | 1369 | executeRound( 1370 | overrides?: Overrides & { from?: string | Promise } 1371 | ): Promise; 1372 | 1373 | genesisLockOnce(overrides?: CallOverrides): Promise; 1374 | 1375 | genesisLockRound( 1376 | overrides?: Overrides & { from?: string | Promise } 1377 | ): Promise; 1378 | 1379 | genesisStartOnce(overrides?: CallOverrides): Promise; 1380 | 1381 | genesisStartRound( 1382 | overrides?: Overrides & { from?: string | Promise } 1383 | ): Promise; 1384 | 1385 | getUserRounds( 1386 | user: string, 1387 | cursor: BigNumberish, 1388 | size: BigNumberish, 1389 | overrides?: CallOverrides 1390 | ): Promise; 1391 | 1392 | getUserRoundsLength( 1393 | user: string, 1394 | overrides?: CallOverrides 1395 | ): Promise; 1396 | 1397 | intervalSeconds(overrides?: CallOverrides): Promise; 1398 | 1399 | ledger( 1400 | arg0: BigNumberish, 1401 | arg1: string, 1402 | overrides?: CallOverrides 1403 | ): Promise; 1404 | 1405 | minBetAmount(overrides?: CallOverrides): Promise; 1406 | 1407 | operatorAddress(overrides?: CallOverrides): Promise; 1408 | 1409 | oracle(overrides?: CallOverrides): Promise; 1410 | 1411 | oracleLatestRoundId( 1412 | overrides?: CallOverrides 1413 | ): Promise; 1414 | 1415 | oracleUpdateAllowance( 1416 | overrides?: CallOverrides 1417 | ): Promise; 1418 | 1419 | owner(overrides?: CallOverrides): Promise; 1420 | 1421 | pause( 1422 | overrides?: Overrides & { from?: string | Promise } 1423 | ): Promise; 1424 | 1425 | paused(overrides?: CallOverrides): Promise; 1426 | 1427 | recoverToken( 1428 | _token: string, 1429 | _amount: BigNumberish, 1430 | overrides?: Overrides & { from?: string | Promise } 1431 | ): Promise; 1432 | 1433 | refundable( 1434 | epoch: BigNumberish, 1435 | user: string, 1436 | overrides?: CallOverrides 1437 | ): Promise; 1438 | 1439 | renounceOwnership( 1440 | overrides?: Overrides & { from?: string | Promise } 1441 | ): Promise; 1442 | 1443 | rounds( 1444 | arg0: BigNumberish, 1445 | overrides?: CallOverrides 1446 | ): Promise; 1447 | 1448 | setAdmin( 1449 | _adminAddress: string, 1450 | overrides?: Overrides & { from?: string | Promise } 1451 | ): Promise; 1452 | 1453 | setBufferAndIntervalSeconds( 1454 | _bufferSeconds: BigNumberish, 1455 | _intervalSeconds: BigNumberish, 1456 | overrides?: Overrides & { from?: string | Promise } 1457 | ): Promise; 1458 | 1459 | setMinBetAmount( 1460 | _minBetAmount: BigNumberish, 1461 | overrides?: Overrides & { from?: string | Promise } 1462 | ): Promise; 1463 | 1464 | setOperator( 1465 | _operatorAddress: string, 1466 | overrides?: Overrides & { from?: string | Promise } 1467 | ): Promise; 1468 | 1469 | setOracle( 1470 | _oracle: string, 1471 | overrides?: Overrides & { from?: string | Promise } 1472 | ): Promise; 1473 | 1474 | setOracleUpdateAllowance( 1475 | _oracleUpdateAllowance: BigNumberish, 1476 | overrides?: Overrides & { from?: string | Promise } 1477 | ): Promise; 1478 | 1479 | setTreasuryFee( 1480 | _treasuryFee: BigNumberish, 1481 | overrides?: Overrides & { from?: string | Promise } 1482 | ): Promise; 1483 | 1484 | transferOwnership( 1485 | newOwner: string, 1486 | overrides?: Overrides & { from?: string | Promise } 1487 | ): Promise; 1488 | 1489 | treasuryAmount(overrides?: CallOverrides): Promise; 1490 | 1491 | treasuryFee(overrides?: CallOverrides): Promise; 1492 | 1493 | unpause( 1494 | overrides?: Overrides & { from?: string | Promise } 1495 | ): Promise; 1496 | 1497 | userRounds( 1498 | arg0: string, 1499 | arg1: BigNumberish, 1500 | overrides?: CallOverrides 1501 | ): Promise; 1502 | }; 1503 | } 1504 | -------------------------------------------------------------------------------- /src/types/typechain/commons.ts: -------------------------------------------------------------------------------- 1 | /* Autogenerated file. Do not edit manually. */ 2 | /* tslint:disable */ 3 | /* eslint-disable */ 4 | 5 | import { Result } from "@ethersproject/abi"; 6 | import { Event, EventFilter } from "ethers"; 7 | 8 | export interface TypedEventFilter<_EventArgsArray, _EventArgsObject> 9 | extends EventFilter {} 10 | 11 | export interface TypedEvent extends Event { 12 | args: EventArgs; 13 | } 14 | 15 | export type TypedListener< 16 | EventArgsArray extends Array, 17 | EventArgsObject 18 | > = ( 19 | ...listenerArg: [ 20 | ...EventArgsArray, 21 | TypedEvent 22 | ] 23 | ) => void; 24 | 25 | export type MinEthersFactory = { 26 | deploy(...a: ARGS[]): Promise; 27 | }; 28 | export type GetContractTypeFromFactory = F extends MinEthersFactory< 29 | infer C, 30 | any 31 | > 32 | ? C 33 | : never; 34 | export type GetARGsTypeFromFactory = F extends MinEthersFactory 35 | ? Parameters 36 | : never; 37 | -------------------------------------------------------------------------------- /src/types/typechain/factories/CandleGeniePredictionV3__factory.ts: -------------------------------------------------------------------------------- 1 | /* Autogenerated file. Do not edit manually. */ 2 | /* tslint:disable */ 3 | /* eslint-disable */ 4 | 5 | import { Provider } from "@ethersproject/providers"; 6 | import { Contract, Signer, utils } from "ethers"; 7 | import type { 8 | CandleGeniePredictionV3, 9 | CandleGeniePredictionV3Interface, 10 | } from "../CandleGeniePredictionV3"; 11 | 12 | const _abi = [ 13 | { 14 | inputs: [ 15 | { 16 | internalType: "address", 17 | name: "_operatorAddress", 18 | type: "address", 19 | }, 20 | ], 21 | stateMutability: "nonpayable", 22 | type: "constructor", 23 | }, 24 | { 25 | anonymous: false, 26 | inputs: [ 27 | { 28 | indexed: true, 29 | internalType: "address", 30 | name: "sender", 31 | type: "address", 32 | }, 33 | { 34 | indexed: true, 35 | internalType: "uint256", 36 | name: "epoch", 37 | type: "uint256", 38 | }, 39 | { 40 | indexed: false, 41 | internalType: "uint256", 42 | name: "amount", 43 | type: "uint256", 44 | }, 45 | ], 46 | name: "BetBear", 47 | type: "event", 48 | }, 49 | { 50 | anonymous: false, 51 | inputs: [ 52 | { 53 | indexed: true, 54 | internalType: "address", 55 | name: "sender", 56 | type: "address", 57 | }, 58 | { 59 | indexed: true, 60 | internalType: "uint256", 61 | name: "epoch", 62 | type: "uint256", 63 | }, 64 | { 65 | indexed: false, 66 | internalType: "uint256", 67 | name: "amount", 68 | type: "uint256", 69 | }, 70 | ], 71 | name: "BetBull", 72 | type: "event", 73 | }, 74 | { 75 | anonymous: false, 76 | inputs: [ 77 | { 78 | indexed: false, 79 | internalType: "uint256", 80 | name: "bufferSeconds", 81 | type: "uint256", 82 | }, 83 | { 84 | indexed: false, 85 | internalType: "uint256", 86 | name: "intervalSeconds", 87 | type: "uint256", 88 | }, 89 | ], 90 | name: "BufferAndIntervalSecondsUpdated", 91 | type: "event", 92 | }, 93 | { 94 | anonymous: false, 95 | inputs: [ 96 | { 97 | indexed: true, 98 | internalType: "uint256", 99 | name: "epoch", 100 | type: "uint256", 101 | }, 102 | ], 103 | name: "CancelRound", 104 | type: "event", 105 | }, 106 | { 107 | anonymous: false, 108 | inputs: [ 109 | { 110 | indexed: true, 111 | internalType: "address", 112 | name: "sender", 113 | type: "address", 114 | }, 115 | { 116 | indexed: true, 117 | internalType: "uint256", 118 | name: "epoch", 119 | type: "uint256", 120 | }, 121 | { 122 | indexed: false, 123 | internalType: "uint256", 124 | name: "amount", 125 | type: "uint256", 126 | }, 127 | ], 128 | name: "Claim", 129 | type: "event", 130 | }, 131 | { 132 | anonymous: false, 133 | inputs: [ 134 | { 135 | indexed: true, 136 | internalType: "uint256", 137 | name: "epoch", 138 | type: "uint256", 139 | }, 140 | { 141 | indexed: false, 142 | internalType: "int256", 143 | name: "price", 144 | type: "int256", 145 | }, 146 | { 147 | indexed: false, 148 | internalType: "uint32", 149 | name: "timestamp", 150 | type: "uint32", 151 | }, 152 | ], 153 | name: "EndRound", 154 | type: "event", 155 | }, 156 | { 157 | anonymous: false, 158 | inputs: [ 159 | { 160 | indexed: true, 161 | internalType: "address", 162 | name: "sender", 163 | type: "address", 164 | }, 165 | { 166 | indexed: true, 167 | internalType: "uint256", 168 | name: "epoch", 169 | type: "uint256", 170 | }, 171 | { 172 | indexed: false, 173 | internalType: "uint256", 174 | name: "bullAmount", 175 | type: "uint256", 176 | }, 177 | { 178 | indexed: false, 179 | internalType: "uint256", 180 | name: "bearAmount", 181 | type: "uint256", 182 | }, 183 | ], 184 | name: "HouseBet", 185 | type: "event", 186 | }, 187 | { 188 | anonymous: false, 189 | inputs: [ 190 | { 191 | indexed: true, 192 | internalType: "address", 193 | name: "sender", 194 | type: "address", 195 | }, 196 | ], 197 | name: "InjectFunds", 198 | type: "event", 199 | }, 200 | { 201 | anonymous: false, 202 | inputs: [ 203 | { 204 | indexed: true, 205 | internalType: "uint256", 206 | name: "epoch", 207 | type: "uint256", 208 | }, 209 | { 210 | indexed: false, 211 | internalType: "int256", 212 | name: "price", 213 | type: "int256", 214 | }, 215 | { 216 | indexed: false, 217 | internalType: "uint32", 218 | name: "timestamp", 219 | type: "uint32", 220 | }, 221 | ], 222 | name: "LockRound", 223 | type: "event", 224 | }, 225 | { 226 | anonymous: false, 227 | inputs: [ 228 | { 229 | indexed: true, 230 | internalType: "uint256", 231 | name: "epoch", 232 | type: "uint256", 233 | }, 234 | { 235 | indexed: false, 236 | internalType: "uint256", 237 | name: "minBetAmount", 238 | type: "uint256", 239 | }, 240 | ], 241 | name: "MinBetAmountUpdated", 242 | type: "event", 243 | }, 244 | { 245 | anonymous: false, 246 | inputs: [ 247 | { 248 | indexed: false, 249 | internalType: "string", 250 | name: "priceSource", 251 | type: "string", 252 | }, 253 | ], 254 | name: "NewPriceSource", 255 | type: "event", 256 | }, 257 | { 258 | anonymous: false, 259 | inputs: [ 260 | { 261 | indexed: true, 262 | internalType: "address", 263 | name: "previousOwner", 264 | type: "address", 265 | }, 266 | { 267 | indexed: true, 268 | internalType: "address", 269 | name: "newOwner", 270 | type: "address", 271 | }, 272 | ], 273 | name: "OwnershipTransferred", 274 | type: "event", 275 | }, 276 | { 277 | anonymous: false, 278 | inputs: [ 279 | { 280 | indexed: true, 281 | internalType: "uint256", 282 | name: "epoch", 283 | type: "uint256", 284 | }, 285 | ], 286 | name: "Pause", 287 | type: "event", 288 | }, 289 | { 290 | anonymous: false, 291 | inputs: [ 292 | { 293 | indexed: false, 294 | internalType: "address", 295 | name: "account", 296 | type: "address", 297 | }, 298 | ], 299 | name: "Paused", 300 | type: "event", 301 | }, 302 | { 303 | anonymous: false, 304 | inputs: [ 305 | { 306 | indexed: true, 307 | internalType: "uint256", 308 | name: "epoch", 309 | type: "uint256", 310 | }, 311 | { 312 | indexed: false, 313 | internalType: "uint256", 314 | name: "rewardBaseCalAmount", 315 | type: "uint256", 316 | }, 317 | { 318 | indexed: false, 319 | internalType: "uint256", 320 | name: "rewardAmount", 321 | type: "uint256", 322 | }, 323 | ], 324 | name: "RewardsCalculated", 325 | type: "event", 326 | }, 327 | { 328 | anonymous: false, 329 | inputs: [ 330 | { 331 | indexed: true, 332 | internalType: "uint256", 333 | name: "epoch", 334 | type: "uint256", 335 | }, 336 | ], 337 | name: "StartRound", 338 | type: "event", 339 | }, 340 | { 341 | anonymous: false, 342 | inputs: [ 343 | { 344 | indexed: true, 345 | internalType: "uint256", 346 | name: "epoch", 347 | type: "uint256", 348 | }, 349 | ], 350 | name: "Unpause", 351 | type: "event", 352 | }, 353 | { 354 | anonymous: false, 355 | inputs: [ 356 | { 357 | indexed: false, 358 | internalType: "address", 359 | name: "account", 360 | type: "address", 361 | }, 362 | ], 363 | name: "Unpaused", 364 | type: "event", 365 | }, 366 | { 367 | inputs: [ 368 | { 369 | internalType: "uint256", 370 | name: "", 371 | type: "uint256", 372 | }, 373 | { 374 | internalType: "address", 375 | name: "", 376 | type: "address", 377 | }, 378 | ], 379 | name: "Bets", 380 | outputs: [ 381 | { 382 | internalType: "enum CandleGeniePredictionV3.Position", 383 | name: "position", 384 | type: "uint8", 385 | }, 386 | { 387 | internalType: "uint256", 388 | name: "amount", 389 | type: "uint256", 390 | }, 391 | { 392 | internalType: "bool", 393 | name: "claimed", 394 | type: "bool", 395 | }, 396 | ], 397 | stateMutability: "view", 398 | type: "function", 399 | }, 400 | { 401 | inputs: [], 402 | name: "OwnershipRenounce", 403 | outputs: [], 404 | stateMutability: "nonpayable", 405 | type: "function", 406 | }, 407 | { 408 | inputs: [ 409 | { 410 | internalType: "address", 411 | name: "newOwner", 412 | type: "address", 413 | }, 414 | ], 415 | name: "OwnershipTransfer", 416 | outputs: [], 417 | stateMutability: "nonpayable", 418 | type: "function", 419 | }, 420 | { 421 | inputs: [ 422 | { 423 | internalType: "uint256", 424 | name: "", 425 | type: "uint256", 426 | }, 427 | ], 428 | name: "Rounds", 429 | outputs: [ 430 | { 431 | internalType: "uint256", 432 | name: "epoch", 433 | type: "uint256", 434 | }, 435 | { 436 | internalType: "uint256", 437 | name: "bullAmount", 438 | type: "uint256", 439 | }, 440 | { 441 | internalType: "uint256", 442 | name: "bearAmount", 443 | type: "uint256", 444 | }, 445 | { 446 | internalType: "uint256", 447 | name: "rewardBaseCalAmount", 448 | type: "uint256", 449 | }, 450 | { 451 | internalType: "uint256", 452 | name: "rewardAmount", 453 | type: "uint256", 454 | }, 455 | { 456 | internalType: "int256", 457 | name: "lockPrice", 458 | type: "int256", 459 | }, 460 | { 461 | internalType: "int256", 462 | name: "closePrice", 463 | type: "int256", 464 | }, 465 | { 466 | internalType: "uint32", 467 | name: "startTimestamp", 468 | type: "uint32", 469 | }, 470 | { 471 | internalType: "uint32", 472 | name: "lockTimestamp", 473 | type: "uint32", 474 | }, 475 | { 476 | internalType: "uint32", 477 | name: "closeTimestamp", 478 | type: "uint32", 479 | }, 480 | { 481 | internalType: "uint32", 482 | name: "lockPriceTimestamp", 483 | type: "uint32", 484 | }, 485 | { 486 | internalType: "uint32", 487 | name: "closePriceTimestamp", 488 | type: "uint32", 489 | }, 490 | { 491 | internalType: "bool", 492 | name: "closed", 493 | type: "bool", 494 | }, 495 | { 496 | internalType: "bool", 497 | name: "cancelled", 498 | type: "bool", 499 | }, 500 | ], 501 | stateMutability: "view", 502 | type: "function", 503 | }, 504 | { 505 | inputs: [ 506 | { 507 | internalType: "address", 508 | name: "", 509 | type: "address", 510 | }, 511 | { 512 | internalType: "uint256", 513 | name: "", 514 | type: "uint256", 515 | }, 516 | ], 517 | name: "UserBets", 518 | outputs: [ 519 | { 520 | internalType: "uint256", 521 | name: "", 522 | type: "uint256", 523 | }, 524 | ], 525 | stateMutability: "view", 526 | type: "function", 527 | }, 528 | { 529 | inputs: [], 530 | name: "_owner", 531 | outputs: [ 532 | { 533 | internalType: "address", 534 | name: "", 535 | type: "address", 536 | }, 537 | ], 538 | stateMutability: "view", 539 | type: "function", 540 | }, 541 | { 542 | inputs: [], 543 | name: "bufferSeconds", 544 | outputs: [ 545 | { 546 | internalType: "uint256", 547 | name: "", 548 | type: "uint256", 549 | }, 550 | ], 551 | stateMutability: "view", 552 | type: "function", 553 | }, 554 | { 555 | inputs: [ 556 | { 557 | internalType: "uint256", 558 | name: "epoch", 559 | type: "uint256", 560 | }, 561 | { 562 | internalType: "address", 563 | name: "user", 564 | type: "address", 565 | }, 566 | ], 567 | name: "claimable", 568 | outputs: [ 569 | { 570 | internalType: "bool", 571 | name: "", 572 | type: "bool", 573 | }, 574 | ], 575 | stateMutability: "view", 576 | type: "function", 577 | }, 578 | { 579 | inputs: [], 580 | name: "control_Pause", 581 | outputs: [], 582 | stateMutability: "nonpayable", 583 | type: "function", 584 | }, 585 | { 586 | inputs: [], 587 | name: "control_Resume", 588 | outputs: [], 589 | stateMutability: "nonpayable", 590 | type: "function", 591 | }, 592 | { 593 | inputs: [ 594 | { 595 | internalType: "uint256", 596 | name: "epoch", 597 | type: "uint256", 598 | }, 599 | { 600 | internalType: "bool", 601 | name: "cancelled", 602 | type: "bool", 603 | }, 604 | { 605 | internalType: "bool", 606 | name: "closed", 607 | type: "bool", 608 | }, 609 | ], 610 | name: "control_RoundCancel", 611 | outputs: [], 612 | stateMutability: "nonpayable", 613 | type: "function", 614 | }, 615 | { 616 | inputs: [ 617 | { 618 | internalType: "int256", 619 | name: "price", 620 | type: "int256", 621 | }, 622 | { 623 | internalType: "uint32", 624 | name: "timestamp", 625 | type: "uint32", 626 | }, 627 | ], 628 | name: "control_RoundExecute", 629 | outputs: [], 630 | stateMutability: "nonpayable", 631 | type: "function", 632 | }, 633 | { 634 | inputs: [ 635 | { 636 | internalType: "int256", 637 | name: "price", 638 | type: "int256", 639 | }, 640 | { 641 | internalType: "uint32", 642 | name: "timestamp", 643 | type: "uint32", 644 | }, 645 | ], 646 | name: "control_RoundLock", 647 | outputs: [], 648 | stateMutability: "nonpayable", 649 | type: "function", 650 | }, 651 | { 652 | inputs: [], 653 | name: "control_RoundStart", 654 | outputs: [], 655 | stateMutability: "nonpayable", 656 | type: "function", 657 | }, 658 | { 659 | inputs: [], 660 | name: "currentBlockNumber", 661 | outputs: [ 662 | { 663 | internalType: "uint256", 664 | name: "", 665 | type: "uint256", 666 | }, 667 | ], 668 | stateMutability: "view", 669 | type: "function", 670 | }, 671 | { 672 | inputs: [], 673 | name: "currentBlockTimestamp", 674 | outputs: [ 675 | { 676 | internalType: "uint256", 677 | name: "", 678 | type: "uint256", 679 | }, 680 | ], 681 | stateMutability: "view", 682 | type: "function", 683 | }, 684 | { 685 | inputs: [], 686 | name: "currentEpoch", 687 | outputs: [ 688 | { 689 | internalType: "uint256", 690 | name: "", 691 | type: "uint256", 692 | }, 693 | ], 694 | stateMutability: "view", 695 | type: "function", 696 | }, 697 | { 698 | inputs: [ 699 | { 700 | internalType: "address", 701 | name: "user", 702 | type: "address", 703 | }, 704 | { 705 | internalType: "uint256", 706 | name: "cursor", 707 | type: "uint256", 708 | }, 709 | { 710 | internalType: "uint256", 711 | name: "size", 712 | type: "uint256", 713 | }, 714 | ], 715 | name: "getUserRounds", 716 | outputs: [ 717 | { 718 | internalType: "uint256[]", 719 | name: "", 720 | type: "uint256[]", 721 | }, 722 | { 723 | components: [ 724 | { 725 | internalType: "enum CandleGeniePredictionV3.Position", 726 | name: "position", 727 | type: "uint8", 728 | }, 729 | { 730 | internalType: "uint256", 731 | name: "amount", 732 | type: "uint256", 733 | }, 734 | { 735 | internalType: "bool", 736 | name: "claimed", 737 | type: "bool", 738 | }, 739 | ], 740 | internalType: "struct CandleGeniePredictionV3.BetInfo[]", 741 | name: "", 742 | type: "tuple[]", 743 | }, 744 | { 745 | internalType: "uint256", 746 | name: "", 747 | type: "uint256", 748 | }, 749 | ], 750 | stateMutability: "view", 751 | type: "function", 752 | }, 753 | { 754 | inputs: [ 755 | { 756 | internalType: "address", 757 | name: "user", 758 | type: "address", 759 | }, 760 | ], 761 | name: "getUserRoundsLength", 762 | outputs: [ 763 | { 764 | internalType: "uint256", 765 | name: "", 766 | type: "uint256", 767 | }, 768 | ], 769 | stateMutability: "view", 770 | type: "function", 771 | }, 772 | { 773 | inputs: [], 774 | name: "intervalSeconds", 775 | outputs: [ 776 | { 777 | internalType: "uint256", 778 | name: "", 779 | type: "uint256", 780 | }, 781 | ], 782 | stateMutability: "view", 783 | type: "function", 784 | }, 785 | { 786 | inputs: [], 787 | name: "lockOnce", 788 | outputs: [ 789 | { 790 | internalType: "bool", 791 | name: "", 792 | type: "bool", 793 | }, 794 | ], 795 | stateMutability: "view", 796 | type: "function", 797 | }, 798 | { 799 | inputs: [], 800 | name: "minBetAmount", 801 | outputs: [ 802 | { 803 | internalType: "uint256", 804 | name: "", 805 | type: "uint256", 806 | }, 807 | ], 808 | stateMutability: "view", 809 | type: "function", 810 | }, 811 | { 812 | inputs: [], 813 | name: "operatorAddress", 814 | outputs: [ 815 | { 816 | internalType: "address", 817 | name: "", 818 | type: "address", 819 | }, 820 | ], 821 | stateMutability: "view", 822 | type: "function", 823 | }, 824 | { 825 | inputs: [], 826 | name: "owner", 827 | outputs: [ 828 | { 829 | internalType: "address", 830 | name: "", 831 | type: "address", 832 | }, 833 | ], 834 | stateMutability: "view", 835 | type: "function", 836 | }, 837 | { 838 | inputs: [ 839 | { 840 | internalType: "address", 841 | name: "_user", 842 | type: "address", 843 | }, 844 | ], 845 | name: "owner_BlackListInsert", 846 | outputs: [], 847 | stateMutability: "nonpayable", 848 | type: "function", 849 | }, 850 | { 851 | inputs: [ 852 | { 853 | internalType: "address", 854 | name: "_user", 855 | type: "address", 856 | }, 857 | ], 858 | name: "owner_BlackListRemove", 859 | outputs: [], 860 | stateMutability: "nonpayable", 861 | type: "function", 862 | }, 863 | { 864 | inputs: [ 865 | { 866 | internalType: "string", 867 | name: "_priceSource", 868 | type: "string", 869 | }, 870 | ], 871 | name: "owner_ChangePriceSource", 872 | outputs: [], 873 | stateMutability: "nonpayable", 874 | type: "function", 875 | }, 876 | { 877 | inputs: [ 878 | { 879 | internalType: "uint256", 880 | name: "value", 881 | type: "uint256", 882 | }, 883 | ], 884 | name: "owner_FundsExtract", 885 | outputs: [], 886 | stateMutability: "nonpayable", 887 | type: "function", 888 | }, 889 | { 890 | inputs: [], 891 | name: "owner_FundsInject", 892 | outputs: [], 893 | stateMutability: "payable", 894 | type: "function", 895 | }, 896 | { 897 | inputs: [ 898 | { 899 | internalType: "uint256", 900 | name: "bullAmount", 901 | type: "uint256", 902 | }, 903 | { 904 | internalType: "uint256", 905 | name: "bearAmount", 906 | type: "uint256", 907 | }, 908 | ], 909 | name: "owner_HouseBet", 910 | outputs: [], 911 | stateMutability: "nonpayable", 912 | type: "function", 913 | }, 914 | { 915 | inputs: [ 916 | { 917 | internalType: "address", 918 | name: "user", 919 | type: "address", 920 | }, 921 | { 922 | internalType: "uint256", 923 | name: "value", 924 | type: "uint256", 925 | }, 926 | ], 927 | name: "owner_RewardUser", 928 | outputs: [], 929 | stateMutability: "nonpayable", 930 | type: "function", 931 | }, 932 | { 933 | inputs: [ 934 | { 935 | internalType: "address", 936 | name: "_operatorAddress", 937 | type: "address", 938 | }, 939 | ], 940 | name: "owner_SetOperator", 941 | outputs: [], 942 | stateMutability: "nonpayable", 943 | type: "function", 944 | }, 945 | { 946 | inputs: [], 947 | name: "paused", 948 | outputs: [ 949 | { 950 | internalType: "bool", 951 | name: "", 952 | type: "bool", 953 | }, 954 | ], 955 | stateMutability: "view", 956 | type: "function", 957 | }, 958 | { 959 | inputs: [], 960 | name: "priceSource", 961 | outputs: [ 962 | { 963 | internalType: "string", 964 | name: "", 965 | type: "string", 966 | }, 967 | ], 968 | stateMutability: "view", 969 | type: "function", 970 | }, 971 | { 972 | inputs: [ 973 | { 974 | internalType: "uint256", 975 | name: "epoch", 976 | type: "uint256", 977 | }, 978 | { 979 | internalType: "address", 980 | name: "user", 981 | type: "address", 982 | }, 983 | ], 984 | name: "refundable", 985 | outputs: [ 986 | { 987 | internalType: "bool", 988 | name: "", 989 | type: "bool", 990 | }, 991 | ], 992 | stateMutability: "view", 993 | type: "function", 994 | }, 995 | { 996 | inputs: [], 997 | name: "rewardRate", 998 | outputs: [ 999 | { 1000 | internalType: "uint256", 1001 | name: "", 1002 | type: "uint256", 1003 | }, 1004 | ], 1005 | stateMutability: "view", 1006 | type: "function", 1007 | }, 1008 | { 1009 | inputs: [ 1010 | { 1011 | internalType: "uint256", 1012 | name: "_bufferSeconds", 1013 | type: "uint256", 1014 | }, 1015 | { 1016 | internalType: "uint256", 1017 | name: "_intervalSeconds", 1018 | type: "uint256", 1019 | }, 1020 | ], 1021 | name: "setBufferAndIntervalSeconds", 1022 | outputs: [], 1023 | stateMutability: "nonpayable", 1024 | type: "function", 1025 | }, 1026 | { 1027 | inputs: [ 1028 | { 1029 | internalType: "uint256", 1030 | name: "_minBetAmount", 1031 | type: "uint256", 1032 | }, 1033 | ], 1034 | name: "settings_SetMinBetAmount", 1035 | outputs: [], 1036 | stateMutability: "nonpayable", 1037 | type: "function", 1038 | }, 1039 | { 1040 | inputs: [ 1041 | { 1042 | internalType: "uint256", 1043 | name: "_rewardRate", 1044 | type: "uint256", 1045 | }, 1046 | ], 1047 | name: "settings_SetRewardRate", 1048 | outputs: [], 1049 | stateMutability: "nonpayable", 1050 | type: "function", 1051 | }, 1052 | { 1053 | inputs: [], 1054 | name: "startOnce", 1055 | outputs: [ 1056 | { 1057 | internalType: "bool", 1058 | name: "", 1059 | type: "bool", 1060 | }, 1061 | ], 1062 | stateMutability: "view", 1063 | type: "function", 1064 | }, 1065 | { 1066 | inputs: [ 1067 | { 1068 | internalType: "uint256", 1069 | name: "epoch", 1070 | type: "uint256", 1071 | }, 1072 | ], 1073 | name: "user_BetBear", 1074 | outputs: [], 1075 | stateMutability: "payable", 1076 | type: "function", 1077 | }, 1078 | { 1079 | inputs: [ 1080 | { 1081 | internalType: "uint256", 1082 | name: "epoch", 1083 | type: "uint256", 1084 | }, 1085 | ], 1086 | name: "user_BetBull", 1087 | outputs: [], 1088 | stateMutability: "payable", 1089 | type: "function", 1090 | }, 1091 | { 1092 | inputs: [ 1093 | { 1094 | internalType: "uint256[]", 1095 | name: "epochs", 1096 | type: "uint256[]", 1097 | }, 1098 | ], 1099 | name: "user_Claim", 1100 | outputs: [], 1101 | stateMutability: "nonpayable", 1102 | type: "function", 1103 | }, 1104 | ]; 1105 | 1106 | export class CandleGeniePredictionV3__factory { 1107 | static readonly abi = _abi; 1108 | static createInterface(): CandleGeniePredictionV3Interface { 1109 | return new utils.Interface(_abi) as CandleGeniePredictionV3Interface; 1110 | } 1111 | static connect( 1112 | address: string, 1113 | signerOrProvider: Signer | Provider 1114 | ): CandleGeniePredictionV3 { 1115 | return new Contract( 1116 | address, 1117 | _abi, 1118 | signerOrProvider 1119 | ) as CandleGeniePredictionV3; 1120 | } 1121 | } 1122 | -------------------------------------------------------------------------------- /src/types/typechain/factories/PancakePredictionV2__factory.ts: -------------------------------------------------------------------------------- 1 | /* Autogenerated file. Do not edit manually. */ 2 | /* tslint:disable */ 3 | /* eslint-disable */ 4 | 5 | import { Provider } from "@ethersproject/providers"; 6 | import { Contract, Signer, utils } from "ethers"; 7 | import type { 8 | PancakePredictionV2, 9 | PancakePredictionV2Interface, 10 | } from "../PancakePredictionV2"; 11 | 12 | const _abi = [ 13 | { 14 | inputs: [ 15 | { 16 | internalType: "address", 17 | name: "_oracleAddress", 18 | type: "address", 19 | }, 20 | { 21 | internalType: "address", 22 | name: "_adminAddress", 23 | type: "address", 24 | }, 25 | { 26 | internalType: "address", 27 | name: "_operatorAddress", 28 | type: "address", 29 | }, 30 | { 31 | internalType: "uint256", 32 | name: "_intervalSeconds", 33 | type: "uint256", 34 | }, 35 | { 36 | internalType: "uint256", 37 | name: "_bufferSeconds", 38 | type: "uint256", 39 | }, 40 | { 41 | internalType: "uint256", 42 | name: "_minBetAmount", 43 | type: "uint256", 44 | }, 45 | { 46 | internalType: "uint256", 47 | name: "_oracleUpdateAllowance", 48 | type: "uint256", 49 | }, 50 | { 51 | internalType: "uint256", 52 | name: "_treasuryFee", 53 | type: "uint256", 54 | }, 55 | ], 56 | stateMutability: "nonpayable", 57 | type: "constructor", 58 | }, 59 | { 60 | anonymous: false, 61 | inputs: [ 62 | { 63 | indexed: true, 64 | internalType: "address", 65 | name: "sender", 66 | type: "address", 67 | }, 68 | { 69 | indexed: true, 70 | internalType: "uint256", 71 | name: "epoch", 72 | type: "uint256", 73 | }, 74 | { 75 | indexed: false, 76 | internalType: "uint256", 77 | name: "amount", 78 | type: "uint256", 79 | }, 80 | ], 81 | name: "BetBear", 82 | type: "event", 83 | }, 84 | { 85 | anonymous: false, 86 | inputs: [ 87 | { 88 | indexed: true, 89 | internalType: "address", 90 | name: "sender", 91 | type: "address", 92 | }, 93 | { 94 | indexed: true, 95 | internalType: "uint256", 96 | name: "epoch", 97 | type: "uint256", 98 | }, 99 | { 100 | indexed: false, 101 | internalType: "uint256", 102 | name: "amount", 103 | type: "uint256", 104 | }, 105 | ], 106 | name: "BetBull", 107 | type: "event", 108 | }, 109 | { 110 | anonymous: false, 111 | inputs: [ 112 | { 113 | indexed: true, 114 | internalType: "address", 115 | name: "sender", 116 | type: "address", 117 | }, 118 | { 119 | indexed: true, 120 | internalType: "uint256", 121 | name: "epoch", 122 | type: "uint256", 123 | }, 124 | { 125 | indexed: false, 126 | internalType: "uint256", 127 | name: "amount", 128 | type: "uint256", 129 | }, 130 | ], 131 | name: "Claim", 132 | type: "event", 133 | }, 134 | { 135 | anonymous: false, 136 | inputs: [ 137 | { 138 | indexed: true, 139 | internalType: "uint256", 140 | name: "epoch", 141 | type: "uint256", 142 | }, 143 | { 144 | indexed: true, 145 | internalType: "uint256", 146 | name: "roundId", 147 | type: "uint256", 148 | }, 149 | { 150 | indexed: false, 151 | internalType: "int256", 152 | name: "price", 153 | type: "int256", 154 | }, 155 | ], 156 | name: "EndRound", 157 | type: "event", 158 | }, 159 | { 160 | anonymous: false, 161 | inputs: [ 162 | { 163 | indexed: true, 164 | internalType: "uint256", 165 | name: "epoch", 166 | type: "uint256", 167 | }, 168 | { 169 | indexed: true, 170 | internalType: "uint256", 171 | name: "roundId", 172 | type: "uint256", 173 | }, 174 | { 175 | indexed: false, 176 | internalType: "int256", 177 | name: "price", 178 | type: "int256", 179 | }, 180 | ], 181 | name: "LockRound", 182 | type: "event", 183 | }, 184 | { 185 | anonymous: false, 186 | inputs: [ 187 | { 188 | indexed: false, 189 | internalType: "address", 190 | name: "admin", 191 | type: "address", 192 | }, 193 | ], 194 | name: "NewAdminAddress", 195 | type: "event", 196 | }, 197 | { 198 | anonymous: false, 199 | inputs: [ 200 | { 201 | indexed: false, 202 | internalType: "uint256", 203 | name: "bufferSeconds", 204 | type: "uint256", 205 | }, 206 | { 207 | indexed: false, 208 | internalType: "uint256", 209 | name: "intervalSeconds", 210 | type: "uint256", 211 | }, 212 | ], 213 | name: "NewBufferAndIntervalSeconds", 214 | type: "event", 215 | }, 216 | { 217 | anonymous: false, 218 | inputs: [ 219 | { 220 | indexed: true, 221 | internalType: "uint256", 222 | name: "epoch", 223 | type: "uint256", 224 | }, 225 | { 226 | indexed: false, 227 | internalType: "uint256", 228 | name: "minBetAmount", 229 | type: "uint256", 230 | }, 231 | ], 232 | name: "NewMinBetAmount", 233 | type: "event", 234 | }, 235 | { 236 | anonymous: false, 237 | inputs: [ 238 | { 239 | indexed: false, 240 | internalType: "address", 241 | name: "operator", 242 | type: "address", 243 | }, 244 | ], 245 | name: "NewOperatorAddress", 246 | type: "event", 247 | }, 248 | { 249 | anonymous: false, 250 | inputs: [ 251 | { 252 | indexed: false, 253 | internalType: "address", 254 | name: "oracle", 255 | type: "address", 256 | }, 257 | ], 258 | name: "NewOracle", 259 | type: "event", 260 | }, 261 | { 262 | anonymous: false, 263 | inputs: [ 264 | { 265 | indexed: false, 266 | internalType: "uint256", 267 | name: "oracleUpdateAllowance", 268 | type: "uint256", 269 | }, 270 | ], 271 | name: "NewOracleUpdateAllowance", 272 | type: "event", 273 | }, 274 | { 275 | anonymous: false, 276 | inputs: [ 277 | { 278 | indexed: true, 279 | internalType: "uint256", 280 | name: "epoch", 281 | type: "uint256", 282 | }, 283 | { 284 | indexed: false, 285 | internalType: "uint256", 286 | name: "treasuryFee", 287 | type: "uint256", 288 | }, 289 | ], 290 | name: "NewTreasuryFee", 291 | type: "event", 292 | }, 293 | { 294 | anonymous: false, 295 | inputs: [ 296 | { 297 | indexed: true, 298 | internalType: "address", 299 | name: "previousOwner", 300 | type: "address", 301 | }, 302 | { 303 | indexed: true, 304 | internalType: "address", 305 | name: "newOwner", 306 | type: "address", 307 | }, 308 | ], 309 | name: "OwnershipTransferred", 310 | type: "event", 311 | }, 312 | { 313 | anonymous: false, 314 | inputs: [ 315 | { 316 | indexed: true, 317 | internalType: "uint256", 318 | name: "epoch", 319 | type: "uint256", 320 | }, 321 | ], 322 | name: "Pause", 323 | type: "event", 324 | }, 325 | { 326 | anonymous: false, 327 | inputs: [ 328 | { 329 | indexed: false, 330 | internalType: "address", 331 | name: "account", 332 | type: "address", 333 | }, 334 | ], 335 | name: "Paused", 336 | type: "event", 337 | }, 338 | { 339 | anonymous: false, 340 | inputs: [ 341 | { 342 | indexed: true, 343 | internalType: "uint256", 344 | name: "epoch", 345 | type: "uint256", 346 | }, 347 | { 348 | indexed: false, 349 | internalType: "uint256", 350 | name: "rewardBaseCalAmount", 351 | type: "uint256", 352 | }, 353 | { 354 | indexed: false, 355 | internalType: "uint256", 356 | name: "rewardAmount", 357 | type: "uint256", 358 | }, 359 | { 360 | indexed: false, 361 | internalType: "uint256", 362 | name: "treasuryAmount", 363 | type: "uint256", 364 | }, 365 | ], 366 | name: "RewardsCalculated", 367 | type: "event", 368 | }, 369 | { 370 | anonymous: false, 371 | inputs: [ 372 | { 373 | indexed: true, 374 | internalType: "uint256", 375 | name: "epoch", 376 | type: "uint256", 377 | }, 378 | ], 379 | name: "StartRound", 380 | type: "event", 381 | }, 382 | { 383 | anonymous: false, 384 | inputs: [ 385 | { 386 | indexed: true, 387 | internalType: "address", 388 | name: "token", 389 | type: "address", 390 | }, 391 | { 392 | indexed: false, 393 | internalType: "uint256", 394 | name: "amount", 395 | type: "uint256", 396 | }, 397 | ], 398 | name: "TokenRecovery", 399 | type: "event", 400 | }, 401 | { 402 | anonymous: false, 403 | inputs: [ 404 | { 405 | indexed: false, 406 | internalType: "uint256", 407 | name: "amount", 408 | type: "uint256", 409 | }, 410 | ], 411 | name: "TreasuryClaim", 412 | type: "event", 413 | }, 414 | { 415 | anonymous: false, 416 | inputs: [ 417 | { 418 | indexed: true, 419 | internalType: "uint256", 420 | name: "epoch", 421 | type: "uint256", 422 | }, 423 | ], 424 | name: "Unpause", 425 | type: "event", 426 | }, 427 | { 428 | anonymous: false, 429 | inputs: [ 430 | { 431 | indexed: false, 432 | internalType: "address", 433 | name: "account", 434 | type: "address", 435 | }, 436 | ], 437 | name: "Unpaused", 438 | type: "event", 439 | }, 440 | { 441 | inputs: [], 442 | name: "MAX_TREASURY_FEE", 443 | outputs: [ 444 | { 445 | internalType: "uint256", 446 | name: "", 447 | type: "uint256", 448 | }, 449 | ], 450 | stateMutability: "view", 451 | type: "function", 452 | }, 453 | { 454 | inputs: [], 455 | name: "adminAddress", 456 | outputs: [ 457 | { 458 | internalType: "address", 459 | name: "", 460 | type: "address", 461 | }, 462 | ], 463 | stateMutability: "view", 464 | type: "function", 465 | }, 466 | { 467 | inputs: [ 468 | { 469 | internalType: "uint256", 470 | name: "epoch", 471 | type: "uint256", 472 | }, 473 | ], 474 | name: "betBear", 475 | outputs: [], 476 | stateMutability: "payable", 477 | type: "function", 478 | }, 479 | { 480 | inputs: [ 481 | { 482 | internalType: "uint256", 483 | name: "epoch", 484 | type: "uint256", 485 | }, 486 | ], 487 | name: "betBull", 488 | outputs: [], 489 | stateMutability: "payable", 490 | type: "function", 491 | }, 492 | { 493 | inputs: [], 494 | name: "bufferSeconds", 495 | outputs: [ 496 | { 497 | internalType: "uint256", 498 | name: "", 499 | type: "uint256", 500 | }, 501 | ], 502 | stateMutability: "view", 503 | type: "function", 504 | }, 505 | { 506 | inputs: [ 507 | { 508 | internalType: "uint256[]", 509 | name: "epochs", 510 | type: "uint256[]", 511 | }, 512 | ], 513 | name: "claim", 514 | outputs: [], 515 | stateMutability: "nonpayable", 516 | type: "function", 517 | }, 518 | { 519 | inputs: [], 520 | name: "claimTreasury", 521 | outputs: [], 522 | stateMutability: "nonpayable", 523 | type: "function", 524 | }, 525 | { 526 | inputs: [ 527 | { 528 | internalType: "uint256", 529 | name: "epoch", 530 | type: "uint256", 531 | }, 532 | { 533 | internalType: "address", 534 | name: "user", 535 | type: "address", 536 | }, 537 | ], 538 | name: "claimable", 539 | outputs: [ 540 | { 541 | internalType: "bool", 542 | name: "", 543 | type: "bool", 544 | }, 545 | ], 546 | stateMutability: "view", 547 | type: "function", 548 | }, 549 | { 550 | inputs: [], 551 | name: "currentEpoch", 552 | outputs: [ 553 | { 554 | internalType: "uint256", 555 | name: "", 556 | type: "uint256", 557 | }, 558 | ], 559 | stateMutability: "view", 560 | type: "function", 561 | }, 562 | { 563 | inputs: [], 564 | name: "executeRound", 565 | outputs: [], 566 | stateMutability: "nonpayable", 567 | type: "function", 568 | }, 569 | { 570 | inputs: [], 571 | name: "genesisLockOnce", 572 | outputs: [ 573 | { 574 | internalType: "bool", 575 | name: "", 576 | type: "bool", 577 | }, 578 | ], 579 | stateMutability: "view", 580 | type: "function", 581 | }, 582 | { 583 | inputs: [], 584 | name: "genesisLockRound", 585 | outputs: [], 586 | stateMutability: "nonpayable", 587 | type: "function", 588 | }, 589 | { 590 | inputs: [], 591 | name: "genesisStartOnce", 592 | outputs: [ 593 | { 594 | internalType: "bool", 595 | name: "", 596 | type: "bool", 597 | }, 598 | ], 599 | stateMutability: "view", 600 | type: "function", 601 | }, 602 | { 603 | inputs: [], 604 | name: "genesisStartRound", 605 | outputs: [], 606 | stateMutability: "nonpayable", 607 | type: "function", 608 | }, 609 | { 610 | inputs: [ 611 | { 612 | internalType: "address", 613 | name: "user", 614 | type: "address", 615 | }, 616 | { 617 | internalType: "uint256", 618 | name: "cursor", 619 | type: "uint256", 620 | }, 621 | { 622 | internalType: "uint256", 623 | name: "size", 624 | type: "uint256", 625 | }, 626 | ], 627 | name: "getUserRounds", 628 | outputs: [ 629 | { 630 | internalType: "uint256[]", 631 | name: "", 632 | type: "uint256[]", 633 | }, 634 | { 635 | components: [ 636 | { 637 | internalType: "enum PancakePredictionV2.Position", 638 | name: "position", 639 | type: "uint8", 640 | }, 641 | { 642 | internalType: "uint256", 643 | name: "amount", 644 | type: "uint256", 645 | }, 646 | { 647 | internalType: "bool", 648 | name: "claimed", 649 | type: "bool", 650 | }, 651 | ], 652 | internalType: "struct PancakePredictionV2.BetInfo[]", 653 | name: "", 654 | type: "tuple[]", 655 | }, 656 | { 657 | internalType: "uint256", 658 | name: "", 659 | type: "uint256", 660 | }, 661 | ], 662 | stateMutability: "view", 663 | type: "function", 664 | }, 665 | { 666 | inputs: [ 667 | { 668 | internalType: "address", 669 | name: "user", 670 | type: "address", 671 | }, 672 | ], 673 | name: "getUserRoundsLength", 674 | outputs: [ 675 | { 676 | internalType: "uint256", 677 | name: "", 678 | type: "uint256", 679 | }, 680 | ], 681 | stateMutability: "view", 682 | type: "function", 683 | }, 684 | { 685 | inputs: [], 686 | name: "intervalSeconds", 687 | outputs: [ 688 | { 689 | internalType: "uint256", 690 | name: "", 691 | type: "uint256", 692 | }, 693 | ], 694 | stateMutability: "view", 695 | type: "function", 696 | }, 697 | { 698 | inputs: [ 699 | { 700 | internalType: "uint256", 701 | name: "", 702 | type: "uint256", 703 | }, 704 | { 705 | internalType: "address", 706 | name: "", 707 | type: "address", 708 | }, 709 | ], 710 | name: "ledger", 711 | outputs: [ 712 | { 713 | internalType: "enum PancakePredictionV2.Position", 714 | name: "position", 715 | type: "uint8", 716 | }, 717 | { 718 | internalType: "uint256", 719 | name: "amount", 720 | type: "uint256", 721 | }, 722 | { 723 | internalType: "bool", 724 | name: "claimed", 725 | type: "bool", 726 | }, 727 | ], 728 | stateMutability: "view", 729 | type: "function", 730 | }, 731 | { 732 | inputs: [], 733 | name: "minBetAmount", 734 | outputs: [ 735 | { 736 | internalType: "uint256", 737 | name: "", 738 | type: "uint256", 739 | }, 740 | ], 741 | stateMutability: "view", 742 | type: "function", 743 | }, 744 | { 745 | inputs: [], 746 | name: "operatorAddress", 747 | outputs: [ 748 | { 749 | internalType: "address", 750 | name: "", 751 | type: "address", 752 | }, 753 | ], 754 | stateMutability: "view", 755 | type: "function", 756 | }, 757 | { 758 | inputs: [], 759 | name: "oracle", 760 | outputs: [ 761 | { 762 | internalType: "contract AggregatorV3Interface", 763 | name: "", 764 | type: "address", 765 | }, 766 | ], 767 | stateMutability: "view", 768 | type: "function", 769 | }, 770 | { 771 | inputs: [], 772 | name: "oracleLatestRoundId", 773 | outputs: [ 774 | { 775 | internalType: "uint256", 776 | name: "", 777 | type: "uint256", 778 | }, 779 | ], 780 | stateMutability: "view", 781 | type: "function", 782 | }, 783 | { 784 | inputs: [], 785 | name: "oracleUpdateAllowance", 786 | outputs: [ 787 | { 788 | internalType: "uint256", 789 | name: "", 790 | type: "uint256", 791 | }, 792 | ], 793 | stateMutability: "view", 794 | type: "function", 795 | }, 796 | { 797 | inputs: [], 798 | name: "owner", 799 | outputs: [ 800 | { 801 | internalType: "address", 802 | name: "", 803 | type: "address", 804 | }, 805 | ], 806 | stateMutability: "view", 807 | type: "function", 808 | }, 809 | { 810 | inputs: [], 811 | name: "pause", 812 | outputs: [], 813 | stateMutability: "nonpayable", 814 | type: "function", 815 | }, 816 | { 817 | inputs: [], 818 | name: "paused", 819 | outputs: [ 820 | { 821 | internalType: "bool", 822 | name: "", 823 | type: "bool", 824 | }, 825 | ], 826 | stateMutability: "view", 827 | type: "function", 828 | }, 829 | { 830 | inputs: [ 831 | { 832 | internalType: "address", 833 | name: "_token", 834 | type: "address", 835 | }, 836 | { 837 | internalType: "uint256", 838 | name: "_amount", 839 | type: "uint256", 840 | }, 841 | ], 842 | name: "recoverToken", 843 | outputs: [], 844 | stateMutability: "nonpayable", 845 | type: "function", 846 | }, 847 | { 848 | inputs: [ 849 | { 850 | internalType: "uint256", 851 | name: "epoch", 852 | type: "uint256", 853 | }, 854 | { 855 | internalType: "address", 856 | name: "user", 857 | type: "address", 858 | }, 859 | ], 860 | name: "refundable", 861 | outputs: [ 862 | { 863 | internalType: "bool", 864 | name: "", 865 | type: "bool", 866 | }, 867 | ], 868 | stateMutability: "view", 869 | type: "function", 870 | }, 871 | { 872 | inputs: [], 873 | name: "renounceOwnership", 874 | outputs: [], 875 | stateMutability: "nonpayable", 876 | type: "function", 877 | }, 878 | { 879 | inputs: [ 880 | { 881 | internalType: "uint256", 882 | name: "", 883 | type: "uint256", 884 | }, 885 | ], 886 | name: "rounds", 887 | outputs: [ 888 | { 889 | internalType: "uint256", 890 | name: "epoch", 891 | type: "uint256", 892 | }, 893 | { 894 | internalType: "uint256", 895 | name: "startTimestamp", 896 | type: "uint256", 897 | }, 898 | { 899 | internalType: "uint256", 900 | name: "lockTimestamp", 901 | type: "uint256", 902 | }, 903 | { 904 | internalType: "uint256", 905 | name: "closeTimestamp", 906 | type: "uint256", 907 | }, 908 | { 909 | internalType: "int256", 910 | name: "lockPrice", 911 | type: "int256", 912 | }, 913 | { 914 | internalType: "int256", 915 | name: "closePrice", 916 | type: "int256", 917 | }, 918 | { 919 | internalType: "uint256", 920 | name: "lockOracleId", 921 | type: "uint256", 922 | }, 923 | { 924 | internalType: "uint256", 925 | name: "closeOracleId", 926 | type: "uint256", 927 | }, 928 | { 929 | internalType: "uint256", 930 | name: "totalAmount", 931 | type: "uint256", 932 | }, 933 | { 934 | internalType: "uint256", 935 | name: "bullAmount", 936 | type: "uint256", 937 | }, 938 | { 939 | internalType: "uint256", 940 | name: "bearAmount", 941 | type: "uint256", 942 | }, 943 | { 944 | internalType: "uint256", 945 | name: "rewardBaseCalAmount", 946 | type: "uint256", 947 | }, 948 | { 949 | internalType: "uint256", 950 | name: "rewardAmount", 951 | type: "uint256", 952 | }, 953 | { 954 | internalType: "bool", 955 | name: "oracleCalled", 956 | type: "bool", 957 | }, 958 | ], 959 | stateMutability: "view", 960 | type: "function", 961 | }, 962 | { 963 | inputs: [ 964 | { 965 | internalType: "address", 966 | name: "_adminAddress", 967 | type: "address", 968 | }, 969 | ], 970 | name: "setAdmin", 971 | outputs: [], 972 | stateMutability: "nonpayable", 973 | type: "function", 974 | }, 975 | { 976 | inputs: [ 977 | { 978 | internalType: "uint256", 979 | name: "_bufferSeconds", 980 | type: "uint256", 981 | }, 982 | { 983 | internalType: "uint256", 984 | name: "_intervalSeconds", 985 | type: "uint256", 986 | }, 987 | ], 988 | name: "setBufferAndIntervalSeconds", 989 | outputs: [], 990 | stateMutability: "nonpayable", 991 | type: "function", 992 | }, 993 | { 994 | inputs: [ 995 | { 996 | internalType: "uint256", 997 | name: "_minBetAmount", 998 | type: "uint256", 999 | }, 1000 | ], 1001 | name: "setMinBetAmount", 1002 | outputs: [], 1003 | stateMutability: "nonpayable", 1004 | type: "function", 1005 | }, 1006 | { 1007 | inputs: [ 1008 | { 1009 | internalType: "address", 1010 | name: "_operatorAddress", 1011 | type: "address", 1012 | }, 1013 | ], 1014 | name: "setOperator", 1015 | outputs: [], 1016 | stateMutability: "nonpayable", 1017 | type: "function", 1018 | }, 1019 | { 1020 | inputs: [ 1021 | { 1022 | internalType: "address", 1023 | name: "_oracle", 1024 | type: "address", 1025 | }, 1026 | ], 1027 | name: "setOracle", 1028 | outputs: [], 1029 | stateMutability: "nonpayable", 1030 | type: "function", 1031 | }, 1032 | { 1033 | inputs: [ 1034 | { 1035 | internalType: "uint256", 1036 | name: "_oracleUpdateAllowance", 1037 | type: "uint256", 1038 | }, 1039 | ], 1040 | name: "setOracleUpdateAllowance", 1041 | outputs: [], 1042 | stateMutability: "nonpayable", 1043 | type: "function", 1044 | }, 1045 | { 1046 | inputs: [ 1047 | { 1048 | internalType: "uint256", 1049 | name: "_treasuryFee", 1050 | type: "uint256", 1051 | }, 1052 | ], 1053 | name: "setTreasuryFee", 1054 | outputs: [], 1055 | stateMutability: "nonpayable", 1056 | type: "function", 1057 | }, 1058 | { 1059 | inputs: [ 1060 | { 1061 | internalType: "address", 1062 | name: "newOwner", 1063 | type: "address", 1064 | }, 1065 | ], 1066 | name: "transferOwnership", 1067 | outputs: [], 1068 | stateMutability: "nonpayable", 1069 | type: "function", 1070 | }, 1071 | { 1072 | inputs: [], 1073 | name: "treasuryAmount", 1074 | outputs: [ 1075 | { 1076 | internalType: "uint256", 1077 | name: "", 1078 | type: "uint256", 1079 | }, 1080 | ], 1081 | stateMutability: "view", 1082 | type: "function", 1083 | }, 1084 | { 1085 | inputs: [], 1086 | name: "treasuryFee", 1087 | outputs: [ 1088 | { 1089 | internalType: "uint256", 1090 | name: "", 1091 | type: "uint256", 1092 | }, 1093 | ], 1094 | stateMutability: "view", 1095 | type: "function", 1096 | }, 1097 | { 1098 | inputs: [], 1099 | name: "unpause", 1100 | outputs: [], 1101 | stateMutability: "nonpayable", 1102 | type: "function", 1103 | }, 1104 | { 1105 | inputs: [ 1106 | { 1107 | internalType: "address", 1108 | name: "", 1109 | type: "address", 1110 | }, 1111 | { 1112 | internalType: "uint256", 1113 | name: "", 1114 | type: "uint256", 1115 | }, 1116 | ], 1117 | name: "userRounds", 1118 | outputs: [ 1119 | { 1120 | internalType: "uint256", 1121 | name: "", 1122 | type: "uint256", 1123 | }, 1124 | ], 1125 | stateMutability: "view", 1126 | type: "function", 1127 | }, 1128 | ]; 1129 | 1130 | export class PancakePredictionV2__factory { 1131 | static readonly abi = _abi; 1132 | static createInterface(): PancakePredictionV2Interface { 1133 | return new utils.Interface(_abi) as PancakePredictionV2Interface; 1134 | } 1135 | static connect( 1136 | address: string, 1137 | signerOrProvider: Signer | Provider 1138 | ): PancakePredictionV2 { 1139 | return new Contract(address, _abi, signerOrProvider) as PancakePredictionV2; 1140 | } 1141 | } 1142 | -------------------------------------------------------------------------------- /src/types/typechain/index.ts: -------------------------------------------------------------------------------- 1 | /* Autogenerated file. Do not edit manually. */ 2 | /* tslint:disable */ 3 | /* eslint-disable */ 4 | export type { CandleGeniePredictionV3 } from "./CandleGeniePredictionV3"; 5 | export { CandleGeniePredictionV3__factory } from "./factories/CandleGeniePredictionV3__factory"; 6 | export { PancakePredictionV2__factory } from "./factories/PancakePredictionV2__factory"; 7 | export type { PancakePredictionV2 } from "./PancakePredictionV2"; 8 | -------------------------------------------------------------------------------- /tsconfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "compilerOptions": { 3 | /* Visit https://aka.ms/tsconfig.json to read more about this file */ 4 | 5 | /* Projects */ 6 | // "incremental": true, /* Enable incremental compilation */ 7 | // "composite": true, /* Enable constraints that allow a TypeScript project to be used with project references. */ 8 | // "tsBuildInfoFile": "./", /* Specify the folder for .tsbuildinfo incremental compilation files. */ 9 | // "disableSourceOfProjectReferenceRedirect": true, /* Disable preferring source files instead of declaration files when referencing composite projects */ 10 | // "disableSolutionSearching": true, /* Opt a project out of multi-project reference checking when editing. */ 11 | // "disableReferencedProjectLoad": true, /* Reduce the number of projects loaded automatically by TypeScript. */ 12 | 13 | /* Language and Environment */ 14 | "target": "es5" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */, 15 | // "lib": [], /* Specify a set of bundled library declaration files that describe the target runtime environment. */ 16 | // "jsx": "preserve", /* Specify what JSX code is generated. */ 17 | // "experimentalDecorators": true, /* Enable experimental support for TC39 stage 2 draft decorators. */ 18 | // "emitDecoratorMetadata": true, /* Emit design-type metadata for decorated declarations in source files. */ 19 | // "jsxFactory": "", /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h' */ 20 | // "jsxFragmentFactory": "", /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */ 21 | // "jsxImportSource": "", /* Specify module specifier used to import the JSX factory functions when using `jsx: react-jsx*`.` */ 22 | // "reactNamespace": "", /* Specify the object invoked for `createElement`. This only applies when targeting `react` JSX emit. */ 23 | // "noLib": true, /* Disable including any library files, including the default lib.d.ts. */ 24 | // "useDefineForClassFields": true, /* Emit ECMAScript-standard-compliant class fields. */ 25 | 26 | /* Modules */ 27 | "module": "commonjs" /* Specify what module code is generated. */, 28 | "rootDir": "./src" /* Specify the root folder within your source files. */, 29 | // "moduleResolution": "node", /* Specify how TypeScript looks up a file from a given module specifier. */ 30 | "baseUrl": "." /* Specify the base directory to resolve non-relative module names. */, 31 | // "paths": {}, /* Specify a set of entries that re-map imports to additional lookup locations. */ 32 | // "rootDirs": [], /* Allow multiple folders to be treated as one when resolving modules. */ 33 | // "typeRoots": [], /* Specify multiple folders that act like `./node_modules/@types`. */ 34 | // "types": [], /* Specify type package names to be included without being referenced in a source file. */ 35 | // "allowUmdGlobalAccess": true, /* Allow accessing UMD globals from modules. */ 36 | // "resolveJsonModule": true, /* Enable importing .json files */ 37 | // "noResolve": true, /* Disallow `import`s, `require`s or ``s from expanding the number of files TypeScript should add to a project. */ 38 | 39 | /* JavaScript Support */ 40 | // "allowJs": true, /* Allow JavaScript files to be a part of your program. Use the `checkJS` option to get errors from these files. */ 41 | // "checkJs": true, /* Enable error reporting in type-checked JavaScript files. */ 42 | // "maxNodeModuleJsDepth": 1, /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */ 43 | 44 | /* Emit */ 45 | // "declaration": true, /* Generate .d.ts files from TypeScript and JavaScript files in your project. */ 46 | // "declarationMap": true, /* Create sourcemaps for d.ts files. */ 47 | // "emitDeclarationOnly": true, /* Only output d.ts files and not JavaScript files. */ 48 | // "sourceMap": true, /* Create source map files for emitted JavaScript files. */ 49 | // "outFile": "./", /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */ 50 | // "outDir": "./", /* Specify an output folder for all emitted files. */ 51 | // "removeComments": true, /* Disable emitting comments. */ 52 | // "noEmit": true, /* Disable emitting files from a compilation. */ 53 | // "importHelpers": true, /* Allow importing helper functions from tslib once per project, instead of including them per-file. */ 54 | // "importsNotUsedAsValues": "remove", /* Specify emit/checking behavior for imports that are only used for types */ 55 | // "downlevelIteration": true, /* Emit more compliant, but verbose and less performant JavaScript for iteration. */ 56 | // "sourceRoot": "", /* Specify the root path for debuggers to find the reference source code. */ 57 | // "mapRoot": "", /* Specify the location where debugger should locate map files instead of generated locations. */ 58 | // "inlineSourceMap": true, /* Include sourcemap files inside the emitted JavaScript. */ 59 | // "inlineSources": true, /* Include source code in the sourcemaps inside the emitted JavaScript. */ 60 | // "emitBOM": true, /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */ 61 | // "newLine": "crlf", /* Set the newline character for emitting files. */ 62 | // "stripInternal": true, /* Disable emitting declarations that have `@internal` in their JSDoc comments. */ 63 | // "noEmitHelpers": true, /* Disable generating custom helper functions like `__extends` in compiled output. */ 64 | // "noEmitOnError": true, /* Disable emitting files if any type checking errors are reported. */ 65 | // "preserveConstEnums": true, /* Disable erasing `const enum` declarations in generated code. */ 66 | // "declarationDir": "./", /* Specify the output directory for generated declaration files. */ 67 | 68 | /* Interop Constraints */ 69 | // "isolatedModules": true, /* Ensure that each file can be safely transpiled without relying on other imports. */ 70 | // "allowSyntheticDefaultImports": true, /* Allow 'import x from y' when a module doesn't have a default export. */ 71 | "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables `allowSyntheticDefaultImports` for type compatibility. */, 72 | // "preserveSymlinks": true, /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */ 73 | "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */, 74 | 75 | /* Type Checking */ 76 | "strict": true /* Enable all strict type-checking options. */, 77 | // "noImplicitAny": true, /* Enable error reporting for expressions and declarations with an implied `any` type.. */ 78 | // "strictNullChecks": true, /* When type checking, take into account `null` and `undefined`. */ 79 | // "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */ 80 | // "strictBindCallApply": true, /* Check that the arguments for `bind`, `call`, and `apply` methods match the original function. */ 81 | // "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */ 82 | // "noImplicitThis": true, /* Enable error reporting when `this` is given the type `any`. */ 83 | // "useUnknownInCatchVariables": true, /* Type catch clause variables as 'unknown' instead of 'any'. */ 84 | // "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */ 85 | // "noUnusedLocals": true, /* Enable error reporting when a local variables aren't read. */ 86 | // "noUnusedParameters": true, /* Raise an error when a function parameter isn't read */ 87 | // "exactOptionalPropertyTypes": true, /* Interpret optional property types as written, rather than adding 'undefined'. */ 88 | // "noImplicitReturns": true, /* Enable error reporting for codepaths that do not explicitly return in a function. */ 89 | // "noFallthroughCasesInSwitch": true, /* Enable error reporting for fallthrough cases in switch statements. */ 90 | // "noUncheckedIndexedAccess": true, /* Include 'undefined' in index signature results */ 91 | // "noImplicitOverride": true, /* Ensure overriding members in derived classes are marked with an override modifier. */ 92 | // "noPropertyAccessFromIndexSignature": true, /* Enforces using indexed accessors for keys declared using an indexed type */ 93 | // "allowUnusedLabels": true, /* Disable error reporting for unused labels. */ 94 | // "allowUnreachableCode": true, /* Disable error reporting for unreachable code. */ 95 | 96 | /* Completeness */ 97 | // "skipDefaultLibCheck": true, /* Skip type checking .d.ts files that are included with TypeScript. */ 98 | "skipLibCheck": true /* Skip type checking all .d.ts files. */ 99 | } 100 | } 101 | --------------------------------------------------------------------------------