2.50%
of the initial token supply (25,000,000 DYDX
) will be distributed to users staking USDC to the liquidity staking pool.14 days
(Blackout Window) before the end of an epoch in order to be able to withdraw the staker's USDC after the end of that epoch. If stakers do not request to withdraw, their staked USDC is rolled over into the next epoch.LS1EpochSchedule
. The borrowed USDC may only be used on dYdX’s Layer 2 Protocol — this is enforced via theStarkProxy
contract which interacts with theStarkEx Perpetual Exchange
contract.Wintermute
, Amber Group
, Wootrade (Kronos)
, Sixtant
, and DAT Trading
, who have been actively market-making on the dYdX Layer 2 Protocol.withdrawStake
. In the same transaction that USDC leaves a staker's wallet, stkUSDC enters the staker's wallet; or vice-versa when unstaking.stake
function. Users can also deposit and stake USDC on behalf of another address by calling thestakeFor
function. Even if you stake USDC directly on the smart contract, you will be deemed to have notice of, and reviewed, the Revolving Credit Agreement (link here).requestWithdrawal
function cannot be called during a blackout window, which is initially configured as the last14 days
of an epoch. New epochs start every 28 days. In other words, users can request a withdrawal for the next epoch up to14 days
before the end of a given epoch.14 days
before the end of an epoch in order to be able to withdraw the staker's USDC after the end of that epoch. If stakers do not request to withdraw, their staked USDC is rolled over into the next epoch.requestWithdrawal
function to request to withdraw USDC for the next epoch. User funds will remain staked and not withdrawable for the current epoch. Starting in the next epoch, funds will be “inactive” and available for withdrawal.withdrawStake
function to withdraw inactive USDC to a specific address. Users can select the amount of inactive funds they want to withdraw or call the `withdrawMaxStake` function to withdraw all inactive funds. The withdrawMaxStake
function is less gas-efficient than querying the max via eth_call and calling withdrawStake()
.setBorrowerAllocations
and setBorrowingRestriction
functions are called to change the allocations of certain borrowers. They can be used to add and remove borrowers. Increases take effect in the next epoch, but decreases will restrict borrowing immediately. These functions cannot be called during the blackout window.autoPayOrBorrow()
to ensure maximum usage of allocated USDC and timely repayment of requested withdrawals. The function only needs to be called successfully once per epoch for a borrower to ensure they are meeting their responsibilities.StarkProxy
contract does not have enough USDC for repayment. In this case, USDC must be added, or withdrawn from the exchange before calling autoPayOrBorrow()
.StarkProxy
and use its on the dYdX Layer 2 Protocol in the same account as borrowed USDC. USDC may be withdrawn from StarkProxy
in either of the following situations:StarkProxy
contract in excess of the borrowed balance may be withdrawn at any time.StarkProxy
contract supports the following borrower-controlled roles. These may be held by a single address or separate addresses depending on the security needs of the borrower. Each role can be held by any number of addresses.StarkProxy
.LiquidityStakingV1
and StarkPerpetual
contracts.forcedWithdrawalRequest()
or forcedTradeRequest()
on the StarkEx Perpetual Exchange
contract.autoPayOrBorrow()
, borrow()
, repay()
, and repayDebt()
on the Liquidity Staking contract.registerUserOnExchange()
, depositToExchange()
, and withdrawFromExchange()
on the StarkEx Perpetual Exchange
contract.StarkProxy
to an allowed recipient.StarkProxy
.StarkProxy
contract.StarkProxy
contract.StarkProxy
contract (e.g. as the second step of a slow withdrawal from the exchange).StarkProxy
contract while circumventing the balance check.markDebt()
function may be called, by anyone, by specifying a list of borrowers who have exceeded their allocations. The amount by which a borrower's borrowed balance exceeds their allocation is called the borrower's shortfall amount.markDebt()
is called, the shortfall amount of each borrower is moved out of their borrowed balance and into a balance called the debt balance. At the same time, the aggregate of these shortfall amounts is taken out of staker inactive balances and distributed as staker debt receipts. Each staker’s inactive balance will take a haircut, and each staker will receive an equivalent amount in the form of debt. In this way, the loss from insolvency is socialized (pro-rata) across all stakers holding inactive balances.markDebt()
is called on a borrower, that borrower loses the right to borrow any further funds from the contract. This right can be reinstated by governance.