Versions Compared

Old Version 101

changes.mady.by.user Ed Rotthoff

Saved on

compared with

New Version 102

changes.mady.by.user Eric Butz

Saved on

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.
Table of Contents

Links

Design

  • This section addresses some of the higher level questions and design issues that must be addressed by the project.

Questions Re FIP-21

Question

Answer

Would it be useful to provide a getter that will tell the user what the rewards amount will be if they unstake now?

whats your opinion on a getter get_staking_rewards(pubkey, amount) returning a breakdown of the rewards and principle..

I would make it more generic and not pass the amount. Also we may need to add staked tokens in get_balance. Let me spec it.

stakefio, unstakefio is bundled, what is the fee when the bundle count is expired?

do some analysis of the finished implementation and come up with recommend.

What are the specific logistics of daily_staking_rewards, and total_staking_rewards?

The daily_staking_rewards should only be used to understand if tokens for staking rewards needs to be minted. Both the total and the daily should be incremented together in synchrony otherwise.

do we need to have the Rate of Exchange (ROE) stored in state. We can compute it when needed, it looks like everywhere we need it we are reading the state table with the info anyway, so its just a divide computation to arrive at the value.

its fine to use the values that make up this value and compute it on the fly as needed and not store it in state.

What are the units of SRP. should we come up with a units of SRP for this, i also would like to understand if theres any decimal resolution necessary for SRPs (similar to SUFs)..

lets call them SUS (smallest units SRP) and lets use 9 decimals just as we do SUFs.

When a user performs multiple stakings, lets say day one they stake 200 FIO, day 2 they stake 100 FIO, then they call unstake on 250 FIO. is it safe to assume that unstaking will perform logic that looks for the longest duration staking and apply that ROE for the amount to unstake, perform that unstake, then go to the next staking event and apply the remained to that event, and so on until all of the desired amount is unstaked, the final stake will need to be “adapted” so as to remain accurate, in this case the day 2 stake will need adapted to become 50 FIO instead of the original 100.

we just store SRPs which are computed when we stake, these are additively recorded upon staking, and decremented upon unsticking.

we also store the total number of FIO which are staked per account, these are also additively recorded upon staking a dn decremented upon unstaking.

so we need two numbers stored by account total_SRPs and total_staked_fio.

The FIP will be reviewed with this in mind and we will attempt to clarify this at the FIP level.

Some clarity is needed regarded what to do when there are locked tokens (Mainnet locks, and general locks)

if an account has genesis locked tokens or General (FIP-6) locks are they prohibited from staking?

Accounts are never prohibited from staking.

if the account has main net locked tokens, then the user may stake and unstake the unlocked portion of those tokens in that account (all unlocked tokens are eligible for staking, and should stake and unstake as expected).

if the account has general locked tokens, then the user may stake and unstake the unlocked portion of those tokens in the account (all unlocked tokens are eligible for staking, and should stake and unstake as expected).

the FIP will be examined to see if clarification can be added.

RAM increment amounts are not specified for the actions in this FIP please add details for RAM increment amounts

these will be computed during development, and updated into the FIP a place holder will be added for this.

Add a line in the implementation of actions to check for max FIO transaction size exceeded.

this will be added to the FIP

Design Approach/Overview

New Constants (dev complete 3/29/2021)

Constant values will be added to the system for the following items:

...

STAKING_REWARDS_RESERVE_MAXIMUM – this will be set to 25,000,000,000,000,000 FIO SUFS.

New Table

We will create a new table in state called the global staking info info this will have the following attributes.

...

this is the amount that has been minted so far for rewards.

(units SUFs)

Requirement: Storing the values of the total_SRPs, and the total_staked_fio by FIO account

There are a couple of approaches to this which should be considered:

...

this approach does not impact the account map or other areas of fio.

Requirement: lock tokens for existing accounts.

We must design a means for the FIO Protocol to perform 2 operations which it does not today:

1) add general locks to a pre-existing FIO account.

