Premia - Next-Generation Options AMM

https://premia.finance

Deployments

Development

Install dependencies via Yarn:

yarn install

Setup Husky to format code on commit:

yarn postinstall

Create a .env file with the following values defined:

Testing

Test contracts via Forge:

forge test -vv

Generate a code coverage report using Forge:

forge coverage

Generate a HTML code coverage report using Forge :

forge coverage --report lcov && genhtml lcov.info --branch-coverage --output-dir coverage

Deployment

Contracts deployment is done through Hardhat. Available networks : arbitrum, arbitrumNova, goerli, arbitrumGoerli

hardhat run ./scripts/deploy/0000-baseLayer.ts --network goerli

Contracts upgrade

Example to upgrade pools implementation on goerli network :

hardhat run ./scripts/upgrade/0000-pools.ts --network goerli

Other upgrades scripts are available in ./scripts/upgrade to upgrade different components of the protocol.

Docker

To run the code in developer mode using docker, start by building the docker image:

docker build -t premia-v3 .

Then run the docker container by using the command:

MacOS/Linux

docker run -it -u=$(id -u $USER):$(id -g $USER) \
           -v $PWD:/src \
           premia-v3

Windows

docker run -it -v %CD%:/src premia-v3

Upon executing, you will have access to the command line inside the container and will be able to run the commands for forge and hardhat.

Licensing

TBD

Contents

• chainlink
• FeedRegistry
• FeedRegistryStorage
• IFeedRegistry
• IOracleAdapter
• IPriceRepository
• OracleAdapter
• PriceRepository
• PriceRepositoryStorage
• Tokens
• Tokens constants

Contents

• ChainlinkAdapter
• ChainlinkAdapterStorage
• IChainlinkAdapter

ChainlinkAdapter

Git Source

Inherits: IChainlinkAdapter, FeedRegistry, OracleAdapter, PriceRepository

This oracle adapter will attempt to use all available feeds to determine prices between pairs

State Variables

STALE_PRICE_THRESHOLD

If the difference between target and last update is greater than the STALE_PRICE_THRESHOLD, the price is considered stale

uint256 internal constant STALE_PRICE_THRESHOLD = 25 hours;

Functions

constructor

constructor(address _wrappedNativeToken, address _wrappedBTCToken)
    FeedRegistry(_wrappedNativeToken, _wrappedBTCToken);

isPairSupported

Returns whether the pair has already been added to the adapter and if it supports the path required for the pair (true, true): Pair is fully supported (false, true): Pair is not supported, but can be added (false, false): Pair cannot be supported

tokenA and tokenB may be passed in either tokenA/tokenB or tokenB/tokenA order

function isPairSupported(address tokenA, address tokenB) external view returns (bool isCached, bool hasPath);

Parameters

Returns

upsertPair

Stores or updates the given token pair data provider configuration. This function will let the adapter take some actions to configure the pair, in preparation for future quotes. Can be called many times in order to let the adapter re-configure for a new context

function upsertPair(address tokenA, address tokenB) external nonReentrant;

Parameters

getPrice

Returns the most recent price for the given token pair

function getPrice(address tokenIn, address tokenOut) external view returns (UD60x18);

Parameters

Returns

getPriceAt

Returns the price closest to target for the given token pair

function getPriceAt(address tokenIn, address tokenOut, uint256 target) external view returns (UD60x18);

Parameters

Returns

_getPriceAt

Returns a price based on the pricing path between tokenIn and tokenOut

function _getPriceAt(address tokenIn, address tokenOut, uint256 target) internal view returns (UD60x18);

describePricingPath

Describes the pricing path used to convert the token to ETH

function describePricingPath(address token)
    external
    view
    returns (AdapterType adapterType, address[][] memory path, uint8[] memory decimals);

Parameters

Returns

pricingPath

Returns the pricing path that will be used when quoting the given pair

tokenA and tokenB may be passed in either tokenA/tokenB or tokenB/tokenA order

function pricingPath(address tokenA, address tokenB) external view returns (PricingPath);

Parameters

Returns

batchRegisterFeedMappings

Registers mappings of ERC20 token, and denomination (ETH, BTC, or USD) to feed

function batchRegisterFeedMappings(FeedMappingArgs[] memory args)
    external
    override(FeedRegistry, IFeedRegistry)
    onlyOwner;

Parameters

setTokenPriceAt

Set the price of token denominated in denomination at the given timestamp

function setTokenPriceAt(address token, address denomination, uint256 timestamp, UD60x18 price)
    external
    override(PriceRepository, IPriceRepository)
    nonReentrant;

Parameters

_pricingPath

Returns the pricing path between tokenA and tokenB and the mapped tokens (unsorted)

function _pricingPath(address tokenA, address tokenB)
    internal
    view
    returns (PricingPath path, address mappedTokenA, address mappedTokenB);

_getDirectPrice

Returns the price of tokenIn denominated in tokenOut when the pair is either ETH/USD, token/ETH or token/USD

function _getDirectPrice(PricingPath path, address tokenIn, address tokenOut, uint256 target)
    internal
    view
    returns (UD60x18);

_getPriceSameDenomination

Returns the price of tokenIn denominated in tokenOut when both tokens share the same token denomination (either ETH or USD)

function _getPriceSameDenomination(PricingPath path, address tokenIn, address tokenOut, uint256 target)
    internal
    view
    returns (UD60x18);

_getPriceDifferentDenomination

Returns the price of tokenIn denominated in tokenOut when one of the tokens uses ETH as the denomination, and the other USD

function _getPriceDifferentDenomination(PricingPath path, address tokenIn, address tokenOut, uint256 target)
    internal
    view
    returns (UD60x18);

_getPriceWBTCPrice

Returns the price of tokenIn denominated in tokenOut when the pair is token/WBTC

function _getPriceWBTCPrice(address tokenIn, address tokenOut, uint256 target) internal view returns (UD60x18);

_determinePricingPath

Returns the pricing path between tokenA and tokenB

function _determinePricingPath(address tokenA, address tokenB) internal view virtual returns (PricingPath);

_tryToFindPath

Attempts to find the best pricing path for token based on the conversionType, if a feed exists

function _tryToFindPath(
    address token,
    ConversionType conversionType,
    PricingPath preferredPath,
    PricingPath fallbackPath
) internal view returns (PricingPath);

_fetchPrice

Returns the latest price of token denominated in denomination, if target is 0, otherwise we algorithmically search for a price which meets our criteria

function _fetchPrice(address token, address denomination, uint256 target, int8 factor)
    internal
    view
    returns (uint256);

_fetchLatestPrice

Returns the latest price of token denominated in denomination

function _fetchLatestPrice(address token, address denomination) internal view returns (uint256);

_fetchPriceAt

Returns the price of token denominated in denomination at or left of target. If the price left of target is stale, we revert and wait until a price override is set.

function _fetchPriceAt(address token, address denomination, uint256 target, int8 factor)
    internal
    view
    returns (uint256);

_performBinarySearchForRoundData

Performs a binary search to find the round data closest to the target timestamp

function _performBinarySearchForRoundData(
    BinarySearchDataInternal memory binarySearchData,
    address feed,
    uint16 phaseId,
    uint64 nextAggregatorRoundId,
    uint256 target
) internal view returns (BinarySearchDataInternal memory);

_latestRoundData

Try/Catch wrapper for Chainlink aggregator's latestRoundData() function

function _latestRoundData(address feed) internal view returns (uint80, int256, uint256, uint256, uint80);

_getRoundData

Try/Catch wrapper for Chainlink aggregator's getRoundData() function

function _getRoundData(address feed, uint80 roundId) internal view returns (uint80, int256, uint256, uint256, uint80);

_aggregator

Returns the Chainlink aggregator for token / denomination

function _aggregator(address token, address denomination) internal view returns (address[] memory aggregator);

_aggregatorDecimals

Returns decimals for aggregator

function _aggregatorDecimals(address aggregator) internal view returns (uint8);

_getPriceAgainstUSD

Returns the scaled price of token denominated in USD at target

function _getPriceAgainstUSD(address token, uint256 target) internal view returns (UD60x18);

_getPriceAgainstETH

Returns the scaled price of token denominated in ETH at target

function _getPriceAgainstETH(address token, uint256 target) internal view returns (UD60x18);

_getETHUSD

Returns the scaled price of ETH denominated in USD at target

function _getETHUSD(uint256 target) internal view returns (UD60x18);

_getBTCUSD

Returns the scaled price of BTC denominated in USD at target

function _getBTCUSD(uint256 target) internal view returns (UD60x18);

_getWBTCBTC

Returns the scaled price of WBTC denominated in BTC at target

function _getWBTCBTC(uint256 target) internal view returns (UD60x18);

_revertIfPriceLeftOfTargetStale

Revert if the difference between target and updateAt is greater than STALE_PRICE_THRESHOLD

function _revertIfPriceLeftOfTargetStale(uint256 updatedAt, uint256 target) internal pure;

_revertIfInvalidDenomination

Revert if denomination is not a valid

function _revertIfInvalidDenomination(address denomination) internal pure;

ChainlinkAdapterStorage

Git Source

State Variables

STORAGE_SLOT

bytes32 internal constant STORAGE_SLOT = keccak256("premia.contracts.storage.ChainlinkAdapter");

Functions

layout

function layout() internal pure returns (Layout storage l);

formatRoundId

function formatRoundId(uint16 phaseId, uint64 aggregatorRoundId) internal pure returns (uint80);

parseRoundId

function parseRoundId(uint256 roundId) internal pure returns (uint16 phaseId, uint64 aggregatorRoundId);

isUSD

function isUSD(address token) internal pure returns (bool);

isBTC

function isBTC(address token) internal pure returns (bool);

isETH

function isETH(address token) internal pure returns (bool);

Structs

Layout

struct Layout {
    mapping(bytes32 key => IChainlinkAdapter.PricingPath) pricingPath;
    mapping(address token => EnumerableSet.AddressSet tokens) pairedTokens;
}

IChainlinkAdapter

Git Source

Inherits: IOracleAdapter, IFeedRegistry, IPriceRepository

Functions

pricingPath

Returns the pricing path that will be used when quoting the given pair

tokenA and tokenB may be passed in either tokenA/tokenB or tokenB/tokenA order

function pricingPath(address tokenA, address tokenB) external view returns (PricingPath);

Parameters

Returns

Events

UpdatedPathForPair

Emitted when the adapter updates the pricing path for a pair

event UpdatedPathForPair(address tokenA, address tokenB, PricingPath path);

Parameters

Errors

ChainlinkAdapter__GetRoundDataCallReverted

Thrown when the getRoundData call reverts without a reason

error ChainlinkAdapter__GetRoundDataCallReverted(bytes data);

ChainlinkAdapter__InvalidDenomination

Thrown when the denomination is invalid

error ChainlinkAdapter__InvalidDenomination(address denomination);

ChainlinkAdapter__LatestRoundDataCallReverted

Thrown when the lastRoundData call reverts without a reason

error ChainlinkAdapter__LatestRoundDataCallReverted(bytes data);

ChainlinkAdapter__PriceAtOrLeftOfTargetNotFound

Thrown when a price at or to the left of target is not found

error ChainlinkAdapter__PriceAtOrLeftOfTargetNotFound(address token, address denomination, uint256 target);

ChainlinkAdapter__PriceLeftOfTargetStale

Thrown when price left of target is stale

error ChainlinkAdapter__PriceLeftOfTargetStale(uint256 updatedAt, uint256 target);

Structs

BinarySearchDataInternal

struct BinarySearchDataInternal {
    int256 leftPrice;
    uint256 leftUpdatedAt;
    int256 rightPrice;
    uint256 rightUpdatedAt;
}

Enums

PricingPath

The path that will be used to calculate quotes for a given pair

