9Lives

You probably want to read the guide as a developer!

9lives is the most customisable and advanced prediction market in the web3 ecosystem, with an orderbook and AMM feature. We can support teams interested in releasing prediction markets themselves using 9lives, including hosting the graph for you. If you're interested in this, contact us at this link!

9Lives is an Arbitrum Stylus smart contract implemented with a simple factory/pair pattern. A factory takes a list of outcomes, and creates a variable number of contracts with a minimal viable proxy pointing to share ERC20s, and a trading contract. It either supports the Dynamic Pari-Mutuel Market (DPM) model to solve liquidity issues in orderbooks, or a Constant Product Market Maker model to be totally separate.

To get started with the contract entrypoint, src/lib.rs contains the matching of features to deploy different contract facets. Testing is done with a mixture of property and mutation testing and a bespoke testing environment for ERC20 accounting and more.

Inventors create campaigns (the prediction markets) by locking up "incentive" amounts, and by picking the type of oracle they want to use. Any fees earned in the campaign are sent to the Inventor, which provides incentive to create markets. Markets must be created with a hard deadline and a Beauty Contest or a Infrastructure Market, or with a Contract Interaction type of outcome. The Inventor must communicate to the Factory which oracle they would like to use, and provide the hash of the string that must be used to determine the outcome. This will then set the correct behaviour.

flowchart TD
    Trader --> |Locks up incentive amount, sets parameters| Factory
    Factory --> |Sets start, end, description, if infra market oracle chosen| Infra[Infra market]
    Factory --> |Deploys contract. Sets parameters| Trading
    Factory --> |Configures Longtail pool| Longtail
    Factory --> |Deploys ERC20 assets for each outcome| ERC20s
    Trading --> |Disables Longtail once trading is done| Factory
    ERC20s --> |Burns and mints supply| Trading
    Infra --> |Tells Trading who won| Trading

Infra Markets are prediction markets where Staked ARB is locked up as LARB, which is used to predict the outcome of another prediction market with a commit and reveal scheme. These markets exist in an optimistic state where anyone can "call" the outcome, before being challenged with a "whinge", which begins the process of a commit and reveal system. Following this, amounts can be claimed with a slashing process based on amounts staked.

Oracle State oracles are very simple comparatively, as presumably the associated Trading contract was configured to allow early activation, so all a caller must do is activate the associated Oracle State contract. These could communicate with LayerZero to pull information from another chain, and the contract will simply check the result of the message. If it's not activated by the date that's given, then it defaults to a "DEFAULT" clause that could be "no" if a user were to try to estimate the price of something.

Roadmap

• UX improvements (shares are more visible, smart account behaviour)
• Mainnet is supported as well. Mainnet has disclosure that funds are locked up until the election is over.
• Achievements and portfolio page is supported. Some socialfi elements.
  1. Users can choose their favourite achievements to display in a minified form next to their Meow Domain.
  2. Meow domains is supported in the UI.
• Collect payoff from the campaign ending in the frontend.
• Custom fee collection and pool configuration supported (use beauty contest with fixed date, many outcomes if they want)
• Anyone can create pools. Custom display of pools a la Ebay customisation.
  1. A fixed fee is sent to creator of when shares are created.
  2. Behind the scenes deferring to the AMM model if more than two outcomes.
  3. Customise the UI of the frontpage for the info
  4. Stack ranking is done for automated updating of frontpage
  5. Campaign report functionality. Images are screened automatically for bad content with CSAM
  6. API to update campaign by the original sender
  7. Custom embed when sharing URL
• Prediction market DAO. Token launch

Building contracts

make build

Updating docs (after editing markdown files)

forge doc -b

Testing

Testing must be done with no trading or contract feature enabled. Testing is only possible on the local environment, or with end to end tests with an Arbitrum node.

./tests.sh

Interrogation of the deployment in the end to end testing library could be done using the build.rs use of environment.lst, which could be in turn read with a fresh deploy (and a clean artifacts directory):

sort $(find target -name environment.lst) | uniq

You could clear the recorded environment variables the same way with a test harness:

rm $(find target -name environment.lst)

You could use this to test the code by making a debug build, which includes more information about reverts, then simulate your calldata against it using stylus-interpreter, making debugging a breeze.

Errors

The error table lives in ERRORS.md.

Deployments

Superposition mainnet

Superposition testnet

IERC20

Git Source

Functions

transferFrom

function transferFrom(address sender, address recipient, uint256 value) external;

approve

function approve(address recipient, uint256 amount) external;

balanceOf

function balanceOf(address spender) external view returns (uint256);

transfer

function transfer(address spender, uint256 amount) external;

