vsuite-integrations

Documentation of vsuite-integrations

The vsuite-integrations are contracts built on top of vsuite to offer ethereum staking services to end users

Dependencies

• forge,cast,anvil
• node,npm
• python,pip

You can then install all the other dependencies by running

make install

Installation

git clone git@github.com:kilnfi/vsuite.git --recurse-submodules

Testing

Unit Testing

Unit tests can be found in most of the files inside the test directory. You can run all the unit tests by doing.

make test

E2E Testing

A suite of E2E test files can be found in test/e2e. This test suite will use the deployment scripts found in scripts to run the deployment process inside a local anvil node. Then it will run tests on top of that state. You will need a running instance of anvil to run these tests. You can run all the E2E tests by doing

# In one terminal that we leave opened
anvil

# In another terminal
make test-e2e

Gas Snapshotting

Some tests contain manual gas snapshots. You can usually find these tests inside the E2E test suites. The generated gas snapshots can be found in .forge-snapshots. Tests will fail if the resulting gas snapshot value does not match the one stored on file. In order to override the files on disk, you can run

# In one terminal that we leave opened
anvil

# In another terminal
make test-force-snapshots test-e2e-force-snapshots

Static Analysis

You can run slither on the repository by running

make analyze

Formatting

You can format the repository by using

make format

and verify the formatting by running

make test-format

Deployment

The deployment uses the deploy.sol library to create artifacts using solidity.

Configuring a deployment

The configuration for a deployment can be made in a dedicated file that contains all the configuration variables required to deploy the system. Here is the example for the goerli configuration

And the Deploy.s.sol contract must be tweaked to add the network in the setUp() method.

Required variables to deploy integration contracts

• admin: This address is the administrator of the integration deployment factory.
• proxyAdmin: This address is required to be a different one than the admin as we use a Transparent Proxy pattern.

Fixes

The same steps found in the kilnfi/vsuite repository README can be applied to deploy a fix to an integration contract.

Contents

• Native20

Contents

• Native20FORKFIXTest
• Native20_Fix_09_12_Invalid_Fork.t constants
• Native20_Fix_09_12_Oracle_Report_Test_FORK
• Native20_Fix_09_12_Oracle_Report_CDC
• Native20_Fix_09_12_Oracle_Report_Ledger

Native20FORKFIXTest

Git Source

Inherits: Test

State Variables

fixL

address fixL;

fixC

address fixC;

hatchersAdmin

address internal constant hatchersAdmin = 0x418c1F1F83Cf34C0eA8bCfCe951c5D7531789754;

vPoolHatcher

Hatcher internal constant vPoolHatcher = Hatcher(0x1D6103243d0507a9d1314bAC09379Bf57a5CF155);

vps

address internal constant vps = 0x00a0BE1BBC0C99898dF7e6524Bf16e893c1e3bB9;

ledger

Native20 internal constant ledger = Native20(0x5DB5235b5C7e247488784986e58019fFFd98FdA4);

ledger_admin

address internal constant ledger_admin = 0x06647B1C6286772d376b923e85623a39172DE7d1;

crypto

Native20 internal constant crypto = Native20(0x437636e4b984EAe19045626AA269a89f906cf96c);

crypto_admin

address internal constant crypto_admin = 0x208e5eF8ABD863fCBDDF60ad4Bb7d0913fA4F968;

native20_impl

address internal constant native20_impl = 0x0843359caE1187b432eEb26E1B40c3a2B2374D7E;

Functions

setUp

function setUp() external;

test_fixed_ledger

function test_fixed_ledger(uint256 amount) external;

test_fixed_cdc

function test_fixed_cdc(uint256 amount) external;

Constants

Git Source

NATIVE20_IMPLEM

address constant NATIVE20_IMPLEM = 0xd0A52e4e860e34B44994842F09758A0A06b02506;

EXIT_QUEUE

vExitQueue constant EXIT_QUEUE = vExitQueue(0x8d6Fd650500f82c7D978a440348e5a9b886943bF);

PROXY_ADMIN

address constant PROXY_ADMIN = 0x06647B1C6286772d376b923e85623a39172DE7d1;

Native20_Fix_09_12_Oracle_Report_Test_FORK

Git Source

Inherits: Test

State Variables

hatchersAdmin

address internal constant hatchersAdmin = 0x418c1F1F83Cf34C0eA8bCfCe951c5D7531789754;

ledger

address internal constant ledger = 0x5DB5235b5C7e247488784986e58019fFFd98FdA4;

ledger_admin

address internal constant ledger_admin = 0x06647B1C6286772d376b923e85623a39172DE7d1;

crypto

address internal constant crypto = 0x437636e4b984EAe19045626AA269a89f906cf96c;

crypto_admin

address internal constant crypto_admin = 0x208e5eF8ABD863fCBDDF60ad4Bb7d0913fA4F968;

native20_impl

address internal constant native20_impl = 0x0843359caE1187b432eEb26E1B40c3a2B2374D7E;

vPoolHatcher

Hatcher internal constant vPoolHatcher = Hatcher(0x1D6103243d0507a9d1314bAC09379Bf57a5CF155);

vps

address internal constant vps = 0x00a0BE1BBC0C99898dF7e6524Bf16e893c1e3bB9;

native20FixLedger

Native20_Fix_09_12_Oracle_Report_Ledger internal native20FixLedger;

native20FixCDC

Native20_Fix_09_12_Oracle_Report_CDC internal native20FixCDC;

Functions

setUp

function setUp() external;

test_Fix_Ledger

function test_Fix_Ledger() external;

test_Fix_CDC

function test_Fix_CDC() external;

Native20_Fix_09_12_Oracle_Report_CDC

Git Source

Inherits: MultiPool20, Implementation, Initializable

Native20 with fix for CDC

Functions

fix

function fix() external;

_stake_fix

copy paste of multiPool20._stake() with customizable staker

function _stake_fix(uint256 totalAmount, address staker) internal notPaused returns (bool);

Events

CommissionSharesReturnedFix091223

event CommissionSharesReturnedFix091223(uint256 shares, uint256 poolId, uint256 eth);

Native20_Fix_09_12_Oracle_Report_Ledger

Git Source

Inherits: MultiPool20, Implementation, Initializable

Native20 with fix for ledger

Functions

fix

function fix() external;

_stake_fix

function _stake_fix(uint256 totalAmount, address staker) internal notPaused returns (bool);

Events

CommissionSharesReturnedFix091223

event CommissionSharesReturnedFix091223(uint256 shares, uint256 poolId, uint256 eth);

Contents

• IERC4907
• IExitQueueClaimHelper
• IFeeDispatcher
• IIntegrationFactory
• ILiquid1155
• ILiquid20
• IMerkleVault
• PoolStakeDetails
• PoolExitDetails
• IMultiPool
• IMultiPool1155
• IMultiPool20
• Native1155Configuration
• INative1155
• Native20Configuration
• INative20
• IvNFT

IERC4907

Git Source

Author: mortimr @ Kiln

Allows NFT owners to rent without changing the NFT ownership, only renting the utility of the NFT

Functions

setUser

Set the user and expires of an NFT. Once the rent is defined, only the rentee can edit or revoke the rent

function setUser(uint256 tokenId, address user, uint64 expires) external;

Parameters

userOf

Get the user address of an NFT

The zero address indicates that there is no user or the user is expired

function userOf(uint256 tokenId) external view returns (address);

Parameters

Returns

userExpires

Get the user expires of an NFT

The zero value indicates that there is no user

function userExpires(uint256 tokenId) external view returns (uint256);

Parameters

Returns

Events

UpdateUser

Emitted when the user of an NFT or the expires of the user is changed

event UpdateUser(uint256 indexed tokenId, address indexed user, uint64 expires);

Parameters

IExitQueueClaimHelper

Git Source

Author: gauthiermyr @ Kiln

Functions

multiResolve

Resolve a list of casksIds for given exitQueues and tickets

function multiResolve(address[] calldata exitQueues, uint256[][] calldata ticketIds)
    external
    view
    returns (int64[][] memory caskIdsOrErrors);

Parameters

multiClaim

Claim caskIds for given tickets on each exit queue

function multiClaim(address[] calldata exitQueues, uint256[][] calldata ticketIds, uint32[][] calldata casksIds)
    external
    returns (IvExitQueue.ClaimStatus[][] memory statuse);

