Replace js-subscriptions with dart

app/js_service_encointer/src/index.js

@@ -4,14 +4,12 @@ import 'regenerator-runtime/runtime.js';
 import account from './service/account.js';
 import encointer from './service/encointer.js';
 import settings from './service/settings.js';
-import chain from './service/chain.js';
 
 window.addEventListener('flutterInAppWebViewPlatformReady', function (event) {
 
   window.send = send;
 
   window.account = account;
-  window.chain = chain;
   window.encointer = encointer;
   window.settings = settings;
 

app/js_service_encointer/src/service/account.js

@@ -2,7 +2,6 @@ import { cryptoWaitReady, mnemonicGenerate } from '@polkadot/util-crypto';
 import {
   hexToU8a,
   u8aToHex,
-  hexToString,
 } from '@polkadot/util';
 import BN from 'bn.js';
 import { Keyring } from '@polkadot/keyring';
@@ -11,7 +10,6 @@ import {
   encointerBalances,
   transfer
 } from '../config/consts.js';
-import { unsubscribe } from '../utils/unsubscribe.js';
 import { extractEvents } from '@encointer/node-api';
 import { stringNumberToEncointerBalanceU8a } from '../utils/utils.js';
 
@@ -99,46 +97,6 @@ async function addressFromUri(uri) {
   return keyring.encodeAddress(pubKey, ss58);
 }
 
-/**
- * get ERT balance of an address
- * @param {String} address
- * @returns {String} balance
- */
-async function getBalance (address) {
-  const all = await api.derive.balances.all(address);
-  const lockedBreakdown = all.lockedBreakdown.map((i) => {
-    return {
-      ...i,
-      use: hexToString(i.id.toHex())
-    };
-  });
-  return {
-    ...all,
-    lockedBreakdown
-  };
-}
-
-/**
- * subscribes to ERT balance of an address
- * @param msgChannel channel that the message handler uses on the dart side
- * @param {String} address
- * @returns {String} balance
- */
-async function subscribeBalance (msgChannel, address) {
-  return await api.derive.balances.all(address, (all) => {
-    const lockedBreakdown = all.lockedBreakdown.map((i) => {
-      return {
-        ...i,
-        use: hexToString(i.id.toHex())
-      };
-    });
-    send(msgChannel, {
-      ...all,
-      lockedBreakdown
-    });
-  }).then((unsub) => unsubscribe(unsub, msgChannel));
-}
-
 function getBlockTime (blocks) {
   return new Promise((resolve) => {
     const res = [];
@@ -335,8 +293,6 @@ export default {
   addressFromUri,
   gen,
   recover,
-  getBalance,
-  subscribeBalance,
   getBlockTime,
   txFeeEstimate,
   sendTx,

app/js_service_encointer/src/service/chain.js

@@ -1,29 +1,9 @@
-import { unsubscribe } from '../utils/unsubscribe.js';
-
-/**
- * Mainly debug method introduced to test subscriptions. Subscribes to the timestamp of the last block
- * @param msgChannel channel that the message handler uses on the dart side
- * @returns {Promise<void>}
- */
-export async function subscribeTimestamp (msgChannel) {
-  await api.query.timestamp.now((moment) => {
-    send(msgChannel, moment);
-  }).then((unsub) => unsubscribe(unsub, msgChannel));
-}
-
-export async function subscribeNewHeads (msgChannel) {
-  await api.rpc.chain.subscribeNewHeads((lastHeader) => {
-    send(msgChannel, lastHeader);
-  }).then((unsub) => unsubscribe(unsub, msgChannel));
-}
 
 export async function getFinalizedHeader () {
   const hash = await api.rpc.chain.getFinalizedHead();
   return api.rpc.chain.getHeader(hash);
 }
 
 export default {
-  subscribeTimestamp,
-  subscribeNewHeads,
   getFinalizedHeader,
 };

app/js_service_encointer/src/service/encointer.js

@@ -1,10 +1,9 @@
 import { assert, hexToU8a } from '@polkadot/util';
 import { cryptoWaitReady } from '@polkadot/util-crypto';
 import { createType } from '@polkadot/types';
-import { parseEncointerBalance, stringToDegree } from '@encointer/types';
+import { parseEncointerBalance } from '@encointer/types';
 import { keyring, sendTxWithPair } from './account.js';
-import { pallets, parachainSpecName, solochainSpecName } from '../config/consts.js';
-import { unsubscribe } from '../utils/unsubscribe.js';
+import { parachainSpecName, solochainSpecName } from '../config/consts.js';
 import { communityIdentifierToString } from '@encointer/util';
 import {
   getMeetupIndex as _getMeetupIndex,
@@ -20,28 +19,6 @@ import {
   hasCommittedFor,
 } from './faucet.js';
 
-/**
- * Subscribes to the current ceremony phase
- * @param msgChannel channel that the message handler uses on the dart side
- * @returns {Promise<void>}
- */
-export async function subscribeCurrentPhase (msgChannel) {
-  return await api.query.encointerScheduler.currentPhase((phase) => {
-    send(msgChannel, phase);
-  }).then((unsub) => unsubscribe(unsub, msgChannel));
-}
-
-/**
- * Subscribes to the currencies registry
- * @param msgChannel channel that the message handler uses on the dart side
- * @returns {Promise<void>}
- */
-export async function subscribeCommunityIdentifiers (msgChannel) {
-  return await api.query[pallets.encointerCommunities.name][pallets.encointerCommunities.calls.communityIdentifiers]((cids) => {
-    send(msgChannel, cids);
-  }).then((unsub) => unsubscribe(unsub, msgChannel));
-}
-
 export async function getBalance (cid, address) {
   const balanceEntry = await api.query.encointerBalances.balance(cid, address);
   return {
@@ -111,32 +88,6 @@ export function encointerTransferAll (fromPair, recipientAddress, cid) {
   return sendTxWithPair(fromPair, txInfo, paramList);
 }
 
-/**
- * Subscribes to the balance of a given cid
- * @param msgChannel channel that the message handler uses on the dart side
- * @returns {Promise<void>}
- */
-export async function subscribeBalance (msgChannel, cid, address) {
-  return await api.query.encointerBalances.balance(cid, address, (b) => {
-    const balance = parseEncointerBalance(b.principal.bits);
-    send(msgChannel, {
-      principal: balance,
-      lastUpdate: b.lastUpdate.toNumber()
-    });
-  }).then((unsub) => unsubscribe(unsub, msgChannel));
-}
-
-/**
- * Subscribes to the business registry of a given cid
- * @param msgChannel channel that the message handler uses on the dart side
- * @returns {Promise<void>}
- */
-export async function subscribeBusinessRegistry (msgChannel, cid) {
-  return await api.query.encointerBazaar.businessRegistry(cid, (businesses) => {
-    send(msgChannel, businesses);
-  }).then((unsub) => unsubscribe(unsub, msgChannel));
-}
-
 export async function getDemurrage (cid) {
   const cidT = api.createType('CommunityIdentifier', cid);
 
@@ -292,10 +243,6 @@ export async function sendNextPhaseTx() {
 }
 
 export default {
-  subscribeCurrentPhase,
-  subscribeBalance,
-  subscribeCommunityIdentifiers,
-  subscribeBusinessRegistry,
   getProofOfAttendance,
   getMeetupIndex,
   hasPendingIssuance,

app/js_service_encointer/test/gesell.test-e2e.js

@@ -49,15 +49,6 @@ describe('encointer', () => {
     });
   });
 
-  describe('accountgetBalances method', () => {
-    it('should return balances', async () => {
-      const address = '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY';
-      const balances = await account.getBalance(address);
-      console.log(balances);
-      expect(balances.availableBalance.gtn(1));
-    });
-  });
-
   describe('can transform problematic location', () => {
     it('should be defined', async () => {
       const loc_js = {

app/js_service_encointer/test/service/account.test.js

@@ -22,16 +22,6 @@ describe('account', () => {
     keyring = new Keyring({ type: 'sr25519' });
   });
 
-  describe('faucet', () => {
-    it('has enough funds', async () => {
-      await cryptoWaitReady();
-      const alice = keyring.addFromUri('//Alice', { name: 'Alice default' });
-      const balance = await account.getBalance(alice.address);
-      const faucetTransferValue = 0.0001 * Math.pow(10, 12);
-      expect(parseInt(balance.freeBalance)).toBeGreaterThan(faucetTransferValue);
-    });
-  });
-
   describe('community-payment', () => {
     // skipping because it needs to have a community setup
     it.skip('community fee payment works for ferdie without native tokens', async () => {

app/lib/page/profile/account/faucet_list_tile.dart

@@ -136,6 +136,6 @@ class _FaucetListTileState extends State<FaucetListTile> {
 
   Future<BigInt> getNativeFreeBalance(String address) async {
     final balance = await webApi.assets.getBalanceOf(address);
-    return balance.freeBalance;
+    return balance.free;
   }
 }

app/lib/service/substrate_api/api.dart

@@ -49,8 +49,8 @@ class Api {
       provider,
       dartApi,
       AccountApi(store, js, provider),
-      AssetsApi(store, js),
-      ChainApi(store, js),
+      AssetsApi(store, js, EncointerKusama(provider)),
+      ChainApi(store, provider),
       EncointerApi(store, js, dartApi, ewHttp, EncointerKusama(provider)),
       isIntegrationTest ? MockIpfsApi(ewHttp) : IpfsApi(ewHttp, gateway: store.settings.ipfsGateway),
       jsServiceEncointer,
@@ -269,14 +269,19 @@ class ReconnectingWsProvider extends Provider {
   }
 
   @override
-  Future disconnect() {
+  Future disconnect() async {
     // We only care if the channel is not equal to null.
     // Because we still want the internal cleanup if
     // the connection was closed from the other end.
     if (provider.channel == null) {
       return Future.value();
     } else {
-      return provider.disconnect();
+      try {
+        await provider.disconnect();
+      } catch (e) {
+        Log.e('Error disconnecting websocket: $e', 'ReconnectingWsProvider');
+        return Future.value();
+      }
     }
   }
 

app/lib/service/substrate_api/assets_api.dart

@@ -1,15 +1,20 @@
+import 'dart:async';
+
 import 'package:encointer_wallet/service/log/log_service.dart';
 import 'package:encointer_wallet/service/substrate_api/core/js_api.dart';
 import 'package:encointer_wallet/store/app.dart';
-import 'package:encointer_wallet/store/assets/types/balances_info.dart';
+import 'package:ew_keyring/ew_keyring.dart';
+import 'package:ew_polkadart/ew_polkadart.dart' show ByteInput, EncointerKusama, StorageChangeSet;
+import 'package:ew_polkadart/generated/encointer_kusama/types/pallet_balances/types/account_data.dart';
 
 class AssetsApi {
-  AssetsApi(this.store, this.jsApi);
+  AssetsApi(this.store, this.jsApi, this.encointerKusama);
 
   final JSApi jsApi;
   final AppStore store;
+  final EncointerKusama encointerKusama;
 
-  final String _balanceSubscribeChannel = 'gas token balance';
+  StreamSubscription<StorageChangeSet>? _balanceSubscription;
 
   Future<void> startSubscriptions() async {
     Log.d('api: starting assets subscriptions', 'AssetsApi');
@@ -18,47 +23,43 @@ class AssetsApi {
 
   Future<void> stopSubscriptions() async {
     Log.d('api: stopping assets subscriptions', 'AssetsApi');
-    await jsApi.unsubscribeMessage(_balanceSubscribeChannel);
+    await _balanceSubscription?.cancel();
+    _balanceSubscription = null;
   }
 
   Future<void> fetchBalance() async {
     final pubKey = store.account.currentAccountPubKey;
     final currentAddress = store.account.currentAddress;
-    if (pubKey != null && pubKey.isNotEmpty) {
-      final address = currentAddress;
-      final res = await jsApi.evalJavascript<Map<String, dynamic>>('account.getBalance("$address")');
-      await store.assets.setAccountBalances(pubKey, Map.of({store.settings.networkState!.tokenSymbol: res}));
+    if (currentAddress.isNotEmpty) {
+      final accountData = await encointerKusama.query.balances.account(AddressUtils.addressToPubKey(currentAddress));
+      await store.assets.setAccountBalances(pubKey, Map.of({store.settings.networkState!.tokenSymbol!: accountData}));
     }
-    await _fetchMarketPrice();
   }
 
-  Future<BalancesInfo> getBalance() async {
+  Future<AccountData> getBalance() async {
     return getBalanceOf(store.account.currentAddress);
   }
 
-  Future<BalancesInfo> getBalanceOf(String address) async {
-    final res = await jsApi.evalJavascript<Map<String, dynamic>>('account.getBalance("$address")');
-    return BalancesInfo.fromJson(res);
+  Future<AccountData> getBalanceOf(String address) async {
+    return encointerKusama.query.balances.account(AddressUtils.addressToPubKey(address));
   }
 
   Future<void> subscribeBalance() async {
-    await jsApi.unsubscribeMessage(_balanceSubscribeChannel);
+    await _balanceSubscription?.cancel();
 
     final pubKey = store.account.currentAccountPubKey;
-    if (pubKey != null && pubKey.isNotEmpty) {
-      final address = store.account.currentAddress;
+    final address = store.account.currentAddress;
 
-      await jsApi.subscribeMessage(
-        'account.subscribeBalance("$_balanceSubscribeChannel","$address")',
-        _balanceSubscribeChannel,
-        (Map<String, dynamic> data) async {
-          await store.assets.setAccountBalances(pubKey, Map.of({store.settings.networkState!.tokenSymbol: data}));
-        },
-      );
-    }
-  }
+    if (pubKey == null || pubKey.isEmpty || address.isEmpty) return;
+
+    final balanceKey = encointerKusama.query.balances.accountKey(AddressUtils.addressToPubKey(address));
 
-  Future<void> _fetchMarketPrice() async {
-    Log.d('Fetch marketprice not implemented for Encointer networks', 'AssetsApi');
+    _balanceSubscription = await encointerKusama.rpc.state.subscribeStorage([balanceKey], (storageChangeSet) async {
+      Log.p('Got account data subscription: $storageChangeSet');
+      if (storageChangeSet.changes[0].value != null) {
+        final accountData = AccountData.decode(ByteInput(storageChangeSet.changes[0].value!));
+        await store.assets.setAccountBalances(pubKey, Map.of({store.settings.networkState!.tokenSymbol!: accountData}));
+      }
+    });
   }
 }