DPMOld

Git Source

Functions

mintPermitE90275AB

function mintPermitE90275AB(bytes8, uint256, address, uint256, uint8, bytes32, bytes32) external returns (uint256);

BuyHelper2

Git Source

State Variables

FACTORY

INineLivesFactory immutable FACTORY;

LONGTAIL

ILongtail immutable LONGTAIL;

FUSDC

IERC20 immutable FUSDC;

WETH

IWETH10 immutable WETH;

Functions

constructor

constructor(INineLivesFactory _factory, ILongtail _longtail, address _fusdc, IWETH10 _weth);

mint

Mint some shares at the trading id and outcome given, using Longtail to make a swap to fUSDC from the asset given.

function mint(
    address _tradingAddr,
    address _asset,
    bytes8 _outcome,
    uint256 _minShareOut,
    uint256 _amount,
    address _referrer
) external payable returns (uint256);

burn

function burn(
    address _tradingAddr,
    bytes8 _outcome,
    uint256 _minFusdc,
    uint256 _maxShareOut,
    uint256 _minShareOut,
    address _referrer
) external returns (uint256, uint256);

InfraMarket

Git Source

Functions

ctor

function ctor(address admin, address emergency, ILockup lockup, address lockedArbToken, INineLivesFactory factoryAddr)
    external;

Lockup

Git Source

Functions

ctor

function ctor(address tokenImpl, address infraMarket, address operator) external;

Factory

Git Source

Functions

ctor

function ctor(
    address shareImpl,
    address tradingDpmExtrasImpl,
    address tradingDpmMintImpl,
    address tradingDpmQuotesImpl,
    address tradingDpmPriceImpl,
    address tradingAMMExtrasImpl,
    address tradingAMMMintImpl,
    address tradingAmmQuotesImpl,
    address tradingAmmPriceImpl,
    address infraMarketOracle,
    address operator
) external;

DeployArgs

Git Source

struct DeployArgs {
    address admin;
    address emergencyCouncil;
    address lockupTokenImpl;
    address shareImpl;
    address factory1Impl;
    address factory2Impl;
    address infraMarketImpl;
    address lockupImpl;
    address tradingDpmExtrasImpl;
    address tradingDpmMintImpl;
    address tradingDpmQuotesImpl;
    address tradingDpmPriceImpl;
    address tradingAmmExtrasImpl;
    address tradingAmmMintImpl;
    address tradingAmmQuotesImpl;
    address tradingAmmPriceImpl;
    address beautyContestImpl;
}

DeployHelper

Git Source

Functions

constructor

constructor(DeployArgs memory _a);

Events

FactoryDeployed

event FactoryDeployed(address indexed addr);

InfraMarketDeployed

event InfraMarketDeployed(address indexed addr);

LockupDeployed

event LockupDeployed(address indexed addr);

BeautyContestDeployed

event BeautyContestDeployed(address indexed addr);

ExtrasBeacon

Git Source

State Variables

OWNER

address immutable OWNER;

defaultFacet

address public defaultFacet;

facet

mapping(uint8 => address) public facet;

Functions

constructor

constructor(address _owner, address _default);

impl

function impl(bytes8 _sel) external view returns (address);

upgradeDefault

function upgradeDefault(address _new) external;

upgrade

function upgrade(uint8 _facet, address _new) external;

ExtrasBeaconFactory

Git Source

Functions

deploy

function deploy(address _owner, address _default) external returns (address beacon, address proxy);

ExtrasBeaconProxy

Git Source

State Variables

BEACON

ExtrasBeacon immutable BEACON;

Functions

constructor

constructor(ExtrasBeacon _b);

fallback

fallback() external;

IERC20Permit

Git Source

Functions

permit

function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
    external;

approve

function approve(address spender, uint256 amount) external;

transferFrom

function transferFrom(address owner, address spender, uint256 amount) external;

CreateArgs

Git Source

struct CreateArgs {
    address oracle;
    FactoryOutcome[] outcomes;
    uint64 timeEnding;
    bytes32 documentation;
    address feeRecipient;
    uint64 feeCreator;
    uint64 feeLp;
    uint64 feeMinter;
    uint64 feeReferrer;
    uint256 seedLiquidity;
}

HelperFactory

Git Source

HelperFactory that assists in deploying different amounts, it does not take any fees currently to reflect the new AMM model.

State Variables

FUSDC

IERC20Permit immutable FUSDC;

FACTORY

INineLivesFactory immutable FACTORY;

INFRA_MARKET

address public immutable INFRA_MARKET;

BEAUTY_CONTEST

address public immutable BEAUTY_CONTEST;

SARP_AI