Parameters

IFeeDispatcher

Git Source

Author: 0xvv @ Kiln

This contract contains functions to dispatch the ETH in a contract upon withdrawal.

Functions

withdrawCommission

Allows the integrator to withdraw the ETH in the contract.

function withdrawCommission() external;

Events

NewCommissionSplit

Emitted when the commission split is changed.

event NewCommissionSplit(address[] recipients, uint256[] splits);

Parameters

CommissionWithdrawn

Emitted when the integrator withdraws ETH

event CommissionWithdrawn(address indexed withdrawer, uint256 amountWithdrawn);

Parameters

Errors

UnequalLengths

Thrown when functions are given lists of different length in batch arguments

error UnequalLengths(uint256 lengthA, uint256 lengthB);

Parameters

Reentrancy

Thrown when a function is called while the contract is locked

error Reentrancy();

IIntegrationFactory

Git Source

Author: gauthiermyr @ Kiln

IntegrationFactory deploys predefined integrations contracts through a ProxyFactory.

Functions

initialize

Initializes the contract with the given parameters.

function initialize(address admin_) external;

Parameters

deployNative20vPoolIntegration

Deploy a proxy for the implementation of a Native vPool integration contract

function deployNative20vPoolIntegration(address proxyOwner, bytes calldata cdata) external returns (address);

Parameters

deployNative20vPoolIntegration

Deploy a proxy for the implementation of a Native vPool integration contract

function deployNative20vPoolIntegration(address proxyOwner, Native20Configuration calldata config) external returns (address);

Parameters

deployLiquid20AvPoolIntegration

Deploy a proxy for the implementation of a liquid ERC20 aToken vPool integration contract

function deployLiquid20AvPoolIntegration(address proxyOwner, Native20Configuration calldata config) external returns (address);

Parameters

deployLiquid20CvPoolIntegration

Deploy a proxy for the implementation of a liquid ERC20 cToken vPool integration contract

function deployLiquid20CvPoolIntegration(address proxyOwner, Native20Configuration calldata config) external returns (address);

Parameters

deployLiquid20AvPoolIntegration

Deploy a proxy for the implementation of a liquid ERC20 aToken vPool integration contract

function deployLiquid20AvPoolIntegration(address proxyOwner, bytes calldata cdata) external returns (address);

Parameters

deployLiquid20CvPoolIntegration

Deploy a proxy for the implementation of a liquid ERC20 cToken vPool integration contract

function deployLiquid20CvPoolIntegration(address proxyOwner, bytes calldata cdata) external returns (address);

Parameters

deployNative1155vPoolIntegration

Deploy a proxy for the implementation of a native 1155 vPool integration contract

function deployNative1155vPoolIntegration(address proxyOwner, Native1155Configuration calldata config) external returns (address);

Parameters

deployLiquid1155vPoolIntegration

Deploy a proxy for the implementation of a liquid 1155 vPool integration contract

function deployLiquid1155vPoolIntegration(address proxyOwner, Native1155Configuration calldata config) external returns (address);

Parameters

deployNative1155vPoolIntegration

Deploy a proxy for the implementation of a native 1155 vPool integration contract

function deployNative1155vPoolIntegration(address proxyOwner, bytes calldata cdata) external returns (address);

Parameters

deployLiquid1155vPoolIntegration

Deploy a proxy for the implementation of a liquid 1155 vPool integration contract

function deployLiquid1155vPoolIntegration(address proxyOwner, bytes calldata cdata) external returns (address);

Parameters

deployVNFTIntegration

Deploy a proxy for the implementation of a vNFT integration contract

function deployVNFTIntegration(address proxyOwner, bytes calldata cdata) external returns (address);

Parameters

deployVNFTIntegration

function deployVNFTIntegration(address proxyOwner, IvNFT.VNFTConfiguration calldata config) external returns (address);

Parameters

updateImplementation

Update the channel implementation address

function updateImplementation(bytes32 channel, address implem, bool updateRequired) external;

Parameters

setDeployer

Allow or disallow an address to deploy integration contracts

function setDeployer(address deployer, bool allowed) external;

Parameters

factory

retrieve the proxy factory address

function factory(bytes32 channel) external view returns (address);

Parameters

implementation

retrieve the implementation address for a channel

function implementation(bytes32 channel) external view returns (address);

Parameters

outdated

retrieve whether the implementation for a channel is outdated

function outdated(bytes32 channel) external view returns (bool);

Parameters

Events

DeployerUpdated

Emitted when a deployer is allowed or disallowed

event DeployerUpdated(address indexed deployer, bool allowed);

Parameters

ChannelImplementationUpdated

Emitted when an implementation is updated

event ChannelImplementationUpdated(bytes32 indexed channel, address implem, bool updateRequired);

Parameters

ProxyFactoryDeployed

Emitted when a ProxyFactory is deployed for a channel

event ProxyFactoryDeployed(bytes32 indexed channel, address factory);

Parameters

Errors

NotAnAllowedDeployer

Thrown when someone not allowed is trying to deploy an integration

error NotAnAllowedDeployer();

FactoryUpdateRequired

Thrown when we try to deploy an outdated implementation

error FactoryUpdateRequired(bytes32 channel);

Parameters

ChannelNotInitialized

Thrown when we try to deploy an integration for a channel that is not initialized

error ChannelNotInitialized(bytes32 channel);

Parameters

ILiquid1155

Git Source

Inherits: IERC165

Author: 0xvv @ Kiln

This contract allows users to stake in any of the vPools with any amount of ETH and track their position. Users are given transferable shares to track their stake, shares of different pools are not equivalent. Users can interact with the contract using the ERC-1155 interface.

Functions

setApprovalForAll

Give the right to an operator to transfer all tokens of the sender.

function setApprovalForAll(address operator, bool approved) external;

Parameters

isApprovedForAll

Returns the operator status of an operator for a given owner.

function isApprovedForAll(address account, address operator) external view returns (bool);

Parameters

safeTransferFrom

Transfers amount tokens of token type id from from to to with extra data.

The caller must be operator of 'from' or 'from' & 'from' must have a balance of at least amount.

function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;

Parameters

safeBatchTransferFrom

Batched version of safeTransferFrom.

function safeBatchTransferFrom(address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data)
    external;

Parameters

Events

ApprovalForAll

Emitted when the status of an operator is changed.

event ApprovalForAll(address indexed account, address indexed operator, bool approved);

Parameters

Errors

ApprovalForSelf

Emitted when a user trier to approve themselves.

error ApprovalForSelf();

ReceiverRejected

Emitted when a the ERC-1155 receiver rejects the transfer.

error ReceiverRejected(address receiver, uint256 id, uint256 amount, bytes data);

Parameters

ReceiverRejectedBatch

Emitted when a the ERC-1155 receiver rejects a batch of transfers.

error ReceiverRejectedBatch(address receiver, uint256[] ids, uint256[] amounts, bytes data);

Parameters

NotAnERC1155Receiver

Emitted when a transfer is attempted but the sender is not a receiver.

error NotAnERC1155Receiver(address receiver);

Parameters

ILiquid20

Git Source

Author: 0xvv @ Kiln

Contains functions to make the token liquid

Functions

transfer

Transfers token from the caller to another address

function transfer(address to, uint256 amount) external returns (bool);

Parameters

allowance

Retrieves the amount of tokens that an owner allowed to a spender

function allowance(address owner, address spender) external view returns (uint256);

Parameters

approve

Approves a spender to transfer tokens on the caller's behalf

function approve(address spender, uint256 amount) external returns (bool);

Parameters

transferFrom

Transfers tokens from one address to another, using the allowance mechanism

function transferFrom(address from, address to, uint256 amount) external returns (bool);

Parameters

IMerkleVault

Git Source

Inherits: IAdministrable

Author: mortimr @ Kiln

Funds distribution vault using merkle proofs to authorize withdrawals

Functions

initialize

function initialize(address admin, bytes32 initialRoot, string calldata initialIpfsHash, uint256 initialFrameSize) external;

Parameters

totalClaimedForAccount

Retrieve the total claimed amount for an account

function totalClaimedForAccount(address account) external view returns (uint256);

Parameters

Returns

totalClaimed

Retrieve the total claimed on the contract

