1 Links
2 Design
3 Questions Re FIP-21
4 Design Approach/Overview
5 Project Plan
6 Risks
7 SDK Requirements
8 Functional Testing
- 8.1 Design
- 8.2 Results
9 Performance Testing
- 9.1 Design
- 9.2 Results
10 Fork Testing plan
11 Rollout/Release plan
12 Rollout/Release verification plan
13 Branching Strategy/Code logistics
14 Project Progress

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

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. (Still TBD?)
stakefio, unstakefio is bundled, what is the fee when the bundle count is expired?	TBD: 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:

COMBINED_TOKEN_POOL_MINIMUM – this will be set to 1,000,000,000,000,000 FIO SUFS

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.

staked_token_pool –

this will be the total FIO tokens staked for all FIO users.

(units FIO SUF)

combined_token_pool –

this will be the total FIO tokens staked for all FIO users plus the staking rewards for all FIO users.

(units FIO SUF)

rewards_token_pool –

this is the amount of rewards collected from fees plus the amount of rewards minted. it is also the amount of rewards available for all of the fio accounts with staked tokens.

(units SUFs)

global_SRP_count –

this is the global SRP count used to compute the rate of exchange for staking rewards.

(Units SUS)

total_staking_rewards –

this is the value of the total staking rewards

(units SUFs)

daily_staking_rewards –

this is the value of the staking rewards per day.

(units SUFs)

staking_rewards_reserve_minted –

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:

Approach #1: Binary Extension of eosio_name/accountmap

The accountmap table already exists within the FIO Protocol. This table can be extended using binary extenstion to add a new attribute called rate_of_exchange.

advantages – no duplication of account in state tables.

disadvantages –

migration issues after update.

testing after the binary extension is very important, after the deployment of the binary extension, the table entries that have not yet set the value of this new attribute will not return the new attribute in the return data using get table, we must test scenarios where an account has been updated to the new table struct, but has not yet done staking, and then calls unstake, we must also test these updated accounts for staking.

Approach #2 (PREFERRED): Create new table with mapping for accounts that stake:

This approach would create a new table called user staking, this table would contain entries for accounts that have staked. when an account unstakes, the entry for that account would be removed from state.

Each user staking record has the following attributes.

id – unique id for the staking event.
account – the account that staked.
total_SRPs – the total SRPs to be awarded (units SUSs).
total_staked_fio – the total fio staked by this account (units SUFs)

dis-advantages – this approach duplicates the account info in state for accounts that stake.

advantages –

this approach only stores staking records in state for staking events for accounts, accounts that do not stake will not have any additional state information associated with the account.

this approach has no migration issues since a new table is created to hold the staking info for accounts.

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

We need to properly lock for 7 days when a user unstakes tokens, even when they have other locked tokens within the account.
When an account has a pre-existing FIP-6 lock (or Main net locks). We need to manage the accounts FIO and general (FIP-6) lock information so that the locking information remains accurate going forward.

We need to do some optimized form of the following logic:

Check to see if the account has Main net locks.

  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 (for unstaking only, you still cannot create a lock on an account with existing tokens), 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: 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: If auto proxy is used in the staking call, the code should not fail voting checks if this is the first call using tpid (when the auto proxy is being established IN the staking call).

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.
  - set_auto_proxy – add a new common method to set auto proxy (usable from bundled fees in staking)
- 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
    - //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.system – establish a new table for general locks locktokensv2 the old table will be retired.
- establish the use of an unlock amount instead of a percentage.
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)

(green items – completed)

(black items – to be completed)

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)
        https://fioprotocol.atlassian.net/browse/BD-2448
      - 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
        modify tests to perform auto proxy testing.
    - 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 requiring testing (and the grant amounts need to be very large grants in the 10s of M in fio), 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. For QA testing 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 needs to be set up to have a shorted unlocking period for testing, (in the current staking branch for fio.contracts, the current time set for genesis locking periods is 2 minutes.)
- The fio.test repository should cnfigure the index.js so that the only test to be run is the test stake-mainnet-locked-tokens.js
- init a dev local test environment by running the 20_debug_staking.sh during chain startup. (the dev branch for staking is already set up to run this script during startup)
- When the chain is initialized. IMMEDIATELY run the rpm test to run these tests.
- expected results, the tests will run and the later tests MAY experience a duplicate tx error, this is OK as long as duplicate TX error is the only error you see.
- these tests run minimal staking tests on the genesis locked token account and they are NOT meant to test token unlocking.
Testing Genesis locked token grant unlocking.
- pre-test setup (not completed yet)
  - set up the 20_debug_staking.sh script to create 2 new locked token accounts
    - one with 10M (be sure to make lock amounts fully populated in resolution, IE 10123456123456789 to encourage overflows if they happen).
    - one with 1M
  - tests to be performed.
    - Test Suite 1 – basic unlock using transfer.
      - unlock funds on both accounts by calling transfer every 2 minutes, and verifying the proper amount is unlocked at each unlock period.
    - Test Suite 2 – basic unlock using vote prducers
      - unlock funds on both accounts by calling vote producers every 2 minutes, and verifying the proper amount is unlocked at each unlock period.
    - Test Suite 3 – intermittent unlocking using transfer
      - unlock at period 3 only then wait for the end of all locks and unlock again using transfer, verify proper amounts are unlocked.
    - Test Suite 5 – intermittent unlocking using voting
      - unlock at period 3 only then wait for the end of all locks and unlock again using vote producers, verify proper amounts are unlocked.
    - Test Suite 6 – errors testing.
      - Transfer errors testing
        try to transfer more than is unlocked during period 1.
        unlock period 1 funds using transfer
        try to transfer successful amount.
        try to transfer more than whats left, see failure
        unlock period 2 funds
        try to transfer successful amount.
        try to transfer more than whats left, see failure
    - Test Suite 7 – voting tests.
      - perform vote and verify the voting power of each account
        unlock period 1 funds using transfer
        reverify voting power.
    - Test Suite 8 – multiple calls tests
      - perform vote after period 1 passes
      - verify lock amount.
      - vote again changing your vote
      - verify no change in lock amounts.
      - vote again changing your vote
      - verify no change in lock amounts.
      - wait for period 2
      - call transfer
      - verify lock amount
      - call transfer
      - verify lock amount remains as before (cuz the next unlock hasn't happened yet)
      - call transfer
      - verify lock amount remains as before (cuz the next unlock hasn't happened yet)
General (FIP-6) locks testing

[FIP-21] FIO Staking Development Spec

Links

Design

Questions Re FIP-21

Design Approach/Overview

New Constants (dev complete 3/29/2021)

New Table

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

Requirement: lock tokens for existing accounts.

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

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

Requirement: Accumulate and manage staking rewards

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

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

Requirement: staked tokens count towards votable balance.

Requirement: staked tokens cannot be used to pay fees.

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

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

Requirement: If auto proxy is used in the staking call, the code should not fail voting checks if this is the first call using tpid (when the auto proxy is being established IN the staking call).

Summary of changes to fio and fio.contracts

Summary of FIO core changes.

Actions and Endpoints

Structs and ABIs

Tables

Project Plan

Risks

SDK Requirements

Functional Testing

Design