address public immutable SARP_AI;

Functions

constructor

constructor(
    IERC20Permit _fusdc,
    INineLivesFactory _factory,
    address _infraMarket,
    address _beautyContest,
    address _sarpAi
);

create

Create a new campaign, ignoring the CreateArgs oracle argument.

function create(address _oracle, CreateArgs calldata _a) internal returns (address);

createWithBeautyContest

function createWithBeautyContest(CreateArgs calldata _a) public returns (address tradingAddr);

createWithAI

function createWithAI(CreateArgs calldata _a) public returns (address tradingAddr);

createWithCustom

It doesn't make sense to use this. It's better to do the setup work yourself with the factory, this is left for convinience reasons. It transfers some fUSDC to the contract for setup.

function createWithCustom(CreateArgs calldata _a) public returns (address tradingAddr);

Constants

Git Source

INCENTIVE_AMT_MODERATION

uint256 constant INCENTIVE_AMT_MODERATION = 1e6;

INCENTIVE_INFRA_MARKET

uint256 constant INCENTIVE_INFRA_MARKET = 2200000;

IDecidable

Git Source

Functions

decide

Decide an outcome. Only callable by the oracle!

function decide(bytes8 outcome) external;

Parameters

escape

Escape an indeterminate/inconclusive campaign, where an associated contract needs to do something.

function escape() external;

IEvents

Git Source

Events

LockupTokenProxyDeployed

event LockupTokenProxyDeployed(address indexed token);

NewTrading2

event NewTrading2(bytes32 indexed identifier, address indexed addr, address indexed oracle, uint8 backend);

OutcomeCreated

event OutcomeCreated(bytes32 indexed tradingIdentifier, bytes32 indexed erc20Identifier, address indexed erc20Addr);

ClaimedDAOFunds

event ClaimedDAOFunds(address indexed recipient, uint256 indexed amount);

OutcomeDecided

event OutcomeDecided(bytes8 indexed identifier, address indexed oracle);

SharesMinted

event SharesMinted(
    bytes8 indexed identifier,
    uint256 indexed shareAmount,
    address indexed spender,
    address recipient,
    uint256 fusdcSpent
);

SharesBurned

event SharesBurned(
    bytes8 indexed identifier,
    uint256 indexed shareAmount,
    address indexed spender,
    address recipient,
    uint256 fusdcReturned
);

PayoffActivated

event PayoffActivated(
    bytes8 indexed identifier,
    uint256 indexed sharesSpent,
    address indexed spender,
    address recipient,
    uint256 fusdcReceived
);

DeadlineExtension

event DeadlineExtension(uint64 indexed timeBefore, uint64 indexed timeAfter);

LiquidityAdded

event LiquidityAdded(
    address indexed sender, uint256 indexed fusdcAmt, address indexed recipient, uint256 liquidityShares
);

LiquidityRemoved

event LiquidityRemoved(uint256 indexed fusdcAmt, address indexed recipient, uint256 indexed liquidityAmt);

LiquidityClaimed

event LiquidityClaimed(address indexed recipient, uint256 indexed fusdcAmt);

LPFeesClaimed

event LPFeesClaimed(
    address indexed sender, address indexed recipient, uint256 indexed feesEarned, uint256 senderLiquidityShares
);

AddressFeesClaimed

event AddressFeesClaimed(address indexed recipient, uint256 indexed amount);

ReferrerEarnedFees

event ReferrerEarnedFees(address indexed referrer, uint256 indexed fees, uint256 indexed volume);

TimeExtension

event TimeExtension(uint256 indexed newDeadline);

InfraMarketEnabled

event InfraMarketEnabled(bool indexed status);

MarketCreated2

event MarketCreated2(
    address indexed incentiveSender,
    address indexed tradingAddr,
    bytes32 indexed desc,
    uint64 launchTs,
    uint64 callDeadline
);

CallMade

event CallMade(address indexed tradingAddr, bytes8 indexed winner, address indexed incentiveRecipient);

InfraMarketClosed

event InfraMarketClosed(address indexed incentiveRecipient, address indexed tradingAddr, bytes8 indexed winner);

DAOMoneyDistributed

event DAOMoneyDistributed(uint256 indexed amount, address indexed recipient);

Committed

event Committed(address indexed trading, address indexed predictor, bytes32 indexed commitment);

CommitmentRevealed

event CommitmentRevealed(
    address indexed trading, address indexed revealer, bytes8 indexed outcome, address caller, uint256 bal
);

Whinged

event Whinged(address indexed trading, bytes8 indexed preferredOutcome, address indexed whinger);

CampaignEscaped