function totalClaimed() external view returns (uint256);

Returns

root

Retrieve the current merkle root

function root() external view returns (bytes32);

Returns

ipfsHash

Retrieve the ipfs hash holding the merkle tree + extra data

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

Returns

setRootAndIpfsHash

Set the current merkle root

function setRootAndIpfsHash(bytes32 newRoot, string calldata newIpfsHash) external;

Parameters

claim

Claims funds based on total claimed and current amount

function claim(address account, uint256 amount, bytes32[] calldata proofs) external;

Parameters

frameSize

Retreive the number of epochs between two reports

function frameSize() external view returns (uint256);

Returns

setFrameSize

Update the number of epochs between two reports

function setFrameSize(uint256 newFrameSize) external;

Parameters

fallback

fallback() external payable;

receive

receive() external payable;

Events

Claimed

Emitted when claim action occured

event Claimed(address account, uint256 amount, uint256 totalClaimed);

Parameters

SetFrameSize

Emitted a new frame size is set

event SetFrameSize(uint256 frameSize);

Parameters

SetRootAndIpfsHash

Emitted when root and ipfs hash are updated

event SetRootAndIpfsHash(bytes32 root, string ipfsHash);

Parameters

Errors

InvalidProofs

Thrown when the provided proofs are invalid

error InvalidProofs(address account, uint256 amount, bytes32[] proofs);

Parameters

NothingToClaim

Thrown when nothing to claim

error NothingToClaim(address account);

Parameters

PoolStakeDetails

Git Source

PoolStakeDetails contains the details of a stake

struct PoolStakeDetails {
    uint128 poolId;
    uint128 ethToPool;
    uint128 ethToIntegrator;
    uint128 pSharesFromPool;
    uint128 pSharesFromIntegrator;
}

Properties

PoolExitDetails

Git Source

PoolExitDetails contains the details of an exit

struct PoolExitDetails {
    uint128 poolId;
    uint128 exitedPoolShares;
}

Properties

IMultiPool

Git Source

Inherits: IFeeDispatcher, IvPoolSharesReceiver

Author: 0xvv @ Kiln

This contract contains the common functions to all integration contracts. Contains the functions to add pools, activate/deactivate a pool, change the fee of a pool and change the commission distribution.

Functions

pools

Returns the list of vPools.

function pools() external view returns (address[] memory vPools);

Returns

getFee

Returns the current fee in basis points for the given pool.

function getFee(uint256 id) external view returns (uint256 feeBps);

Parameters

Returns

changeFee

Allows the integrator to change the fee.

Reverts if there are unsold integrator shares.

function changeFee(uint256 poolId, uint256 newFeeBps) external;

Parameters

changeSplit

Allows the admin to change the fee sharing upon withdrawal.

function changeSplit(address[] calldata recipients, uint256[] calldata splits) external;

Parameters

addPool

Allows the integrator to add a vPool.

Reverts if the pool is already in the pools list.

function addPool(address newPool, uint256 fee) external;

Parameters

getPoolActivation

Returns true if the pool is active, false otherwise

function getPoolActivation(uint256 poolId) external view returns (bool);

Parameters

integratorCommissionOwed

Returns the ETH value of integrator shares left to sell.

function integratorCommissionOwed(uint256 poolId) external view returns (uint256);

Parameters

Returns

exitCommissionShares

Allows the integrator to exit the integrator shares of a vPool.

function exitCommissionShares(uint256 poolId) external;

Parameters

pauseDeposits

Allows the integrator to pause and unpause deposits only.

function pauseDeposits(bool isPaused) external;

Parameters

depositsPaused

Returns true if deposits are paused, false otherwise

function depositsPaused() external view returns (bool);

Events

VPoolSharesReceived

Emitted when vPool shares are received

event VPoolSharesReceived(address vPool, uint256 poolId, uint256 amount);

Parameters

PoolActivation

Emitted when a vPool in enabled or disabled

event PoolActivation(address poolAddress, uint256 id, bool isActive);

Parameters

PoolAdded

Emitted when a vPool address is added to vPools

event PoolAdded(address poolAddress, uint256 id);

Parameters

SetFee

Emitted when the integrator fee is changed

event SetFee(uint256 poolId, uint256 operatorFeeBps);

Parameters

SetName

Emitted when the display name is changed

event SetName(string name);

Parameters

SetSymbol

Emitted when the display symbol is changed

event SetSymbol(string symbol);

Parameters

SetMaxCommission

Emitted when the max commission is set

event SetMaxCommission(uint256 maxCommission);

Parameters

SetDepositsPaused

Emitted when the deposits are paused or unpaused

event SetDepositsPaused(bool isPaused);

Parameters

Stake

Emitted when staking occurs, contains the details for all the pools

event Stake(address indexed staker, uint128 depositedEth, uint128 mintedTokens, PoolStakeDetails[] stakeDetails);

Parameters

Exit

Emitted when an exit occurs, contains the details for all the pools

event Exit(address indexed staker, uint128 exitedTokens, PoolExitDetails[] exitDetails);

Parameters

ExitedCommissionShares

Emitted when the commission is distributed via a manual call

event ExitedCommissionShares(uint256 indexed poolId, uint256 shares, uint256[] weights, address[] recipients);

Parameters

Errors

DepositsPaused

Thrown on stake if deposits are paused

error DepositsPaused();

InvalidAmounts

Thrown when trying to stake but the sum of amounts is not equal to the msg.value

error InvalidAmounts(uint256 sum, uint256 msgValue);

Parameters

EmptyPoolList

Thrown when trying to init the contract without providing a pool address

error EmptyPoolList();

OutstandingCommission

Thrown when trying to change the fee but there are integrator shares left to sell

error OutstandingCommission(uint256 ethLeft, uint256 id);

Parameters

PoolAlreadyRegistered

Thrown when trying to add a Pool that is already registered in the contract

error PoolAlreadyRegistered(address newPool);

Parameters

PoolDisabled

Thrown when trying to deposit to a disabled pool

error PoolDisabled(uint256 poolId);

Parameters

NotARegisteredPool

Thrown when trying the pool shares callback is called by an address that is not registered

error NotARegisteredPool(address poolAddress);

Parameters

PoolTransferFailed

Emitted when a pool transfer does not return true.

error PoolTransferFailed(uint256 id);

Parameters

InvalidPoolId

Thrown when passing an invalid poolId

error InvalidPoolId(uint256 poolId);

Parameters

CommissionPaidUnderflow

Thrown when the commission underflow when lowering the fee

To avoid this, the integrator can call exitCommissionShares before lowering the fee or wait for the integrator shares to be sold

error CommissionPaidUnderflow();

ZeroSharesMint

Thrown when minting a null amount of shares

error ZeroSharesMint();

FeeOverMax

Thrown when trying to see a fee over the max fee set at initialization

error FeeOverMax(uint256 maxFeeBps);

CallbackNotFromMinting

Thrown when trying to call the callback outside of the minting process

error CallbackNotFromMinting();

NoSharesToExit

Thrown when trying to exit the commission shares but there are no shares to exit

error NoSharesToExit(uint256 poolId);

IMultiPool1155

Git Source

Author: 0xvv @ Kiln

This contract contains internal functions to stake and track positions in multiple pools. It also exposes supply getters and pool addition.

Functions

totalUnderlyingSupply

Returns the amount of pool shares owned by the users.

function totalUnderlyingSupply(uint256 id) external view returns (uint256);

Parameters

Returns

totalSupply

Returns the total amount of vStakes shares.

function totalSupply(uint256 id) external view returns (uint256);

Parameters

Returns

requestExit

Sends the given number of shares to the exit queue, the user receives the NFT ticket

function requestExit(uint256 id, uint256 amount) external;

Parameters

batchRequestExit

Batched version of requestExit

function batchRequestExit(uint256[] calldata ids, uint256[] calldata amounts) external;

Parameters

poolRate

Returns the poolShare to ETH conversion rate for the given ID

function poolRate(uint256 id) external returns (uint256);

Parameters

Returns

setPoolActivation

Allows the integrator to prevent users from depositing to a vPool.

function setPoolActivation(uint256 poolId, bool status) external;

Parameters

Events

TransferSingle

Emitted when a transfer occurs.

event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

Parameters

TransferBatch