enum PricingPath {
    NONE,
    ETH_USD,
    TOKEN_USD,
    TOKEN_ETH,
    TOKEN_USD_TOKEN,
    TOKEN_ETH_TOKEN,
    A_USD_ETH_B,
    A_ETH_USD_B,
    TOKEN_USD_BTC_WBTC
}

ConversionType

The conversion type used when determining the token pair pricing path

enum ConversionType {
    TO_BTC,
    TO_USD,
    TO_ETH,
    TO_USD_TO_TOKEN,
    TO_ETH_TO_TOKEN
}

FeedRegistry

Git Source

Inherits: IFeedRegistry

State Variables

WRAPPED_NATIVE_TOKEN

address internal immutable WRAPPED_NATIVE_TOKEN;

WRAPPED_BTC_TOKEN

address internal immutable WRAPPED_BTC_TOKEN;

Functions

constructor

constructor(address _wrappedNativeToken, address _wrappedBTCToken);

batchRegisterFeedMappings

Registers mappings of ERC20 token, and denomination (ETH, BTC, or USD) to feed

function batchRegisterFeedMappings(FeedMappingArgs[] memory args) external virtual;

Parameters

feed

Returns the feed for token and denomination

function feed(address token, address denomination) external view returns (address);

Parameters

Returns

_feed

Returns the feed for token and denomination

function _feed(address token, address denomination) internal view returns (address);

_feedExists

Returns true if a feed exists for token and denomination

function _feedExists(address token, address denomination) internal view returns (bool);

_tokenToDenomination

Returns the denomination mapped to token, if it has one

Should only map wrapped tokens which are guaranteed to have a 1:1 ratio

function _tokenToDenomination(address token) internal view returns (address);

_mapToDenominationAndSort

Returns the sorted and mapped tokens for tokenA and tokenB

function _mapToDenominationAndSort(address tokenA, address tokenB) internal view returns (address, address);

_mapToDenomination

Returns the mapped tokens for tokenA and tokenB

function _mapToDenomination(address tokenA, address tokenB)
    internal
    view
    returns (address mappedTokenA, address mappedTokenB);

FeedRegistryStorage

Git Source

State Variables

STORAGE_SLOT

bytes32 internal constant STORAGE_SLOT = keccak256("premia.contracts.storage.FeedRegistry");

Functions

layout

function layout() internal pure returns (Layout storage l);

Structs

Layout

struct Layout {
    mapping(bytes32 key => address feed) feeds;
}

IFeedRegistry

Git Source

Functions

batchRegisterFeedMappings

Registers mappings of ERC20 token, and denomination (ETH, BTC, or USD) to feed

function batchRegisterFeedMappings(FeedMappingArgs[] memory args) external;

Parameters

feed

Returns the feed for token and denomination

function feed(address token, address denomination) external view returns (address);

Parameters

Returns

Events

FeedMappingsRegistered

Emitted when new price feed mappings are registered

event FeedMappingsRegistered(FeedMappingArgs[] args);

Parameters

Structs

FeedMappingArgs

struct FeedMappingArgs {
    address token;
    address denomination;
    address feed;
}

IOracleAdapter

Git Source

Functions

isPairSupported

Returns whether the pair has already been added to the adapter and if it supports the path required for the pair (true, true): Pair is fully supported (false, true): Pair is not supported, but can be added (false, false): Pair cannot be supported

tokenA and tokenB may be passed in either tokenA/tokenB or tokenB/tokenA order

function isPairSupported(address tokenA, address tokenB) external view returns (bool isCached, bool hasPath);

Parameters

Returns

upsertPair

Stores or updates the given token pair data provider configuration. This function will let the adapter take some actions to configure the pair, in preparation for future quotes. Can be called many times in order to let the adapter re-configure for a new context

function upsertPair(address tokenA, address tokenB) external;

Parameters

getPrice

Returns the most recent price for the given token pair

function getPrice(address tokenIn, address tokenOut) external view returns (UD60x18);

Parameters

Returns

getPriceAt

Returns the price closest to target for the given token pair

function getPriceAt(address tokenIn, address tokenOut, uint256 target) external view returns (UD60x18);

Parameters

Returns

describePricingPath

Describes the pricing path used to convert the token to ETH

function describePricingPath(address token)
    external
    view
    returns (AdapterType adapterType, address[][] memory path, uint8[] memory decimals);

Parameters

Returns

Errors

OracleAdapter__ArrayCannotExpand

Thrown when attempting to increase array size

error OracleAdapter__ArrayCannotExpand(uint256 arrayLength, uint256 size);

OracleAdapter__InvalidTarget

Thrown when the target is zero or before the current block timestamp

error OracleAdapter__InvalidTarget(uint256 target, uint256 blockTimestamp);

OracleAdapter__InvalidPrice

Thrown when the price is non-positive

error OracleAdapter__InvalidPrice(int256 price);

OracleAdapter__PairCannotBeSupported

Thrown when trying to add support for a pair that cannot be supported

error OracleAdapter__PairCannotBeSupported(address tokenA, address tokenB);

OracleAdapter__PairNotSupported

Thrown when trying to execute a quote with a pair that isn't supported

error OracleAdapter__PairNotSupported(address tokenA, address tokenB);

OracleAdapter__TokensAreSame

Thrown when trying to add pair where addresses are the same

error OracleAdapter__TokensAreSame(address tokenA, address tokenB);

OracleAdapter__ZeroAddress

Thrown when one of the parameters is a zero address

error OracleAdapter__ZeroAddress();

Enums

AdapterType

The type of adapter

enum AdapterType {
    None,
    Chainlink
}

IPriceRepository

Git Source

Functions

setTokenPriceAt

Set the price of token denominated in denomination at the given timestamp

function setTokenPriceAt(address token, address denomination, uint256 timestamp, UD60x18 price) external;

Parameters

Events

PriceUpdate

event PriceUpdate(address indexed token, address indexed denomination, uint256 timestamp, UD60x18 price);

OracleAdapter

Git Source

Inherits: IOracleAdapter

Functions

_scale

Scales amount by factor

function _scale(uint256 amount, int8 factor) internal pure returns (uint256);

_revertIfTargetInvalid

Revert if target is zero or after block.timestamp

function _revertIfTargetInvalid(uint256 target) internal view;

_revertIfPriceInvalid

Revert if price is zero or negative

function _revertIfPriceInvalid(int256 price) internal pure;

_revertIfTokensAreSame

Revert if tokenA has same address as tokenB

function _revertIfTokensAreSame(address tokenA, address tokenB) internal pure;

_revertIfZeroAddress

Revert if tokenA or tokenB are null addresses

function _revertIfZeroAddress(address tokenA, address tokenB) internal pure;

PriceRepository

Git Source

Inherits: IPriceRepository, ReentrancyGuard, RelayerAccessManager

Functions

setTokenPriceAt

Set the price of token denominated in denomination at the given timestamp

function setTokenPriceAt(address token, address denomination, uint256 timestamp, UD60x18 price) external virtual;

Parameters

_getTokenPriceAt

Returns the price of token denominated in denomination at a given timestamp, if zero, a price has not been recorded

function _getTokenPriceAt(address token, address denomination, uint256 timestamp)
    internal
    view
    returns (UD60x18 price);

PriceRepositoryStorage

Git Source

State Variables

STORAGE_SLOT

bytes32 internal constant STORAGE_SLOT = keccak256("premia.contracts.storage.PriceRepository");

Functions

layout

function layout() internal pure returns (Layout storage l);

Structs

Layout

struct Layout {
    mapping(address token => mapping(address denomination => mapping(uint256 timestamp => UD60x18 price))) prices;
}

Tokens

Git Source

Functions

keyForUnsortedPair

Returns the key for the unsorted tokenA and tokenB

function keyForUnsortedPair(address tokenA, address tokenB) internal pure returns (bytes32);

keyForSortedPair

Returns the key for the sorted tokenA and tokenB

function keyForSortedPair(address tokenA, address tokenB) internal pure returns (bytes32);

sortTokens

Returns the sorted tokenA and tokenB, where sortedA < sortedB

function sortTokens(address tokenA, address tokenB) internal pure returns (address sortedA, address sortedB);

Constants

Git Source

FOREX_DECIMALS

uint8 constant FOREX_DECIMALS = 8;

ETH_DECIMALS

uint8 constant ETH_DECIMALS = 18;

Contents

• IPoolFactory
• IPoolFactoryDeployer
• IPoolFactoryEvents
• PoolFactory
• PoolFactoryDeployer
• PoolFactoryProxy
• PoolFactoryStorage

IPoolFactory

Git Source

Inherits: IPoolFactoryEvents

Functions

isPool

Returns whether the given address is a pool

function isPool(address contractAddress) external view returns (bool);

Parameters

Returns

getPoolAddress

Returns the address of a valid pool, and whether it has been deployed. If the pool configuration is invalid the transaction will revert.

function getPoolAddress(PoolKey calldata k) external view returns (address pool, bool isDeployed);

Parameters

Returns

deployPool

Deploy a new option pool

function deployPool(PoolKey calldata k) external payable returns (address poolAddress);

Parameters

Returns

initializationFee

DEPRECATED: Calculates the initialization fee for a pool

function initializationFee(PoolKey calldata k) external view returns (UD60x18);

Parameters

Returns

Errors

PoolFactory__IdenticalAddresses

error PoolFactory__IdenticalAddresses();

PoolFactory__OptionExpired

error PoolFactory__OptionExpired(uint256 maturity);

PoolFactory__OptionMaturityExceedsMax

error PoolFactory__OptionMaturityExceedsMax(uint256 maturity);

PoolFactory__OptionMaturityNot8UTC

error PoolFactory__OptionMaturityNot8UTC(uint256 maturity);

PoolFactory__OptionMaturityNotFriday

error PoolFactory__OptionMaturityNotFriday(uint256 maturity);

PoolFactory__OptionMaturityNotLastFriday

error PoolFactory__OptionMaturityNotLastFriday(uint256 maturity);

PoolFactory__OptionStrikeEqualsZero

error PoolFactory__OptionStrikeEqualsZero();

PoolFactory__OptionStrikeInvalid

error PoolFactory__OptionStrikeInvalid(UD60x18 strike, UD60x18 strikeInterval);

PoolFactory__PoolAlreadyDeployed

error PoolFactory__PoolAlreadyDeployed(address poolAddress);

PoolFactory__TransferNativeTokenFailed

error PoolFactory__TransferNativeTokenFailed();

PoolFactory__ZeroAddress

error PoolFactory__ZeroAddress();

Structs

PoolKey

struct PoolKey {
    address base;
    address quote;
    address oracleAdapter;
    UD60x18 strike;
    uint256 maturity;
    bool isCallPool;
}

IPoolFactoryDeployer

Git Source

Functions

deployPool

Deploy a new option pool

function deployPool(IPoolFactory.PoolKey calldata k) external returns (address poolAddress);

Parameters

Returns

calculatePoolAddress

Calculate the deterministic address deployment of a pool

function calculatePoolAddress(IPoolFactory.PoolKey calldata k) external view returns (address);

Errors

PoolFactoryDeployer__NotPoolFactory

error PoolFactoryDeployer__NotPoolFactory(address caller);

IPoolFactoryEvents

Git Source

Events

PoolDeployed

event PoolDeployed(
    address indexed base,
    address indexed quote,
    address oracleAdapter,
    UD60x18 strike,
    uint256 maturity,
    bool isCallPool,
    address poolAddress
);

PricingPath

event PricingPath(
    address pool,
    address[][] basePath,
    uint8[] basePathDecimals,
    IOracleAdapter.AdapterType baseAdapterType,
    address[][] quotePath,
    uint8[] quotePathDecimals,
    IOracleAdapter.AdapterType quoteAdapterType
);

