This contract is being backfilled. You may encounter incomplete storage history.

TherundownConsumer

Verified contract

Implementation

Active on Base with 0 txns
Deployed by via 0xd421…81f7 at 3903136
Slot
32
30
28
26
24
22
20
18
16
14
12
10
8
6
4
2
0
20 additional variables

No balances found for "TherundownConsumer"

No transactions found for "TherundownConsumer"

Functions
Getter at block 23190963
AWAY_WIN() view returns (uint256)
2
CANCELLED() view returns (uint256)
0
HOME_WIN() view returns (uint256)
1
MIN_TAG_NUMBER() view returns (uint256)
9000
RESULT_DRAW() view returns (uint256)
3
STATUS_RETIRED() view returns (uint256)
201
lastPauseTime() view returns (uint256)
0
maxNumberOfMarketsToResolve() view returns (uint256)
0
nominatedOwner() view returns (address)
0x0000000000000000000000000000000000000000
oddsObtainer() view returns (address)
0x0000000000000000000000000000000000000000
owner() view returns (address)
0x0000000000000000000000000000000000000000
paused() view returns (bool)
false
playerProps() view returns (address)
0x0000000000000000000000000000000000000000
queues() view returns (address)
0x0000000000000000000000000000000000000000
sportsManager() view returns (address)
0x0000000000000000000000000000000000000000
verifier() view returns (address)
0x0000000000000000000000000000000000000000
wrapperAddress() view returns (address)
0x0000000000000000000000000000000000000000
Read-only
backupOdds(bytes32) view returns (bytes32 gameId, int24 homeOdds, int24 awayOdds, int24 drawOdds)
canMarketBeUpdated(address) view returns (bool)
cancelGameStatuses(uint256) view returns (bool)
gameCreated(bytes32) view returns (bytes32 gameId, uint256 startTime, int24 homeOdds, int24 awayOdds, int24 drawOdds, string homeTeam, string awayTeam)
gameFulfilledCreated(bytes32) view returns (bool)
gameFulfilledResolved(bytes32) view returns (bool)
gameIdPerMarket(address) view returns (bytes32)
gameOdds(bytes32) view returns (bytes32 gameId, int24 homeOdds, int24 awayOdds, int24 drawOdds)
gameOnADate(bytes32) view returns (uint256)
gameResolved(bytes32) view returns (bytes32 gameId, uint8 homeScore, uint8 awayScore, uint8 statusId, uint40 lastUpdated)
gamesPerDate(uint256, uint256) view returns (bytes32)
gamesPerDatePerSport(uint256, uint256, uint256) view returns (bytes32)
getGameCreatedById(bytes32 _gameId) view returns (struct TherundownConsumerGameCreate)
getGamePropsForOdds(address _market) view returns (uint256 _sportId, uint256 _gameDate, bytes32 _id)
getGameStartTime(bytes32 _gameId) view returns (uint256)
getGamesPerDatePerSport(uint256 _sportId, uint256 _date) view returns (bytes32[])
getNormalizedOddsForMarket(address _market) view returns (uint256[])
ignoreChildCancellationPerSportIfDraw(uint256) view returns (bool)
invalidOdds(address) view returns (bool)
isChildMarket(address _market) view returns (bool)
isGameResolvedOrCanceled(bytes32 _gameId) view returns (bool)
isPausedByCanceledStatus(address) view returns (bool)
isSportOnADate(uint256, uint256) view returns (bool)
isSportTwoPositionsSport(uint256 _sportsId) view returns (bool)
marketCanceled(address) view returns (bool)
marketCreated(address) view returns (bool)
marketPerGameId(bytes32) view returns (address)
marketResolved(address) view returns (bool)
oddsLastPulledForGame(bytes32) view returns (uint256)
requestIdGamesCreated(bytes32, uint256) view returns (bytes)
requestIdGamesOdds(bytes32, uint256) view returns (bytes)
requestIdGamesResolved(bytes32, uint256) view returns (bytes)
sportsIdPerGame(bytes32) view returns (uint256)
supportResolveGameStatuses(uint256) view returns (bool)
supportedSport(uint256) view returns (bool)
twoPositionSport(uint256) view returns (bool)
whitelistedAddresses(address) view returns (bool)
State-modifying
acceptOwnership() 
addToWhitelist(address _whitelistAddress, bool _flag) 
createAllMarketsForGames(bytes32[] _gameIds) 
createMarketForGame(bytes32 _gameId) 
fulfillGamesCreated(bytes32 _requestId, bytes[] _games, uint256 _sportId, uint256 _date) 
fulfillGamesOdds(bytes32 _requestId, bytes[] _games) 
fulfillGamesResolved(bytes32 _requestId, bytes[] _games, uint256 _sportId) 
initialize(address _owner, uint256[] _supportedSportIds, address _sportsManager, uint256[] _twoPositionSports, address _queues, uint256[] _resolvedStatuses, uint256[] _cancelGameStatuses) 
nominateNewOwner(address _owner) 
pauseOrUnpauseMarket(address _market, bool _pause) 
pauseOrUnpauseMarketForPlayerProps(address _main, bool _pause, bool _invalidOdds, bool _circuitBreaker) 
pauseOrUnpauseMarketManually(address _market, bool _pause) 
reopenGameForCreationProcessing(bytes32 gameId) 
resolveAllMarketsForGames(bytes32[] _gameIds) 
resolveMarketForGame(bytes32 _gameId) 
resolveMarketManually(address _market, uint256 _outcome, uint8 _homeScore, uint8 _awayScore, bool _useBackupOdds) 
setGameIdPerChildMarket(bytes32 _gameId, address _child) 
setIgnoreChildCancellationPerSportIfDraw(uint256 _sportId, bool _flag) 
setNewMaxNumberOfMarketsToResolve(uint256 _maxNumberOfMarketsToResolve) 
setOwner(address _owner) 
setPaused(bool _paused) 
setPausedByCanceledStatus(address _market, bool _flag) 
setSportContracts(address _wrapperAddress, address _queues, address _sportsManager, address _verifier, address _oddsObtainer, address _playerProps) 
setSupportedCancelStatuses(uint256 _status, bool _isSupported) 
setSupportedResolvedStatuses(uint256 _status, bool _isSupported) 
setSupportedSport(uint256 _sportId, bool _isSupported) 
setTwoPositionSport(uint256 _sportId, bool _isTwoPosition) 
transferOwnershipAtInit(address proxyAddress) 
Events
AddedIntoWhitelist(address _whitelistAddress, bool _flag) 
CancelSportsMarket(address _marketAddress, bytes32 _id) 
CreateSportsMarket(address _marketAddress, bytes32 _id, struct TherundownConsumerGameCreate _game, uint256[] _tags, uint256[] _normalizedOdds) 
GameCreated(bytes32 _requestId, uint256 _sportId, bytes32 _id, struct TherundownConsumerGameCreate _game, uint256 _queueIndex, uint256[] _normalizedOdds) 
GameOddsAdded(bytes32 _requestId, bytes32 _id, struct TherundownConsumerGameOdds _game, uint256[] _normalizedOdds) 
GameResolved(bytes32 _requestId, uint256 _sportId, bytes32 _id, struct TherundownConsumerGameResolve _game, uint256 _queueIndex) 
GameTimeMovedAhead(address _market, bytes32 _gameId, uint256 _oldStartTime, uint256 _newStartTime) 
IgnoreChildCancellationPerSportIfDraw(uint256 _sportId, bool _flag) 
InvalidOddsForMarket(bytes32 _requestId, address _marketAddress, bytes32 _id, struct TherundownConsumerGameOdds _game) 
NewMaxNumberOfMarketsToResolve(uint256 _maxNumber) 
NewQueueAddress(address _queues) 
NewSportContracts(address _wrapperAddress, address _queues, address _sportsManager, address _verifier, address _oddsObtainer, address _playerProps) 
NewSportsMarketManager(address _sportsManager) 
NewWrapperAddress(address _wrapperAddress) 
OddsCircuitBreaker(address _marketAddress, bytes32 _id) 
OwnerChanged(address oldOwner, address newOwner) 
OwnerNominated(address newOwner) 
PauseChanged(bool isPaused) 
PauseSportsMarket(address _marketAddress, bool _pause) 
ResolveSportsMarket(address _marketAddress, bytes32 _id, uint256 _outcome) 
SupportedCancelStatusChanged(uint256 _status, bool _isSupported) 
SupportedResolvedStatusChanged(uint256 _status, bool _isSupported) 
SupportedSportsChanged(uint256 _sportId, bool _isSupported) 
TwoPositionSportChanged(uint256 _sportId, bool _isTwoPosition) 
Constructor

This contract contains no constructor objects.

Fallback and receive

This contract contains no fallback and receive objects.

Errors

This contract contains no error objects.