Emitted when a batch transfer occurs, sending shares of multiple pools to the same recipient.

event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values);

Parameters

CommissionSharesSold

Emitted when some integrator shares are sold

event CommissionSharesSold(uint256 pSharesSold, uint256 id, uint256 amountSold);

Parameters

Errors

InsufficientBalance

Emitted when a transfer is attempted but the sender does not have enough balance.

error InsufficientBalance(uint256 id, uint256 amount, uint256 balance);

Parameters

IMultiPool20

Git Source

Author: 0xvv @ Kiln

This contract contains the internal logic for an ERC-20 token based on one or multiple pools.

Functions

setPoolPercentages

Set the percentage of new stakes to route to each pool

If a pool is disabled it needs to be set to 0 in the array

function setPoolPercentages(uint256[] calldata split) external;

Parameters

requestExit

Burns the sender's shares and sends the exitQueue tickets to the caller.

function requestExit(uint256 amount) external;

Parameters

rate

Returns the share to ETH conversion rate

function rate() external returns (uint256);

Returns

setPoolActivation

Allows the integrator to prevent users from depositing to a vPool.

function setPoolActivation(uint256 poolId, bool status, uint256[] calldata newPoolPercentages) external;

Parameters

Events

Transfer

Emitted when a stake is transferred.

event Transfer(address indexed from, address indexed to, uint256 value);

Parameters

Approval

Emitted when an allowance is created.

event Approval(address indexed owner, address indexed spender, uint256 value);

Parameters

CommissionSharesSold

Emitted when some integrator shares are sold

event CommissionSharesSold(uint256 pSharesSold, uint256 id, uint256 amountSold);

Parameters

SetPoolPercentages

Emitted when new split is set.

event SetPoolPercentages(uint256[] split);

Parameters

Errors

InsufficientBalance

Thrown when a transfer is attempted but the sender does not have enough balance.

error InsufficientBalance(uint256 amount, uint256 balance);

Parameters

InsufficientAllowance

Thrown when a transferFrom is attempted but the spender does not have enough allowance.

error InsufficientAllowance(uint256 amount, uint256 allowance);

NonZeroPercentageOnDeactivatedPool

Thrown when trying to set a pool percentage != 0 to a deactivated pool

error NonZeroPercentageOnDeactivatedPool(uint256 id);

Native1155Configuration

Git Source

Configuration for the Native-1155 contract.

struct Native1155Configuration {
    string name;
    string symbol;
    address admin;
    address[] pools;
    uint256[] poolFees;
    address[] commissionRecipients;
    uint256[] commissionDistribution;
    string baseUri;
    uint256 maxCommissionBps;
}

Properties

INative1155

Git Source

Author: 0xvv @ Kiln

This contract allows users to stake in any of the vPools with any amount of ETH and track their position. Users are given non transferable shares to track their stake, shares of different pools are not equivalent. Users can interact with the contract using the ERC-1155 style interface, but the contract is not ERC-1155 compliant as it does not support transfers.

Functions

initialize

Initializes the contract with the given parameters.

function initialize(Native1155Configuration calldata args) external;

Parameters

uri

Returns the URI for token type id.

function uri(uint256 id) external view returns (string memory);

Parameters

Returns

setPrefixUri

Sets the base URI for all tokens.

Ony callable by the admin.

function setPrefixUri(string calldata _uri) external;

Parameters

name

Returns the name of the token.

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

Returns

symbol

Returns the symbol of the token.

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

Returns

balanceOf

Returns the amount of staking shares of a given pool for an account.

function balanceOf(address account, uint256 id) external view returns (uint256);

Parameters

Returns

balanceOfBatch

Batch version of balanceOf().

function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory);

Parameters

Returns

balanceOfUnderlying

Returns the amount of pool shares for an account in a given pool.

function balanceOfUnderlying(address account, uint256 id) external view returns (uint256);

Parameters

Returns

balanceOfUnderlyingBatch

Batch version of balanceOfUnderlying().

function balanceOfUnderlyingBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory);

Parameters

Returns

stake

Stake the given amounts of ETH in the given pools.

Sum of amounts must be equal to msg.value.

The length of amounts and ids must be equal.

function stake(uint256[] calldata amounts, uint256[] calldata ids) external payable returns (bool);

Parameters

Returns

Events

SetURIPrefix

Emitted when the base uri is changed

event SetURIPrefix(string uri);

Parameters

Native20Configuration

Git Source

Configuration parameters for the Native20 contract.

struct Native20Configuration {
    string name;
    string symbol;
    address admin;
    address[] pools;
    uint256[] poolFees;
    address[] commissionRecipients;
    uint256[] commissionDistribution;
    uint256[] poolPercentages;
    uint256 maxCommissionBps;
    uint256 monoTicketThreshold;
}

Properties

INative20

Git Source

Author: 0xvv @ Kiln

This contract allows users to stake any amount of ETH in the vPool(s). Users are given non transferable ERC-20 type shares to track their stake.

Functions

initialize

Initializes the contract with the given parameters.

function initialize(Native20Configuration calldata args) external;

Parameters

name

Returns the name of the token.

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

symbol

Returns the symbol of the token, usually a shorter version of the name.

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

decimals

Returns the number of decimals used to get its user representation.

function decimals() external view returns (uint8);

totalSupply

Returns the total amount of staking shares.

function totalSupply() external view returns (uint256);

Returns

totalUnderlyingSupply

Returns the amount of ETH owned by the users in the pool(s).

function totalUnderlyingSupply() external view returns (uint256);

Returns

balanceOf

Returns the amount of staking shares for an account.

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

Parameters

Returns

balanceOfUnderlying

Returns the ETH value of the account balance.

function balanceOfUnderlying(address account) external view returns (uint256);

Parameters

Returns

stake

Function to stake ETH.

function stake() external payable;

IvNFT

Git Source

Inherits: INFT, IAdministrable

Author: mortimr @ Kiln

Mint or Purchase 1 NFT = own 1 validator

Functions

initialize

function initialize(VNFTConfiguration calldata config) external;

Parameters

factory

Retrieve the factory address

function factory() external view returns (address);

Returns

integrator

Retrieve the integrator address

function integrator() external view returns (address);

Returns

beneficiaryOf

Retriver the current beneficiary of EL and CL rewards

function beneficiaryOf(uint256 tokenId) external view returns (address beneficiary);

Parameters

Returns

operatorCommission

Retrieve the operator commission

This value is not used inside the contract but only in the off-chain accounting engine building the exec layer vault merkle tree

function operatorCommission() external view returns (uint256);

Returns

integratorCommission

Retrieve the integrator commission

This value is not used inside the contract but only in the off-chain accounting engine building the exec layer vault merkle tree

function integratorCommission() external view returns (uint256);

Returns

soulboundMode

Retrieve the soulbound mode status

if active, thansfers are disabled

function soulboundMode() external view returns (bool);

Returns

startTokenId

Retrieve the starting token id

function startTokenId() external pure returns (uint256);

Returns

execLayerVault

Retrieve the exec layer vault address

function execLayerVault() external view returns (address);

Returns

extraData

Retrieve the extra data used for each deposit

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

Returns

resolve

Retrieve the associated validator ids for the given token ids

function resolve(uint256[] calldata tokenIds) external view returns (uint256[] memory);

Parameters

Returns

uriPrefix

Retrieve the uri prefix used for all token uris

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

Returns

isExited

Retrieve if the token is exited

function isExited(uint256 tokenId) external view returns (bool);

Parameters

Returns

purchasable

Retrieve the amount of purchasable validators

function purchasable() external view returns (uint256);

Returns

purchasePaused

Retrieve the purchase function status

function purchasePaused() external view returns (bool);

Returns

setIntegrator

Sets the integrator address

function setIntegrator(address newIntegrator) external;

Parameters

setIntegratorCommission

Sets the integrator commission

function setIntegratorCommission(uint256 newIntegratorCommission) external;

Parameters

setOperatorCommission

Sets the operator commission

function setOperatorCommission(uint256 newOperatorCommission) external;

Parameters

setName

Sets the ERC721 contract name

function setName(string calldata newName) external;

Parameters

setSymbol

Sets the ERC721 contract symbol

function setSymbol(string calldata newSymbol) external;

Parameters

setUriPrefix

Sets the uri prefix of the contract