The initial thought on this is to make a new contract action that does the job of creating a lock on a pre-existing account, this should only be callable contract to contract (authorization checks should prohibit other callers from calling the action).

2) modify pre-existing lock information to properly record the resulting locks whenever unstaking occurs.

The initial thought is to make a new action addlockperiod which will only be callable contract to contract, (authorization checks should prohibit other callers from calling the action).

...

Code Block
  if (main net locks exist) 

              {

                 Check to see if the account has a general lock (fip-6) already.

                 if (general locks exist)

                 {

                      adapt the lock amount, remaining lock amount, and lock periods to add the new 7 day lock.

                 }

                else

                 {

                     verify the remaining locked amount in the account. (amount in account - main net remaining locked >= amount to lock)

                     make a new general lock with one seven day period.

                 }

             }

             else  if main net locks do not exist.

             {

                 Check to see if the account has a general lock (fip-6) already.

                 if (general locks exist)

                 {

                      adapt the lock amount, remaining lock amount, and lock periods to add the new 7 day lock.

                 }

                else

                 {

                       make a new general lock with one seven day period.

                 }

             }

Requirement: Accumulate and manage staking rewards

Proposed:

  • Modify the fio.common process_rewards, processbucketrewards, and processrewardsnotpid to perform the accumulation and management of staking rewards

  • Small cleanup of code, to remove int literals from these methods, and use global constants.

Requirement: Perform fee accounting, and new BP claim logic to manage staking rewards (including minting)

Proposed:

  • Modify the existing bpclaim action in the fio.treasury towards this purpose.

Requirement: Compute the usable balance accurately when an account has staked tokens.

Proposed:

  • Modify the existing logic computing usable balance to include staking amounts. (fio.token contract). Presently main net locked tokens and general (FIP-6) locks cannot co-exist within an account. This FIP specifies that main net locks, general locks, and staking of tokens can all co-exist within an account in FIO. This will require some careful rework of the logic computing usable balances for transfer.

Requirement: staked tokens count towards votable balance.

Proposed:

  • since we will permit main net and FIP-6 locks to co-exist, we must combine the votable balance computations to provide an accurate votable balance when both types of lock are co-existing in the same account.

Requirement: staked tokens cannot be used to pay fees.

  • we must ensure that staked token balances are accounted for properly in fee pay logic. this affects fio.token contract transfer action, we must ensure that staked amounts are accounted for accurately.

Requirement: TPIDs will receive a percentage of the Fees AND part of staking rewards.

  • When user unstakes FIO Tokens, the TPID attached to the unstake action receives 10% of the difference between tokens being unstaked and FIO Tokens received as a result of SRP to FIO Token conversion. If no TPID is provided, the 10% remains undistributed.

Requirement: In order for you to stake tokens you must have voted in the past 30 days, or auto proxied.

  • we must enforce this business rule.

Summary of changes to fio and fio.contracts

  • a list of affected contracts, files and changes to files. including logic will be posted.

    • fio.common.hpp – add new constants for

      • STAKED_TOKEN_POOL_MINIMUM,

      • STAKING_REWARDS_RESERVE_MAXIMUM

      • process_rewards – modify percentages, integrate update to staking globals.

      • processbucketrewards – modify percentages, integrate update staking globals.

      • processrewardsnotpid – modify percentages, integrate update staking globals.

      • add constants for percentage amounts in rewards processing, instead of int literals.

    • fio.staking.hpp

      • staking_info – struct for the global staking info records in the global staking table.

      • account_staking_info – struct for account staking info records in account_staking table.

      • add new tables

        • global_staking – the table to hold global staking info.

        • account_staking – the table holding account-wise staking info.

    • fio.staking.cpp

      • stakefio – perform the staking of fio.

      • unstakefio – perform the unstaking of fio.

      • add the following actions to the fio.staking contract

        • Code Block
          //FIP-21 actions to update staking state.

