slide`There are several models that might be used to evaluate this two token model.
TNT similar to an exotic convertable bond where market forces dictate the debt/equity ratio.
SNT as an option on Teller Network Fees.
`
slide`In the convertable bond model, the cost of the debt becomes the interest yield on the locked up SNT + retained earnings from teller`
slide`According to the Modigliani–Miller theorem, in an efficient market the capital structure does not change the value`
slide`Adding debt to the capital structure mix turns unlevered equity into levered equity
<span style="font-size:0.5em">levered beta = unlevered beta * (1 + DEBT/EQUITY)</span>`
viewof percentageOfUsersTransacting = slider({
min: 0,
max: 1,
step: .01,
value: .05,
title: "Percentage of users that transact in a given year",
description: "Increments in percentages of 1"
})
viewof percentageOfUserStaking = slider({
min: 0,
max: 1,
step: .01,
value: .05,
title: "Percentage of users that stake in a given year",
description: "Increments in percentages of 1"
})
viewof minStakeAmount = slider({
min: 0,
max: 100,
step: 1,
value: 1,
title: "The minimum amount a user has to stake",
description: "Increments in 1s"
})
viewof averageDollarValuePerTrade = slider({
min: 0,
max: 1000,
step: 10,
value: 100,
title: "Average dollar value per trade",
description: "Increments in $10"
})
viewof numberOfTransactionsPerUserYear = slider({
min: 0,
max: 100,
step: 1,
value: 2,
title: "Number of transactions per user per year",
description: "increments in 1"
})
viewof transactionFee = slider({
min: 0,
max: 0.01,
step: 0.0001,
value: 0.0025,
precision: 4,
title: "Transaction fee per trade",
description: "The transaction fee which will be sent to stakers"
})
stakers = users.map(year => Math.round(year * percentageOfUserStaking))
transactionFeeDollarDemandPerYear = {
return users.map((userCount, idx) => {
if (idx) return Math.round((userCount - users[idx-1]) * averageDollarValuePerTrade * numberOfTransactionsPerUserYear * transactionFee)
return userCount * averageDollarValuePerTrade * numberOfTransactionsPerUserYear * transactionFee
})
}
md`### While some users will stake more than others, it assumes that the total the staked value will seek its target yield`
stakedValuePerYear = transactionFeeDollarDemandPerYear.map(year => Math.round(year / stakingYieldTarget))
marketCap = stakedValuePerYear.map((year,idx, arr) => {
if (!idx) return year + sntMarketCap
return year + arr[idx-1]
})
percentageDebtCapital = stakedValuePerYear.map((year,idx) => year / marketCap[idx])
totalEquity = percentageDebtCapital.map((debt, idx) => (1 - debt) * marketCap[idx])
stakedLiqidationValue = -stakedValuePerYear.reduce((pv,cv) => pv + cv)
discountedLiqidationValue = stakedLiqidationValue / ((1+WACC.slice(-1)[0])**stakedValuePerYear.length)
aggregateDollarDemandPerYear = users.map((year,idx) => licenseDollarDemandPerYear[idx] + stakedValuePerYear[idx])
aggregateLiquidationValue = [...aggregateDollarDemandPerYear, stakedLiqidationValue]
slide`The nature of non-continous cash flows from fees in teller makes looking at other markets such as nuo.network where returns are discrete a good possible source for what kind of staking dynamics might drive here
https://docs.google.com/spreadsheets/d/14hIGgmL4masiMwU1yhKjXUjJaE6oraeXtk4VqUmj6bc/edit?usp=sharing`
slide`Additional Considerations`
slide`A wiping out of the teller token would be a deleveraging event where all the locked up SNT + retained earnings would be released to wipe out the debt (teller tokens)`
slide`Does adding debt only lever the beta for Teller network or SNT as a whole?`
slide`Teller token holders are effectively getting a free option.
Why not charge them an 'option premium' over the NAV when they stake in?`
viewof newStakersPct = slider({
min: 0,
max: 1,
step: 0.0001,
value: 0.17,
precision: 4,
title: "What percentage of staked funds would not otherwise be held?",
description: "Funds that are entering the SNT economy specifically for the purpose of being staked"
})
adjustedCurrentUtility = Math.round(currentUtilityValue)
acuv = formatCurrency(adjustedCurrentUtility)
liquidationUtilityValue = (Math.floor(NPVaggregate(discountRate, ...aggregateLiquidationValue)) * (1- probabilityOfFailure))
aLiquidationValue = Math.round(liquidationUtilityValue)
acluv = formatCurrency(aLiquidationValue)
CLUV = formatCurrency(liquidationUtilityValue)
CUV = formatCurrency(currentUtilityValue)
import { statusUsers, userGrowth, terminalGrowth, churnRate, getUsers, getDiscountRate, numberWithCommas, NPV } from '@bgits/status-im'
NPVaggregate = function (rate) {
var npv = arguments[1];
for (var i = 2; i < arguments.length; i++) {
npv +=(arguments[i] / Math.pow((1 + WACC[i-2]), i));
}
return Math.round(npv);
}
formatCurrency = num => num.toLocaleString(undefined, { style: 'currency', currency: 'USD'}).split('.')[0]
import {CUV as originalCUV, CLUV as originalCLUV} from '@bgits/status-teller-network-utility-value-exploration'
import {sntBeta, sntMarketCap,calculateCostOfEquity, marketReturnExpectation, riskFreeRate} from '@bgits/status-cost-of-capital'
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