function setUriPrefix(string calldata newUriPrefix) external;

Parameters

purchase

Purchase one or several validators

The msg.value should be a multiple of 32 ETH > 0

function purchase() external payable returns (uint256[] memory);

Returns

withdraw

Triggers a withdrawal action on the underlying validators

function withdraw(uint256[] calldata tokenIds, address recipient) external returns (uint256[] memory);

Parameters

exit

Triggers an exit action on the underlying validators

function exit(uint256[] calldata tokenIds) external;

Parameters

clearUsership

Withdraw rewards if any for the user and clears the usership

function clearUsership(uint256 tokenId) external returns (uint256);

Parameters

pausePurchase

Pause the purchase function

function pausePurchase() external;

unpausePurchase

Unpause the purchase function

function unpausePurchase() external;

claimDebt

Claim the rewards due to the user

function claimDebt() external;

debt

Retrieve the debt due to an user

function debt(address user) external view returns (uint256);

Parameters

Returns

Events

SetFactory

Emitted when the factory is changed

event SetFactory(address factory);

Parameters

SetExtraData

Emitted when the extraData value is changed

event SetExtraData(string extraData);

Parameters

SetURIPrefix

Emitted when the uri prefix value is changed

event SetURIPrefix(string uriPrefix);

Parameters

SetExecLayerVault

Emitted when the exec layer vault address is changed

event SetExecLayerVault(address execLayerVault);

Parameters

SetIntegratorCommission

Emitted when the integrator commission is changed

event SetIntegratorCommission(uint256 integratorCommission);

Parameters

SetOperatorCommission

Emitted when the operator commission is changed

event SetOperatorCommission(uint256 operatorCommission);

Parameters

SetIntegrator

Emitted when the integrator address is changed

event SetIntegrator(address integrator);

Parameters

SetSoulboundMode

Emitted when the soulbound mode is changed

event SetSoulboundMode(bool active);

Parameters

PurchasedValidator

Emitted when a validator has been purchased by the contract

event PurchasedValidator(address indexed owner, uint256 tokenId, uint256 validatorId);

Parameters

UsershipCleared

Emitted when owner claims back the usership of the NFT

event UsershipCleared(uint256 indexed tokenId);

Parameters

SetPurchasePause

Emitted when the purchase function is paused or unpaused

event SetPurchasePause(bool isPaused);

Parameters

DebtClaimed

Emitted when an user claims its debt

event DebtClaimed(address indexed user, uint256 amount);

Parameters

TokenIdUpdated

Emitted when a NFT is reminted for a validator

event TokenIdUpdated(uint256 indexed oldTokenId, uint256 indexed newTokenId, uint256 validatorId);

Parameters

Errors

InvalidAmount

Thrown when the provided amount is invalid

error InvalidAmount(uint256 amount);

Parameters

ValidatorCountUnavailable

Thrown when the requested validator count to purchase is unavailable

error ValidatorCountUnavailable(uint256 requestedAmount, uint256 availableAmount);

Parameters

InvalidDepositCount

Thrown when the validator count retrieved by the factory is invalid

error InvalidDepositCount(uint256 requestedAmount, uint256 depositedAmount);

Parameters

EmptyTokenIdArray

Thrown when the provided token id array is empty

error EmptyTokenIdArray();

PurchasePaused

Thrown when purchase function is paused

error PurchasePaused();

ClearUsershipError

Thrown when usership cannot be claimed (no user is set or not expired yet)

error ClearUsershipError();

IllegalTransferWhileInSoulboundMode

Thrown when the soulbound mode is enabled and a transfer is attempted

error IllegalTransferWhileInSoulboundMode();

IllegalTransferOfExitedToken

Thrown when the a user tries to transfer an exited token

error IllegalTransferOfExitedToken(uint256 tokenId);

IllegalExpirationExtensionAttempt

Thrown when a user tries to change the expiration for a greater value

error IllegalExpirationExtensionAttempt(address user, uint64 initialExpiration, uint64 proposedExpiration);

Parameters

IllegalExpirationValue

Thrown when a user tries to set an expiration in the past

error IllegalExpirationValue(uint64 expiration);

Parameters

WithdrawError

Thrown when a withdrawal fails

error WithdrawError();

ValidatorAlreadyExited

Thrown when a validator is already exited

error ValidatorAlreadyExited(uint256 tokenId);

Parameters

CannotExitWhileRented

Thrown when a validator is already rented and the owner wants to exit

error CannotExitWhileRented(uint256 tokenId);

Parameters

Structs

VNFTConfiguration

Struct containing the configuration for the vNFT

struct VNFTConfiguration {
    string name;
    string symbol;
    string uriPrefix;
    string extraData;
    address[4] actors;
    uint256[2] commissions;
    bool soulboundMode;
}

Properties

Contents

• ExitedEthIncrementer

ExitedEthIncrementer

Git Source

Author: 0xvv @ Kiln

This contract allows to increment the exited Eth for a pool

State Variables

$exitedEth

The mapping of exited Eth for different pools

Type: mapping(uint256 => uint256)

Slot: keccak256(bytes("multiPool.1.exitedEth")) - 1

types.Mapping internal constant $exitedEth = types.Mapping.wrap(0x76a0ecda094c6ccf2a55f6f1ef41b98d3c1f2dfcb9c1970701fe842ce778ff9b);

$commissionPaid

The mapping of commission paid for different pools

Type: mapping(uint256 => uint256)

Slot: keccak256(bytes("multiPool.1.commissionPaid")) - 1

types.Mapping internal constant $commissionPaid = types.Mapping.wrap(0x6c8f9259db4f6802ea7a1e0a01ddb54668b622f1e8d6b610ad7ba4d95f59da29);

Functions

migrate

function migrate() external;

Contents

• LBalance
• LUser4907Mapping
• victypes

LBalance

Git Source

Functions

get

function get(victypes.BalanceMapping position) internal pure returns (mapping(address => uint256) storage data);

LUser4907Mapping

Git Source

Functions

get

function get(victypes.User4907Mapping position) internal pure returns (mapping(uint256 => victypes.User4907) storage data);

victypes

Git Source

Structs

User4907

struct User4907 {
    address user;
    uint64 expiration;
}

ExitQueueClaimHelper

Git Source

Inherits: IExitQueueClaimHelper

Author: gauthiermyr @ Kiln

This contract contains functions to resolve and claim casks on several exit queues.

Functions

multiResolve

Resolve a list of casksIds for given exitQueues and tickets

function multiResolve(address[] calldata exitQueues, uint256[][] calldata ticketIds)
    external
    view
    override
    returns (int64[][] memory caskIdsOrErrors);

Parameters

multiClaim

Claim caskIds for given tickets on each exit queue

function multiClaim(address[] calldata exitQueues, uint256[][] calldata ticketIds, uint32[][] calldata casksIds)
    external
    override
    returns (IvExitQueue.ClaimStatus[][] memory statuses);

Parameters

FeeDispatcher

Git Source

Inherits: IFeeDispatcher

Author: 0xvv @ Kiln

This contract contains functions to dispatch the ETH in a contract upon withdrawal.

State Variables

$feeRecipients

The recipients of the fees upon withdrawal.

Slot: keccak256(bytes("feeDispatcher.1.feeRecipients")) - 1

types.Array internal constant $feeRecipients = types.Array.wrap(0xd681f9d3e640a2dd835404271506ef93f020e2fc065878793505e5ea088fde3d);

$feeSplits

The splits of each recipient of the fees upon withdrawal.

Slot: keccak256(bytes("feeDispatcher.1.feeSplits")) - 1

types.Array internal constant $feeSplits = types.Array.wrap(0x31a3fa329157566a07927d0c2ba92ff801e4db8af2ec73f92eaf3e7f78d587a8);

$locked

The lock to prevent reentrancy

Slot: keccak256(bytes("feeDispatcher.1.locked")) - 1

types.Uint256 internal constant $locked = types.Uint256.wrap(0x8472de2bbf04bc62a7ee894bd625126d381bf5e8b726e5cd498c3a9dad76d85b);

UNLOCKED

The states of the lock, 1 = unlocked, 2 = locked

uint256 internal constant UNLOCKED = 1;

LOCKED

uint256 internal constant LOCKED = 2;

Functions

constructor

constructor();

_initFeeDispatcher

An internal function to set the fee split & unlock the reentrancy lock. Should be called in the initializer of the inheriting contract.

function _initFeeDispatcher(address[] calldata recipients, uint256[] calldata splits) internal;

nonReentrant

Modifier to prevent reentrancy

modifier nonReentrant() virtual;

withdrawCommission

Allows the integrator to withdraw the ETH in the contract.

function withdrawCommission() external nonReentrant;

getCurrentSplit

Returns the current fee split and recipients

This function is not pure as it fetches the current fee split and recipients from storage

function getCurrentSplit() external pure returns (address[] memory, uint256[] memory);

Returns

_setFeeSplit

Internal utility to set the fee distribution upon withdrawal

function _setFeeSplit(address[] calldata recipients, uint256[] calldata splits) internal;

Parameters

IntegrationFactory

Git Source

Inherits: IIntegrationFactory, Administrable, Initializable, Implementation

Author: gauthiermyr @ Kiln

IntegrationFactory deploys predefined integrations contracts through a ProxyFactory.

Unstructured Storage Friendly

State Variables

$factories

Mapping of deployed factories for channels

Type: mapping(bytes32 -> address)

Slot: keccak256(bytes("IntegrationFactory.1.factories")) - 1

types.Mapping internal constant $factories = types.Mapping.wrap(0x4e2544bc56f6c4fa0a65524c59b2051825cbd54dcbec5c39527253c4ae3998cb);

$implementations

Implementations mapping. Gives implementation address for a given channel

Type: mapping(bytes32 -> address)

Slot: keccak256(bytes("IntegrationFactory.1.implementations")) - 1

types.Mapping internal constant $implementations = types.Mapping.wrap(0x8185f5197e680e22bd57ca6481ef122b0bbaabba72f7030265b674bc0e43b011);

$outdated

Gives true for a channel if the related implementation requires a factory update

Type: mapping(bytes32 -> address)

Slot: keccak256(bytes("IntegrationFactory.1.outdated")) - 1

types.Mapping internal constant $outdated = types.Mapping.wrap(0xfa6a2da202829c8efa37af360272640192c97d0eaad911d49d5a3827eeb49e23);

$deployers

Mapping of accounts allowed to deploy integrations :

Type: mapping(address -> bool)

Slot: keccak256(bytes("IntegrationFactory.1.deployers")) - 1

types.Mapping internal constant $deployers = types.Mapping.wrap(0xb7fa6aee54ea33d353c1a47f0af14ba42a132b7ecbca87c0f3c74f23231367be);

CHANNEL_NATIVE_20_VPOOL

Channel identifier for Native vPool implementation 0x4e41544956455f32305f76504f4f4c0000000000000000000000000000000000

bytes32 constant CHANNEL_NATIVE_20_VPOOL = bytes32(abi.encodePacked("NATIVE_20_vPOOL"));

CHANNEL_LIQUID_20_A_VPOOL

Channel identifier for liquid ERC20 aToken implementation 0x4c49515549445f32305f415f76504f4f4c000000000000000000000000000000

bytes32 constant CHANNEL_LIQUID_20_A_VPOOL = bytes32(abi.encodePacked("LIQUID_20_A_vPOOL"));

CHANNEL_LIQUID_20_C_VPOOL

Channel identifier for liquid ERC20 cToken implementation 0x4c49515549445f32305f435f76504f4f4c000000000000000000000000000000

bytes32 constant CHANNEL_LIQUID_20_C_VPOOL = bytes32(abi.encodePacked("LIQUID_20_C_vPOOL"));

CHANNEL_NATIVE_1155_VPOOL

Channel identifier for native 1155 implementation 0x4e41544956455f313135355f76504f4f4c000000000000000000000000000000

bytes32 constant CHANNEL_NATIVE_1155_VPOOL = bytes32(abi.encodePacked("NATIVE_1155_vPOOL"));

CHANNEL_LIQUID_1155_VPOOL

Channel identifier for liquid 1155 implementation 0x4c49515549445f313135355f76504f4f4c000000000000000000000000000000

bytes32 constant CHANNEL_LIQUID_1155_VPOOL = bytes32(abi.encodePacked("LIQUID_1155_vPOOL"));

CHANNEL_VNFT

Channel identifier for vNFT implementation

bytes32 constant CHANNEL_VNFT = bytes32(abi.encodePacked("vNFT"));

Functions

onlyAllowedDeployer

This modifier ensures that only an allowed deployer or the contract admin is trying to deploy an integration

modifier onlyAllowedDeployer();

initialize

Initializes the contract with the given parameters.

function initialize(address admin_) external init(0);

Parameters

deployNative20vPoolIntegration

Deploy a proxy for the implementation of a Native vPool integration contract

function deployNative20vPoolIntegration(address proxyOwner, Native20Configuration calldata config)
    external
    override
    onlyAllowedDeployer
    returns (address);

Parameters

deployLiquid20AvPoolIntegration

Deploy a proxy for the implementation of a liquid ERC20 aToken vPool integration contract

function deployLiquid20AvPoolIntegration(address proxyOwner, Native20Configuration calldata config)
    external
    override
    onlyAllowedDeployer
    returns (address);

Parameters

deployLiquid20CvPoolIntegration

Deploy a proxy for the implementation of a liquid ERC20 cToken vPool integration contract

function deployLiquid20CvPoolIntegration(address proxyOwner, Native20Configuration calldata config)
    external
    override
    onlyAllowedDeployer
    returns (address);

Parameters

deployNative20vPoolIntegration

Deploy a proxy for the implementation of a Native vPool integration contract

Warning: this method does not check that the the calldata corresponds to the last implementation.

function deployNative20vPoolIntegration(address proxyOwner, bytes calldata cdata) external override onlyAllowedDeployer returns (address);

Parameters

deployLiquid20AvPoolIntegration

Deploy a proxy for the implementation of a liquid ERC20 aToken vPool integration contract

Warning: this method does not check that the the calldata corresponds to the last implementation.

function deployLiquid20AvPoolIntegration(address proxyOwner, bytes calldata cdata)
    external
    override
    onlyAllowedDeployer
    returns (address);

Parameters

deployLiquid20CvPoolIntegration

Deploy a proxy for the implementation of a liquid ERC20 cToken vPool integration contract

Warning: this method does not check that the the calldata corresponds to the last implementation.

function deployLiquid20CvPoolIntegration(address proxyOwner, bytes calldata cdata)
    external
    override
    onlyAllowedDeployer
    returns (address);

Parameters

deployNative1155vPoolIntegration

Deploy a proxy for the implementation of a native 1155 vPool integration contract

function deployNative1155vPoolIntegration(address proxyOwner, Native1155Configuration calldata config)
    external
    override
    onlyAllowedDeployer
    returns (address);

Parameters

deployLiquid1155vPoolIntegration

Deploy a proxy for the implementation of a liquid 1155 vPool integration contract

function deployLiquid1155vPoolIntegration(address proxyOwner, Native1155Configuration calldata config)
    external
    override
    onlyAllowedDeployer
    returns (address);

Parameters

deployNative1155vPoolIntegration

Deploy a proxy for the implementation of a native 1155 vPool integration contract

Warning: this method does not check that the the calldata corresponds to the last implementation.

function deployNative1155vPoolIntegration(address proxyOwner, bytes calldata cdata)
    external
    override
    onlyAllowedDeployer
    returns (address);

Parameters

deployLiquid1155vPoolIntegration

Deploy a proxy for the implementation of a liquid 1155 vPool integration contract

Warning: this method does not check that the the calldata corresponds to the last implementation.

function deployLiquid1155vPoolIntegration(address proxyOwner, bytes calldata cdata)
    external
    override
    onlyAllowedDeployer
    returns (address);

Parameters

deployVNFTIntegration

Deploy a proxy for the implementation of a vNFT integration contract

Warning: this method does not check that the the calldata corresponds to the last vNFT implementation.

function deployVNFTIntegration(address proxyOwner, bytes calldata cdata) external override onlyAllowedDeployer returns (address);

Parameters

deployVNFTIntegration

Deploy a proxy for the implementation of a vNFT integration contract

function deployVNFTIntegration(address proxyOwner, IvNFT.VNFTConfiguration calldata config)
    external
    override
    onlyAllowedDeployer
    returns (address);

