Merge branch 'master' into support_not_in

Author: jellegerbrandy

src/index.ts

@@ -9,6 +9,7 @@ export { Queue, IQueueState, IQueueQueryOptions } from './queue'
 export { Reputation, IReputationState, IReputationQueryOptions } from './reputation'
 export { Reward, IRewardState, IRewardQueryOptions } from './reward'
 export { Scheme, ISchemeState, ISchemeQueryOptions } from './scheme'
+export { ReputationFromTokenScheme } from './schemes/reputationFromToken'
 export { IContributionReward} from './schemes/contributionReward'
 export { IGenericScheme } from './schemes/genericScheme'
 export { ISchemeRegistrar } from './schemes/schemeRegistrar'

src/scheme.ts

@@ -7,6 +7,7 @@ import { Operation, toIOperationObservable } from './operation'
 import { IProposalCreateOptions, IProposalQueryOptions, Proposal } from './proposal'
 import * as ContributionReward from './schemes/contributionReward'
 import * as GenericScheme from './schemes/genericScheme'
+import { ReputationFromTokenScheme } from './schemes/reputationFromToken'
 import * as SchemeRegistrar from './schemes/schemeRegistrar'
 import { Address, ICommonQueryOptions, IStateful } from './types'
 import { createGraphQlQuery, isAddress } from './utils'
@@ -57,11 +58,25 @@ export interface ISchemeQueryOptions extends ICommonQueryOptions {
   }
 }
 
+export interface ISchemeQueryOptions extends ICommonQueryOptions {
+  where?: {
+    address?: Address
+    canDelegateCall?: boolean
+    canRegisterSchemes?: boolean
+    canUpgradeController?: boolean
+    canManageGlobalConstraints?: boolean
+    dao?: Address
+    id?: string
+    name?: string
+    paramsHash?: string
+    [key: string]: any
+  }
+}
+
 /**
  * A Scheme represents a scheme instance that is registered at a DAO
  */
 export class Scheme implements IStateful<ISchemeState> {
-
   /**
    * Scheme.search(context, options) searches for scheme entities
    * @param  context an Arc instance that provides connection information
@@ -106,16 +121,15 @@ export class Scheme implements IStateful<ISchemeState> {
     }   `
     const itemMap = (item: any): Scheme|null => {
       if (!options.where) { options.where = {}}
-      return new Scheme(
-        {
-          address: item.address,
-          dao: item.dao.id,
-          id: item.id,
-          name: item.name,
-          paramsHash: item.paramsHash
-        },
-        context
-      )
+
+      const scheme = new Scheme({
+        address: item.address,
+        dao: item.dao.id,
+        id: item.id,
+        name: item.name,
+        paramsHash: item.paramsHash
+      }, context)
+      return scheme
     }
 
     return context.getObservableList(
@@ -126,9 +140,10 @@ export class Scheme implements IStateful<ISchemeState> {
   }
 
   public id: Address
-  public staticState: ISchemeStaticState|null = null
+  public staticState: ISchemeStaticState | null = null
+  public ReputationFromToken: ReputationFromTokenScheme | null = null
 
-  constructor(idOrOpts: Address|ISchemeStaticState, public context: Arc) {
+  constructor(idOrOpts: Address | ISchemeStaticState, public context: Arc) {
     this.context = context
     if (typeof idOrOpts === 'string') {
       this.id = idOrOpts as string
@@ -147,17 +162,21 @@ export class Scheme implements IStateful<ISchemeState> {
    * fetch the static state from the subgraph
    * @return the statatic state
    */
-  public async fetchStaticState(): Promise<ISchemeStaticState> {
+  public async fetchStaticState(): Promise < ISchemeStaticState > {
     if (!!this.staticState) {
       return this.staticState
     } else {
       const state = await this.state().pipe(first()).toPromise()
       this.staticState = state
+      if (this.staticState.name ===  'ReputationFromToken') {
+        this.ReputationFromToken = new ReputationFromTokenScheme(this)
+      }
+
       return state
     }
   }
 
-  public state(): Observable<ISchemeState> {
+  public state(): Observable < ISchemeState > {
     const query = gql`
         {
         controllerScheme (id: "${this.id}") {
@@ -284,7 +303,7 @@ export class Scheme implements IStateful<ISchemeState> {
      * @param  options [description ]
      * @return a Proposal instance
      */
-    public createProposal(options: IProposalCreateOptions): Operation<Proposal>  {
+    public createProposal(options: IProposalCreateOptions): Operation < Proposal >  {
       const observable = Observable.create(async (observer: any) => {
         let msg: string
         const context = this.context

src/schemes/reputationFromToken.ts

@@ -0,0 +1,53 @@
+import { from } from 'rxjs'
+import { concatMap } from 'rxjs/operators'
+
+import {
+  Operation,
+  toIOperationObservable
+} from '../operation'
+
+import { Address } from '../types'
+
+import { Scheme } from '../scheme'
+
+export class ReputationFromTokenScheme {
+
+  constructor(public scheme: Scheme) {
+
+  }
+
+  public redeem(beneficiary: Address): Operation<any> {
+    const mapReceipt = (receipt: any) => {
+      return receipt
+    }
+
+    const observable = from(this.getContract())
+      .pipe(
+      concatMap((contract) => {
+        const errorHandler = async (error: Error) => {
+          return error
+        }
+
+        const redeemMethod = contract.methods.redeem(
+          beneficiary
+        )
+
+        return this.scheme.context.sendTransaction(redeemMethod, mapReceipt, errorHandler)
+      })
+    )
+    return toIOperationObservable(observable)
+  }
+
+  public async redemptionAmount(beneficiary: Address): Promise<number> {
+    const contract = await this.getContract()
+    const amount = await contract.methods.redeem(beneficiary).call()
+    return amount
+  }
+
+  private async getContract() {
+    const state = await this.scheme.fetchStaticState()
+    const contract =  this.scheme.context.getContract(state.address)
+    return contract
+  }
+
+}

test/operation.spec.ts

@@ -66,5 +66,5 @@ describe('Operation', () => {
       transactionHash: listOfUpdates[2].transactionHash
     })
 
-  }, 20000)
+  })
 })

test/scheme-reputationfromtoken.spec.ts

@@ -0,0 +1,30 @@
+import { Scheme } from '../src/scheme'
+import { getTestDAO, newArc } from './utils'
+
+jest.setTimeout(60000)
+/**
+ * Scheme test
+ */
+describe('Scheme', () => {
+
+  it.skip('Test the whole flow', async () => {
+    const arc = await newArc()
+    const dao = await getTestDAO()
+
+    const scheme = new Scheme({
+        address: '0x1224',
+        dao: dao.id,
+        id: '0.x123455',
+        name: 'ReputationFromToken',
+        paramsHash: '0x124'
+    }, arc)
+
+    expect(scheme.ReputationFromToken).not.toBeFalsy()
+    if (scheme.ReputationFromToken) {
+      const amount = await scheme.ReputationFromToken.redemptionAmount(arc.web3.eth.defaultAccount)
+      expect(amount).toEqual(0)
+      await scheme.ReputationFromToken.redeem(arc.web3.eth.defaultAccount)
+    }
+  })
+
+})