CampaignEscaped, because a campaign is in an indeterminate state! The DAO may be needed to step in.

event CampaignEscaped(address indexed tradingAddr);

InfraMarketUpdated

event InfraMarketUpdated(address indexed old, address indexed new_);

Declared

Declare was called on a market in the infra market.

event Declared(address indexed trading, bytes8 indexed winningOutcome, address indexed feeRecipient);

LockupEnabled

event LockupEnabled(bool indexed status);

LockedUp

event LockedUp(uint256 indexed amount, address indexed recipient);

Withdrew

event Withdrew(uint256 indexed amount, address indexed recipient);

Slashed

event Slashed(address indexed victim, address indexed recipient, uint256 indexed slashedAmount);

Frozen

event Frozen(address indexed victim, uint64 indexed until);

Requested

Outstanding ticket requested by a user for SARP to resolve a market.

event Requested(address indexed trading, uint256 indexed ticket);

Concluded

A request from a submitter was appropriate and resulted in a non-indeterminate state. Refund the investor.

event Concluded(uint256 indexed ticket, bytes32 indexed justification);

IInfraMarket

Git Source

Functions

ctor

function ctor(address operator, address emergencyCouncil, address lockup, address lockedArbToken, address factory)
    external;

register

Register this campaign, taking a small stipend for management from the creator in the form of $3 fUSDC. Factory caller only.

function register(address trading, bytes32 desc, uint64 launchTs, uint64 callDeadlineTs) external returns (uint256);

Parameters

call

Call the outcome, changing the state to allow a user to disagree with it with the whinge function. Takes a $2 fUSDC bond.

function call(address tradingAddr, bytes8 winner, address incentiveRecipient) external returns (uint256);

Parameters

whinge

Whinge the outcome, indicating that the sender disagrees with the call decision that was made. This is only possible during a two day window. A $7 fUSDC must be taken from the user.

function whinge(address tradingAddr, bytes8 preferredOutcome, address bondRecipient) external returns (uint256);

Parameters

predict

Make a commitment as to what the preferred outcome should be, now that there's been calling and whinging. The voting power comes from the lockup contract, which takes ARB and locks it up for an amount of time that this trading should close.

function predict(address tradingAddr, bytes32 commit) external;

Parameters

curOutcomeVestedArb

Get the amount of vested ARB in a specific outcome produced by reveals up until now.

function curOutcomeVestedArb(address trading, bytes8 outcome) external view returns (uint256);

Parameters

epochNumber

Get the current epoch number for the trading contract given.

function epochNumber(address trading) external view returns (uint256 epochNo);

Parameters

whingerPreferredWinner

Get the preferred whinger of the infra market given.

function whingerPreferredWinner(address trading) external view returns (bytes8);

Parameters

callerPreferredOutcome

Get the caller preferred outcome of the infra market given.

function callerPreferredOutcome(address trading) external view returns (bytes8);

Parameters

reveal

Reveal a previously made commitment. Should be done in the revealing period (two days after the first whinge, for two days).

function reveal(address tradingAddr, address committerAddr, bytes8 outcome, uint256 seed) external;

Parameters

sweep

Sweep money from a bettor who bet incorrectly, or someone who neglected to reveal their commitment, who is assumed to be betting that the system is in an indeterminate state.

function sweep(address tradingAddr, uint256 epochNo, address victim, address feeRecipientAddr)
    external
    returns (uint256 yieldForFeeRecipient);

Parameters

capture

Capture amounts from the prize pool. Can only be done once, so be careful!

function capture(address tradingAddr, uint256 epochNo, address feeRecipient)
    external
    returns (uint256 yieldForFeeRecipient);

Parameters

close

Close this campaign if it's been in a state where anyone can whinge for some time, two days since someone whinged and no-one had whinged.

function close(address tradingAddr, address feeRecipient) external;

Parameters

escape

Escape a trading market that has gone over the limit. This calls the escape function in the trading contract to indicate something has gone wrong. This should only be callable if the contract is in the state for calling past the deadline.

function escape(address tradingAddr) external;

Parameters

winner

Winner that was declared for this infra market, if there is one.

function winner(address tradingAddr) external view returns (bytes8 winnerId);

status

Status of this trading contract's oracle.

function status(address tradingAddr) external view returns (InfraMarketState currentState, uint64 secsRemaining);

startTs

Starting timestamp of the campaign.

function startTs(address trading) external view returns (uint64);

endTs

Ending timestamp of the campaign.

function endTs(address trading) external view returns (uint64);

declare

Declare a winner, by providing the outcomes that were in use, along with a fee recipient to collect the fee for providing this correct calldata to.