Parameters

updateImplementation

Update the channel implementation address

function updateImplementation(bytes32 channel, address implem, bool updateRequired) external onlyAdmin;

Parameters

setDeployer

Allow or disallow an address to deploy integration contracts

function setDeployer(address deployer, bool allowed) external onlyAdmin;

Parameters

_factory

Internal methods

function _factory(bytes32 channel) internal view returns (address);

_implementation

function _implementation(bytes32 channel) internal view returns (address);

_isOutdated

function _isOutdated(bytes32 channel) internal view returns (bool);

_checkOutdated

Throw an error if the implementation has been updated and then the factory requires an update too

function _checkOutdated(bytes32 channel) internal view;

Parameters

_deploy

function _deploy(bytes32 channel, address owner, bytes memory cdata) internal returns (address);

_deploy20

function _deploy20(bytes32 channel, address owner, Native20Configuration calldata config) internal returns (address);

_deploy1155

function _deploy1155(bytes32 channel, address owner, Native1155Configuration calldata config) internal returns (address);

factory

Getters

function factory(bytes32 channel) external view returns (address);

Parameters

implementation

retrieve the implementation address for a channel

function implementation(bytes32 channel) external view returns (address);

Parameters

outdated

retrieve whether the implementation for a channel is outdated

function outdated(bytes32 channel) external view returns (bool);

Parameters

Liquid1155

Git Source

Inherits: Native1155, ILiquid1155

Author: 0xvv @ Kiln

This contract allows users to stake in any of the vPools with any amount of ETH and track their position

Users are given transferable shares to track their stake, shares of different pools are not equivalent

Users can interact with the contract using the ERC-1155 interface

State Variables

$approvals

Stores the approvals.

Type: mapping(address => mapping(address => bool))

Slot: keccak256(bytes("liquid1155.1.approvals")) - 1

uctypes.OperatorApprovalsMapping internal constant $approvals =
    uctypes.OperatorApprovalsMapping.wrap(0xf49f1126f15fa50e7f83c3d26f874246f4209fea59edc2c13d900d8b240b28c5);

Functions

setApprovalForAll

Give the right to an operator to transfer all tokens of the sender.

function setApprovalForAll(address operator, bool approved) external;

Parameters

isApprovedForAll

Returns the operator status of an operator for a given owner.

function isApprovedForAll(address account, address operator) public view returns (bool);

Parameters

safeTransferFrom

Transfers amount tokens of token type id from from to to with extra data.

The caller must be operator of 'from' or 'from' & 'from' must have a balance of at least amount.

function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) public virtual override;

Parameters

safeBatchTransferFrom

Batched version of safeTransferFrom.

function safeBatchTransferFrom(address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
    public
    virtual
    override;

Parameters

supportsInterface

function supportsInterface(bytes4 interfaceId) public pure returns (bool);

_safeTransferFrom

Private functions

function _safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) internal virtual;

_safeBatchTransferFrom

function _safeBatchTransferFrom(address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)
    internal
    virtual;

_setApprovalForAll

function _setApprovalForAll(address owner, address operator, bool approved) internal virtual;

_doSafeTransferAcceptanceCheck

function _doSafeTransferAcceptanceCheck(address operator, address from, address to, uint256 id, uint256 amount, bytes memory data)
    private;

_doSafeBatchTransferAcceptanceCheck

function _doSafeBatchTransferAcceptanceCheck(
    address operator,
    address from,
    address to,
    uint256[] memory ids,
    uint256[] memory amounts,
    bytes memory data
) private;

_isContract

function _isContract(address account) internal view returns (bool);

Liquid20A

Git Source

Inherits: Native20, ILiquid20

Author: 0xvv @ Kiln

This contract allows users to stake any amount of ETH in the vPool(s). Users are given an ERC-20 aToken to track their stake.

Functions

transfer

Transfers token from the caller to another address

function transfer(address to, uint256 amount) external returns (bool);

Parameters

allowance

Retrieves the amount of tokens that an owner allowed to a spender

function allowance(address owner, address spender) external view returns (uint256);

Parameters

approve

Approves a spender to transfer tokens on the caller's behalf

function approve(address spender, uint256 amount) external returns (bool);

Parameters

transferFrom

Transfers tokens from one address to another, using the allowance mechanism

function transferFrom(address from, address to, uint256 amount) external returns (bool);

Parameters

totalSupply

function totalSupply() external view override returns (uint256);

balanceOf

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

requestExit

Burns the sender's shares and sends the exitQueue tickets to the caller.

function requestExit(uint256 amount) external override;

Parameters

_transfer

function _transfer(address from, address to, uint256 amount) internal override;

_transferFrom

function _transferFrom(address spender, address from, address to, uint256 amount) internal override;

Liquid20C

Git Source

Inherits: Native20, ILiquid20

Author: 0xvv @ Kiln

This contract allows users to stake any amount of ETH in the vPool(s). Users are given an ERC-20 cToken to track their stake.

Functions

transfer

Transfers token from the caller to another address

function transfer(address to, uint256 amount) external returns (bool);

Parameters

allowance

Retrieves the amount of tokens that an owner allowed to a spender

function allowance(address owner, address spender) external view returns (uint256);

Parameters

approve

Approves a spender to transfer tokens on the caller's behalf

function approve(address spender, uint256 amount) external returns (bool);

Parameters

transferFrom

Transfers tokens from one address to another, using the allowance mechanism

function transferFrom(address from, address to, uint256 amount) external returns (bool);

Parameters

MerkleVault

Git Source

Inherits: IMerkleVault, Administrable, Initializable, Implementation

Author: mortimr @ Kiln

Funds distribution vault using merkle proofs to authorize withdrawals

State Variables

$root

The current merkle root used to verify claim requests

Slot: keccak256(bytes("merkleVault.1.root")) - 1

types.Bytes32 internal constant $root = types.Bytes32.wrap(0x1d72bdd8ebb24cdc615789f17c463dfb1fe22d0a9c3e2e83db3203cf4b1f2be0);

$ipfsHash

The current ipfs hash associated with the merkle root

Slot: keccak256(bytes("merkleVault.1.ipfsHash")) - 1

types.String internal constant $ipfsHash = types.String.wrap(0xe9bb128fd68516c65b38522aa2f7739e85d47a3214671ac9273550d2cef5e1a4);

$totalClaimedPerAccount

The mapping of already claimed amounts : mapping(address => uint256)

Slot: keccak256(bytes("merkleVault.1.totalClaimedPerAccount")) - 1

types.Mapping internal constant $totalClaimedPerAccount =
    types.Mapping.wrap(0x434b080ec0dc7613d87ca93b5b660083adb8c732eaa35678d5918a3b53d5ff81);

$totalClaimed

The sum of all claimed amounts

Slot: keccak256(bytes("merkleVault.1.totalClaimed")) - 1

types.Uint256 internal constant $totalClaimed = types.Uint256.wrap(0xd861ffae2fee684c1e2f63e370c8ea498da9e58b75f637eeee60d1a01ca75c59);

$frameSize

Amount of epochs per frame

Slot: keccak256(bytes("merkleVault.1.frameSize")) - 1

types.Uint256 internal constant $frameSize = types.Uint256.wrap(0xe906a0ea72c128fe3b63278ff794cbb58f458fcecc52717e792bf287499a0fa7);

Functions

initialize

function initialize(address admin, bytes32 initialRoot, string calldata initialIpfsHash, uint256 initialFrameSize) external init(0);

Parameters

totalClaimedForAccount

Retrieve the total claimed amount for an account

function totalClaimedForAccount(address account) external view returns (uint256);

Parameters

Returns

totalClaimed

Retrieve the total claimed on the contract

function totalClaimed() external view returns (uint256);

Returns

root

Retrieve the current merkle root

function root() external view returns (bytes32);

Returns

ipfsHash

Retrieve the ipfs hash holding the merkle tree + extra data

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

Returns

setRootAndIpfsHash

Set the current merkle root

function setRootAndIpfsHash(bytes32 newRoot, string calldata newIpfsHash) external onlyAdmin;

Parameters

claim

Claims funds based on total claimed and current amount

function claim(address account, uint256 amount, bytes32[] calldata proofs) external;

Parameters

frameSize

Retreive the number of epochs between two reports