//clrgdailyrew performs the clearing of the daily rewards.
// params none!
// logic
//   set daily_staking_rewards = 0;

//incgstkmint increments the staking_rewards_reserves_minted
// params
//     amountfiosufs, this is the amount of FIO that has been minted, units SUFs
//FIP-21 actions to update staking state.

    • fio.system.cpp --add new actions for (these actions will be added to the fio.staking contract, once this is prototyped successfully this document will be updated).

      • adaptlock – update FIP-6 locks.

      • updbpclaim – update to perform necessary accounting for staking.

      • resetclaim – update to perform necessary accounting for staking.

    • voting.cpp

      • the computation of the votable balance will be modified to properly consider accounts having main net locks, general locks and staked tokens (along with the rules for voting for these)..

    • fio.treasury.cpp –

      • bpclaim – modify to perform modified logic for staking, including minting of staking rewards according to spec.

    • fio.token.hpp --

      • can_transfer, can_transfer_general – we will combine the logic of these 2 calls into one call that checks main net locks, general (FIP-6) locks, and staking amount to determine the allowability of transfers.

Summary of FIO core changes.

In order for new contracts to be added to the Fio Protocol, the FIO core code must be modified to add new system accounts to the list of system accounts. This is somewhat limiting and forces the systems core code to be upgraded by all BPs, integrators, exchanges, and API node operators. The solution to this is to provide enhancements to the FIO core so that the system uses the contract names in the actions table to determine the list of system accounts. These changes will be developed and delivered before this project delivers, and this will remove the need for future mandatory upgrades for projects introducing new contracts and system accounts (such as wrapping, marketplace, and any others that come about).

Actions and Endpoints

  • New Actions

    • stakefio

    • unstakefio

    • adaptlock

    • please see above list of actions in fio.staking for comprehensive list.

  • Modified Actions

    • updlbpclaim

    • resetclaim

    • bpclaim

    • transfer

    • trnsfiopubky

Structs and ABIs

  • ABI changes will be published here as development commences.

Tables

  • fio.staking contract

    • staking table – this is the new table which will hold global state items relating to staking.

      • uint64_t staked_token_pool – this will be the total FIO tokens staked for all FIO users. (units FIO SUF)

      • uint64_t combined_token_pool – this will be the total FIO tokens staked for all FIO users plus the staking rewards. (units FIO SUF)

      • uint64_t rewards_token_pool – this is the value of the total staking rewards (units SUFs)

      • uint64_t global_SRP_count –this is the global SRP count used to compute the rate of exchange for staking rewards. (Units SUS)

      • uint64_t daily_staking_rewards – this is the value of the staking rewards per day. (units SUFs)

      • uint64_t staking_rewards_reserve_minted –this is the amount that has been minted so far for rewards. (units SUFs)

      • uint64_t treasury_staking_rewards –this is the amount of FIO in the treasury ear marked for staking rewards. (units SUFs)

    • stakeaccount – this is a new table that will hold staking information by FIO account.

      • uint64_t id – unique id for the staking event

      • name account – the account that staked.

      • uint64_t total_SRPs – the total SRPs to be awarded (units SUSs).

      • uint64_t total_staked_fio – the total fio staked by this account (units SUFs)

Project Plan

color key

(blue items – in progress)