function declare(address tradingAddr, bytes8[] calldata outcomes, address feeRecipient) external returns (uint256);

Parameters

enableContract

Enable or disable the contract.

function enableContract(bool status) external returns (bool);

Parameters

ILockup

Git Source

Functions

lockup

Lockup ARB to receive LARB.

function lockup(uint256 amount, address recipient) external returns (uint256);

Parameters

Returns

tokenAddr

Token address of LARB.

function tokenAddr() external view returns (address);

lockedUntil

Get the until locked time timestamp.

function lockedUntil(address spender) external view returns (uint64 timestamp);

Parameters

withdraw

Withdraw some LARB to ARB.

function withdraw(uint256 amount, address recipient) external returns (uint256);

Parameters

Returns

slash

Slash a user's entire position portfolio on request. only usable by InfraMarket. This can be called repeatedly safely without context. When this is used the user's amount before they started to lose funds is tracked to be drawn down.

function slash(address victim, uint256 amount, address recipient) external returns (uint256);

Parameters

Returns

freeze

freeze a user's position to prevent it from being taken until after this deadline. If the amount is already set, then we use the latest value. The infra market is responsible for a correct interaction here.

function freeze(address spender, uint64 until) external;

updateInfraMarket

function updateInfraMarket(address addr) external;

ILongtail

Git Source

Functions

createPool653F395E

function createPool653F395E(address pool, uint256 price, uint32 fee) external;

enablePool579DA658

function enablePool579DA658(address pool, bool enabled) external;

quote72E2ADE7

function quote72E2ADE7(address pool, bool zeroForOne, int256 amount, uint256 priceLimitX96) external;

swapIn32502CA71

function swapIn32502CA71(address _token, uint256 _amount, uint256 _minOut) external returns (int256, int256);

FactoryOutcome

Git Source

struct FactoryOutcome {
    bytes8 identifier;
    uint256 sqrtPrice;
    string name;
}

INineLivesFactory

Git Source

Functions

newTrading320E32E9

set up new trading contract, seeding the initial amounts

function newTrading320E32E9(
    FactoryOutcome[] memory outcomes,
    address oracle,
    uint64 timeStart,
    uint64 timeEnding,
    bytes32 documentation,
    address feeRecipient,
    uint64 feeCreator,
    uint64 feeLp,
    uint64 feeMinter,
    uint64 feeReferrer
) external returns (address tradingAddr);

Parameters

Returns

isModerationFeeEnabled

is the current fee that's taken for moderation reasons active?

function isModerationFeeEnabled() external view returns (bool);

getOwner

gets the owner address from the trading contract address

function getOwner(address addr) external view returns (address);

Parameters

getBackend

function getBackend(address addr) external view returns (uint8);

getTradingAddr

function getTradingAddr(bytes32 id) external view returns (address);

shareImpl

function shareImpl() external pure returns (address);

dpmTradingHash

return the keccak256 hash of the trading contract in DPM form.

function dpmTradingHash() external view returns (bytes32);

ammTradingHash

return the keccak256 hash of the trading contract in AMM form.

function ammTradingHash() external view returns (bytes32);

erc20Hash

return the keccak256 hash of the ERC20

function erc20Hash() external view returns (bytes32);

CtorArgs

Git Source

struct CtorArgs {
    bytes8[] outcomes;
    address oracle;
    uint64 timeStart;
    uint64 timeEnding;
    address feeRecipient;
    address shareImpl;
    bool shouldBufferTime;
    uint64 feeCreator;
    uint64 feeMinter;
    uint64 feeLp;
    uint64 feeReferrer;
}

Properties

INineLivesTrading

Git Source

Functions

ctor

ctor to set the values for this contract.

function ctor(CtorArgs calldata ctorArgs) external;

Parameters

oracle

oracle that's in use in this trading contract.

function oracle() external view returns (address);

mint8A059B6E

Mint some shares in exchange for fUSDC. Optionally branches to permit or a classic approval based on the deadline argument (if set to 0, assumes approval)

function mint8A059B6E(bytes8 outcome, uint256 value, address referrer, address recipient) external returns (uint256);

burn854CC96E

Burn some shares by inverting the AMM function using the fUSDC amount, or the shares, depending on the shouldEstimateShares argument. Returns the burned shares, and the fusdc returned.

function burn854CC96E(
    bytes8 outcome,
    uint256 amount,
    bool shouldEstimateShares,
    uint256 minShares,
    address referrer,
    address recipient
) external returns (uint256 burnedShares, uint256 fusdcReturned);

quoteC0E17FC7

Quote function for testing the amount that could be minted.

function quoteC0E17FC7(bytes8 outcome, uint256 fusdcValue) external returns (uint256 purchased, uint256 fees);

