Subgraphs integration

.gitignore

@@ -6,6 +6,7 @@ doc/
 test/**/*.js
 src/**/*.js
 package-lock.json
+yarn.lock
 
 src/metadata\.json
 .idea

integration/config.ts

@@ -6,11 +6,12 @@ LoggerInstance.setLevel(LogLevel.Error)
 
 const configBase: Config = {
     nodeUri: 'http://localhost:8545',
-    metadataUri: 'http://nevermined-metadata:5000',
+    metadataUri: 'http://172.17.0.1:5000',
     faucetUri: 'http://localhost:3001',
     gatewayUri: 'http://localhost:8030',
     secretStoreUri: 'http://localhost:12001',
     gatewayAddress: '0x068ed00cf0441e4829d9784fcbe7b9e26d4bd8d0',
+    // graphHttpUri: 'http://localhost:9000/subgraphs/name/neverminedio',
     gasMultiplier: 1.1,
     verbose: LogLevel.Error
 }

integration/nevermined/ContractEvent.test.ts

@@ -0,0 +1,128 @@
+import { Account, Nevermined } from '../../src'
+import { config } from '../config'
+import { assert } from 'chai'
+import Web3 from 'web3'
+import { ContractEvent } from '../../src/keeper/ContractEvent'
+import { TransactionReceipt } from 'web3-core'
+
+describe('ContractEvent', () => {
+    let account: Account
+    let nevermined: Nevermined
+    let executeTransaction: () => Promise<any>
+
+    before(async () => {
+        config.graphHttpUri = undefined
+        nevermined = await Nevermined.getInstance(config)
+        ;[account] = await nevermined.accounts.list()
+
+        await nevermined.keeper.dispenser.requestTokens(1, account.getId())
+
+        executeTransaction = () =>
+            nevermined.keeper.dispenser.requestTokens(1, account.getId())
+    })
+
+    it('should get a ContractEvent instance', async () => {
+        assert.instanceOf(nevermined.keeper.token.events, ContractEvent)
+    })
+
+    it('should query for the event', async () => {
+        const response = await nevermined.keeper.token.events.getEventData({
+            filterJsonRpc: {
+                to: account.getId()
+            },
+            result: {
+                to: true,
+                value: true
+            },
+            eventName: 'Transfer'
+        })
+        assert.strictEqual(
+            Web3.utils.toChecksumAddress(response.pop().returnValues.to),
+            Web3.utils.toChecksumAddress(account.getId())
+        )
+    })
+
+    it('should be able to listen to events', async () => {
+        let validResolve = false
+        let subscription
+
+        const waitUntilEvent = new Promise(resolve => {
+            subscription = nevermined.keeper.token.events.subscribe(
+                events => {
+                    assert.isDefined(events)
+                    assert.isAtLeast(events.length, 1)
+                    if (validResolve) {
+                        resolve(0)
+                    }
+                },
+                {
+                    eventName: 'Transfer',
+                    filterJsonRpc: { to: account.getId() },
+                    fromBlock: 0,
+                    toBlock: 'latest'
+                }
+            )
+        })
+
+        await Promise.all([executeTransaction(), executeTransaction()])
+
+        await new Promise(resolve => setTimeout(resolve, 2000))
+        validResolve = true
+
+        await Promise.all([executeTransaction(), executeTransaction()])
+
+        await waitUntilEvent
+
+        subscription.unsubscribe()
+    })
+
+    it('should listen to event only once', async () => {
+        const to = account.getId()
+        // const event = await eventHandler.getEvent(nevermined.keeper.token)
+        const event = nevermined.keeper.token.events
+        let canBeRejected = false
+
+        const waitUntilEvent = new Promise((resolve, reject) => {
+            event.once(
+                () => {
+                    if (canBeRejected) {
+                        reject(new Error(''))
+                    }
+                    setTimeout(resolve, 600)
+                },
+                {
+                    eventName: 'Transfer',
+                    filterJsonRpc: {
+                        to
+                    }
+                }
+            )
+        })
+
+        await executeTransaction()
+
+        await new Promise(resolve => setTimeout(resolve, 2000))
+        canBeRejected = true
+
+        await executeTransaction()
+
+        await waitUntilEvent
+    })
+
+    it('should get the event like a promise', async () => {
+        const to = account.getId()
+        // const event = await eventHandler.getEvent(nevermined.keeper.token)
+        const event = nevermined.keeper.token.events
+
+        const waitUntilEvent = event.once(events => console.log(events), {
+            eventName: 'Transfer',
+            filterJsonRpc: { to }
+        })
+
+        await new Promise(resolve => setTimeout(resolve, 400))
+
+        await executeTransaction()
+
+        await waitUntilEvent
+    })
+})

integration/nevermined/SubgraphEvent.test.ts