PoolFactory

Git Source

Inherits: IPoolFactory, OwnableInternal, ReentrancyGuard

State Variables

DIAMOND

address internal immutable DIAMOND;

POOL_FACTORY_DEPLOYER

address internal immutable POOL_FACTORY_DEPLOYER;

Functions

constructor

constructor(address diamond, address poolFactoryDeployer);

isPool

Returns whether the given address is a pool

function isPool(address contractAddress) external view returns (bool);

Parameters

Returns

getPoolAddress

Returns the address of a valid pool, and whether it has been deployed. If the pool configuration is invalid the transaction will revert.

function getPoolAddress(PoolKey calldata k) external view returns (address pool, bool isDeployed);

Parameters

Returns

_getPoolAddress

Returns the address of a pool using the encoded poolKey

function _getPoolAddress(bytes32 poolKey) internal view returns (address);

deployPool

Deploy a new option pool

function deployPool(PoolKey calldata k) external payable nonReentrant returns (address poolAddress);

Parameters

Returns

initializationFee

DEPRECATED: Calculates the initialization fee for a pool

function initializationFee(IPoolFactory.PoolKey calldata k) public pure returns (UD60x18);

Parameters

Returns

_safeTransferNativeToken

Safely transfer native token to the given address

function _safeTransferNativeToken(address to, uint256 amount) internal;

_revertIfAddressInvalid

Revert if the base and quote are identical or if the base, quote, or oracle adapter are zero

function _revertIfAddressInvalid(PoolKey calldata k) internal pure;

_revertIfOptionStrikeInvalid

Revert if the strike price is not a multiple of the strike interval

function _revertIfOptionStrikeInvalid(UD60x18 strike) internal pure;

_revertIfOptionMaturityInvalid

Revert if the maturity is invalid

function _revertIfOptionMaturityInvalid(uint256 maturity) internal view;

PoolFactoryDeployer

Git Source

Inherits: IPoolFactoryDeployer, ReentrancyGuard

State Variables

DIAMOND

address public immutable DIAMOND;

POOL_FACTORY

address public immutable POOL_FACTORY;

Functions

constructor

constructor(address diamond, address poolFactory);

deployPool

Deploy a new option pool

function deployPool(IPoolFactory.PoolKey calldata k) external nonReentrant returns (address poolAddress);

Parameters

Returns

calculatePoolAddress

Calculate the deterministic address deployment of a pool

function calculatePoolAddress(IPoolFactory.PoolKey calldata k) external view returns (address);

_encodePoolProxyArgs

Returns the encoded arguments for the pool proxy using pool key k

function _encodePoolProxyArgs(IPoolFactory.PoolKey calldata k) internal view returns (bytes memory);

_revertIfNotPoolFactory

function _revertIfNotPoolFactory(address caller) internal view;

PoolFactoryProxy

Git Source

Inherits: ProxyUpgradeableOwnable

Functions

constructor

constructor(address implementation) ProxyUpgradeableOwnable(implementation);

PoolFactoryStorage

Git Source

State Variables

STORAGE_SLOT

bytes32 internal constant STORAGE_SLOT = keccak256("premia.contracts.storage.PoolFactory");

Functions

layout

function layout() internal pure returns (Layout storage l);

poolKey

Returns the encoded pool key using the pool key k

function poolKey(IPoolFactory.PoolKey memory k) internal pure returns (bytes32);

strikeKey

Returns the encoded strike key using the pool key k

function strikeKey(IPoolFactory.PoolKey memory k) internal pure returns (bytes32);

maturityKey

Returns the encoded maturity key using the pool key k

function maturityKey(IPoolFactory.PoolKey memory k) internal pure returns (bytes32);

Structs

Layout

struct Layout {
    mapping(bytes32 key => address pool) pools;
    mapping(address pool => bool) isPool;
    mapping(bytes32 key => uint256 count) __deprecated_strikeCount;
    mapping(bytes32 key => uint256 count) __deprecated_maturityCount;
    UD60x18 __deprecated_discountPerPool;
    address __deprecated_feeReceiver;
}

Contents

• interfaces
• lzApp
• token
• util

Contents

• ILayerZeroEndpoint
• ILayerZeroReceiver
• ILayerZeroUserApplicationConfig

ILayerZeroEndpoint

Git Source

Inherits: ILayerZeroUserApplicationConfig

Functions

send

Send a LayerZero message to the specified address at a LayerZero endpoint.

function send(
    uint16 dstChainId,
    bytes calldata destination,
    bytes calldata payload,
    address payable refundAddress,
    address zroPaymentAddress,
    bytes calldata adapterParams
) external payable;

Parameters

receivePayload

Used by the messaging library to publish verified payload

function receivePayload(
    uint16 srcChainId,
    bytes calldata srcAddress,
    address dstAddress,
    uint64 nonce,
    uint256 gasLimit,
    bytes calldata payload
) external;

Parameters

getInboundNonce

Get the inboundNonce of a lzApp from a source chain which could be EVM or non-EVM chain

function getInboundNonce(uint16 srcChainId, bytes calldata srcAddress) external view returns (uint64);

Parameters

getOutboundNonce

Get the outboundNonce from this source chain which, consequently, is always an EVM

function getOutboundNonce(uint16 dstChainId, address srcAddress) external view returns (uint64);

Parameters

estimateFees

Gets a quote in source native gas, for the amount that send() requires to pay for message delivery

function estimateFees(
    uint16 dstChainId,
    address userApplication,
    bytes calldata payload,
    bool payInZRO,
    bytes calldata adapterParam
) external view returns (uint256 nativeFee, uint256 zroFee);

Parameters

getChainId

get this Endpoint's immutable source identifier

function getChainId() external view returns (uint16);

retryPayload

The interface to retry failed message on this Endpoint destination

function retryPayload(uint16 srcChainId, bytes calldata srcAddress, bytes calldata payload) external;

Parameters

hasStoredPayload

Query if any STORED payload (message blocking) at the endpoint.

function hasStoredPayload(uint16 srcChainId, bytes calldata srcAddress) external view returns (bool);

Parameters

getSendLibraryAddress

Query if the libraryAddress is valid for sending msgs.

function getSendLibraryAddress(address userApplication) external view returns (address);

Parameters

getReceiveLibraryAddress

Query if the libraryAddress is valid for receiving msgs.

function getReceiveLibraryAddress(address userApplication) external view returns (address);

Parameters

isSendingPayload

Query if the non-reentrancy guard for send() is on

function isSendingPayload() external view returns (bool);

Returns

isReceivingPayload

Query if the non-reentrancy guard for receive() is on

function isReceivingPayload() external view returns (bool);

Returns

getConfig

Get the configuration of the LayerZero messaging library of the specified version

function getConfig(uint16 version, uint16 chainId, address userApplication, uint256 configType)
    external
    view
    returns (bytes memory);

Parameters

getSendVersion

Get the send() LayerZero messaging library version

function getSendVersion(address userApplication) external view returns (uint16);

Parameters

getReceiveVersion

Get the lzReceive() LayerZero messaging library version

function getReceiveVersion(address userApplication) external view returns (uint16);

Parameters

ILayerZeroReceiver

Git Source

Functions

lzReceive

LayerZero endpoint will invoke this function to deliver the message on the destination

function lzReceive(uint16 srcChainId, bytes calldata srcAddress, uint64 nonce, bytes calldata payload) external;

Parameters

ILayerZeroUserApplicationConfig

Git Source

Functions

setConfig

Set the configuration of the LayerZero messaging library of the specified version

function setConfig(uint16 version, uint16 chainId, uint256 configType, bytes calldata config) external;

Parameters

setSendVersion

Set the send() LayerZero messaging library version to version

function setSendVersion(uint16 version) external;

Parameters

setReceiveVersion

Set the lzReceive() LayerZero messaging library version to version

function setReceiveVersion(uint16 version) external;

Parameters

forceResumeReceive

Only when the UA needs to resume the message flow in blocking mode and clear the stored payload

function forceResumeReceive(uint16 srcChainId, bytes calldata srcAddress) external;

Parameters

Contents

• LzApp
• LzAppStorage
• NonblockingLzApp
• NonblockingLzAppStorage

LzApp

Git Source

Inherits: OwnableInternal, ILayerZeroReceiver, ILayerZeroUserApplicationConfig

State Variables

lzEndpoint

ILayerZeroEndpoint public immutable lzEndpoint;

Functions

constructor

constructor(address endpoint);

lzReceive

LayerZero endpoint will invoke this function to deliver the message on the destination

function lzReceive(uint16 srcChainId, bytes memory srcAddress, uint64 nonce, bytes memory payload) public virtual;

Parameters

_blockingLzReceive

function _blockingLzReceive(uint16 srcChainId, bytes memory srcAddress, uint64 nonce, bytes memory payload)
    internal
    virtual;

_lzSend

function _lzSend(
    uint16 dstChainId,
    bytes memory payload,
    address payable refundAddress,
    address zroPaymentAddress,
    bytes memory adapterParams,
    uint256 nativeFee
) internal virtual;

getConfig

function getConfig(uint16 version, uint16 chainId, address, uint256 configType) external view returns (bytes memory);

setConfig

Set the configuration of the LayerZero messaging library of the specified version

function setConfig(uint16 version, uint16 chainId, uint256 configType, bytes calldata config) external onlyOwner;

Parameters

setSendVersion

Set the send() LayerZero messaging library version to version

function setSendVersion(uint16 version) external onlyOwner;

Parameters

setReceiveVersion

Set the lzReceive() LayerZero messaging library version to version

function setReceiveVersion(uint16 version) external onlyOwner;

Parameters

forceResumeReceive

Only when the UA needs to resume the message flow in blocking mode and clear the stored payload

function forceResumeReceive(uint16 srcChainId, bytes calldata srcAddress) external onlyOwner;

Parameters

setTrustedRemoteAddress

function setTrustedRemoteAddress(uint16 remoteChainId, bytes calldata remoteAddress) external onlyOwner;

getTrustedRemoteAddress

function getTrustedRemoteAddress(uint16 _remoteChainId) external view returns (bytes memory);

isTrustedRemote

function isTrustedRemote(uint16 srcChainId, bytes memory srcAddress) external view returns (bool);

_isTrustedRemote

function _isTrustedRemote(uint16 srcChainId, bytes memory srcAddress) internal view returns (bool);

Events

SetTrustedRemoteAddress

event SetTrustedRemoteAddress(uint16 _remoteChainId, bytes _remoteAddress);

Errors

LzApp__InvalidEndpointCaller

error LzApp__InvalidEndpointCaller();

LzApp__InvalidSource

error LzApp__InvalidSource();

LzApp__NotTrustedSource

error LzApp__NotTrustedSource();

LzApp__NoTrustedPathRecord

error LzApp__NoTrustedPathRecord();

LzAppStorage

Git Source

State Variables

STORAGE_SLOT

bytes32 internal constant STORAGE_SLOT = keccak256("premia.contracts.storage.LzApp");

Functions

layout

function layout() internal pure returns (Layout storage l);

Structs

Layout

struct Layout {
    mapping(uint16 => bytes) trustedRemote;
    address precrime;
}

NonblockingLzApp

Git Source

Inherits: LzApp

Functions

constructor

constructor(address endpoint) LzApp(endpoint);

_blockingLzReceive

function _blockingLzReceive(uint16 srcChainId, bytes memory srcAddress, uint64 nonce, bytes memory payload)
    internal
    virtual
    override;

nonblockingLzReceive

function nonblockingLzReceive(uint16 srcChainId, bytes memory srcAddress, uint64 nonce, bytes memory payload)
    public
    virtual;

_nonblockingLzReceive

function _nonblockingLzReceive(uint16 srcChainId, bytes memory srcAddress, uint64 nonce, bytes memory payload)
    internal
    virtual;