Parameters

estimateBurnE9B09A17

function estimateBurnE9B09A17(bytes8 outcome, uint256 shareAmount) external returns (uint256);

rescue276DD9AB

function rescue276DD9AB(address recipient) external returns (uint256);

claimLiquidity9C391F85

function claimLiquidity9C391F85(address recipient) external;

claimLpFees66980F36

function claimLpFees66980F36(address recipient) external;

addLiquidityA975D995

function addLiquidityA975D995(uint256 liquidity, address recipient) external returns (uint256 userLiquidity);

removeLiquidity3C857A15

function removeLiquidity3C857A15(uint256 liquidity, address recipient)
    external
    returns (uint256 fusdcAmount, uint256 lpFeesEarned);

claimAddressFeesB302CF6D

Claim fees owed to a specific address, perhaps after they've been doing referrals.

function claimAddressFeesB302CF6D(address recipient) external returns (uint256);

Parameters

priceA827ED27

Get the price of an outcome in fUSDC.

function priceA827ED27(bytes8 outcome) external returns (uint256);

Parameters

shutdown

Shutdown this contract by disabling associated pools. Compensates callers of this function by distributing them a small amount of token for doing so. This can only be called when the contract has exceeded its deadline.

function shutdown() external returns (uint256);

decide

Decide an outcome. Only callable by the oracle!

function decide(bytes8 outcome) external;

Parameters

payoffCB6F2565

Collect the payoff if holding winning shares!

function payoffCB6F2565(bytes8 outcomeId, uint256 amount, address recipient) external returns (uint256);

Parameters

details

Details that're available for this outcome.

function details(bytes8 outcomeId)
    external
    view
    returns (uint256 shares, uint256 invested, uint256 globalInvested, bytes8 winner);

Parameters

escape

function escape() external;

isDpm

is this trading contract running the DPM?

function isDpm() external view returns (bool);

globalShares

global shares minted.

function globalShares() external view returns (uint256);

invested

Invested amount of fusdc in the predicting pool.

function invested() external view returns (uint256);

timeEnding

function timeEnding() external view returns (uint64);

timeStart

function timeStart() external view returns (uint64);

shareAddr

get a share address using the identifier given instead of an online check.

function shareAddr(bytes8 outcomeId) external view returns (address);

version

function version() external pure returns (string memory);

fees62DAA154

fees currently set in the market. Scaled by FEE_SCALING.

function fees62DAA154() external view returns (Fees memory);

userLiquidityShares

function userLiquidityShares(address spender) external view returns (uint256);

Structs

UserLiqAdded

struct UserLiqAdded {
    bytes8 outcome;
    uint256 sharesReceived;
}

UserLiqRemoved

struct UserLiqRemoved {
    bytes8 outcome;
    uint256 sharesReceived;
}

Fees

struct Fees {
    uint256 feeCreator;
    uint256 feeMinter;
    uint256 feeLp;
    uint256 feeReferrer;
}

ITradingBeacon

Git Source

Functions

mint

function mint() external view returns (address);

quotes

function quotes() external view returns (address);

price

function price() external view returns (address);

extras

function extras() external view returns (address);

IWETH10

Git Source

Functions

deposit

function deposit() external payable;

InfraMarketState

Git Source

enum InfraMarketState {
    Callable,
    Closable,
    Whinging,
    Predicting,
    Revealing,
    Declarable,
    Sweeping,
    Closed
}

LPHelper

Git Source

LPHelper is a simple contract that facilitates LPing multiple trading addresses at once. It can be combined with an off-chain measurement of trading fees and information on popularity to be used.

IERC20

Git Source

Functions

balanceOf

function balanceOf(address) external view returns (uint256);

LensesV1

Git Source

State Variables

LONGTAIL

ILongtail public immutable LONGTAIL;

FACTORY

INineLivesFactory public immutable FACTORY;

Functions

constructor

constructor(ILongtail _longtail, INineLivesFactory _factory);

getLongtailQuote

function getLongtailQuote(address _pool, bool _zeroForOne, int256 _amount, uint256 _priceLimit)
    external
    returns (string memory data);

getShareAddr

function getShareAddr(INineLivesFactory _factory, bytes32 _hash, address _tradingAddr, bytes8 _outcomeId)
    public
    pure
    returns (address shareAddr);

balancesWithFactoryAndHash

function balancesWithFactoryAndHash(
    INineLivesFactory _factory,
    bytes32 _hash,
    address _tradingAddr,
    bytes32[] calldata _words,
    address _spender
) external view returns (uint256[] memory bals);

LockupToken

Git Source