function frameSize() external view returns (uint256);

Returns

setFrameSize

Update the number of epochs between two reports

function setFrameSize(uint256 newFrameSize) external onlyAdmin;

Parameters

fallback

fallback() external payable;

receive

receive() external payable;

_leaf

Converts the account and amount combo to a bytes32 leaf

function _leaf(address account, uint256 amount) internal pure returns (bytes32);

Parameters

Returns

_verify

Internal utility to verify if a leaf is part of a merkle tree

function _verify(bytes32 leaf, bytes32[] calldata proofs) internal view returns (bool);

Parameters

Returns

_setRootAndIpfsHash

Internal utility to change the stored merkle root

function _setRootAndIpfsHash(bytes32 newRoot, string calldata newIpfsHash) internal;

Parameters

_setFrameSize

Internal utility to change the frame size

function _setFrameSize(uint256 newFrameSize) internal;

Parameters

MultiPool

Git Source

Inherits: IMultiPool, FeeDispatcher, Administrable, ExitQueueClaimHelper

Author: 0xvv @ Kiln

This contract contains the common functions to all integration contracts

Contains the functions to add pools, activate/deactivate a pool, change the fee of a pool and change the commission distribution

State Variables

$poolMap

The mapping of pool addresses

Type: mapping(uint256 => address)

Slot: keccak256(bytes("multiPool.1.poolMap")) - 1

types.Mapping internal constant $poolMap = types.Mapping.wrap(0xbbbff6eb43d00812703825948233d51219dc930ada33999d17cf576c509bebe5);

$fees

The mapping of fee amounts in basis point to be applied on rewards from different pools

Type: mapping(uint256 => uint256)

Slot: keccak256(bytes("multiPool.1.fees")) - 1

types.Mapping internal constant $fees = types.Mapping.wrap(0x725bc5812d869f51ca713008babaeead3e54db7feab7d4cb185136396950f0e3);

$commissionPaid

The mapping of commission paid for different pools

Type: mapping(uint256 => uint256)

Slot: keccak256(bytes("multiPool.1.commissionPaid")) - 1

types.Mapping internal constant $commissionPaid = types.Mapping.wrap(0x6c8f9259db4f6802ea7a1e0a01ddb54668b622f1e8d6b610ad7ba4d95f59da29);

$injectedEth

The mapping of injected Eth for different pools

Type: mapping(uint256 => uint256)

Slot: keccak256(bytes("multiPool.1.injectedEth")) - 1

types.Mapping internal constant $injectedEth = types.Mapping.wrap(0x03abd4c14227eca60c6fecceef3797455c352f43ab35128096ea0ac0d9b2170a);

$exitedEth

The mapping of exited Eth for different pools

Type: mapping(uint256 => uint256)

Slot: keccak256(bytes("multiPool.1.exitedEth")) - 1

types.Mapping internal constant $exitedEth = types.Mapping.wrap(0x76a0ecda094c6ccf2a55f6f1ef41b98d3c1f2dfcb9c1970701fe842ce778ff9b);

$poolActivation

The mapping storing whether users can deposit or not to each pool

Type: mapping(uint256 => bool)

Slot: keccak256(bytes("multiPool.1.poolActivation")) - 1

types.Mapping internal constant $poolActivation = types.Mapping.wrap(0x17b1774c0811229612ec3762023ccd209d6a131e52cdd22f3427eaa8005bcb2f);

$poolShares

The mapping of pool shares owned for each pools

Type: mapping(uint256 => uint256)

Slot: keccak256(bytes("multiPool.1.poolShares")) - 1

types.Mapping internal constant $poolShares = types.Mapping.wrap(0x357e26a850dc4edaa8b82b6511eec141075372c9c551d3ddb37c35a301f00018);

$poolCount

The number of pools.

Slot: keccak256(bytes("multiPool.1.poolCount")) - 1

types.Uint256 internal constant $poolCount = types.Uint256.wrap(0xce6dbdcc28927f6ed428550e539c70c9145bd20fc6e3d7611bd20e170e9b1840);

$depositPaused

True if deposits are paused

Slot: keccak256(bytes("multiPool.1.depositsPaused")) - 1

types.Bool internal constant $depositPaused = types.Bool.wrap(0xa030c45ae387079bc9a34aa1365121b47b8ef2d06c04682ce63b90b7c06843e7);

$maxCommission

The maximum commission that can be set for a pool, in basis points, to be set at initialization

Slot: keccak256(bytes("multiPool.1.maxCommission")) - 1

types.Uint256 internal constant $maxCommission = types.Uint256.wrap(0x70be78e680b682a5a3c38e305d79e28594fd0c62048cca29ef1bd1d746ca8785);

Functions

notPaused

This modifier reverts if the deposit is paused

modifier notPaused();

pools

Returns the list of vPools.

function pools() public view returns (address[] memory);

Returns

pauseDeposits

Allows the integrator to pause and unpause deposits only.

function pauseDeposits(bool isPaused) external onlyAdmin;

Parameters

depositsPaused

Returns true if deposits are paused, false otherwise

function depositsPaused() external view returns (bool);

getFee

Returns the current fee in basis points for the given pool.

function getFee(uint256 poolId) public view returns (uint256);

Parameters

Returns

changeFee

Allows the integrator to change the fee.

Reverts if there are unsold integrator shares.

function changeFee(uint256 poolId, uint256 newFeeBps) external onlyAdmin;

Parameters

changeSplit

Allows the admin to change the fee sharing upon withdrawal.

function changeSplit(address[] calldata recipients, uint256[] calldata splits) external onlyAdmin;

Parameters

addPool

Allows the integrator to add a vPool.

Reverts if the pool is already in the pools list.

function addPool(address pool, uint256 feeBps) external onlyAdmin;

Parameters

getPoolActivation

Returns true if the pool is active, false otherwise

function getPoolActivation(uint256 poolId) external view returns (bool);

Parameters

integratorCommissionOwed

Returns the ETH value of integrator shares left to sell.

function integratorCommissionOwed(uint256 poolId) external view returns (uint256);

Parameters

Returns

exitCommissionShares

Allows the integrator to exit the integrator shares of a vPool.

function exitCommissionShares(uint256 poolId) external onlyAdmin;

Parameters

onvPoolSharesReceived

function onvPoolSharesReceived(address operator, address from, uint256 amount, bytes memory) external returns (bytes4);

_exitCommissionShares

PRIVATE METHODS

Internal utility to exit commission shares

function _exitCommissionShares(uint256 poolId) internal;

Parameters

_sendSharesToExitQueue

Internal utility to send pool shares to the exit queue

function _sendSharesToExitQueue(uint256 poolId, uint256 shares, IvPool pool, address ticketOwner) internal;

_findPoolIdOrRevert

Internal utility to find the id of a pool using its address

Reverts if the address is not found

function _findPoolIdOrRevert(address poolAddress) internal view returns (uint256);

Parameters

_setFee

Internal utility to set the integrator fee value

function _setFee(uint256 integratorFeeBps, uint256 poolId) internal;

Parameters

_getPool

Internal utility to get get the pool address

function _getPool(uint256 poolId) public view returns (IvPool);

Parameters

Returns

_addPool

Add a pool to the list.

function _addPool(address newPool, uint256 fee) internal;

Parameters

_checkPoolIsEnabled

Reverts if the given pool is not enabled.

function _checkPoolIsEnabled(uint256 poolId) internal view;

Parameters

_stakedEthValue

Returns the ETH value of the vPool shares in the contract.

function _stakedEthValue(uint256 poolId) internal view returns (uint256);

Returns

_integratorCommissionEarned

Returns the amount of ETH earned by the integrator.

function _integratorCommissionEarned(uint256 poolId) internal view returns (uint256);

Returns

_integratorCommissionOwed

Returns the amount of ETH owed to the integrator.

function _integratorCommissionOwed(uint256 poolId) internal view returns (uint256);

Returns

_ethAfterCommission

Returns the ETH value of the vPool shares after subtracting integrator commission.

function _ethAfterCommission(uint256 poolId) internal view returns (uint256);

Returns

_poolSharesOfIntegrator

Returns the number of vPool shares owed as commission.

function _poolSharesOfIntegrator(uint256 poolId) internal view returns (uint256);

Returns

_setMaxCommission