retryMessage

function retryMessage(uint16 srcChainId, bytes memory srcAddress, uint64 nonce, bytes memory payload)
    public
    payable
    virtual;

failedMessages

function failedMessages(uint16 srcChainId, bytes memory srcAddress, uint64 nonce) external view returns (bytes32);

Events

MessageFailed

event MessageFailed(uint16 srcChainId, bytes srcAddress, uint64 nonce, bytes payload, bytes reason);

RetryMessageSuccess

event RetryMessageSuccess(uint16 srcChainId, bytes srcAddress, uint64 nonce, bytes32 payloadHash);

Errors

NonblockingLzApp__CallerNotLzApp

error NonblockingLzApp__CallerNotLzApp();

NonblockingLzApp__InvalidPayload

error NonblockingLzApp__InvalidPayload();

NonblockingLzApp__NoStoredMessage

error NonblockingLzApp__NoStoredMessage();

NonblockingLzAppStorage

Git Source

State Variables

STORAGE_SLOT

bytes32 internal constant STORAGE_SLOT = keccak256("premia.contracts.storage.NonblockingLzApp");

Functions

layout

function layout() internal pure returns (Layout storage l);

Structs

Layout

struct Layout {
    mapping(uint16 => mapping(bytes => mapping(uint64 => bytes32))) failedMessages;
}

Contents

• oft

Contents

• IOFT
• IOFTCore
• OFT
• OFTCore
• OFTCoreStorage
• OFTProxy

IOFT

Git Source

Inherits: IOFTCore, ISolidStateERC20

Interface of the OFT standard

Errors

OFT_InsufficientAllowance

error OFT_InsufficientAllowance();

IOFTCore

Git Source

Inherits: IERC165

Interface of the IOFT core standard

Functions

estimateSendFee

Estimate send token tokenId to (dstChainId, toAddress)

function estimateSendFee(
    uint16 dstChainId,
    bytes calldata toAddress,
    uint256 amount,
    bool useZro,
    bytes calldata adapterParams
) external view returns (uint256 nativeFee, uint256 zroFee);

Parameters

sendFrom

Send amount amount of token to (dstChainId, toAddress) from from

function sendFrom(
    address from,
    uint16 dstChainId,
    bytes calldata toAddress,
    uint256 amount,
    address payable refundAddress,
    address zroPaymentAddress,
    bytes calldata adapterParams
) external payable;

Parameters

circulatingSupply

Returns the circulating amount of tokens on current chain

function circulatingSupply() external view returns (uint256);

Events

SendToChain

Emitted when amount tokens are moved from the sender to (dstChainId, toAddress)

event SendToChain(address indexed sender, uint16 indexed dstChainId, bytes indexed toAddress, uint256 amount);

ReceiveFromChain

Emitted when amount tokens are received from srcChainId into the toAddress on the local chain.

event ReceiveFromChain(uint16 indexed srcChainId, bytes indexed srcAddress, address indexed toAddress, uint256 amount);

SetUseCustomAdapterParams

event SetUseCustomAdapterParams(bool _useCustomAdapterParams);

OFT

Git Source

Inherits: OFTCore, SolidStateERC20, IOFT

Functions

constructor

constructor(address lzEndpoint) OFTCore(lzEndpoint);

circulatingSupply

function circulatingSupply() public view virtual override returns (uint256);

_debitFrom

function _debitFrom(address from, uint16, bytes memory, uint256 amount) internal virtual override;

_creditTo

function _creditTo(uint16, address toAddress, uint256 amount) internal virtual override;

OFTCore

Git Source

Inherits: NonblockingLzApp, ERC165Base, IOFTCore

State Variables

PT_SEND

uint16 public constant PT_SEND = 0;

Functions

constructor

constructor(address lzEndpoint) NonblockingLzApp(lzEndpoint);

estimateSendFee

function estimateSendFee(
    uint16 dstChainId,
    bytes memory toAddress,
    uint256 amount,
    bool useZro,
    bytes memory adapterParams
) public view virtual override returns (uint256 nativeFee, uint256 zroFee);

sendFrom

function sendFrom(
    address from,
    uint16 dstChainId,
    bytes memory toAddress,
    uint256 amount,
    address payable refundAddress,
    address zroPaymentAddress,
    bytes memory adapterParams
) public payable virtual override;

_nonblockingLzReceive

function _nonblockingLzReceive(uint16 srcChainId, bytes memory srcAddress, uint64 nonce, bytes memory payload)
    internal
    virtual
    override;

_send

function _send(
    address from,
    uint16 dstChainId,
    bytes memory toAddress,
    uint256 amount,
    address payable refundAddress,
    address zroPaymentAddress,
    bytes memory adapterParams
) internal virtual;

_sendAck

function _sendAck(uint16 srcChainId, bytes memory, uint64, bytes memory payload) internal virtual;

_debitFrom

function _debitFrom(address from, uint16 dstChainId, bytes memory toAddress, uint256 amount) internal virtual;

_creditTo

function _creditTo(uint16 srcChainId, address toAddress, uint256 amount) internal virtual;

OFTCoreStorage

Git Source

State Variables

STORAGE_SLOT

bytes32 internal constant STORAGE_SLOT = keccak256("premia.contracts.storage.OFTCore");

Functions

layout

function layout() internal pure returns (Layout storage l);

Structs

Layout

struct Layout {
    bool useCustomAdapterParams;
}

OFTProxy

Git Source

Inherits: ProxyUpgradeableOwnable, ERC165BaseInternal

Functions

constructor

constructor(address implementation) ProxyUpgradeableOwnable(implementation);

Contents

• BytesLib
• ExcessivelySafeCall

BytesLib

Git Source

Author: Gonçalo Sá [email protected]

Bytes tightly packed arrays utility library for ethereum contracts written in Solidity. The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.

Functions

concat

function concat(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bytes memory);

concatStorage

function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal;

slice

function slice(bytes memory _bytes, uint256 _start, uint256 _length) internal pure returns (bytes memory);

toAddress

function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address);

toUint8

function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8);

toUint16

function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16);

toUint32

function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32);

toUint64

function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64);

toUint96

function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96);

toUint128

function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128);

toUint256

function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256);

toBytes32

function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32);

equal

function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool);

equalStorage

function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool);

Errors

BytesLib__Overflow

error BytesLib__Overflow();

BytesLib__OutOfBounds

error BytesLib__OutOfBounds();

ExcessivelySafeCall

Git Source

State Variables

LOW_28_MASK

uint256 constant LOW_28_MASK = 0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff;

Functions

excessivelySafeCall

Use when you really really really don't trust the called contract. This prevents the called contract from causing reversion of the caller in as many ways as we can.

The main difference between this and a solidity low-level call is that we limit the number of bytes that the callee can cause to be copied to caller memory. This prevents stupid things like malicious contracts returning 10,000,000 bytes causing a local OOG when copying to memory.

function excessivelySafeCall(address _target, uint256 _gas, uint16 _maxCopy, bytes memory _calldata)
    internal
    returns (bool, bytes memory);

Parameters

Returns

excessivelySafeStaticCall

Use when you really really really don't trust the called contract. This prevents the called contract from causing reversion of the caller in as many ways as we can.

The main difference between this and a solidity low-level call is that we limit the number of bytes that the callee can cause to be copied to caller memory. This prevents stupid things like malicious contracts returning 10,000,000 bytes causing a local OOG when copying to memory.

function excessivelySafeStaticCall(address _target, uint256 _gas, uint16 _maxCopy, bytes memory _calldata)
    internal
    view
    returns (bool, bytes memory);

Parameters

Returns

swapSelector

Swaps function selectors in encoded contract calls

Allows reuse of encoded calldata for functions with identical argument types but different names. It simply swaps out the first 4 bytes for the new selector. This function modifies memory in place, and should only be used with caution.

function swapSelector(bytes4 _newSelector, bytes memory _buf) internal pure;

Parameters

Contents

• ArrayUtils
• Constants
• DoublyLinkedListUD60x18
• EnumerableSetUD60x18
• IPosition
• IPricing
• OptionMath
• OptionMathExternal
• PRBMathExtra
• PoolName
• Position
• Pricing
• SD49x28
• SD49x28_Mul_InputTooSmall
• SD49x28_Mul_Overflow
• SD49x28_Div_InputTooSmall
• SD49x28_Div_Overflow
• SD49x28_IntoUD50x28_Underflow
• SD49x28_Abs_MinSD49x28
• avg
• wrap
• gt
• lshift
• sub
• isZero
• mod
• and
• abs
• add
• intoSD59x18
• and2
• sd49x28
• rshift
• gte
• lt
• not
• div
• uncheckedUnary
• or
• intoUD50x28
• unwrap
• xor
• neq
• mul
• uncheckedSub
• eq
• intoUD60x18
• lte
• uncheckedAdd
• unary
• SD49x28 constants
• UD50x28
• UD50x28_IntoSD49x28_Overflow
• uncheckedAdd
• gte
• wrap
• neq
• lte
• sub
• not
• xor
• uncheckedSub
• unwrap
• intoUD60x18
• lshift
• avg
• add
• gt
• and
• eq
• mod
• ud50x28
• mul
• or
• intoSD49x28
• rshift
• lt
• isZero
• div
• and2
• UD50x28 constants

ArrayUtils

Git Source

Functions

resizeArray

Resizes the array to size, reverts if size > array.length

It is not safe to increase array size this way

function resizeArray(uint8[] memory array, uint256 size) internal pure;

resizeArray

Resizes the array to size, reverts if size > array.length

It is not safe to increase array size this way

function resizeArray(uint256[] memory array, uint256 size) internal pure;

resizeArray

Resizes the array to size, reverts if size > array.length

It is not safe to increase array size this way

function resizeArray(address[] memory array, uint256 size) internal pure;

revertIfTryingToExpand

Reverts if trying to expand array size, as increasing array size through inline assembly is not safe

function revertIfTryingToExpand(uint256 currentLength, uint256 targetSize) internal pure;

Errors

ArrayUtils__ArrayCannotExpand

Thrown when attempting to increase array size

error ArrayUtils__ArrayCannotExpand(uint256 arrayLength, uint256 size);

Constants

Git Source

ZERO

UD60x18 constant ZERO = UD60x18.wrap(0);

ONE_HALF

UD60x18 constant ONE_HALF = UD60x18.wrap(0.5e18);

ONE

UD60x18 constant ONE = UD60x18.wrap(1e18);

TWO

UD60x18 constant TWO = UD60x18.wrap(2e18);

THREE

UD60x18 constant THREE = UD60x18.wrap(3e18);

FIVE

UD60x18 constant FIVE = UD60x18.wrap(5e18);

iZERO

SD59x18 constant iZERO = SD59x18.wrap(0);

iONE

SD59x18 constant iONE = SD59x18.wrap(1e18);

iTWO

SD59x18 constant iTWO = SD59x18.wrap(2e18);

iNINE

SD59x18 constant iNINE = SD59x18.wrap(9e18);

UD50_ZERO

UD50x28 constant UD50_ZERO = UD50x28.wrap(0);

UD50_ONE

UD50x28 constant UD50_ONE = UD50x28.wrap(1e28);

UD50_TWO

UD50x28 constant UD50_TWO = UD50x28.wrap(2e28);

SD49_ZERO

SD49x28 constant SD49_ZERO = SD49x28.wrap(0);

SD49_ONE

SD49x28 constant SD49_ONE = SD49x28.wrap(1e28);

SD49_TWO

SD49x28 constant SD49_TWO = SD49x28.wrap(2e28);

WAD

uint256 constant WAD = 1e18;

ONE_YEAR

uint256 constant ONE_YEAR = 365 days;

ONE_HOUR