...

  • Epic – FIO staking

    • Stories

      • Produce design spec, and revise FIP-21. (1 week Complete)

        • review internal, and community.

      • FIO Staking Development (3 weeks In progress 85% complete)

        • implement the solution as per FIP-21 and detailed development spec.

          • Started work March 29

          • constants implemented

          • staking global state implemented

          • account staking implementation implemented

          • port existing work to new contract fio.staking, completed

            • make shell of the new contract and integrate into the build.

            • integrate all table implementations for staking into fio.staking contract.

            • integrate stake and unstake shell into fio.staking contract.

          • Develop new logic to permit new contracts and system accounts to be added to the FIO protocol without mandatory core upgrades (completed, in QA for Bahamas)

          • implement and test actions to update global state for staking. In progress (100% completed)

            • implement stakefio (completed)

            • implement unstakefio (completed)

            • implement modified locking mechanism to support unstakefio (completed)

            • impelement and test incgrewards

            • implement and test clrdrewards

            • implement and test recorddaily

          • adapt usable balance logic

          • adapt voting power logic

          • transfer

          • transfer using pub key

          • modify fee collection logic

            • process_rewards

            • processbucketrewards

            • processrewardsnotpic

          • bpclaim

            • bpclaim

          • implement the removal of expired periods during lock adaptation on unstaking.

          • implement the use of an existing period if there is a period in this same day during unstaking

          • Implement new model for general locks, place SUF amount instead of percent.

            • retire old lock tokens and replace with locktokensv2 table.

            • integrate new table throughout contracts and chain_plugin.

        • Dev test. (30% completed)

          • Regression testing (runs of fio.test) completed

          • dev test cases

            • pre existing main net locks (test all unlocking periods using transfer and vote producer) (manual testing completed)

            • pre existing main net locks (test staking and transfer before and after first unlock period) (javascript fio.test integrated testing completed)

            • modify all general locks tests to run with the new v2 general locks table.

            • modify performance tests to use new general locks structure

            • incgrewards

            • recorddaily

            • no pre-existing locks

            • pre existing general locks

            • use existing main net locked account to create general lock

            • pre existing main net AND general locks

        • develop tests matching test plan in design spec.

        • internal code review

        • internal testing review.

        • perform QA and resolve all issues (comprehensive QA analysis)

        • Acceptance testing review by product owner.

      • FIO staking – Security/Performance testing (dev net) (1 week)

        • develop tests to load system and drive volume of requests (we desire a max stakes test, and also a volume of staking unstaking requests once loaded maximally) performance test plan is still TBD.

      • Rollout testing (dev net) (2 days)

        • load previous version of contracts, perform contract MSIGs, repeat load testing.

      • Test net testing – (1 week)

        • roll out msigs, perform subset of functional tests on test net (tests to be performed are TBD)

      • Main net rollout (2 days)

        • roll out MSIGs, perform minimal success testing to verify deployment (tests to be performed are TBD).

  • security of the new locking actions will require relatively complete QA testing (a test plan will be published).

Risks

  • Performance analysis should be performed on dev net. A testing plan will be published.

  • security of the new locking actions will require relatively complete QA testing (a test plan will be published).

  • This FIP provides that main net locks, general (FIP-6) locks, and staking amounts can co-exist together within an account. So testing of main net locks, and general locks will need to be performed to ensure bugs are not introduced.

SDK Requirements

  • Update all SDKs to include new endpoints for staking.

  • FIOSdk_typescript

    • integrate stakefio into SDK (6 hours) (completed)

    • expand tests to cover stakefio in SDK (4 hours)

    • Integrate unstakefio into SDK (6 hours)

    • expand tests to cover unstakefio (4 hours)

    • integrate changes to get_balance (4 hours)

    • integrate get_staked_info into SDK (6 hours)

    • expand tests to cover get_staked_info (4 hours)

  • FIOSdk_Kotlin

    • integrate stakefio into SDK (6 hours)

    • expand tests to cover stakefio in SDK (4 hours)

    • Integrate unstakefio into SDK (6 hours)

    • expand tests to cover unstakefio (4 hours)

    • integrate changes to get_balance (4 hours)

    • integrate get_staked_info into SDK (6 hours)

    • expand tests to cover get_staked_info (4 hours)

  • FIOSdk_IOS

    • integrate stakefio into SDK (6 hours)

    • expand tests to cover stakefio in SDK (4 hours)

    • Integrate unstakefio into SDK (6 hours)

    • expand tests to cover unstakefio (4 hours)

    • integrate changes to get_balance (4 hours)

    • integrate get_staked_info into SDK (6 hours)

    • expand tests to cover get_staked_info (4 hours)

Functional Testing

