Poll services token balance directly in UserDepositService

Author: manuelwedler

src/app/services/token-info-retriever.service.ts

@@ -37,7 +37,7 @@ export class TokenInfoRetrieverService {
     async createBatch(
         tokenAddresses: string[],
         raidenAddress: string,
-        userTokens: { [address: string]: UserToken | null }
+        userTokens: { [address: string]: UserToken | null } = {}
     ): Promise<{ [address: string]: UserToken }> {
         const batchManager = this.batchManagerFactory.create(
             this.raidenConfig.web3.currentProvider

src/app/services/user-deposit.service.spec.ts

@@ -17,17 +17,19 @@ import { ContractOptions } from 'web3-eth-contract/types';
 import { AbiItem } from 'web3-utils/types';
 import Spy = jasmine.Spy;
 import { TokenInfoRetrieverService } from './token-info-retriever.service';
+import { UserToken } from '../models/usertoken';
 
 describe('UserDepositService', () => {
     let service: UserDepositService;
     let reconnectedSubject: BehaviorSubject<void>;
     let rpcConnectedSubject: Subject<void>;
-    let tokenResult: Promise<string>;
+    let tokenAddressResult: Promise<string>;
     let balanceResult: Promise<string>;
+    let tokenBalanceResult: Promise<string>;
     let tokenRetrieverSpy: Spy;
 
     const balance = '40000000';
-    const token = createToken();
+    let token: UserToken;
 
     beforeEach(() => {
         const raidenServiceMock = stub<RaidenService>();
@@ -54,31 +56,47 @@ describe('UserDepositService', () => {
         });
         const raidenConfig = TestBed.inject(RaidenConfig);
 
-        tokenResult = Promise.resolve(token.address);
+        token = createToken();
+        tokenAddressResult = Promise.resolve(token.address);
         balanceResult = Promise.resolve(balance);
+        tokenBalanceResult = Promise.resolve(token.balance.toString());
 
         // @ts-ignore
         raidenConfig.web3.eth.Contract = function (
-            jsonInterface: AbiItem[] | AbiItem,
+            jsonInterface: AbiItem[],
             address?: string,
             options?: ContractOptions
         ) {
-            return {
+            const contractMock = {
                 address: address,
                 options: {},
-                methods: {
+                methods: {},
+            };
+            if (
+                jsonInterface.find((item: AbiItem) => item.name === 'balanceOf')
+            ) {
+                contractMock.methods = {
+                    balanceOf: () => {
+                        return {
+                            call: () => tokenBalanceResult,
+                        };
+                    },
+                };
+            } else {
+                contractMock.methods = {
                     token: () => {
                         return {
-                            call: () => tokenResult,
+                            call: () => tokenAddressResult,
                         };
                     },
                     balances: () => {
                         return {
                             call: () => balanceResult,
                         };
                     },
-                },
-            };
+                };
+            }
+            return contractMock;
         };
 
         tokenRetrieverSpy = spyOn(
@@ -123,13 +141,17 @@ describe('UserDepositService', () => {
         tokenRetrieverSpy.and.returnValue(
             Promise.resolve({ [token.address]: token })
         );
+        tokenBalanceResult = Promise.resolve('999999');
+        const tokenWithFetchedBalance = Object.assign({}, token, {
+            balance: new BigNumber('999999'),
+        });
 
         const spy = jasmine.createSpy();
         const subscription = service.servicesToken$.subscribe(spy);
 
         tick(15000);
         expect(spy).toHaveBeenCalledTimes(2);
-        expect(spy).toHaveBeenCalledWith(token);
+        expect(spy).toHaveBeenCalledWith(tokenWithFetchedBalance);
         flush();
         subscription.unsubscribe();
     }));
@@ -140,10 +162,10 @@ describe('UserDepositService', () => {
         );
 
         const spy = jasmine.createSpy();
-        tokenResult = Promise.reject();
+        tokenAddressResult = Promise.reject();
         const subscription = service.servicesToken$.subscribe(spy);
 
-        tokenResult = Promise.resolve(token.address);
+        tokenAddressResult = Promise.resolve(token.address);
         rpcConnectedSubject.next();
 
         tick();

src/app/services/user-deposit.service.ts

@@ -1,7 +1,7 @@
 import { Injectable } from '@angular/core';
 import { RaidenService } from './raiden.service';
 import { TokenInfoRetrieverService } from './token-info-retriever.service';
-import { Observable, zip, interval } from 'rxjs';
+import { Observable, zip, interval, of } from 'rxjs';
 import { UserToken } from '../models/usertoken';
 import {
     switchMap,
@@ -10,14 +10,14 @@ import {
     startWith,
     retryWhen,
     switchMapTo,
-    tap,
 } from 'rxjs/operators';
 import { backoff } from '../shared/backoff.operator';
 import { RaidenConfig } from './raiden.config';
 import { userDepositAbi } from '../models/userDepositAbi';
 import { fromPromise } from 'rxjs/internal-compatibility';
 import BigNumber from 'bignumber.js';
 import { Contract } from 'web3-eth-contract';
+import { tokenabi } from '../models/tokenabi';
 
 @Injectable({
     providedIn: 'root',
@@ -26,8 +26,6 @@ export class UserDepositService {
     readonly balance$: Observable<BigNumber>;
     readonly servicesToken$: Observable<UserToken>;
 
-    private servicesToken: UserToken;
-
     constructor(
         private raidenService: RaidenService,
         private tokenInfoRetriever: TokenInfoRetrieverService,
@@ -87,32 +85,47 @@ export class UserDepositService {
         const servicesTokenAddress$ = userDepositContract$.pipe(
             switchMap((userDepositContract) =>
                 fromPromise<string>(userDepositContract.methods.token().call())
-            ),
-            tap(() => {
-                this.servicesToken = undefined;
-            }),
-            retryWhen((errors) =>
-                errors.pipe(switchMapTo(this.raidenService.rpcConnected$))
-            ),
-            shareReplay(1)
+            )
         );
 
-        const fetchTokenInfo$ = zip(
+        const servicesTokenInfo$ = zip(
             this.raidenService.raidenAddress$,
             servicesTokenAddress$
         ).pipe(
             switchMap(([raidenAddress, tokenAddress]) =>
                 fromPromise(
                     this.tokenInfoRetriever.createBatch(
                         [tokenAddress],
-                        raidenAddress,
-                        { [tokenAddress]: this.servicesToken }
+                        raidenAddress
                     )
                 )
             ),
             map((result) => Object.values(result)[0]),
-            tap((token) => {
-                this.servicesToken = token;
+            retryWhen((errors) =>
+                errors.pipe(switchMapTo(this.raidenService.rpcConnected$))
+            ),
+            shareReplay(1)
+        );
+
+        const fetchTokenBalance$ = zip(
+            this.raidenService.raidenAddress$,
+            servicesTokenInfo$
+        ).pipe(
+            switchMap(([raidenAddress, servicesTokenInfo]) => {
+                const tokenContract = new this.raidenConfig.web3.eth.Contract(
+                    tokenabi,
+                    servicesTokenInfo.address
+                );
+                return zip(
+                    of(servicesTokenInfo),
+                    fromPromise<string>(
+                        tokenContract.methods.balanceOf(raidenAddress).call()
+                    )
+                );
+            }),
+            map(([servicesTokenInfo, balance]) => {
+                servicesTokenInfo.balance = new BigNumber(balance);
+                return servicesTokenInfo;
             }),
             retryWhen((errors) =>
                 errors.pipe(switchMapTo(this.raidenService.rpcConnected$))
@@ -121,7 +134,7 @@ export class UserDepositService {
 
         return interval(15000).pipe(
             startWith(0),
-            switchMapTo(fetchTokenInfo$),
+            switchMapTo(fetchTokenBalance$),
             shareReplay({ bufferSize: 1, refCount: true })
         );
     }