Inherits: Initializable, ERC20Upgradeable, ERC20BurnableUpgradeable, OwnableUpgradeable, ERC20PermitUpgradeable, ERC20VotesUpgradeable

Functions

constructor

Note: oz-upgrades-unsafe-allow: constructor

constructor();

ctor

function ctor(address initialOwner) public initializer;

mint

function mint(address to, uint256 amount) public onlyOwner;

burn

function burn(address to, uint256 amount) public onlyOwner;

clock

function clock() public view override returns (uint48);

CLOCK_MODE

function CLOCK_MODE() public pure override returns (string memory);

_update

function _update(address from, address to, uint256 value) internal override(ERC20Upgradeable, ERC20VotesUpgradeable);

delegate

function delegate(address) public pure override;

delegateBySig

function delegateBySig(address, uint256, uint256, uint8, bytes32, bytes32) public pure override;

nonces

function nonces(address owner) public view override(ERC20PermitUpgradeable, NoncesUpgradeable) returns (uint256);

NinelivesCash

Git Source

Inherits: Initializable, ERC20Upgradeable, OwnableUpgradeable, ERC20PermitUpgradeable

State Variables

debt

mapping(address => uint256) public debt;

Functions

constructor

Note: oz-upgrades-unsafe-allow: constructor

constructor();

initialize

function initialize(address initialOwner) public initializer;

mint

function mint(address to, uint256 amount) public onlyOwner;

NinelivesLockedARB

Git Source

Inherits: Initializable, ERC20Upgradeable, ERC20BurnableUpgradeable, OwnableUpgradeable, ERC20PermitUpgradeable, ERC20VotesUpgradeable

Functions

constructor

Note: oz-upgrades-unsafe-allow: constructor

constructor();

ctor

function ctor(address initialOwner) public initializer;

mint

function mint(address to, uint256 amount) public onlyOwner;

clock

function clock() public view override returns (uint48);

CLOCK_MODE

function CLOCK_MODE() public pure override returns (string memory);

_update

function _update(address from, address to, uint256 value) internal override(ERC20Upgradeable, ERC20VotesUpgradeable);

nonces

function nonces(address owner) public view override(ERC20PermitUpgradeable, NoncesUpgradeable) returns (uint256);

transfer

function transfer(address, uint256) public pure override returns (bool);

transferFrom

function transferFrom(address, address, uint256) public pure override returns (bool);

SARPSignaller

Git Source

Inherits: IEvents

SARPSignaller is a on-chain system with a bond that allows a user to formally request conclusion of a market with SARP. This is done so as an alternative to an off-chain system based on the conclusion of a market.

State Variables

tickets

mapping(uint256 => Ticket) public tickets;

ticketCount

uint256 private ticketCount;

feeCollection

uint256 public feeCollection;

SARP

address immutable SARP;

Functions

constructor

constructor(address _sarp);

request

Request a conclusion to a market using SARP, transferring the bond payment from the user to escrow here for redemption.

function request(address _trading, address _recipient) external;

conclude

Conclude a market if the outcome was not an indeterminate state by refunding the spender. In the calldata, it logs the receipt of the justification for its decision.

function conclude(uint256 _ticket, bytes32 _note) external;

Parameters

Structs

Ticket

struct Ticket {
    address addr;
}

Share

Git Source

Inherits: Initializable, ERC20Upgradeable, OwnableUpgradeable, ERC20PermitUpgradeable

State Variables

admin

address public admin;

Functions

constructor

constructor();

ctor

function ctor(string calldata name, address _admin) public initializer;

decimals

function decimals() public pure override returns (uint8);

mint

function mint(address to, uint256 amount) public onlyOwner;

burn

function burn(address owner, uint256 value) public onlyOwner;

TradingBeacon

Git Source

Inherits: ITradingBeacon

State Variables

admin

address public admin;

mint

address public mint;

quotes

address public quotes;

price

address public price;

extras

address public extras;

Functions

constructor

constructor(address _admin, address _mintImpl, address _quotesImpl, address _priceImpl, address _extrasImpl);

shutdown

shutdown the contract by preventing it from servicing any delegatecalls. This is useful in an emergency context.

function shutdown() external;

changeAdmin

function changeAdmin(address _oldAdmin, address _newAdmin) external;

upgradeMint

function upgradeMint(address _oldImpl, address _newImpl) external;

upgradeQuotes

function upgradeQuotes(address _oldImpl, address _newImpl) external;

upgradePrice

function upgradePrice(address _oldImpl, address _newImpl) external;

upgradeExtras

function upgradeExtras(address _oldImpl, address _newImpl) external;

Events

NewAdmin

