ElasticGovernanceToken (EGT) is a positively rebasing asset-backed governance token.

Just as the first DAO deployed on the Elastic DAO Protocol is named ElasticDAO, Elastic Governance (EGT) is the first Elastic Governance Token and will be used for governing ElasticDAO.

For the sake of eliminating confusion, the remainder of this section will talk about the characteristics, formulae, and rebasing dynamics of Elastic Governance (EGT). All dynamics discussed apply to any Elastic Governance Token of a DAO deployed via the Elastic DAO Protocol.

`TLDR`

: The overall supply of EGT and the amount of assets backing each EGT increase every time a rebase happens.

â€‹

`lambda`

The base value of EGT; increases every time someone joins the DAO. Decreases every time someone exits the DAO.

`m:`

Lambda modifier - the rebasing modifier ; increases every time someone joins the DAO and is the technical driver behind the rebasing mechanism

`elasticity:`

The percentage increase in backing assets every time a rebase is triggered.

`k:`

Token multiplier; increases the number of EGT that each base unit (lambda) represents.

â€ŒThe redemption value of each EGT is given by Capital Delta(Î´), which is calculated by:

**Capital Delta (Î´):**

$Î´ = e /t$

e - The total amount of backing assets in the DAO's vault (ETH)

t - The total supply of EGT

â€‹

The total supply of EGT (t) is given by:

**Tokens (t):**

$t = Î»* m*k$

Î» - Lambda

m - Lambda modifier

k - Token multiplier

â€‹

Capital Delta ( **Î´ ) **and Tokens (t) are functions on ElasticMath.sol.

â€ŒThe rebase is triggered when someone calls the join function in ElasticDAO.sol

function join(uint256 _deltaLambda)

The amount of ETH required to mint ** deltaLambda** accounts for the increase in the value of each EGT. The increase in

The Dash notation, e.g t' and m', etc, represents the state after the rebase, which then becomes the value for the next rebase.

E.g If t = 100 before rebase, t' = 110

For the next rebase,

t = 110 ( so on and so forth )

The amount of ETH required to purchase deltaLambda ( **Î”E** ) is given by:

$Î”E = Î´ * k *( Î»'* m'* ( 1 + elasticity ) - Î» * m )$

Î´ - Capital Delta

k - Token multiplier

Î»' - The amount of lambda after the rebase.

Î» - The amount of Lambda before the rebase.

m' - The value of the Lambda modifier after the rebase.

m - The value of the Lambda modifier before the rebase.

elasticity - Increase in the number of assets backing each EGT.

â€Œ

Every time the rebase is triggered, the lambda modifier * m* gets modified:

$m' = ( Î»' / Î» ) * m$

where,

$Î»' = Î» + Î”Î»$

Î»' - Number of Lambda after the join

Î» - Number of Lambda before the join

Î”Î» - DeltaLambda - The Amount of Lambda minted

resulting in the new supply of tokens being,

$t' = Î»' *m'*k$

â€ŒSince `deltaLambda > 0`

(uint can never be negative), this results in` Î»' > Î»,`

and `m' > m`

.

This means `t' > t`

, i.e, **the supply of tokens has increased**.

Also,

$Î´' = Î´* ( 1 + e)$

$Î´' = e' / t'$

Note that, upon every rebase `Î´' > Î´`

i.e **the number of assets backing each EGT has gone up.**

â€Œ

The numerical value of `m`

, `k`

, `elasticity`

and ETH provided at summoning determines the price trend and supply of the token.

There exists a logical range between the assets required to mint each EGT (via the join function - triggering a rebase) and the assets received for each EGT during redemption (a call to the exit function).

For a given set of values of `m`

, `elasticity`

, `k`

the trend is given by: