return 0;

return 0;

return 0;

let result = {

test: [] ,

epochInDay : epochInDay,

epochNetRBP : epochNetRBP,

epochNetQAP : epochNetQAP,

epochNetBasePower : epochNetBasePower,

epochNetStoragePledge : epochNetStoragePledge,

epochNetStorageConsensusPledge : epochNetStorageConsensusPledge,

epochNetInitialPledge : epochNetInitialPledge,

epochNetDealPledge : epochNetDealPledge,

epochCumSumRealized : Number(epochCumSumRealized),

epochNetNewReward : epochNetNewReward,

epochNetMinedFIL : Number(epochNetMinedFIL),

epochNetLockedFIL : Number(epochNetLockedFIL),

epochNetRewardLocked : Number(epochNetRewardLocked),

epochNetBurntFIL : Number(epochNetBurntFIL),

epochNetVestedFIL : Number(epochNetVestedFIL),

epochNetCircFIL : Number(epochNetCircFIL),

epochNetReserveDisbursed : Number(epochNetReserveDisbursed),

epochNetRewardFilter : new abFilter(epochNetRewardPosition, epochNetRewardVelocity),

epochNetPowerFilter : new abFilter(epochNetQAPowerPosition, epochNetQAPowerVelocity),

epochMinerRBP : epochMinerRBP,

epochMinerQAP : epochMinerQAP,

epochMinerStoragePledge : Number(epochMinerStoragePledge),

epochMinerConsensusPledge : Number(epochMinerConsensusPledge),

epochMinerInitialPledge : epochMinerInitialPledge,

epochMinerDealPledge : epochMinerDealPledge,

dailyMinerTotalPledge : Array.from({length:projectedDays.length},()=>(0)),

dailyMinerCumSumRewards : dailyMinerCumSumRewards.map(x=>x),

dailyMinerTotalCost : dailyMinerTotalCost.map(x=>x),

dailyMinerReleasedRewards : dailyMinerReleasedRewards.map(x=>x),

dailyMinerLockedRewards : dailyMinerLockedRewards.map(x=>x),

dailyMinerInvestment : dailyMinerInvestment.map(x=>x),

dailyMinerProfit : dailyMinerProfit.map(x=>x),

projectedVerifiedStoragePercent : projectedVerifiedStoragePercent,

dailyNetBurn : dailyNetBurn.map(x=>x),

dailyMinerDeals: dailyMinerDeals.map(x=>x),

cumMinerLockedReward: 0,

cumMinerReleasedReward: 0,

initial_pledge_lock_target: Number(initial_pledge_lock_target),

testmove: [],

dailyNetNewPledge : dailyNetNewPledge.map(x=>x),

dailyNetRenewPledge : dailyNetRenewPledge.map(x=>x),

dailyNetNewDealPledge: dailyNetNewDealPledge.map(x => x),

dailyMinerRBPCommitted: dailyMinerRBPCommitted.map(x => x),

dailyMinerQAPCommitted: dailyMinerQAPCommitted.map(x => x),

dailyMinerLockedPledge: dailyMinerLockedPledge.map(x=>x),

dailyMinerReleasedPledge: dailyMinerReleasedPledge.map(x=>x),

}