Design

  • Main net (genesis) locks functional testing

  • APPROACH --

    • The approach is to cover the required regression testing as efficiently as possible, transfer fio pub key, voting for producers, staking and unstakingre are the critical calls, these calls need to be tested so as to ensure overflow errors are not present, and that the proper unlocking is performed by the system according to the schedule. it will be important to create test accounts that have been granted the largest and smallest scale of FIO genesis grants (is this 100M and 1M), then test these grants in various ways throughout the unlocking periods.

    • The FIO Protocol will need to be set up to have a shorted unlocking period for testing, this will provide efficient time utilization.

      • set the system unlocking period to be a new pre-determined interval (10-20 minutes)

      • load the system with genesis grants that match closely the genesis grants provided at FIO launch

        • at least have a few that use the same scale of locked token values (hundreds of thousands, millions, tens of millions)

        • perhaps have an account directed at each test case identified.

      • regression test unlocking of genesis grants. (transfer and vote must both be tested to verify they unlock properly after being called)

        • tactic one – skip unlock periods, verify proper unlocking when periods are skipped.

        • tactic two – unlock every period sometime after the unlock

        • tactic three – wait until all unlocking periods pass then transfer or vote.

        • tactic four – error testing.

          • verify that transfers fail with more than the unlocked amount specified.

          • other error scenarios.

        • tactic five – no action scenarios

          • vote multiple times in a row, note that no unlocking occurs on subsequent unlocks.

      • regression test staking and unstaking during unlocking periods.

        • perform stake and unstake

        • shorten the 7 day unlock period on unstake to some pre-determined test duration.

        • perform transfers both before and after the unstaking lock period is expired.

      • error scenarios

        • verify staking and unstaking failures

          • inadequate unlocked funds.

          • cannot unstake more than has been staked.

          • more…

  • General (FIP-6) locks testing

    • regression test general locks, unlocking and transfer especially.

    • existing tests may be adequate for this.

  • Staking rewards Tests

    • load system with load which does not provide minting. (less than 1M staked).

      • verify correct BP rewards

      • verify correct staking rewards.

    • load system with load which does provide minting. (more than 1M staked)

      • verify correct BP rewards

      • verify correct staking rewards.

  • stakefio

    • Authorization Tests

      • call using authority not matching actor, invalid signature error.

    • Parameter tests

      • set amount 0 invalid amount error.

      • set amount -100 invalid amount error.

      • set max_fee 0 invalid fee error.

      • set max_fee -100 invalid fee error

      • set invalid tpid – invalid tpid error.

      • set invalid actor – invalid actor error.

    • Success tests

      • stake fio from an account that has genesis tokens unlocked. verify global state results

        • perform multiple consecutive stakes of varying amounts that are premised. verify global state results

      • stake fio from an account that has FIP-6 locked token grant, and unlocked tokens. verify global state results

        • perform multiple consecutive stakes of varying amounts that are premised. verify global state results

      • stake from an account with FIP-6 locked token grant and tokens added to account. verify global state results

        • perform multiple consecutive stakes of varying amounts that are premised. verify global state results

      • stake from an account without any locked token grants. verify global state results

        • perform multiple consecutive stakes of varying amounts that are premised. verify global state results

    • Failure tests

      • stake more than account has unlocked, fio from an account that has genesis locked tokens.

      • stake more than account has unlocked, fio from an account that has FIP-6 locked tokens.

      • stake more than account has, fio from an account that has no locked tokens.

  • unstakefio

    • Authorization Tests

      • call using authority not matching actor, invalid signature error.

    • Parameter tests

      • set amount 0 invalid amount error.

      • set amount -100 invalid amount error.

      • set max_fee 0 invalid fee error.

      • set max_fee -100 invalid fee error

      • set invalid tpid – invalid tpid error.

      • set invalid actor – invalid actor error.

    • Success tests

      • unstake amount less than what was staked. verify accounting. verify lock result

        • examine if this is necessary to test on locked token accounts. verify lock result

      • unstake remained that is staked. verify accounting. verify lock amount.

        • examine if this is necessary to test on locked token accounts.

    • Failure tests

      • unstake more than remaining staked. verify error/exceptioin.

  • adaptlock

    • Authorization Tests

      • call as a non system account, verify this fails with auth error.

    • Parameter tests

      • call with duration on locking period set to 0

      • call with duration on locking period set to -100

      • call with percent set to 0

      • call with percent set to -1

    • Success tests

      • see unstake fio success tests, these drive these success cases.

    • Failure tests

      • see unstake failure tests, these test through this logic.

  • updatestake

    • Authorization Tests

      • call as a non system account, verify this fails with auth error.

    • Parameter tests

      • call with invalid parameters, for each parameter, verify errors.

    • Success tests

      • call bpclaim, verify that daily staking is updated as expected.

      • see stakefio success tests

      • see staking rewards tests.

    • Failure tests.

      • evaluate, and discover any test cases necessary.