event NewAdmin(address indexed newAdmin);

UpgradedMint

event UpgradedMint(address indexed impl);

UpgradedQuotes

event UpgradedQuotes(address indexed impl);

UpgradedPrice

event UpgradedPrice(address indexed price);

UpgradedExtras

event UpgradedExtras(address indexed extras);

StorageSlot

Git Source

Functions

getAddressSlot

function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r);

Structs

AddressSlot

struct AddressSlot {
    address value;
}

TradingBeaconProxy

Git Source

This is only useful for a very limited context, which is a limited run "blessed" deployment that's inaccessible using the normal path of addressing trading deployments. This could be useful for experimental releases that need upgradeability. The beacon also has a custom feature to disable the running, useful for an experimental release.

State Variables

BEACON

ITradingBeacon immutable BEACON;

Functions

constructor

constructor(ITradingBeacon _impl);

indicateProxy

indicateProxy is an optional function to indicate the beacon address.

Let's hope we don't have a signature collision here.

function indicateProxy() external;

fallback

fallback() external;

Constants

Git Source

SLOT_BEACON

bytes32 constant SLOT_BEACON = bytes32(uint256(keccak256("eip1967.proxy.beacon")) - 1);

TradingBeaconProxyDeployHelperFactory

Git Source

State Variables

BEACON

ITradingBeacon public immutable BEACON;

IMPL

TradingBeaconProxy immutable IMPL;

Functions

constructor

constructor(address _admin, address _mint, address _quotes, address _price, address _extras);

clone

function clone(address _impl, bytes memory _args) public returns (address instance);

create

function create(CreateArgs calldata _a) external returns (INineLivesTrading);

Events

DeploymentCompleted

event DeploymentCompleted(ITradingBeacon indexed beacon, TradingBeaconProxy indexed impl);

Structs

CreateArgs

struct CreateArgs {
    bytes8[] outcomes;
    address oracle;
    uint64 timeStart;
    uint64 timeEnding;
    address feeRecipient;
    address shareImpl;
    bool shouldBufferTime;
    uint64 feeCreator;
    uint64 feeMinter;
    uint64 feeLp;
    uint64 feeReferrer;
}

IProxy

Git Source

Functions

upgradeAndCall

function upgradeAndCall(address, address, bytes memory) external;

TwoProxyAdmin

Git Source

State Variables

admin

address public admin;

Functions

constructor

constructor(address _admin);

transferOwnership

function transferOwnership(address _newAdmin) external;

upgrade

function upgrade(address _proxy, address _impl1, address _impl2, bytes memory _data) external;

Events

TransferOwnership

event TransferOwnership(address old, address new_);

IBeacon

Git Source

Functions

mintAddr

function mintAddr(bool isDpm) external view returns (address);

quotesAddr

function quotesAddr(bool isDpm) external view returns (address);

priceAddr

function priceAddr(bool isDpm) external view returns (address);

extrasAddr

function extrasAddr(bool isDpm) external view returns (address);

UpgradeableFourBeaconProxy

Git Source

State Variables

BEACON

IBeacon immutable BEACON;

IS_DPM

bool immutable IS_DPM;

Functions

constructor

constructor(IBeacon _b, bool _d);

directDelegate

function directDelegate(address to) internal;

fallback

fallback() external;

StorageSlot

Git Source

Functions

getAddressSlot

function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r);

Structs

AddressSlot

struct AddressSlot {
    address value;
}

UpgradeableTwoProxy

Git Source

UpgradeableTwoProxy is a proxy that does delegation based on the 3rd byte of the signature used in the message received to the contract.

State Variables

admin_

address private immutable admin_;

Functions

constructor

constructor(address _admin, address _impl1, address _impl2, bytes memory _data);

fallback

fallback() external;

Events

Upgraded1

event Upgraded1(address impl);

Upgraded2

event Upgraded2(address impl);

AdminChanged

event AdminChanged(address previousAdmin, address newAdmin);

Constants

Git Source

ADMIN_SLOT

bytes32 constant ADMIN_SLOT = bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1);

IMPL_1_SLOT

bytes32 constant IMPL_1_SLOT = bytes32(uint256(keccak256("eip1967.proxy.implementation.1")) - 1);

IMPL_2_SLOT

bytes32 constant IMPL_2_SLOT = bytes32(uint256(keccak256("eip1967.proxy.implementation.2")) - 1);

WordPackingLib

Git Source

Functions

pack

function pack(bytes8 word1, bytes8 word2, bytes8 word3, bytes8 word4) external pure returns (bytes32 word);

unpack

function unpack(bytes32 word) external pure returns (bytes8, bytes8, bytes8, bytes8);