Get repuation reward for batch (#576)

* Package version 0.2.84

* add getRepuationRewardForBatch

* use Decimal.js

Author: orenyodfat

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@daostack/arc.js",
-  "version": "0.2.84",
+  "version": "0.2.85",
   "description": "",
   "keywords": [],
   "main": "dist/lib/index.js",
@@ -112,6 +112,7 @@
     "apollo-link-http": "^1.5.15",
     "apollo-link-retry": "^2.2.15",
     "apollo-link-ws": "^1.0.18",
+    "decimal.js": "^10.2.1",
     "form-data": "^3.0.0",
     "graphql": "^14.4.2",
     "graphql-tag": "^2.10.1",

package.json

@@ -12,7 +12,7 @@ export { Reputation, IReputationState, IReputationQueryOptions } from './reputat
 export { Reward, IRewardState, IRewardStaticState, IRewardQueryOptions } from './reward'
 export { Scheme, ISchemeState, ISchemeStaticState, ISchemeQueryOptions } from './scheme'
 export { ReputationFromTokenScheme } from './schemes/reputationFromToken'
-export { CTL4RScheme } from './schemes/ctl4rep'
+export { CL4RScheme } from './schemes/cl4rep'
 export { IContributionReward} from './schemes/contributionReward'
 export { hasCompetitionContract, isCompetitionScheme,
     IProposalCreateOptionsCompetition,

src/index.ts

@@ -6,11 +6,11 @@ import { mapGenesisProtocolParams } from './genesisProtocol'
 import { Operation, toIOperationObservable } from './operation'
 import { IProposalCreateOptions, IProposalQueryOptions, Proposal } from './proposal'
 import { ISchemeQueryOptions, ISchemeState, ISchemeStaticState, SchemeBase } from './schemes/base'
+import { CL4RScheme } from './schemes/cl4rep'
 import { CompetitionScheme, isCompetitionScheme } from './schemes/competition'
 import * as Competition from './schemes/competition'
 import * as ContributionReward from './schemes/contributionReward'
 import * as ContributionRewardExt from './schemes/contributionRewardExt'
-import { CTL4RScheme } from './schemes/ctl4rep'
 import * as GenericScheme from './schemes/genericScheme'
 import * as GenericSchemeMultiCall from './schemes/genericSchemeMultiCall'
 import { ReputationFromTokenScheme } from './schemes/reputationFromToken'
@@ -185,7 +185,7 @@ export class Scheme extends SchemeBase  {
   public id: Address
   public staticState: ISchemeStaticState | null = null
   public ReputationFromToken: ReputationFromTokenScheme | null = null
-  public CTL4R: CTL4RScheme | null = null
+  public CTL4R: CL4RScheme | null = null
 
   constructor(idOrOpts: Address | ISchemeStaticState, public context: Arc) {
     super(idOrOpts, context)
@@ -205,7 +205,7 @@ export class Scheme extends SchemeBase  {
       this.ReputationFromToken = new ReputationFromTokenScheme(this)
     }
     if (this.staticState.name ===  'ContinuousLocking4Reputation') {
-      this.CTL4R = new CTL4RScheme(this)
+      this.CTL4R = new CL4RScheme(this)
     }
   }
 

src/scheme.ts

@@ -8,7 +8,7 @@ import {
   IProposalCreateOptions,
   IProposalQueryOptions, Proposal } from '../proposal'
 import { Address, ICommonQueryOptions, IStateful } from '../types'
-import { CTL4RScheme } from './ctl4rep'
+import { CL4RScheme } from './cl4rep'
 import { ReputationFromTokenScheme } from './reputationFromToken'
 
 export interface ISchemeStaticState {
@@ -249,7 +249,7 @@ export abstract class SchemeBase implements IStateful<ISchemeState> {
   public id: Address
   public staticState: ISchemeStaticState | null = null
   public ReputationFromToken: ReputationFromTokenScheme | null = null
-  public CTL4R: CTL4RScheme | null = null
+  public CTL4R: CL4RScheme | null = null
 
   constructor(idOrOpts: Address | ISchemeStaticState, public context: Arc) {
     this.context = context
@@ -286,7 +286,7 @@ export abstract class SchemeBase implements IStateful<ISchemeState> {
         this.ReputationFromToken = new ReputationFromTokenScheme(this)
       }
       if (this.staticState.name ===  'ContinuousLocking4Reputation') {
-        this.CTL4R = new CTL4RScheme(this)
+        this.CTL4R = new CL4RScheme(this)
       }
       return state
     }

src/schemes/base.ts

@@ -1,6 +1,8 @@
 import BN = require('bn.js')
+import {Decimal} from 'decimal.js'
 import { from } from 'rxjs'
 import { concatMap } from 'rxjs/operators'
+import { realMathToBN, realMathToNumber } from '../utils'
 
 import {
   Operation,
@@ -11,12 +13,31 @@ import { Address } from '../types'
 
 import { Scheme } from '../scheme'
 
-export class CTL4RScheme {
+export class CL4RScheme {
 
   constructor(public scheme: Scheme) {
 
   }
 
+  /**
+   * getRepuationRewardForBatch
+   * according to the formula
+   * repPerBatch = _repRewardConstA * ((_repRewardConstB/1000) ** batchIndex)
+   * @param  repRewardConstA
+   * @param  repRewardConstB
+   * @param  batchIndex the batchIndex to calculate
+   * @return     RepuationRewardForBatch
+   */
+  public async getRepuationRewardForBatch(repRewardConstA: string,
+                                          repRewardConstB: string,
+                                          batchIndex: number)
+                                          : Promise<Decimal> {
+    const constB = new Decimal(realMathToNumber(new BN(repRewardConstB)))
+    const constA = new Decimal(realMathToBN(new BN(repRewardConstA)).toString())
+    return constA.times(constB.toPower(batchIndex))
+
+  }
+
   public async getAgreementHash(): Promise<string> {
     const contract = await this.getContract()
     const result = await contract.methods.getAgreementHash().call()
@@ -25,13 +46,17 @@ export class CTL4RScheme {
 
   public async getReputationRewardForLockingIds(lockingIds: number[],
                                                 batchIndex: number,
-                                                repuationRewardForPeriod: BN)
-                                                : Promise<BN> {
-    let reputation = new BN('0')
+                                                repuationRewardForPeriod: Decimal)
+                                                : Promise<Decimal> {
+    let reputation = new Decimal('0')
     const contract = await this.getContract()
-    const lockingTotalScore = new BN(await contract.methods.batches(batchIndex).call())
+    const lockingTotalScore = new Decimal(await contract.methods.batches(batchIndex).call())
+
+    if (lockingTotalScore.isZero()) {
+      return lockingTotalScore
+    }
     for (const lockingId of lockingIds) {
-      const lockingIdScore = new BN(await contract.methods.getLockingIdScore(batchIndex, lockingId).call())
+      const lockingIdScore = new Decimal(await contract.methods.getLockingIdScore(batchIndex, lockingId).call())
       reputation = reputation.add(lockingIdScore.div(lockingTotalScore).mul(repuationRewardForPeriod))
     }
     return reputation

src/schemes/ctl4rep.ts renamed to src/schemes/cl4rep.ts

@@ -94,6 +94,12 @@ export function realMathToNumber(t: BN): number {
   return t.shrn(REAL_FBITS).toNumber() + fraction
 }
 
+export function realMathToBN(t: BN): BN {
+  const REAL_FBITS = 40
+  const fraction = t.maskn(REAL_FBITS).div((new BN('2')).pow(new BN(REAL_FBITS.toString())))
+  return t.shrn(REAL_FBITS).add(fraction)
+}
+
 export const NULL_ADDRESS = '0x0000000000000000000000000000000000000000'
 
 /**

src/utils.ts

@@ -1,7 +1,8 @@
 import { first } from 'rxjs/operators'
-import { Arc, CTL4RScheme } from '../src'
+import { Arc, CL4RScheme } from '../src'
 import { newArc } from './utils'
 import BN = require('bn.js')
+import {Decimal} from 'decimal.js';
 import { createAProposal, getTestAddresses, getTestDAO, voteToPassProposal, waitUntilTrue} from './utils'
 import {
   IProposalState,
@@ -22,6 +23,7 @@ describe('Scheme', () => {
   let dao : any
   let proposalToAdd :any
   let token :any
+  const REP_CONST_A = '85000000000000000000000'
   beforeAll(async () => {
     arc = await newArc()
     token = arc.GENToken()
@@ -47,12 +49,12 @@ describe('Scheme', () => {
 
     continuousLocking4ReputationAddress = await continuousLocking4ReputationFactory.methods.createCL4R(
       dao.id,
-      new BN('10000000'),
+      new BN('10000000000000000000000000'),
       startTime,
       new BN('1000'),
       redeemEnableTime,
       new BN('12'),
-      new BN('85000'),
+      new BN(REP_CONST_A),
       new BN('900'),
       new BN('5'),
       token.address,
@@ -61,12 +63,12 @@ describe('Scheme', () => {
 
     await continuousLocking4ReputationFactory.methods.createCL4R(
       dao.id,
-      new BN('10000000'),
+      new BN('10000000000000000000000000'),
       startTime,
       new BN('1000'),
       redeemEnableTime,
       new BN('12'),
-      new BN('85000'),
+      new BN(REP_CONST_A),
       new BN('900'),
       new BN('5'),
       token.address,
@@ -100,22 +102,25 @@ describe('Scheme', () => {
     const schemes = await dao.schemes({ where: { address: continuousLocking4ReputationAddress.toLowerCase() } }).pipe(first()).toPromise()
     const scheme = schemes[0]
     expect(scheme.CTL4R).not.toBeFalsy()
-    const ctl4r = scheme.CTL4R as CTL4RScheme
-    await ctl4r.getScheme().context.fetchContractInfos({fetchPolicy: 'network-only'})
-    expect(await ctl4r.getAgreementHash()).toEqual(agreementHash)
+    const cl4r = scheme.CTL4R as CL4RScheme
+    await cl4r.getScheme().context.fetchContractInfos({fetchPolicy: 'network-only'})
+    expect(await cl4r.getAgreementHash()).toEqual(agreementHash)
     const lockAmount = new BN('300')
     await token.approveForStaking(continuousLocking4ReputationAddress.toLowerCase(), lockAmount).send()
     await token.mint(accounts[0].address, lockAmount).send()
     await arc.fetchContractInfos({fetchPolicy: 'network-only'})
     const continuousLocking4ReputationContract = arc.getContract(continuousLocking4ReputationAddress.toLowerCase())
     const lockCounterBefore = await continuousLocking4ReputationContract.methods.lockCounter().call()
-    await ctl4r.lock(lockAmount,1,0,agreementHash).send()
+    await cl4r.lock(lockAmount,1,0,agreementHash).send()
     const lockCounterAfter = await continuousLocking4ReputationContract.methods.lockCounter().call()
     expect(Number(lockCounterBefore)+1).toEqual(Number(lockCounterAfter))
-    const reputationRewardPerPeriod = new BN('85000')
-    const repreward = await ctl4r.getReputationRewardForLockingIds([lockCounterAfter],0,reputationRewardPerPeriod)
+    const reputationRewardPerPeriod = new Decimal(REP_CONST_A)
+    const A = await continuousLocking4ReputationContract.methods.repRewardConstA().call()
+    const B = await continuousLocking4ReputationContract.methods.repRewardConstB().call()
+    const repreward = await cl4r.getReputationRewardForLockingIds([lockCounterAfter],0,reputationRewardPerPeriod)
     expect(repreward).toEqual(reputationRewardPerPeriod)
-    await ctl4r.extendLocking(2,0,lockCounterAfter,agreementHash).send()
+    expect(await cl4r.getRepuationRewardForBatch(A,B,0)).toEqual(reputationRewardPerPeriod)
+    await cl4r.extendLocking(2,0,lockCounterAfter,agreementHash).send()
 
   })
 })