Results

  • Link to JS tests and description of which test sections were updated/added

  • Paste results of tests

Performance Testing

Design

  • Load the system with 50k accounts holding FIO.

    • make each account to have staked tokens.

    • hit the chain with volumes of stake and unstake operations (verify the results after each).

    • the goal is to ensure that as the FIO protocol expands in adoption, that larger volumes of staking users won't become problematic.

Results

  • Summary of performance tests that were run and results

Fork Testing plan

  • This project does not introduce any mandatory changes to existing table structures, no fork testing is required.

  • A pre and post contracts update will be published.

  • Modifications to add new endpoints to the chain code will be tested.

    • changes to get_staked

Rollout/Release plan

  • a comprehensive list of all necessary changes will be published

    • chain code update for new endpoints. call each new endpoint and verify success case function.

    • fio.treasury

    • fio.system

    • all contracts using fio.common.hpp (a complete list will be made as development proceeds using contract hashes).

  • Include (new actions, removed actions, MSIGs for all required operations, and step by step instructions.

    • verify success case stakefio, unstakefio, get_staked_info (use the functional tests to verify success cases).

Rollout/Release verification plan

  • verify success case stakefio, unstakefio, get_staked_info (use the functional tests to verify success cases).

Branching Strategy/Code logistics

  • Development branches for this effort will be created as follows.

    • fio – feature/FIO-staking-fio-develop-05122021

    • fio.contracts – feature/FIP-21-Staking-fio-contracts-develop-03212021

    • fio.devtools – feature/FIP-21-Staking-fio-devtools-develop-04282021

Project Progress

  • 3/19 Review of the Detailed Design Specification

    • attendees Lukes Stokes, Paweł Mastelerz, Adam Androuladakus, Casey Gardener, Todd G.

    • discussions included

      • Is is more desirable to move towards a notion of rewards points, and away from the notion of SRP (a token, that isn't a token).

        • it was deemed desirable to move to the notion of rewards points (SRP).

      • the necessity of the 7 day holding period.

        • deemed to be necessary to discourage gaming style use of the process.

      • should the rewards points be a whole number.

        • deemed to be necessary to maintain the 9 digit resolution.

      • should we consider to purge general locks of any already used locking periods as we go through the process of modifying locks to add new locking periods for the 7 day locking period.

        • YES

      • to prohibit a performance based attack on the locking periods, is it best to establish one time of day for seven day unlocking period, and then set all unstaking events done that day to use this locking period (IE: modify this locking period as multiple unstaking events occur during the same day).

        • YES

      • What if a general lock is made which is not votable?

        • Make the general grant votable? this has implications.

        • Make the staked amount to be not votable.

        • fail the staking request with an error, and instruct the user to stake in another account.

        • the most desirable option is to fail with an error. this will be implemented.

      • Can you add information to the design addressing the management of voting weights?

        • yes, this is completed.

      • add information for the important requirements ( tpids receive part of rewards, must have voted in the past 30 days).

...