projectedDays.map((x,day)=>{

if(day == 0) return;

//grab daily power difference and compute epoch-based power growth

let epochNetRBPGrowth = (dailyNetRBP[day] - dailyNetRBP[day - 1]) / epochInDay

let epochNetQAPGrowth = (dailyNetQAP[day] - dailyNetQAP[day - 1]) / epochInDay

// ------------------------------------------------------- Power Update Starts Here ----------------------------------------------------//

// calculate the daily & epoch based scheduled expiration part

let dayKnownSERBP = (day < known_se_power.length) ? known_se_power[day] : 0

let dayModelSERBP_o = (day > projectedAvgSectorDurationDays) ? (dailyNetRBP[day - projectedAvgSectorDurationDays] - dailyNetRBP[day - projectedAvgSectorDurationDays - 1]) : 0

let dayModelSERBP_se = (day > projectedAvgSectorDurationDays) && (day - projectedAvgSectorDurationDays < known_se_power.length) ? projectedRenewalRate * known_se_power[day - projectedAvgSectorDurationDays] : 0

let daySERBP = dayKnownSERBP + dayModelSERBP_o + dayModelSERBP_se

// calculate today's renewal part

let dayRenewRBP = projectedRenewalRate * daySERBP

// do the same thing for QAP

let dayKnownSEQAP = (day < known_se_power.length) ? (9 * projectedVerifiedStoragePercent + 1) * known_se_power[day] : 0

let dayModelSEQAP_o = (day > projectedAvgSectorDurationDays) ? dailyNetQAP[day - projectedAvgSectorDurationDays] - dailyNetQAP[day - projectedAvgSectorDurationDays - 1] : 0

let dayModelSEQAP_r = (day > projectedAvgSectorDurationDays) && (day - projectedAvgSectorDurationDays < known_se_power.length) ? qualityNetPowerAvgMultiplier * projectedRenewalRate * known_se_power[day - projectedAvgSectorDurationDays] : 0

let daySEQAP = dayKnownSEQAP + dayModelSEQAP_o + dayModelSEQAP_r

// QAP: calculate the daily renewal part

let dayRenewQAP = projectedRenewalRate * daySEQAP

// make everything as epochs

let epochSERBP = daySERBP / epochInDay

let epochRenewRBP = dayRenewRBP / epochInDay

let epochSEQAP = daySEQAP / epochInDay

let epochRenewQAP = dayRenewQAP / epochInDay

// --------------------------------------------------------- Power Update Ends Here ----------------------------------------------------//

// ------------------------------------------------- Miner Power Update Starts Here ----------------------------------------------------//

// ------------------------------------------------- Miner Power Update Ends Here ------------------------------------------------------//

//start calculations epoch-wise

for(let index = 0; index < epochInDay; index++){

// update the current epoch

let epoch = Number(epochStart) + ((day - 1) * epochInDay) + index

// update the network for the current epoch

// update network power

result.epochNetRBP = Number(result.epochNetRBP) + epochNetRBPGrowth - epochSERBP + epochRenewRBP

result.epochNetQAP = Number(result.epochNetQAP) + epochNetQAPGrowth - epochSEQAP + epochRenewQAP

result.epochNetBasePower = getBaselineByEpoch(epoch)

// update network pledge terms

let epochPerRBPCircSupply = result.epochNetCircFIL / Math.max(result.epochNetRBP, result.epochNetBasePower)

let epochPerQAPCircSupply = result.epochNetCircFIL / Math.max(result.epochNetQAP, result.epochNetBasePower)

// -------------------------------------------------- Daily New Pledge Starts Here ----------------------------------------------------//

// initial storage pledge

result.epochNetStoragePledge = Math.max(epochNetQAPGrowth * extrapolateCumsumRatio(result.epochNetRewardFilter,

result.epochNetPowerFilter,

20 * epochInDay

), 0)

result.epochNetStorageConsensusPledge = Math.max(epochPerQAPCircSupply * initial_pledge_lock_target * epochNetQAPGrowth, 0)

result.epochNetInitialPledge = result.epochNetStoragePledge + result.epochNetStorageConsensusPledge

result.dailyNetNewPledge[day] += result.epochNetInitialPledge

// deal pledge

result.epochNetDealPledge = Math.max(result.projectedVerifiedStoragePercent * epochPerRBPCircSupply * 0.01 * epochNetRBPGrowth, 0)

result.dailyNetNewDealPledge[day] += result.epochNetDealPledge

// update it here

result.epochNetLockedFIL += (result.epochNetDealPledge + result.epochNetInitialPledge)

// -------------------------------------------------- Daily New Pledge Ends Here -------------------------------------------------------//

// ----------------------------------------- Known Scheduled Expiration Starts Here ----------------------------------------------------//

// deal effect omitted for now //

/////////////////////////////////////////////////////////// Leaves ///////////////////////////////////////////////////////////////////////

let dailyKnownSEOut = (day < known_se_pledge.length) ? (1 - projectedRenewalRate) * known_se_pledge[day]: 0

let epochKnownSEOut = dailyKnownSEOut / epochInDay

result.epochNetLockedFIL = result.epochNetLockedFIL - epochKnownSEOut

/////////////////////////////////////////////////////////// Repledges ////////////////////////////////////////////////////////////////////

let epochKnownSERBP = dayKnownSERBP / epochInDay

let dailyKnownSERepledged = (day < known_se_pledge.length) ? projectedRenewalRate * known_se_pledge[day] : 0

let epochKnownSERepledged = dailyKnownSERepledged / epochInDay

let epochKnownRenewStoragePledge = Math.max(qualityNetPowerAvgMultiplier * projectedRenewalRate * epochKnownSERBP *

extrapolateCumsumRatio(result.epochNetRewardFilter, result.epochNetPowerFilter, 20 * epochInDay), 0)

let epochKnownRenewConsensusPledge = Math.max(epochPerQAPCircSupply * initial_pledge_lock_target * qualityNetPowerAvgMultiplier * projectedRenewalRate * epochKnownSERBP, 0)

result.epochNetLockedFIL = result.epochNetLockedFIL + epochKnownRenewStoragePledge + epochKnownRenewConsensusPledge - epochKnownSERepledged

/////////////////////////////////////////////////////////// Save a Record ////////////////////////////////////////////////////////////////

result.dailyNetRenewPledge[day] += epochKnownRenewStoragePledge + epochKnownRenewConsensusPledge

// ------------------------------------------ Known Scheduled Expiration Ends Here ----------------------------------------------------//

// -------------------------------------- Modelled Scheduled Expiration Starts Here ----------------------------------------------------//

// deal effect omitted for now //

/////////////////////////////////////////////////////////// Leaves ///////////////////////////////////////////////////////////////////////

let epochNetNewPledgeOut = (day > projectedAvgSectorDurationDays) ? (1 - projectedRenewalRate) * result.dailyNetNewPledge[day - projectedAvgSectorDurationDays] / epochInDay : 0

let epochNetRenewPledgeOut = (day > projectedAvgSectorDurationDays) ? (1 - projectedRenewalRate) * result.dailyNetRenewPledge[day - projectedAvgSectorDurationDays] / epochInDay : 0

result.epochNetLockedFIL = result.epochNetLockedFIL - epochNetNewPledgeOut - epochNetRenewPledgeOut

/////////////////////////////////////////////////////////// Repledges ////////////////////////////////////////////////////////////////////

// step 1: get the re-pledged out part

let epochNetNewPledgeRe = (day > projectedAvgSectorDurationDays) ? projectedRenewalRate * result.dailyNetNewPledge[day - projectedAvgSectorDurationDays] / epochInDay: 0

let epochNetRenewPledgeRe = (day > projectedAvgSectorDurationDays) ? projectedRenewalRate * result.dailyNetRenewPledge[day - projectedAvgSectorDurationDays] / epochInDay: 0

result.epochNetLockedFIL = result.epochNetLockedFIL - epochNetNewPledgeRe - epochNetRenewPledgeRe

// step 2: construct up the re-pledges

//// Model out the newly onboarded part

let epochModelSERBP_o = dayModelSERBP_o / epochInDay

let epochModelSERBP_o_storage_pledge = Math.max(qualityNetPowerAvgMultiplier * projectedRenewalRate * epochModelSERBP_o *

extrapolateCumsumRatio(result.epochNetRewardFilter, result.epochNetPowerFilter, 20 * epochInDay), 0)

let epochModelSERBP_o_consensus_pledge = Math.max(epochPerQAPCircSupply * initial_pledge_lock_target * qualityNetPowerAvgMultiplier * projectedRenewalRate * epochModelSERBP_o, 0)

let epochModelSERBP_o_new = (day > projectedAvgSectorDurationDays) ? epochModelSERBP_o_storage_pledge + epochModelSERBP_o_consensus_pledge : 0

result.epochNetLockedFIL = result.epochNetLockedFIL + epochModelSERBP_o_new

//// model out the known expiration part

let epochModelSERBP_se = dayModelSERBP_se / epochInDay

let epochModelSERBP_se_storage_pledge = Math.max(qualityNetPowerAvgMultiplier * projectedRenewalRate * epochModelSERBP_se *

extrapolateCumsumRatio(result.epochNetRewardFilter, result.epochNetPowerFilter, 20 * epochInDay), 0)

let epochModelSERBP_se_consensus_pledge = Math.max(epochPerQAPCircSupply * initial_pledge_lock_target * qualityNetPowerAvgMultiplier * projectedRenewalRate * epochModelSERBP_se, 0)

let epochModelSERBP_se_new = (day > projectedAvgSectorDurationDays) ? epochModelSERBP_se_storage_pledge + epochModelSERBP_se_consensus_pledge : 0

result.epochNetLockedFIL = result.epochNetLockedFIL + epochModelSERBP_se_new

// --------------------------------------- Modelled Scheduled Expiration Ends Here ----------------------------------------------------//

// update new rewards & FIL Mined

let epochPrevNetTimeEpoch = derive_network_time(result.epochCumSumRealized)

result.epochCumSumRealized += Math.min(result.epochNetBasePower, result.epochNetRBP)

let epochCurrNetTimeEpoch = derive_network_time(result.epochCumSumRealized)

result.epochNetNewReward = computeBlockReward(epoch, epoch - 1, epochCurrNetTimeEpoch, epochPrevNetTimeEpoch)

result.epochNetMinedFIL += result.epochNetNewReward // keep mining

result.epochNetRewardLocked += 0.75 * result.epochNetNewReward // lock away new rewards

result.epochNetRewardLocked -= result.epochNetRewardLocked / 180 / epochInDay // release part of the rewards

// reward part

result.epochNetLockedFIL += 0.75 * result.epochNetNewReward

result.epochNetLockedFIL -= result.epochNetRewardLocked / 180 / epochInDay // release part of the rewards

result.epochNetBurntFIL += result.dailyNetBurn[day] / epochInDay

result.epochNetVestedFIL += getVestOnEpoch(epoch)

// update the total network circulating supply field

result.epochNetCircFIL = result.epochNetReserveDisbursed + result.epochNetMinedFIL + result.epochNetVestedFIL - result.epochNetLockedFIL - result.epochNetBurntFIL

// update ab filters for next round prediction

result.epochNetRewardFilter.update(result.epochNetNewReward, 1)

result.epochNetPowerFilter.update(result.epochNetQAP, 1)

// some pledge accounting

//accounting up

result.dailyMinerQAPCommitted[day] += epochMinerRBPGrowth

result.dailyMinerRBPCommitted[day] += epochMinerQAPGrowth

// more accounting

let dailyMinerRBPRetire = (day > projectedSPStorageDurationDays) && (day - projectedSPStorageDurationDays < daysForSealing) ? result.dailyMinerRBPCommitted[day - projectedSPStorageDurationDays] : 0

let dailyMinerQAPRetire = (day > projectedSPStorageDurationDays) && (day - projectedSPStorageDurationDays < daysForSealing) ? result.dailyMinerQAPCommitted[day - projectedSPStorageDurationDays] : 0

let epochMinerRBPRetire = dailyMinerRBPRetire / epochInDay

let epochMinerQAPRetire = dailyMinerQAPRetire / epochInDay

result.epochMinerRBP = epochMinerRBPRetire

result.epochMinerQAP -= epochMinerQAPRetire

// update the miners for this epoch

// if we're still sealing, then add up pledges

if (epoch <= daysForSealing * epochInDay + Number(epochStart)){

// onboarding storage power

result.epochMinerRBP += epochMinerRBPGrowth

result.epochMinerQAP += epochMinerQAPGrowth

// accumulate pledges

result.epochMinerStoragePledge = epochMinerQAPGrowth * extrapolateCumsumRatio(result.epochNetRewardFilter,

result.epochNetPowerFilter,

20 * epochInDay

)

result.epochMinerConsensusPledge = (epochMinerQAPGrowth / Math.max(result.epochNetQAP, result.epochNetBasePower)) * result.epochNetCircFIL * 0.3

result.epochMinerInitialPledge = result.epochMinerStoragePledge + result.epochMinerConsensusPledge

result.epochMinerDealPledge = (verifiedPercentage * epochMinerRBPGrowth / Math.max(result.epochNetRBP, result.epochNetBasePower)) * result.epochNetCircFIL * 0.01 / 100

// aggregate the pledges daily

result.dailyMinerTotalPledge[day] = result.dailyMinerTotalPledge[day] + result.epochMinerInitialPledge + result.epochMinerDealPledge

}

// mint and assign new rewards

result.dailyMinerCumSumRewards[day] = result.dailyMinerCumSumRewards[day] + (result.epochMinerQAP / result.epochNetQAP) * result.epochNetNewReward

}

// update EOD power

result.dailyMinerDeals[day] = result.epochMinerRBP * verifiedPercentage * 0.01

// update the daily balance sheet items

//// get the cumulative sum of the rewards

result.dailyMinerReleasedRewards[day] += 0.25 * result.dailyMinerCumSumRewards[day] + result.cumMinerLockedReward / 180

result.dailyMinerLockedRewards[day] += 0.75 * result.dailyMinerCumSumRewards[day] - result.cumMinerLockedReward / 180

result.cumMinerLockedReward += result.dailyMinerLockedRewards[day]

result.cumMinerReleasedReward += result.dailyMinerReleasedRewards[day]

// get the cumulative sum of the pledges

let dailyMinerPledgeRelease = (day > projectedSPStorageDurationDays) ? result.dailyMinerTotalPledge[day - projectedSPStorageDurationDays] : 0

result.dailyMinerReleasedPledge[day] = dailyMinerPledgeRelease

result.dailyMinerLockedPledge[day] = result.dailyMinerTotalPledge[day] - result.dailyMinerReleasedPledge[day]

result.dailyMinerInvestment[day] += result.dailyMinerTotalPledge[day]

result.dailyMinerProfit[day] += result.dailyMinerCumSumRewards[day] - result.dailyMinerTotalCost[day]

})

return result

}