uint256 constant ONE_HOUR = 1 hours;

DoublyLinkedListUD60x18

Git Source

Functions

contains

Returns true if the doubly linked list self contains the value

function contains(DoublyLinkedList.Bytes32List storage self, UD60x18 value) internal view returns (bool);

prev

Returns the stored element before value in the doubly linked list self

function prev(DoublyLinkedList.Bytes32List storage self, UD60x18 value) internal view returns (UD60x18);

next

Returns the stored element after value in the doubly linked list self

function next(DoublyLinkedList.Bytes32List storage self, UD60x18 value) internal view returns (UD60x18);

insertBefore

Returns true if newValue was successfully inserted before nextValue in the doubly linked list self

function insertBefore(DoublyLinkedList.Bytes32List storage self, UD60x18 nextValue, UD60x18 newValue)
    internal
    returns (bool status);

insertAfter

Returns true if newValue was successfully inserted after prevValue in the doubly linked list self

function insertAfter(DoublyLinkedList.Bytes32List storage self, UD60x18 prevValue, UD60x18 newValue)
    internal
    returns (bool status);

push

Returns true if value was successfully inserted at the end of the doubly linked list self

function push(DoublyLinkedList.Bytes32List storage self, UD60x18 value) internal returns (bool status);

pop

Removes the first element in the doubly linked list self, returns the removed element value

function pop(DoublyLinkedList.Bytes32List storage self) internal returns (UD60x18 value);

shift

Removes the last element in the doubly linked list self, returns the removed element value

function shift(DoublyLinkedList.Bytes32List storage self) internal returns (UD60x18 value);

unshift

Returns true if value was successfully inserted at the front of the doubly linked list self

function unshift(DoublyLinkedList.Bytes32List storage self, UD60x18 value) internal returns (bool status);

remove

Returns true if value was successfully removed from the doubly linked list self

function remove(DoublyLinkedList.Bytes32List storage self, UD60x18 value) internal returns (bool status);

replace

Returns true if oldValue was successfully replaced with newValue in the doubly linked list self

function replace(DoublyLinkedList.Bytes32List storage self, UD60x18 oldValue, UD60x18 newValue)
    internal
    returns (bool status);

EnumerableSetUD60x18

Git Source

Functions

at

Returns the element at a given index i in the enumerable set self

function at(EnumerableSet.Bytes32Set storage self, uint256 i) internal view returns (UD60x18);

contains

Returns true if the enumerable set self contains value

function contains(EnumerableSet.Bytes32Set storage self, UD60x18 value) internal view returns (bool);

indexOf

Returns the index of value in the enumerable set self

function indexOf(EnumerableSet.Bytes32Set storage self, UD60x18 value) internal view returns (uint256);

length

Returns the number of elements in the enumerable set self

function length(EnumerableSet.Bytes32Set storage self) internal view returns (uint256);

add

Returns true if value is added to the enumerable set self

function add(EnumerableSet.Bytes32Set storage self, UD60x18 value) internal returns (bool);

remove

Returns true if value is removed from the enumerable set self

function remove(EnumerableSet.Bytes32Set storage self, UD60x18 value) internal returns (bool);

toArray

Returns an array of all elements in the enumerable set self

function toArray(EnumerableSet.Bytes32Set storage self) internal view returns (UD60x18[] memory);

IPosition

Git Source

Errors

Position__InvalidOrderType

error Position__InvalidOrderType();

Position__InvalidPositionUpdate

error Position__InvalidPositionUpdate(UD60x18 currentBalance, SD59x18 amount);

Position__LowerGreaterOrEqualUpper

error Position__LowerGreaterOrEqualUpper(UD60x18 lower, UD60x18 upper);

IPricing

Git Source

Errors

Pricing__PriceCannotBeComputedWithinTickRange

error Pricing__PriceCannotBeComputedWithinTickRange();

Pricing__PriceOutOfRange

error Pricing__PriceOutOfRange(UD60x18 lower, UD60x18 upper, UD60x18 marketPrice);

Pricing__UpperNotGreaterThanLower

error Pricing__UpperNotGreaterThanLower(UD60x18 lower, UD60x18 upper);

OptionMath

Git Source

State Variables

ALPHA

SD59x18 internal constant ALPHA = SD59x18.wrap(-6.37309208e18);

LAMBDA

SD59x18 internal constant LAMBDA = SD59x18.wrap(-0.61228883e18);

S1

SD59x18 internal constant S1 = SD59x18.wrap(-0.11105481e18);

S2

SD59x18 internal constant S2 = SD59x18.wrap(0.44334159e18);

SQRT_2PI

int256 internal constant SQRT_2PI = 2_506628274631000502;

MIN_INPUT_PRICE

UD60x18 internal constant MIN_INPUT_PRICE = UD60x18.wrap(1e1);

MAX_INPUT_PRICE

UD60x18 internal constant MAX_INPUT_PRICE = UD60x18.wrap(1e34);

Functions

helperNormal

Helper function to evaluate used to compute the normal CDF approximation

function helperNormal(SD59x18 x) internal pure returns (SD59x18 result);

Parameters

Returns

normalCdf

Approximation of the normal CDF

The approximation implemented is based on the paper 'Accurate RMM-Based Approximations for the CDF of the Normal Distribution' by Haim Shore

function normalCdf(SD59x18 x) internal pure returns (SD59x18 result);

Parameters

Returns

normalPdf

Normal Distribution Probability Density Function.

Equal to Z(x) = (1 / σ√2π)e^( (-(x - µ)^2) / 2σ^2 ). Only computes pdf of a distribution with µ = 0 and σ = 1.

function normalPdf(SD59x18 x) internal pure returns (SD59x18 z);

Parameters

Returns

relu

Implementation of the ReLu function f(x)=(x)^+ to compute call / put payoffs

function relu(SD59x18 x) internal pure returns (UD60x18);

Parameters

Returns

d1d2

Returns the terms d1 and d2 from the Black-Scholes formula that are used to compute the price of a call / put option.

function d1d2(UD60x18 spot, UD60x18 strike, UD60x18 timeToMaturity, UD60x18 volAnnualized, UD60x18 riskFreeRate)
    internal
    pure
    returns (SD59x18 d1, SD59x18 d2);

Parameters

Returns

optionDelta

Calculate option delta

function optionDelta(
    UD60x18 spot,
    UD60x18 strike,
    UD60x18 timeToMaturity,
    UD60x18 volAnnualized,
    UD60x18 riskFreeRate,
    bool isCall
) internal pure returns (SD59x18);

Parameters

Returns

blackScholesPrice

Calculate the price of an option using the Black-Scholes model

this implementation assumes zero interest

function blackScholesPrice(
    UD60x18 spot,
    UD60x18 strike,
    UD60x18 timeToMaturity,
    UD60x18 volAnnualized,
    UD60x18 riskFreeRate,
    bool isCall
) internal pure returns (UD60x18);

Parameters

Returns

is8AMUTC

Returns true if the maturity time is 8AM UTC

function is8AMUTC(uint256 maturity) internal pure returns (bool);

Parameters

Returns

isFriday

Returns true if the maturity day is Friday

function isFriday(uint256 maturity) internal pure returns (bool);

Parameters

Returns

isLastFriday

Returns true if the maturity day is the last Friday of the month

function isLastFriday(uint256 maturity) internal pure returns (bool);

Parameters

Returns

calculateTimeToMaturity

Calculates the time to maturity in seconds

function calculateTimeToMaturity(uint256 maturity) internal view returns (uint256);

Parameters

Returns

calculateStrikeInterval

Calculates the strike interval for strike

function calculateStrikeInterval(UD60x18 strike) internal pure returns (UD60x18);

Parameters

Returns

roundToStrikeInterval

Rounds strike using the calculated strike interval

function roundToStrikeInterval(UD60x18 strike) internal pure returns (UD60x18);

Parameters

Returns

scaleDecimals

Converts a number with inputDecimals, to a number with given amount of decimals

function scaleDecimals(uint256 value, uint8 inputDecimals, uint8 targetDecimals) internal pure returns (uint256);

Parameters

Returns

scaleDecimals

Converts a number with inputDecimals, to a number with given amount of decimals

function scaleDecimals(int256 value, uint8 inputDecimals, uint8 targetDecimals) internal pure returns (int256);

Parameters

Returns

fromTokenDecimals

Converts a number with decimals, to a UD60x18 type

function fromTokenDecimals(uint256 value, uint8 decimals) internal pure returns (UD60x18);

Parameters

Returns

toTokenDecimals

Converts a UD60x18 number with decimals, to it's uint256 type scaled down.

function toTokenDecimals(UD60x18 value, uint8 decimals) internal pure returns (uint256);

Parameters

Returns

truncate

Truncates a UD60x18 number down to the correct precision.

function truncate(UD60x18 value, uint8 decimals) internal pure returns (UD60x18);

Parameters

Returns

log10Floor

Performs a naive log10 calculation on input returning the floor of the result

function log10Floor(uint256 input) internal pure returns (uint256 count);

computeCLevel