@@ -0,0 +1,145 @@
+import { Account, Nevermined } from '../../src'
+import { config } from '../config'
+import { assert } from 'chai'
+import Web3 from 'web3'
+
+describe('SubgraphEvent', () => {
+    let account: Account
+    let nevermined: Nevermined
+    let executeTransaction: () => Promise<any>
+
+    before(async () => {
+        config.graphHttpUri =
+            config.graphHttpUri || 'http://localhost:9000/subgraphs/name/neverminedio'
+        nevermined = await Nevermined.getInstance(config)
+        ;[account] = await nevermined.accounts.list()
+
+        await nevermined.keeper.dispenser.requestTokens(1, account.getId())
+
+        executeTransaction = () =>
+            nevermined.keeper.dispenser.requestTokens(1, account.getId())
+    })
+
+    it('should query for the event', async () => {
+        const response = await nevermined.keeper.token.events.getEventData({
+            methodName: 'getTransfers',
+            filterSubgraph: {
+                where: {
+                    to: account.getId()
+                }
+            },
+            result: {
+                to: true,
+                value: true
+            }
+        })
+        console.log(response)
+        assert.strictEqual(
+            Web3.utils.toChecksumAddress(response.pop().to),
+            Web3.utils.toChecksumAddress(account.getId())
+        )
+    })
+
+    it('should be able to listen to events', async () => {
+        let validResolve = false
+        let subscription
+
+        const waitUntilEvent = new Promise(resolve => {
+            subscription = nevermined.keeper.token.events.subscribe(
+                events => {
+                    assert.isDefined(events)
+                    assert.isAtLeast(events.length, 1)
+                    if (validResolve) {
+                        resolve(0)
+                    }
+                },
+                {
+                    methodName: 'getTransfers',
+                    filterSubgraph: {
+                        where: {
+                            to: account.getId()
+                        }
+                    },
+                    result: {
+                        to: true,
+                        value: true
+                    }
+                }
+            )
+        })
+
+        await Promise.all([executeTransaction(), executeTransaction()])
+
+        await new Promise(resolve => setTimeout(resolve, 2000))
+        validResolve = true
+
+        await Promise.all([executeTransaction(), executeTransaction()])
+
+        await waitUntilEvent
+
+        subscription.unsubscribe()
+    })
+
+    it('should listen to event only once', async () => {
+        // const event = await eventHandler.getEvent(nevermined.keeper.token)
+        const event = nevermined.keeper.token.events
+        let canBeRejected = false
+
+        const waitUntilEvent = new Promise((resolve, reject) => {
+            event.once(
+                events => {
+                    if (canBeRejected) {
+                        reject(new Error(''))
+                    }
+                    setTimeout(resolve, 600)
+                },
+                {
+                    methodName: 'getTransfers',
+                    filterSubgraph: {
+                        where: {
+                            to: account.getId()
+                        }
+                    },
+                    result: {
+                        to: true,
+                        value: true
+                    }
+                }
+            )
+        })
+
+        await executeTransaction()
+
+        await new Promise(resolve => setTimeout(resolve, 2000))
+        canBeRejected = true
+
+        await executeTransaction()
+
+        await waitUntilEvent
+    })
+
+    it('should get the event like a promise', async () => {
+        const to = account.getId()
+        // const event = await eventHandler.getEvent(nevermined.keeper.token)
+        const event = nevermined.keeper.token.events
+
+        const waitUntilEvent = event.once(events => console.log(events), {
+            methodName: 'getTransfers',
+            filterSubgraph: {
+                where: {
+                    to: account.getId()
+                }
+            },
+            result: {
+                to: true,
+                value: true
+            }
+        })
+
+        await new Promise(resolve => setTimeout(resolve, 400))
+
+        await executeTransaction()
+
+        await waitUntilEvent
+    })
+})

package.json

@@ -55,6 +55,7 @@
   "dependencies": {
     "@nevermined-io/contracts": "^1.3.4",
     "@nevermined-io/secret-store-client": "^0.0.16",
+    "@nevermined-io/subgraphs": "0.2.1",
     "bignumber.js": "^9.0.0",
     "circom": "^0.5.45",
     "circomlib": "^0.5.3",
@@ -159,4 +160,4 @@
       "!src/**/*.d.ts"
     ]
   }
-}
+}

src/Instantiable.abstract.ts

@@ -65,7 +65,8 @@ export abstract class Instantiable {
         return { nevermined, web3, config, logger }
     }
 
-    public static async getInstance(...args: any[]): Promise<any>
+    public static getInstance(...args: any[]): any
+    // public static async getInstance(...args: any[]): Promise<any>
 
     public static async getInstance(config: InstantiableConfig): Promise<any> {
         LoggerInstance.warn('getInstance() methods has needs to be added to child class.')