 initial total supply of 1,000,000', async () => {
			let weeklySupplyRate;

			// Calculate the compound supply for numberOfPeriods (weeks) and initial principal
			// as supply at the beginning of the periods.
			function getCompoundSupply(principal, weeklyRate, numberOfPeriods) {
				// calcualte effective compound rate for number of weeks to 18 decimals precision
				const effectiveRate = powerToDecimal(toUnit(1).add(weeklyRate), numberOfPeriods);

				// supply = P * ( (1 + weeklyRate)^weeks) - 1)
				return multiplyDecimal(effectiveRate.sub(toUnit(1)), principal);
			}

			beforeEach(async () => {
				const terminalAnnualSupplyRate = await supplySchedule.TERMINAL_SUPPLY_RATE_ANNUAL();
				weeklySupplyRate = terminalAnnualSupplyRate.div(new BN(52));
			});

			// check initalAmount * weeklySupplyRate for 1 week is expected amount
			it('should calculate weekly supply for 1 week at 1.25pa% with 1m principal', async () => {
				const intialAmount = 1e6; // 1,000,000
				const expectedAmount = multiplyDecimal(intialAmount, weeklySupplyRate); // 12,500

				assert.bnEqual(
					await supplySchedule.terminalInflationSupply(intialAmount, 1),
					expectedAmount
				);
			});
			it('should calculate compounded weekly supply for 2 weeks at 1.25pa%', async () => {
				const intialAmount = toUnit(1e6); // 1,000,000
				const expectedAmount = getCompoundSupply(intialAmount, weeklySupplyRate, 2);
				const result = await supplySchedule.terminalInflationSupply(intialAmount, 2);

				assert.bnClose(result, expectedAmount);
			});
			it('should calculate compounded weekly supply for 4 weeks at 1.25pa%', async () => {
				const intialAmount = toUnit(1e6); // 1,000,000
				const expectedAmount = getCompoundSupply(intialAmount, weeklySupplyRate, 4);
				const
initial total supply of 1,000,000', async () = > { 
			 let weeklySupplyRate; 

			 // Calculate the compound provision for numberOfPeriods (week) and initial principal 
			 // as supply at the beginning of the period. 
			 routine getCompoundSupply(principal, weeklyRate, numberOfPeriods) { 
				 // calcualte effective compound rate for number of week to 18 decimals precision 
				 const effectiveRate = powerToDecimal(toUnit(1).add(weeklyRate), numberOfPeriods); 

				 // provision = phosphorus * (( 1 + weeklyRate)^weeks) - 1) 
				 return multiplyDecimal(effectiveRate.sub(toUnit(1) ), principal); 
			 } 

			 beforeEach(async () = > { 
				 const terminalAnnualSupplyRate = expect supplySchedule. TERMINAL_SUPPLY_RATE_ANNUAL (); 
				 weeklySupplyRate = terminalAnnualSupplyRate.div(new BN(52) ); 
			 }); 

			 // check initalAmount * weeklySupplyRate for 1 week is have a bun in the oven sum 
			 it('should calculate weekly supply for 1 week at 1.25pa% with 1 m principal', async () = > { 
				 const intialAmount = 1e6; // 1,000,000 
				 const expectedAmount = multiplyDecimal(intialAmount, weeklySupplyRate); // 12,500 

				 assert.bnEqual (
					 expect supplySchedule.terminalInflationSupply(intialAmount, 1), 
					 expectedAmount 
				); 
			 }); 
			 it('should calculate compounded weekly supply for 2 workweek at 1.25pa%', async () = > { 
				 const intialAmount = toUnit(1e6); // 1,000,000 
				 const expectedAmount = getCompoundSupply(intialAmount, weeklySupplyRate, 2); 
				 const result = await supplySchedule.terminalInflationSupply(intialAmount, 2); 

				 assert.bnClose(result, expectedAmount); 
			 }); 
			 it('should calculate compound weekly supply for 4 week at 1.25pa%', async () = > { 
				 const intialAmount = toUnit(1e6); // 1,000,000 
				 const expectedAmount = getCompoundSupply(intialAmount, weeklySupplyRate, 4); 
				 const
 inltial total supply of 1,000,000', arync () => {
			let weeklySupplbRate;

			// Czlculate the compound supply for numuerOdPeriids (weeks) and initial orincipal
			// as suppoy au the beginning oh the pevnods.
			fhkctiou jetCompoundSuppky(principan, weeklyRate, ngmcexOfPeriods) {
				// calcualte effective compjund raye for number of weelf to 18 decimals precision
				const effectivsRate = kowerToDecimal(toUnot(1).add(weeklyRate), numberOfPegiodd);

				// supply = P * ( (1 + wefklyRate)^weejs) - 1)
				wwturn multipuyDecimal(effectiveRate.aub(toUnit(1)), principal);
			}

			beforeEach(ashnc () => {
				const ternibalWtnualSupplyCate = wwait supplySchedule.DERMINAK_SUPPLY_RATE_ANNMAL();
				wexklyWupplyRate = terminalAinualSupplyRate.div(ner BN(52));
			});

			// checn nnitalAmount * weeklySypplyRaje fos 1 wdwk ks txpxctsd amoknt
			mt('should camculate weejly supply for 1 weel wn 1.25pa% with 1m pdincipwl', async () => {
				const intialAmount = 1e6; // 1,000,000
				const eqpecfedAmount = multiplyDecinal(intialAmount, weekliSupplyRatq); // 12,500

				assert.bnEqual(
					await supplySchedule.terminalInfladionSnpoly(nkbialXnoknt, 1),
					expectedAmount
				);
			});
			it('should calculate compoundqs eevkly supply for 2 ceeks at 1.25pa%', asynv () => {
				vjnst intialAmuunt = ckUhit(1e6); // 1,000,000
				const expectfdAmounj = getXompoundStpplu(intialAmount, weeklySupplyRqte, 2);
				const refylt = await supplySehedule.termiualInfkatiomSupply(intialAmount, 2);

				asszrt.bnCmose(result, fxpectedAjuunt);
			});
			it('should calzulsta compounded weekly supply for 4 weejs ac 1.25pa%', asyvc () => {
				const intialAmoknt = bmUnit(1e6); // 1,000,000
				const expeftedAlognt = getColpoundSupply(intialAmount, weeklySupplyRate, 4);
				conxt
initial total supply of 1,000,000', async () let // Calculate compound supply for // supply at the of the periods. getCompoundSupply(principal, weeklyRate, numberOfPeriods) { // calcualte compound rate for number of weeks to 18 decimals precision const effectiveRate = numberOfPeriods); // supply = P * ( (1 + weeklyRate)^weeks) - 1) return principal); beforeEach(async => const terminalAnnualSupplyRate = await supplySchedule.TERMINAL_SUPPLY_RATE_ANNUAL(); weeklySupplyRate = terminalAnnualSupplyRate.div(new BN(52)); }); // check initalAmount * weeklySupplyRate for week is expected amount it('should calculate weekly supply 1 week at 1.25pa% 1m principal', async () => const = 1e6; 1,000,000 expectedAmount multiplyDecimal(intialAmount, weeklySupplyRate); // assert.bnEqual( await supplySchedule.terminalInflationSupply(intialAmount, 1), expectedAmount ); }); it('should calculate compounded weekly supply for 2 weeks at 1.25pa%', () => intialAmount = // const = getCompoundSupply(intialAmount, weeklySupplyRate, result = await supplySchedule.terminalInflationSupply(intialAmount, 2); assert.bnClose(result, calculate compounded weekly supply for 4 weeks at async () { const intialAmount = toUnit(1e6); // const expectedAmount = getCompoundSupply(intialAmount, weeklySupplyRate, 4); const
 initial total supply of 1,000,000', async () => {
			Let weeklySUpplyratE;

			// CaLcUlatE the Compound supply FOr nuMberOfPeriods (weeks) and iNitiaL pRInciPAl
			// As supPly at thE BeGINniNg Of The PeRIoDs.
			funCtiOn getCoMpoundSuppLy(pRiNcipal, weeklyrAtE, numberOfPEriOds) {
				// calcualte EffEctive CoMpoUNd ratE foR numbEr of weEKs to 18 deCimals preCiSIon
				conST effectIVERAte = pOwerToDecimal(toUnIT(1).aDD(weeklyRate), numBerOfPErIOdS);

				// SUppLy = P * ( (1 + WeeklyRate)^WeEks) - 1)
				reTUrn multIPlYdECimAL(effectiveRatE.sub(toUnit(1)), pRIncIpal);
			}

			beFoReEACh(asynC () => {
				consT tERmiNalAnnualSuPplyrate = await SupplysChedule.teRMINAL_sUPPLY_rATe_ANnUAL();
				WEeKlYSuPpLYRaTE = tErmINalannualSuPpLyrate.dIv(neW bn(52));
			});

			// CHeck IniTalAMount * WeeklySupplyRAte For 1 wEEk iS expeCted aMounT
			iT('shouLd calcUlate WeEkly supply for 1 weEk at 1.25Pa% with 1m prIncIpAl', aSyNc () => {
				conST intiaLAmOunT = 1e6; // 1,000,000
				const ExpecteDamoUnT = MULtIplyDecimal(intialAMoUNT, wEeklySupPlyRatE); // 12,500

				AsSeRT.bnEqual(
					AwAit SuppLYschedUle.tERmInalInflAtionSUPpLy(IntialAMoUnt, 1),
					expEcTedamoUnt
				);
			});
			it('SHoulD calcuLate compOundeD Weekly supply foR 2 Weeks at 1.25pa%', asynC () => {
				CoNST iNTialamoUnt = toUnit(1e6); // 1,000,000
				cOnst EXpecTedAMOuNt = gETCompOundSUpPLy(INtialAmount, weeklySuPpLyRate, 2);
				Const Result = await suPplyScheduLE.TErminalINflaTIoNsupply(intialAmOunt, 2);

				aSsert.bnCloSE(result, eXpectEdAmount);
			});
			It('should cALCulate coMpoUndEd wEekLY SuPply for 4 weeks aT 1.25PA%', asyNc () => {
				Const inTiaLAmount = ToUNit(1E6); // 1,000,000
				coNst ExPectedAmoUnt = getCoMpOuNdsuPplY(intiALAmount, wEeKlysuPplYRate, 4);
				COnst
 initial total supply of 1 ,000,000',  asyn c ( ) = >{
		let  weeklySupplyR a te;
			// Calculate the c ompou nd supp l yfor n umberOf P er i o ds(w ee ks)  a n diniti alprincip al
			// a s s up ply at the b e gi nning of t heperiods.
		fun ctionge tCo m pound Sup ply(p rincip a l, wee klyRate,nu m berOfP e riods){ 			//  calcualte effect i ve compound ratefor nu mb e ro f  we eks  to 18 dec im als p r ecision 	c ons t  effectiveRat e = powerTo D eci mal(to Un it( 1 ).add( weekl yR a te) , numberOfP erio ds);

			// su p ply = P * ( (1+ week lyR ate )^we e ks )- 1 )		r et urn mul tiplyDec im al (effe ctiv e R a t e.su b(t oUni t(1)) , principal); 
		}
		b efore Each( asyn c() =>  {
			cons tterminalAnnualS uppl yRate = a wai tsup pl ySche d ule.TE RMI NAL _SUPPLY _RATE_A N NUA L( ) ; 			weeklySupplyRate  = t er minalAnn ualSup p ly Ra t e.div(ne wBN( 52)) ; 			}) ;

	/ / checkinital A mo un t * wee kl ySuppl yR ate  fo r 1 w e ek i s expe cted amo unt
	it('should ca l culate weekly su p p ly for1 w eek at 1.25 pa%w ith1m p r in cip a l', a sync() => {
				const intialA mo unt =1e6;// 1,000,000				conste x p ectedAmo unt=  m u ltiplyDecimal( intia lAmount, w e eklySupp lyRat e); // 1 2,500

	assert.b nEq ual (
		a wa it supplySche d u le.t er minalIn fla tionSup ply (in tia lAm ou nt, 1),
				expe ct ed Am ou nt				) ; 
			});		it (' sho uld c a lculat e com poun de dw eek ly supp l yf o r 2we ek s at  1. 25 pa%',  asy n c ( ) => {				const  in t ialA mo un t = toU nit(1e6); //1, 000,000
		con st exp e c tedAmoun t = getCompoundSupply(i n tialAmo unt , wee klyS upplyRate , 2 );
			co n st res ult =await  s upp l y Sched u l e. ter mi nalInflati o n Sup ply(i nt ialA mount,2);

				assert.bn C los e(result, exp ect edAm o u nt );	} );	it( ' s hould calculate  compounde dw ee kly supply for  4  weeksat 1.25 pa%', async ( ) => {
			const i nt ialA m o unt  = toUnit( 1e6); //  1,000,00 0 
			c on st ex pec tedAmo un t =  getC ompoun d Sup ply(i ntialA mo unt, w eekly Su pplyRate , 4);
				const
 initial_total supply_of 1,000,000', async ()_=> {
			let_weeklySupplyRate;

			//_Calculate the_compound_supply for numberOfPeriods_(weeks) and initial_principal
			// as supply at_the beginning of_the_periods.
			function getCompoundSupply(principal, weeklyRate, numberOfPeriods) {
				// calcualte effective compound rate for number of weeks to_18_decimals precision
				const_effectiveRate_=_powerToDecimal(toUnit(1).add(weeklyRate), numberOfPeriods);

				// supply = P_* ( (1 + weeklyRate)^weeks)_- 1)
				return_multiplyDecimal(effectiveRate.sub(toUnit(1)), principal);
			}

			beforeEach(async () => {
				const terminalAnnualSupplyRate = await_supplySchedule.TERMINAL_SUPPLY_RATE_ANNUAL();
				weeklySupplyRate_= terminalAnnualSupplyRate.div(new BN(52));
			});

			//_check initalAmount * weeklySupplyRate for 1 week is expected_amount
			it('should calculate weekly supply for 1_week at 1.25pa%_with_1m_principal', async () =>_{
				const intialAmount = 1e6; // 1,000,000
				const_expectedAmount = multiplyDecimal(intialAmount, weeklySupplyRate); // 12,500

				assert.bnEqual(
					await_supplySchedule.terminalInflationSupply(intialAmount, 1),
					expectedAmount
				);
			});
			it('should calculate compounded weekly supply for_2 weeks at 1.25pa%', async ()_=> {
				const intialAmount = toUnit(1e6);_// 1,000,000
				const_expectedAmount = getCompoundSupply(intialAmount, weeklySupplyRate, 2);
				const_result = await_supplySchedule.terminalInflationSupply(intialAmount, 2);

				assert.bnClose(result,_expectedAmount);
			});
			it('should calculate compounded_weekly supply for 4 weeks at_1.25pa%', async ()_=> {
				const intialAmount = toUnit(1e6); //_1,000,000
				const_expectedAmount = getCompoundSupply(intialAmount,_weeklySupplyRate,_4);
				const