Calculates the C-level given a utilisation value and time since last trade value (duration). (https://www.desmos.com/calculator/0uzv50t7jy)

function computeCLevel(
    UD60x18 utilisation,
    UD60x18 duration,
    UD60x18 alpha,
    UD60x18 minCLevel,
    UD60x18 maxCLevel,
    UD60x18 decayRate
) internal pure returns (UD60x18);

Parameters

Returns

computeCLevelGeoMean

Calculates the geo-mean C-level given a utilisation before and after collateral is utilised.

function computeCLevelGeoMean(
    UD60x18 utilisationBefore,
    UD60x18 utilisationAfter,
    UD60x18 duration,
    UD60x18 alpha,
    UD60x18 minCLevel,
    UD60x18 maxCLevel,
    UD60x18 decayRate
) internal pure returns (UD60x18 cLevel);

Parameters

Returns

Errors

OptionMath__NonPositiveVol

error OptionMath__NonPositiveVol();

OptionMath__OutOfBoundsPrice

error OptionMath__OutOfBoundsPrice(UD60x18 min, UD60x18 max, UD60x18 price);

OptionMath__Underflow

error OptionMath__Underflow();

OptionMath__UtilisationOutOfBounds

error OptionMath__UtilisationOutOfBounds();

Structs

BlackScholesPriceVarsInternal

struct BlackScholesPriceVarsInternal {
    int256 discountFactor;
    int256 timeScaledVol;
    int256 timeScaledVar;
    int256 timeScaledRiskFreeRate;
}

OptionMathExternal

Git Source

Functions

optionDelta

Calculate option delta

function optionDelta(
    UD60x18 spot,
    UD60x18 strike,
    UD60x18 timeToMaturity,
    UD60x18 volAnnualized,
    UD60x18 riskFreeRate,
    bool isCall
) public pure returns (SD59x18);

Parameters

Returns

blackScholesPrice

Calculate the price of an option using the Black-Scholes model

this implementation assumes zero interest

function blackScholesPrice(
    UD60x18 spot,
    UD60x18 strike,
    UD60x18 timeToMaturity,
    UD60x18 volAnnualized,
    UD60x18 riskFreeRate,
    bool isCall
) public pure returns (UD60x18);

Parameters

Returns

computeCLevel

Calculates the C-level given a utilisation value and time since last trade value (duration). (https://www.desmos.com/calculator/0uzv50t7jy)

function computeCLevel(
    UD60x18 utilisation,
    UD60x18 duration,
    UD60x18 alpha,
    UD60x18 minCLevel,
    UD60x18 maxCLevel,
    UD60x18 decayRate
) public pure returns (UD60x18);

Parameters

Returns

computeCLevelGeoMean

Calculates the geo-mean C-level given a utilisation before and after collateral is utilised.

function computeCLevelGeoMean(
    UD60x18 utilisationBefore,
    UD60x18 utilisationAfter,
    UD60x18 duration,
    UD60x18 alpha,
    UD60x18 minCLevel,
    UD60x18 maxCLevel,
    UD60x18 decayRate
) public pure returns (UD60x18 cLevel);

Parameters

Returns

PRBMathExtra

Git Source

Functions

intoSD49x28

function intoSD49x28(SD59x18 x) internal pure returns (SD49x28 result);

intoUD50x28

function intoUD50x28(UD60x18 x) internal pure returns (UD50x28 result);

max

Returns the greater of two numbers a and b

function max(UD60x18 a, UD60x18 b) internal pure returns (UD60x18);

min

Returns the lesser of two numbers a and b

function min(UD60x18 a, UD60x18 b) internal pure returns (UD60x18);

max

Returns the greater of two numbers a and b

function max(SD59x18 a, SD59x18 b) internal pure returns (SD59x18);

min

Returns the lesser of two numbers a and b

function min(SD59x18 a, SD59x18 b) internal pure returns (SD59x18);

add

Returns the sum of a and b

function add(UD60x18 a, SD59x18 b) internal pure returns (UD60x18);

sub

Returns the difference of a and b

function sub(UD60x18 a, SD59x18 b) internal pure returns (UD60x18);

max

Returns the greater of two numbers a and b

function max(UD50x28 a, UD50x28 b) internal pure returns (UD50x28);

min

Returns the lesser of two numbers a and b

function min(UD50x28 a, UD50x28 b) internal pure returns (UD50x28);

max

Returns the greater of two numbers a and b

function max(SD49x28 a, SD49x28 b) internal pure returns (SD49x28);

min

Returns the lesser of two numbers a and b

function min(SD49x28 a, SD49x28 b) internal pure returns (SD49x28);

add

Returns the sum of a and b

function add(UD50x28 a, SD49x28 b) internal pure returns (UD50x28);

sub

Returns the difference of a and b

function sub(UD50x28 a, SD49x28 b) internal pure returns (UD50x28);

roundToNearestUD60x18

Rounds an UD50x28 to the nearest UD60x18

function roundToNearestUD60x18(UD50x28 value) internal pure returns (UD60x18 result);

Errors

SD59x18_IntoSD49x28_Overflow

error SD59x18_IntoSD49x28_Overflow(SD59x18 x);

UD60x18_IntoUD50x28_Overflow

error UD60x18_IntoUD50x28_Overflow(UD60x18 x);

PoolName

Git Source

Functions

name

Returns pool parameters as human-readable text

function name(address base, address quote, uint256 maturity, uint256 strike, bool isCallPool)
    internal
    view
    returns (string memory);

strikeToString

Converts the strike into a string

function strikeToString(uint256 strike) internal pure returns (string memory);

maturityToString

Converts the maturity into a string

function maturityToString(uint256 maturity) internal pure returns (string memory);

monthToString

Converts the month into a string

function monthToString(uint256 month) internal pure returns (string memory);

Position

Git Source

Keeps track of LP positions. Stores the lower and upper Ticks of a user's range order, and tracks the pro-rata exposure of the order.

Functions

keyHash

Returns the position key hash for self

function keyHash(Key memory self) internal pure returns (bytes32);

keyHash

Returns the position key hash for self

function keyHash(KeyInternal memory self) internal pure returns (bytes32);

toKeyInternal

Returns the internal position key for self

function toKeyInternal(Key memory self, UD60x18 strike, bool isCall) internal pure returns (KeyInternal memory);

Parameters

isShort

Returns true if the position orderType is short

function isShort(OrderType orderType) internal pure returns (bool);

isLong

Returns true if the position orderType is long

function isLong(OrderType orderType) internal pure returns (bool);

pieceWiseLinear

Returns the percentage by which the market price has passed through the lower and upper prices from left to right.

Usage:
CS order: f(x) defines the amount of shorts of a CS order holding one unit of liquidity.
LC order: (1 - f(x)) defines the amount of longs of a LC order holding one unit of liquidity.
Function definition:
case 1. f(x) = 0                                for x < lower
case 2. f(x) = (x - lower) / (upper - lower)    for lower <= x <= upper
case 3. f(x) = 1                                for x > upper

function pieceWiseLinear(KeyInternal memory self, UD50x28 price) internal pure returns (UD50x28);

pieceWiseQuadratic

Returns the amount of 'bid-side' collateral associated to a range order with one unit of liquidity.

Usage:
CS order: bid-side collateral defines the premiums generated from selling options.
LC order: bid-side collateral defines the collateral used to pay for buying long options.
Function definition:
case 1. f(x) = 0                                            for x < lower
case 2. f(x) = (price**2 - lower) / [2 * (upper - lower)]   for lower <= x <= upper
case 3. f(x) = (upper + lower) / 2                          for x > upper

function pieceWiseQuadratic(KeyInternal memory self, UD50x28 price) internal pure returns (UD50x28);

collateralToContracts

Converts _collateral to the amount of contracts normalized to 18 decimals

function collateralToContracts(UD60x18 _collateral, UD60x18 strike, bool isCall) internal pure returns (UD60x18);

Parameters

contractsToCollateral

Converts _contracts to the amount of collateral normalized to 18 decimals

WARNING: Decimals needs to be scaled before using this amount for collateral transfers

function contractsToCollateral(UD60x18 _contracts, UD60x18 strike, bool isCall) internal pure returns (UD60x18);

Parameters

collateralToContracts

Converts _collateral to the amount of contracts normalized to 28 decimals

function collateralToContracts(UD50x28 _collateral, UD60x18 strike, bool isCall) internal pure returns (UD50x28);

Parameters

contractsToCollateral

Converts _contracts to the amount of collateral normalized to 28 decimals

WARNING: Decimals needs to be scaled before using this amount for collateral transfers

function contractsToCollateral(UD50x28 _contracts, UD60x18 strike, bool isCall) internal pure returns (UD50x28);

Parameters

liquidityPerTick

Returns the per-tick liquidity phi (delta) for a specific position key self

function liquidityPerTick(KeyInternal memory self, UD60x18 size) internal pure returns (UD50x28);

Parameters

bid

Returns the bid collateral (18 decimals) either used to buy back options or revenue/ income generated from underwriting / selling options.

For a <= p <= b we have:
bid(p; a, b) = [ (p - a) / (b - a) ] * [ (a + p)  / 2 ]
= (p^2 - a^2) / [2 * (b - a)]

function bid(KeyInternal memory self, UD60x18 size, UD50x28 price) internal pure returns (UD60x18);

Parameters

collateral

Returns the total collateral (18 decimals) held by the position key self. Note that here we do not distinguish between ask- and bid-side collateral. This increases the capital efficiency of the range order

function collateral(KeyInternal memory self, UD60x18 size, UD50x28 price) internal pure returns (UD60x18 _collateral);

Parameters

contracts

Returns the total contracts (18 decimals) held by the position key self

function contracts(KeyInternal memory self, UD60x18 size, UD50x28 price) internal pure returns (UD60x18);

Parameters

long

Returns the number of long contracts (18 decimals) held in position self at current price

function long(KeyInternal memory self, UD60x18 size, UD50x28 price) internal pure returns (UD60x18);

Parameters

short

Returns the number of short contracts (18 decimals) held in position self at current price

function short(KeyInternal memory self, UD60x18 size, UD50x28 price) internal pure returns (UD60x18);

Parameters

calculatePositionUpdate

Calculate the update for the Position. Either increments them in case withdraw is False (i.e. in case there is a deposit) and otherwise decreases them. Returns the change in collateral, longs, shorts. These are transferred to (withdrawal)or transferred from (deposit) Position.operator.

function calculatePositionUpdate(KeyInternal memory self, UD60x18 currentBalance, SD59x18 amount, UD50x28 price)
    internal
    pure
    returns (Delta memory delta);

Parameters

Returns

revertIfLowerGreaterOrEqualUpper

Revert if lower is greater or equal to upper

function revertIfLowerGreaterOrEqualUpper(UD60x18 lower, UD60x18 upper) internal pure;

Structs

Key

struct Key {
    address owner;
    address operator;
    UD60x18 lower;
    UD60x18 upper;
    OrderType orderType;
}

KeyInternal

All the data used to calculate the key of the position

struct KeyInternal {
    address owner;
    address operator;
    UD60x18 lower;
    UD60x18 upper;
    OrderType orderType;
    bool isCall;
    UD60x18 strike;
}

Data

All the data required to be saved in storage

struct Data {
    SD49x28 lastFeeRate;
    UD60x18 claimableFees;
    uint256 lastDeposit;
}

Delta

struct Delta {
    SD59x18 collateral;
    SD59x18 longs;
    SD59x18 shorts;
}

Enums

OrderType

The order type of a position

enum OrderType {
    CSUP,
    CS,
    LC
}

Pricing

Git Source

This library implements the functions necessary for computing price movements within a tick range.

WARNING: This library should not be used for computations that span multiple ticks. Instead, the user should use the functions of this library to simplify computations for more complex price calculations.

Functions

proportion

Returns the percentage by which the market price has passed through the lower and upper prices from left to right. Reverts if the market price is not within the range of the lower and upper prices.

function proportion(UD60x18 lower, UD60x18 upper, UD50x28 marketPrice) internal pure returns (UD50x28);

proportion

Returns the percentage by which the market price has passed through the lower and upper prices from left to right. Reverts if the market price is not within the range of the lower and upper prices.

function proportion(Args memory args) internal pure returns (UD50x28);

amountOfTicksBetween

Find the number of ticks of an active tick range. Used to compute the aggregate, bid or ask liquidity either of the pool or the range order.

min_tick_distance = 0.01
lower = 0.01
upper = 0.03
num_ticks = 2
0.01               0.02               0.03
|xxxxxxxxxxxxxxxxxx|xxxxxxxxxxxxxxxxxx|
Then there are two active ticks, 0.01 and 0.02, within the active tick range.

function amountOfTicksBetween(UD60x18 lower, UD60x18 upper) internal pure returns (UD60x18);

amountOfTicksBetween

Returns the number of ticks between args.lower and args.upper

function amountOfTicksBetween(Args memory args) internal pure returns (UD60x18);

liquidity

Returns the liquidity between args.lower and args.upper

function liquidity(Args memory args) internal pure returns (UD60x18);

bidLiquidity

Returns the bid-side liquidity between args.lower and args.upper

function bidLiquidity(Args memory args) internal pure returns (UD60x18);

askLiquidity

Returns the ask-side liquidity between args.lower and args.upper

function askLiquidity(Args memory args) internal pure returns (UD60x18);

maxTradeSize

Returns the maximum trade size (askLiquidity or bidLiquidity depending on the TradeSide).

function maxTradeSize(Args memory args) internal pure returns (UD60x18);

price

Computes price reached from the current lower/upper tick after buying/selling trade_size amount of contracts

function price(Args memory args, UD60x18 tradeSize) internal pure returns (UD50x28);

nextPrice

Gets the next market price within a tick range after buying/selling tradeSize amount of contracts

function nextPrice(Args memory args, UD60x18 tradeSize) internal pure returns (UD50x28);

Structs

Args

struct Args {
    UD50x28 liquidityRate;
    UD50x28 marketPrice;
    UD60x18 lower;
    UD60x18 upper;
    bool isBuy;
}

SD49x28

Git Source

type SD49x28 is int256;

SD49x28_Mul_InputTooSmall

Git Source

error SD49x28_Mul_InputTooSmall();

SD49x28_Mul_Overflow

Git Source

error SD49x28_Mul_Overflow(SD49x28 x, SD49x28 y);

SD49x28_Div_InputTooSmall

Git Source

error SD49x28_Div_InputTooSmall();

SD49x28_Div_Overflow

Git Source

error SD49x28_Div_Overflow(SD49x28 x, SD49x28 y);

SD49x28_IntoUD50x28_Underflow

Git Source

error SD49x28_IntoUD50x28_Underflow(SD49x28 x);

SD49x28_Abs_MinSD49x28

Git Source

error SD49x28_Abs_MinSD49x28();

avg

Git Source

Calculates the arithmetic average of x and y.

*Notes:

• The result is rounded toward zero.*

function avg(SD49x28 x, SD49x28 y) pure returns (SD49x28 result);

Parameters

Returns

wrap

Git Source

Wraps a int256 number into the SD49x28 value type.

function wrap(int256 x) pure returns (SD49x28 result);

gt

Git Source

Implements the greater than operation (>) in the SD49x28 type.

function gt(SD49x28 x, SD49x28 y) pure returns (bool result);

lshift

Git Source

Implements the left shift operation (<<) in the SD49x28 type.

function lshift(SD49x28 x, uint256 bits) pure returns (SD49x28 result);

sub

Git Source

Implements the checked subtraction operation (-) in the SD49x28 type.

function sub(SD49x28 x, SD49x28 y) pure returns (SD49x28 result);

isZero

Git Source

Implements a zero comparison check function in the SD49x28 type.

function isZero(SD49x28 x) pure returns (bool result);

mod

Git Source

Implements the unchecked modulo operation (%) in the SD49x28 type.

function mod(SD49x28 x, SD49x28 y) pure returns (SD49x28 result);

and

Git Source

Implements the AND (&) bitwise operation in the SD49x28 type.

function and(SD49x28 x, int256 bits) pure returns (SD49x28 result);

abs

Git Source

Calculates the absolute value of x.

*Requirements:

• x must be greater than MIN_SD49x28.*

function abs(SD49x28 x) pure returns (SD49x28 result);

Parameters

add

Git Source

Implements the checked addition operation (+) in the SD49x28 type.

function add(SD49x28 x, SD49x28 y) pure returns (SD49x28 result);

intoSD59x18

Git Source

function intoSD59x18(SD49x28 x) pure returns (SD59x18 result);

and2

Git Source

Implements the AND (&) bitwise operation in the SD49x28 type.

function and2(SD49x28 x, SD49x28 y) pure returns (SD49x28 result);

sd49x28

Git Source

function sd49x28(int256 x) pure returns (SD49x28 result);

rshift

Git Source

Implements the right shift operation (>>) in the SD49x28 type.

function rshift(SD49x28 x, uint256 bits) pure returns (SD49x28 result);

gte

Git Source

Implements the greater than or equal to operation (>=) in the SD49x28 type.

function gte(SD49x28 x, SD49x28 y) pure returns (bool result);

lt

Git Source

Implements the lower than operation (<) in the SD49x28 type.

function lt(SD49x28 x, SD49x28 y) pure returns (bool result);

not

Git Source

Implements the NOT (~) bitwise operation in the SD49x28 type.

function not(SD49x28 x) pure returns (SD49x28 result);

div

Git Source

Divides two SD49x28 numbers, returning a new SD49x28 number.

*This is an extension of {Common.mulDiv} for signed numbers, which works by computing the signs and the absolute values separately. Notes:

• Refer to the notes in {Common.mulDiv}.
• The result is rounded toward zero. Requirements:
• Refer to the requirements in {Common.mulDiv}.
• None of the inputs can be MIN_SD49x28.
• The denominator must not be zero.
• The result must fit in SD49x28.*

function div(SD49x28 x, SD49x28 y) pure returns (SD49x28 result);

Parameters

uncheckedUnary

Git Source

Implements the unchecked unary minus operation (-) in the SD49x28 type.

function uncheckedUnary(SD49x28 x) pure returns (SD49x28 result);

or

Git Source

Implements the OR (|) bitwise operation in the SD49x28 type.

function or(SD49x28 x, SD49x28 y) pure returns (SD49x28 result);

intoUD50x28

Git Source

Casts an SD49x28 number into UD50x28.

*Requirements:

• x must be positive.*

function intoUD50x28(SD49x28 x) pure returns (UD50x28 result);

unwrap

Git Source

Unwraps a SD49x28 number into int256.

function unwrap(SD49x28 x) pure returns (int256 result);

xor

Git Source

Implements the XOR (^) bitwise operation in the SD49x28 type.

function xor(SD49x28 x, SD49x28 y) pure returns (SD49x28 result);

neq

Git Source

Implements the not equal operation (!=) in the SD49x28 type.

function neq(SD49x28 x, SD49x28 y) pure returns (bool result);

mul

Git Source

Multiplies two SD49x28 numbers together, returning a new SD49x28 number.

*Notes:

• Refer to the notes in {Common.mulDiv18}. Requirements:
• Refer to the requirements in {Common.mulDiv18}.
• None of the inputs can be MIN_SD49x28.
• The result must fit in SD49x28.*

function mul(SD49x28 x, SD49x28 y) pure returns (SD49x28 result);

Parameters

Returns

uncheckedSub

Git Source

Implements the unchecked subtraction operation (-) in the SD49x28 type.

function uncheckedSub(SD49x28 x, SD49x28 y) pure returns (SD49x28 result);

eq

Git Source

Implements the equal (=) operation in the SD49x28 type.

function eq(SD49x28 x, SD49x28 y) pure returns (bool result);

intoUD60x18

Git Source

function intoUD60x18(SD49x28 x) pure returns (UD60x18 result);

lte

Git Source

Implements the lower than or equal to operation (<=) in the SD49x28 type.

function lte(SD49x28 x, SD49x28 y) pure returns (bool result);

uncheckedAdd

Git Source

Implements the unchecked addition operation (+) in the SD49x28 type.

function uncheckedAdd(SD49x28 x, SD49x28 y) pure returns (SD49x28 result);

unary

Git Source

Implements the checked unary minus operation (-) in the SD49x28 type.

function unary(SD49x28 x) pure returns (SD49x28 result);

Constants

Git Source

uMAX_SD49x28

Max SD49x28 value

int256 constant uMAX_SD49x28 = type(int256).max;

uMIN_SD49x28

Min SD49x28 value

int256 constant uMIN_SD49x28 = type(int256).min;

uUNIT

The unit number, which gives the decimal precision of SD49x28.

int256 constant uUNIT = 1e28;

UNIT

SD49x28 constant UNIT = SD49x28.wrap(uUNIT);

SCALING_FACTOR

int256 constant SCALING_FACTOR = 1e10;

UD50x28

Git Source

type UD50x28 is uint256;

UD50x28_IntoSD49x28_Overflow

Git Source

error UD50x28_IntoSD49x28_Overflow(UD50x28 x);

uncheckedAdd

Git Source

Implements the unchecked addition operation (+) in the UD50x28 type.

function uncheckedAdd(UD50x28 x, UD50x28 y) pure returns (UD50x28 result);

gte

Git Source

Implements the greater than or equal to operation (>=) in the UD50x28 type.

function gte(UD50x28 x, UD50x28 y) pure returns (bool result);

wrap

Git Source

Wraps a uint256 number into the UD50x28 value type.

function wrap(uint256 x) pure returns (UD50x28 result);

neq

Git Source

Implements the not equal operation (!=) in the UD50x28 type.

function neq(UD50x28 x, UD50x28 y) pure returns (bool result);

lte

Git Source

Implements the lower than or equal to operation (<=) in the UD50x28 type.

function lte(UD50x28 x, UD50x28 y) pure returns (bool result);

sub

Git Source

Implements the checked subtraction operation (-) in the UD50x28 type.

function sub(UD50x28 x, UD50x28 y) pure returns (UD50x28 result);

not

Git Source

Implements the NOT (~) bitwise operation in the UD50x28 type.

function not(UD50x28 x) pure returns (UD50x28 result);

xor

Git Source

Implements the XOR (^) bitwise operation in the UD50x28 type.

function xor(UD50x28 x, UD50x28 y) pure returns (UD50x28 result);

uncheckedSub

Git Source

Implements the unchecked subtraction operation (-) in the UD50x28 type.

function uncheckedSub(UD50x28 x, UD50x28 y) pure returns (UD50x28 result);

unwrap

Git Source

Unwraps a UD50x28 number into uint256.

function unwrap(UD50x28 x) pure returns (uint256 result);

intoUD60x18

Git Source

function intoUD60x18(UD50x28 x) pure returns (UD60x18 result);

lshift

Git Source

Implements the left shift operation (<<) in the UD50x28 type.

function lshift(UD50x28 x, uint256 bits) pure returns (UD50x28 result);

avg

Git Source

Calculates the arithmetic average of x and y using the following formula: $$ avg(x, y) = (x & y) + ((xUint ^ yUint) / 2) $$ In English, this is what this formula does:

1. AND x and y.
2. Calculate half of XOR x and y.
3. Add the two results together. This technique is known as SWAR, which stands for "SIMD within a register". You can read more about it here: https://devblogs.microsoft.com/oldnewthing/20220207-00/?p=106223

*Notes:

• The result is rounded down.*

function avg(UD50x28 x, UD50x28 y) pure returns (UD50x28 result);

Parameters

Returns

add

Git Source

Implements the checked addition operation (+) in the UD50x28 type.

function add(UD50x28 x, UD50x28 y) pure returns (UD50x28 result);

gt

Git Source

Implements the greater than operation (>) in the UD50x28 type.

function gt(UD50x28 x, UD50x28 y) pure returns (bool result);

and

Git Source

Implements the AND (&) bitwise operation in the UD50x28 type.

function and(UD50x28 x, uint256 bits) pure returns (UD50x28 result);

eq

Git Source

Implements the equal operation (==) in the UD50x28 type.

function eq(UD50x28 x, UD50x28 y) pure returns (bool result);

mod

Git Source

Implements the checked modulo operation (%) in the UD50x28 type.

function mod(UD50x28 x, UD50x28 y) pure returns (UD50x28 result);

ud50x28

Git Source

function ud50x28(uint256 x) pure returns (UD50x28 result);

mul

Git Source

Multiplies two UD50x28 numbers together, returning a new UD50x28 number.

*Uses {Common.mulDiv} to enable overflow-safe multiplication and division. Notes:

• Refer to the notes in {Common.mulDiv}. Requirements:
• Refer to the requirements in {Common.mulDiv}.*

See the documentation in {Common.mulDiv18}.

function mul(UD50x28 x, UD50x28 y) pure returns (UD50x28 result);

Parameters

Returns

or

Git Source

Implements the OR (|) bitwise operation in the UD50x28 type.

function or(UD50x28 x, UD50x28 y) pure returns (UD50x28 result);

intoSD49x28

Git Source

Casts a UD50x28 number into SD49x28.

*Requirements:

• x must be less than or equal to uMAX_SD49x28.*

function intoSD49x28(UD50x28 x) pure returns (SD49x28 result);

rshift

Git Source

Implements the right shift operation (>>) in the UD50x28 type.

function rshift(UD50x28 x, uint256 bits) pure returns (UD50x28 result);

lt

Git Source

Implements the lower than operation (<) in the UD50x28 type.

function lt(UD50x28 x, UD50x28 y) pure returns (bool result);

isZero

Git Source

Implements a zero comparison check function in the UD50x28 type.

function isZero(UD50x28 x) pure returns (bool result);

div

Git Source

Divides two UD50x28 numbers, returning a new UD50x28 number.

*Uses {Common.mulDiv} to enable overflow-safe multiplication and division. Notes:

• Refer to the notes in {Common.mulDiv}. Requirements:
• Refer to the requirements in {Common.mulDiv}.*

function div(UD50x28 x, UD50x28 y) pure returns (UD50x28 result);

Parameters

and2

Git Source

Implements the AND (&) bitwise operation in the UD50x28 type.

function and2(UD50x28 x, UD50x28 y) pure returns (UD50x28 result);

Constants

Git Source

uMAX_UD50x28

Max UD50x28 value

uint256 constant uMAX_UD50x28 = type(uint256).max;

uUNIT

The unit number, which gives the decimal precision of UD50x28.

uint256 constant uUNIT = 1e28;

UNIT

UD50x28 constant UNIT = UD50x28.wrap(uUNIT);

SCALING_FACTOR

uint256 constant SCALING_FACTOR = 1e10;

Contents

• dualMining
• optionPS
• optionReward
• vaultMining
• IMiningAddRewards
• IPaymentSplitter
• PaymentSplitter

Contents

• DualMining
• DualMiningManager
• DualMiningProxy
• DualMiningStorage
• IDualMining

DualMining

Git Source

Inherits: IDualMining, ReentrancyGuard

State Variables

VAULT_MINING

address internal immutable VAULT_MINING;

Functions

constructor

constructor(address vaultMining);

init

Initialize dual mining. Can only be called by VAULT_MINING contract

function init(UD60x18 initialParentAccRewardsPerShare) external nonReentrant;

addRewards

Add rewards to the contract

function addRewards(UD60x18 amount) external nonReentrant;

getRewardsAvailable

Return amount of rewards not yet allocated

function getRewardsAvailable() external view returns (UD60x18);

updatePool

Trigger an update for this mining pool. Can only be called by VAULT_MINING contract

function updatePool(UD60x18 poolRewards, UD60x18 accRewardsPerShare) external nonReentrant;

_updatePool

function _updatePool(DualMiningStorage.Layout storage l, UD60x18 parentPoolRewards, UD60x18 accRewardsPerShare)
    internal;

updateUser

Trigger an update for a specific user. Can only be called by VAULT_MINING contract

function updateUser(
    address user,
    UD60x18 oldShares,
    UD60x18 oldRewardDebt,
    UD60x18 parentPoolRewards,
    UD60x18 parentUserRewards,
    UD60x18 accRewardsPerShare
) external nonReentrant;

_calculateUserRewardToSubtract

Calculate user reward accumulated in parent contract before the start of the emission in this contract.

function _calculateUserRewardToSubtract(
    DualMiningStorage.Layout storage l,
    IDualMining.UserInfo storage uInfo,
    UD60x18 oldShares,
    UD60x18 oldRewardDebt,
    UD60x18 accRewardsPerShare
) internal view returns (UD60x18);

claim

Claim rewards. Can only be called by VAULT_MINING contract

The claim is done through VAULT_MINING, as we need to trigger updates through VAULT_MINING before being able to claim the rewards anyway.

function claim(address user) external nonReentrant;

Parameters

getPendingUserRewards

Return amount of pending rewards (not yet claimed) for the given user

function getPendingUserRewards(address user) external view returns (UD60x18);

getUserInfo

Return internal variables for the given user

function getUserInfo(address user) external view returns (UserInfo memory);

_calculateRewardsUpdate

function _calculateRewardsUpdate(DualMiningStorage.Layout storage l) internal view returns (UD60x18 rewardAmount);

_revertIfNotVaultMining

function _revertIfNotVaultMining(address caller) internal view;

_revertIfNotInitialized

function _revertIfNotInitialized(DualMiningStorage.Layout storage l) internal view;

_revertIfInitialized

function _revertIfInitialized(DualMiningStorage.Layout storage l) internal view;

_revertIfMiningEnded

function _revertIfMiningEnded(DualMiningStorage.Layout storage l) internal view;

_revertIfNoMiningRewards

function _revertIfNoMiningRewards(DualMiningStorage.Layout storage l) internal view;

DualMiningManager

Git Source

Inherits: ProxyManager, SafeOwnable

Manages the proxy implementation of DualMining contracts

Functions

constructor

constructor(address implementation);

_transferOwnership

function _transferOwnership(address account) internal virtual override(OwnableInternal, SafeOwnable);

DualMiningProxy

Git Source

Inherits: Proxy

State Variables

MANAGER

IProxyManager private immutable MANAGER;

Functions

constructor

constructor(IProxyManager manager, address vault, address rewardToken, UD60x18 rewardsPerYear);

_getImplementation

get logic implementation address

function _getImplementation() internal view override returns (address);

Returns

getImplementation

get address of implementation contract

function getImplementation() external view returns (address);

Returns

DualMiningStorage

Git Source

State Variables

STORAGE_SLOT

bytes32 internal constant STORAGE_SLOT = keccak256("premia.contracts.storage.DualMining");

Functions

layout

function layout() internal pure returns (Layout storage l);

Structs

Layout

struct Layout {
    address vault;
    uint256 startTimestamp;
    uint256 endTimestamp;
    UD60x18 rewardsPerYear;
    UD60x18 rewardsAvailable;
    address rewardToken;
    uint8 rewardTokenDecimals;
    UD60x18 parentAccTotalRewards;
    UD60x18 accTotalRewards;
    UD60x18 initialParentAccRewardsPerShare;
    UD60x18 finalParentAccRewardsPerShare;
    uint256 lastRewardTimestamp;
    mapping(address user => IDualMining.UserInfo info) userInfo;
}

IDualMining

Git Source

Functions

init

Initialize dual mining. Can only be called by VAULT_MINING contract

function init(UD60x18 initialParentAccRewardsPerShare) external;

addRewards

Add rewards to the contract

function addRewards(UD60x18 amount) external;

getRewardsAvailable

Return amount of rewards not yet allocated

function getRewardsAvailable() external view returns (UD60x18);

updatePool

Trigger an update for this mining pool. Can only be called by VAULT_MINING contract

function updatePool(UD60x18 poolRewards, UD60x18 accRewardsPerShare) external;

updateUser

Trigger an update for a specific user. Can only be called by VAULT_MINING contract

function updateUser(
    address user,
    UD60x18 oldShares,
    UD60x18 oldRewardDebt,
    UD60x18 poolRewards,
    UD60x18 userRewards,
    UD60x18 accRewardsPerShare
) external;

claim

Claim rewards. Can only be called by VAULT_MINING contract

The claim is done through VAULT_MINING, as we need to trigger updates through VAULT_MINING before being able to claim the rewards anyway.

function claim(address user) external;

Parameters

getPendingUserRewards

Return amount of pending rewards (not yet claimed) for the given user

function getPendingUserRewards(address user) external view returns (UD60x18);

getUserInfo

Return internal variables for the given user

function getUserInfo(address user) external view returns (UserInfo memory);

Events

Initialized

event Initialized(address indexed caller, UD60x18 initialParentAccRewardsPerShare, uint256 timestamp);

Claim

event Claim(address indexed user, UD60x18 rewardAmount);

MiningEnded

event MiningEnded(UD60x18 finalParentAccRewardsPerShare);

Errors

DualMining__AlreadyInitialized

error DualMining__AlreadyInitialized();

DualMining__NoMiningRewards

error DualMining__NoMiningRewards();

DualMining__NoShareSupply

error DualMining__NoShareSupply();

DualMining__NotAuthorized

error DualMining__NotAuthorized(address caller);

DualMining__NotInitialized

error DualMining__NotInitialized();

DualMining__MiningEnded

error DualMining__MiningEnded();

Structs

UserInfo

struct UserInfo {
    uint256 lastUpdateTimestamp;
    UD60x18 lastParentAccTotalRewards;
    UD60x18 lastAccTotalRewards;
    UD60x18 reward;
}

Contents

• IOptionPS
• IOptionPSFactory
• OptionPS
• OptionPSFactory
• OptionPSFactoryStorage
• OptionPSProxy
• OptionPSStorage

IOptionPS

Git Source

Inherits: IERC1155Base, IERC1155Enumerable

Functions

name

Returns the name of the physically settled option token

function name() external view returns (string memory);

symbol

Returns the symbol of the physically settled option token

function symbol() external view returns (string memory);

getSettings

Returns the pair infos for this option

function getSettings() external view returns (address base, address quote, bool isCall);

underwrite

Underwrite an option by depositing collateral

function underwrite(UD60x18 strike, uint64 maturity, address longReceiver, UD60x18 contractSize) external;

Parameters

annihilate

Burn longs and shorts, to recover collateral of the option

function annihilate(UD60x18 strike, uint64 maturity, UD60x18 contractSize) external;

Parameters

getExerciseCost

Returns the amount of exerciseToken to pay to exercise the given amount of contracts

function getExerciseCost(UD60x18 strike, UD60x18 contractSize)
    external
    view
    returns (uint256 totalExerciseCost, uint256 fee);

Parameters

Returns

getExerciseValue

Returns the amount of collateral that would be received for a given amount of long tokens

function getExerciseValue(UD60x18 strike, UD60x18 contractSize) external view returns (uint256);

Parameters

Returns

exercise

Pay the exercise cost for a given amount contracts. The exercise value will be claimable after maturity.

function exercise(UD60x18 strike, uint64 maturity, UD60x18 contractSize) external;

Parameters

cancelExercise

Cancel an exercise before maturity, and recover the exerciseToken paid. (The fee paid during exercise is not recovered.

function cancelExercise(UD60x18 strike, uint64 maturity, UD60x18 contractSize) external;

Parameters

settleLong

Settle the exercised long options held by the caller.

function settleLong(UD60x18 strike, uint64 maturity, UD60x18 contractSize) external returns (uint256 exerciseValue);

Parameters

Returns

settleShort

Settles the short options held by the caller.

function settleShort(UD60x18 strike, uint64 maturity, UD60x18 contractSize)
    external
    returns (uint256 collateralAmount, uint256 exerciseTokenAmount);

Parameters

Returns

getTokenIds

Returns the list of existing tokenIds with non zero balance

function getTokenIds() external view returns (uint256[] memory);

Returns

Events

Exercise

event Exercise(
    address indexed user, UD60x18 strike, uint256 maturity, UD60x18 contractSize, UD60x18 exerciseCost, UD60x18 fee
);

CancelExercise

event CancelExercise(
    address indexed user, UD60x18 strike, uint256 maturity, UD60x18 contractSize, UD60x18 exerciseCostRefunded
);

SettleLong

event SettleLong(address indexed user, UD60x18 strike, uint256 maturity, UD60x18 contractSize, UD60x18 exerciseValue);

SettleShort

event SettleShort(
    address indexed user,
    UD60x18 strike,
    uint256 maturity,
    UD60x18 contractSize,
    UD60x18 collateralAmount,
    UD60x18 exerciseTokenAmount
);

Underwrite

event Underwrite(
    address indexed underwriter, address indexed longReceiver, UD60x18 strike, uint256 maturity, UD60x18 contractSize
);

Annihilate

event Annihilate(address indexed annihilator, UD60x18 strike, uint256 maturity, UD60x18 contractSize);

Errors

OptionPS__OptionMaturityNot8UTC

error OptionPS__OptionMaturityNot8UTC(uint256 maturity);

OptionPS__OptionExpired

error OptionPS__OptionExpired(uint256 maturity);

OptionPS__OptionNotExpired

error OptionPS__OptionNotExpired(uint256 maturity);

OptionPS__StrikeNotMultipleOfStrikeInterval

error OptionPS__StrikeNotMultipleOfStrikeInterval(UD60x18 strike, UD60x18 strikeInterval);

Enums

TokenType

enum TokenType {
    Long,
    Short,
    LongExercised
}

IOptionPSFactory

Git Source

Inherits: IProxyManager

Functions

isProxyDeployed

Return whether proxy is a deployed proxy

function isProxyDeployed(address proxy) external view returns (bool);

getProxyAddress

Return the proxy address and whether it is deployed

function getProxyAddress(OptionPSArgs calldata args) external view returns (address proxy, bool isDeployed);

Parameters

Returns