9Lives

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.

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

This table is a helpful reference for the types of errors the contracts might produce. To generate these, run ./print-error-table.sh.

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;

AiCreationDetails

Git Source

struct AiCreationDetails {
    FactoryOutcome[] outcomes;
    uint64 timeEnding;
    bytes32 documentation;
    address feeRecipient;
    uint64 feeCreator;
    uint64 feeLp;
    uint64 feeMinter;
}

BuyHelper

Git Source

State Variables

FACTORY

INineLivesFactory immutable FACTORY;

LONGTAIL

ILongtail immutable LONGTAIL;

FUSDC

IERC20 immutable FUSDC;

WETH

IWETH10 immutable WETH;

HELPER

HelperFactory immutable HELPER;

Functions

constructor

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

_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(bytes32 _id, uint256 _fusdc, bytes8 _outcome, uint256 _minShareOut) internal returns (uint256);

_swapInAsset

function _swapInAsset(address _asset, uint256 _amount) internal returns (uint256);

mint

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

mintSetupAI

function mintSetupAI(
    AiCreationDetails calldata d,
    IERC20 _asset,
    bytes8 _outcome,
    uint256 _minShareOut,
    uint256 _amount
) external payable returns (uint256);

IERC20

Git Source

Functions

transferFrom

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

approve

function approve(address recipient, uint256 amount) external;

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)
    external
    payable
    returns (uint256);

burn

function burn(address _tradingAddr, bytes8 _outcome, uint256 _maxShareOut, uint256 _minShareOut, uint256 _fusdcAmt)
    external
    returns (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);

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;

CreationDetails

Git Source

struct CreationDetails {
    FactoryOutcome[] outcomes;
    uint64 timeEnding;
    bytes32 documentation;
    address feeRecipient;
    uint64 feeCreator;
    uint64 feeLp;
    uint64 feeMinter;
}

HelperFactory

Git Source

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

function create(
    address oracle,
    FactoryOutcome[] calldata outcomes,
    uint64 timeEnding,
    bytes32 documentation,
    address feeRecipient,
    uint64 feeCreator,
    uint64 feeLp,
    uint64 feeMinter
) internal returns (address);

createWithInfraMarket

Create with the Infra Market, transferring the amount needed for the oracle, as well as the Trading contract itself.

function createWithInfraMarket(
    FactoryOutcome[] calldata outcomes,
    uint64 timeEnding,
    bytes32 documentation,
    address feeRecipient,
    uint64 feeCreator,
    uint64 feeLp,
    uint64 feeMinter
) public returns (address tradingAddr);

createWithInfraMarketPermit

function createWithInfraMarketPermit(CreationDetails calldata d, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
    external
    returns (address tradingAddr);

createWithBeautyContest

function createWithBeautyContest(
    FactoryOutcome[] calldata outcomes,
    uint64 timeEnding,
    bytes32 documentation,
    address feeRecipient,
    uint64 feeCreator,
    uint64 feeLp,
    uint64 feeMinter
) public returns (address tradingAddr);

createWithBeautyContestPermit

function createWithBeautyContestPermit(CreationDetails calldata d, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
    external
    returns (address tradingAddr);

createWithAI

function createWithAI(
    FactoryOutcome[] calldata outcomes,
    uint64 timeEnding,
    bytes32 documentation,
    address feeRecipient,
    uint64 feeCreator,
    uint64 feeLp,
    uint64 feeMinter
) public returns (address tradingAddr);

createWithAIPermit

function createWithAIPermit(CreationDetails calldata d, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
    external
    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(
    address oracle,
    FactoryOutcome[] calldata outcomes,
    uint64 timeEnding,
    bytes32 documentation,
    address feeRecipient,
    uint64 feeCreator,
    uint64 feeLp,
    uint64 feeMinter
) public returns (address tradingAddr);

createWithCustomPermit

Read the developer comment for createWithCustom.

function createWithCustomPermit(
    CreationDetails calldata d,
    address oracle,
    uint256 deadline,
    uint8 v,
    bytes32 r,
    bytes32 s
) 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);

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

newTrading90C25562

set up new trading contract, seeding the initial amounts

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

Parameters

Returns

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

INineLivesTrading

Git Source

Functions

ctor

ctor to set the values for this contract.

function ctor(
    bytes8[] memory outcomes,
    address oracle,
    uint64 timeStart,
    uint64 timeEnding,
    address feeRecipient,
    address shareImpl,
    bool shouldBufferTime,
    uint64 feeCreator,
    uint64 feeMinter,
    uint64 feeLp
) external;

Parameters

oracle

oracle that's in use in this trading contract.

function oracle() external view returns (address);

mintPermitE90275AB

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 mintPermitE90275AB(
    bytes8 outcome,
    uint256 value,
    address recipient,
    uint256 deadline,
    uint8 v,
    bytes32 r,
    bytes32 s
) external returns (uint256);

burnPermit7045A604

Burn some shares by inverting the AMM function using the fUSDC amount.

function burnPermit7045A604(bytes8 outcome, uint256 fusdcAmount, address recipient) external returns (uint256);

quoteC0E17FC7

Quote function for testing the amount that could be minted.

function quoteC0E17FC7(bytes8 outcome, uint256 value) 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

payoff91FA8C2E

Collect the payoff if holding winning shares!

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

Parameters

payoffQuote1FA6DC28

Return the amount that would be earned if payoff was used under normal circumstances.

function payoffQuote1FA6DC28(bytes8 outcomeId, uint256 amount) external view 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 betting 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);

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(address _tradingAddr, bytes8 _outcomeId) public view returns (address shareAddr);

balances

function balances(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);

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

We do this to protect the user from being distracted by other tokens.

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;

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_);

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