refactor substrate_sdk.dart provider file; Add local node entry in settings

lib/providers/substrate_sdk.dart

@@ -33,170 +33,66 @@ class SubstrateSdk with ChangeNotifier {
   TextEditingController jsonKeystore = TextEditingController();
   TextEditingController keystorePassword = TextEditingController();
 
-  Future getStorage(String call) async {
-    return await sdk.webView!.evalJavascript('api.query.$call');
-  }
-
-  Future<void> initApi() async {
-    sdkLoading = true;
-    await keyring.init([ss58]);
-    keyring.setSS58(ss58);
-
-    await sdk.init(keyring);
-    sdkReady = true;
-    sdkLoading = false;
-    notifyListeners();
-  }
-
-  Future<void> connectNode(BuildContext ctx) async {
-    HomeProvider homeProvider = Provider.of<HomeProvider>(ctx, listen: false);
-
-    homeProvider.changeMessage("connectionPending".tr(), 0);
-
-    // configBox.delete('customEndpoint');
-    final List<NetworkParams> listEndpoints =
-        configBox.containsKey('customEndpoint')
-            ? [getDuniterCustomEndpoint()]
-            : getDuniterBootstrap();
-
-    int timeout = 10000;
-
-    if (sdk.api.connectedNode?.endpoint != null) {
-      await sdk.api.setting.unsubscribeBestNumber();
-    }
+  /////////////////////////////////////
+  ////////// 1: API METHODS ///////////
+  /////////////////////////////////////
 
-    isLoadingEndpoint = true;
-    notifyListeners();
-    final res = await sdk.api.connectNode(keyring, listEndpoints).timeout(
-          Duration(milliseconds: timeout),
-          onTimeout: () => null,
+  Future<String> executeCall(
+      TxInfoData txInfo, txOptions, String password) async {
+    try {
+      final hash = await sdk.api.tx
+          .signAndSend(
+            txInfo,
+            txOptions,
+            password,
+          )
+          .timeout(
+            const Duration(seconds: 12),
+            onTimeout: () => {},
           );
-    isLoadingEndpoint = false;
-    notifyListeners();
-    if (res != null) {
-      nodeConnected = true;
-      // await getSs58Prefix();
-
-      // Subscribe bloc number
-      sdk.api.setting.subscribeBestNumber((res) {
-        blocNumber = int.parse(res.toString());
-        // log.d(sdk.api.connectedNode?.endpoint);
-        if (sdk.api.connectedNode?.endpoint == null) {
-          nodeConnected = false;
-          homeProvider.changeMessage("networkLost".tr(), 0);
-        } else {
-          nodeConnected = true;
-        }
+      log.d(hash);
+      if (hash.isEmpty) {
+        transactionStatus = 'timeout';
         notifyListeners();
-      });
 
-      // currencyName = await getCurencyName();
-      notifyListeners();
-      homeProvider.changeMessage(
-          "wellConnectedToNode"
-              .tr(args: [getConnectedEndpoint()!.split('/')[2]]),
-          5);
-      // snackNode(ctx, true);
+        return 'timeout';
       } else {
-      nodeConnected = false;
-      debugConnection = res.toString();
+        transactionStatus = hash.toString();
         notifyListeners();
-      homeProvider.changeMessage("noDuniterEndointAvailable".tr(), 0);
-      // snackNode(ctx, false);
-    }
-
-    log.d(sdk.api.connectedNode?.endpoint);
-  }
-
-  List<NetworkParams> getDuniterBootstrap() {
-    List<NetworkParams> node = [];
-
-    for (String endpoint in configBox.get('endpoint')) {
-      final n = NetworkParams();
-      n.name = currencyName;
-      n.endpoint = endpoint;
-      n.ss58 = ss58;
-      node.add(n);
+        return hash.toString();
       }
-    return node;
+    } catch (e) {
+      transactionStatus = e.toString();
+      notifyListeners();
+      return e.toString();
     }
-
-  NetworkParams getDuniterCustomEndpoint() {
-    final nodeParams = NetworkParams();
-    nodeParams.name = currencyName;
-    nodeParams.endpoint = configBox.get('customEndpoint');
-    nodeParams.ss58 = ss58;
-    return nodeParams;
   }
 
-  Future<String> importAccount(
-      {String mnemonic = '',
-      bool fromMnemonic = false,
-      String derivePath = '',
-      String password = ''}) async {
-    // toy exercise immense month enter answer table prefer speed cycle gold phone
-    final clipboardData = await Clipboard.getData(Clipboard.kTextPlain);
-    if (mnemonic != '') {
-      fromMnemonic = true;
-      generatedMnemonic = mnemonic;
-    } else if (clipboardData!.text!.split(' ').length == 12) {
-      fromMnemonic = true;
-      generatedMnemonic = clipboardData.text!;
+  Future getStorage(String call) async {
+    return await sdk.webView!.evalJavascript('api.query.$call');
   }
 
-    if (password == '') {
-      password = keystorePassword.text;
-    }
+  List batchCall(TxSenderData sender, List calls) {
+    TxInfoData txInfo = TxInfoData(
+      'utility',
+      'batchAll',
+      sender,
+    );
+    List txOptions = calls;
 
-    final KeyType keytype;
-    final String keyToImport;
-    if (fromMnemonic) {
-      keytype = KeyType.mnemonic;
-      keyToImport = generatedMnemonic;
-    } else {
-      keytype = KeyType.keystore;
-      keyToImport = jsonKeystore.text.replaceAll("'", "\\'");
+    return [txInfo, txOptions];
   }
 
-    importIsLoading = true;
-    notifyListeners();
-    if (clipboardData?.text != null) jsonKeystore.text = clipboardData!.text!;
-    var json = await sdk.api.keyring
-        .importAccount(keyring,
-            keyType: keytype,
-            key: keyToImport,
-            name: derivePath,
-            password: password,
-            derivePath: derivePath,
-            cryptoType: CryptoType.sr25519)
-        .catchError((e) {
-      importIsLoading = false;
-      notifyListeners();
-    });
-    if (json == null) return '';
-    // log.d(json);
-    try {
-      await sdk.api.keyring.addAccount(
-        keyring,
-        keyType: keytype,
-        acc: json,
-        password: password,
+  TxSenderData _setSender() {
+    return TxSenderData(
+      keyring.current.address,
+      keyring.current.pubKey,
     );
-    } catch (e) {
-      log.e(e);
-      importIsLoading = false;
-      notifyListeners();
-    }
-
-    importIsLoading = false;
-
-    notifyListeners();
-    return keyring.allAccounts.last.address!;
   }
 
-  void reload() {
-    notifyListeners();
-  }
+  ////////////////////////////////////////////
+  ////////// 2: GET ONCHAIN STORAGE //////////
+  ////////////////////////////////////////////
 
   Future<List<AddressInfo>> getKeyStoreAddress() async {
     List<AddressInfo> result = [];
@@ -322,54 +218,296 @@ class SubstrateSdk with ChangeNotifier {
     return totalAmount;
   }
 
-  Future<double> subscribeBalance(String address, {bool isUd = false}) async {
-    double balance = 0.0;
-    if (nodeConnected) {
-      await sdk.api.account.subscribeBalance(address, (balanceData) {
-        balance = int.parse(balanceData.freeBalance) / 100;
-        notifyListeners();
-      });
+  Future<int> getSs58Prefix() async {
+    final List res = await sdk.webView!.evalJavascript(
+            'api.consts.system.ss58Prefix.words',
+            wrapPromise: false) ??
+        [42];
+
+    ss58 = res[0];
+    log.d(ss58);
+    return ss58;
   }
 
-    return balance;
+  Future<bool> isMemberGet(String address) async {
+    return await idtyStatus(address) == 'Validated';
   }
 
-  KeyPairData getKeypair(String address) {
-    return keyring.keyPairs.firstWhere((kp) => kp.address == address,
-        orElse: (() => KeyPairData()));
+  Future<String> getMemberAddress() async {
+    // TODOO: Continue digging memberAddress detection
+    String memberAddress = '';
+    walletBox.toMap().forEach((key, value) async {
+      final bool isMember = await isMemberGet(value.address!);
+      log.d(isMember);
+      if (isMember) {
+        final currentChestNumber = configBox.get('currentChest');
+        ChestData newChestData = chestBox.get(currentChestNumber)!;
+        newChestData.memberWallet = value.number;
+        await chestBox.put(currentChestNumber, newChestData);
+        memberAddress = value.address!;
+        return;
+      }
+    });
+    log.d(memberAddress);
+    return memberAddress;
   }
 
-  Future<bool> checkPassword(String address, String pass) async {
-    final account = getKeypair(address);
+  Future<Map<String, int>> certState(String from, String to) async {
+    Map<String, int> result = {};
+    if (from != to && await isMemberGet(from)) {
+      final removableOn = await getCertValidityPeriod(from, to);
+      final certMeta = await getCertMeta(from);
+      final int nextIssuableOn = certMeta['nextIssuableOn'] ?? 0;
+      final certRemovableDuration = (removableOn - blocNumber) * 6;
+      const int renewDelay = 2 * 30 * 24 * 3600; // 2 months
 
-    return await sdk.api.keyring.checkPassword(account, pass);
+      if (certRemovableDuration >= renewDelay) {
+        final certRenewDuration = certRemovableDuration - renewDelay;
+        result.putIfAbsent('certRenewable', () => certRenewDuration);
+      } else if (nextIssuableOn > blocNumber) {
+        final certDelayDuration = (nextIssuableOn - blocNumber) * 6;
+        result.putIfAbsent('certDelay', () => certDelayDuration);
+      } else {
+        result.putIfAbsent('canCert', () => 0);
+      }
+    }
+    return result;
   }
 
-  Future<String> getSeed(String address, String pin) async {
-    final account = getKeypair(address);
-    keyring.setCurrent(account);
+  Future<Map> getCertMeta(String address) async {
+    var idtyIndex = await getIdentityIndexOf(address);
 
-    final seed = await sdk.api.keyring.getDecryptedSeed(keyring, pin);
+    final certMeta =
+        await getStorage('cert.storageIdtyCertMeta($idtyIndex)') ?? '';
 
-    String seedText;
-    if (seed == null) {
-      seedText = '';
-    } else {
-      seedText = seed.seed!.split('//')[0];
+    return certMeta;
   }
 
-    log.d(seedText);
-    return seedText;
-  }
+  Future<String> idtyStatus(String address, [bool smooth = true]) async {
+    var idtyIndex = await getIdentityIndexOf(address);
 
-  int getDerivationNumber(String address) {
-    final account = getKeypair(address);
-    final deriveNbr = account.name!.split('//')[1];
-    return int.parse(deriveNbr);
+    if (idtyIndex == 0) {
+      return 'noid';
     }
 
-  Future<KeyPairData?> changePassword(BuildContext context, String address,
-      String passOld, String? passNew) async {
+    final idtyStatus = await getStorage('identity.identities($idtyIndex)');
+
+    if (idtyStatus != null) {
+      final String status = idtyStatus['status'];
+
+      return (status);
+    } else {
+      return 'expired';
+    }
+  }
+
+  Future getCurencyName() async {}
+
+  /////////////////////////////////////
+  ////// 3: SUBSTRATE CONNECTION //////
+  /////////////////////////////////////
+
+  Future<void> initApi() async {
+    sdkLoading = true;
+    await keyring.init([ss58]);
+    keyring.setSS58(ss58);
+
+    await sdk.init(keyring);
+    sdkReady = true;
+    sdkLoading = false;
+    notifyListeners();
+  }
+
+  String? getConnectedEndpoint() {
+    return sdk.api.connectedNode?.endpoint;
+  }
+
+  Future<void> connectNode(BuildContext ctx) async {
+    HomeProvider homeProvider = Provider.of<HomeProvider>(ctx, listen: false);
+
+    homeProvider.changeMessage("connectionPending".tr(), 0);
+
+    // configBox.delete('customEndpoint');
+    final List<NetworkParams> listEndpoints =
+        configBox.containsKey('customEndpoint')
+            ? [getDuniterCustomEndpoint()]
+            : getDuniterBootstrap();
+
+    int timeout = 10000;
+
+    if (sdk.api.connectedNode?.endpoint != null) {
+      await sdk.api.setting.unsubscribeBestNumber();
+    }
+
+    isLoadingEndpoint = true;
+    notifyListeners();
+    final res = await sdk.api.connectNode(keyring, listEndpoints).timeout(
+          Duration(milliseconds: timeout),
+          onTimeout: () => null,
+        );
+    isLoadingEndpoint = false;
+    notifyListeners();
+    if (res != null) {
+      nodeConnected = true;
+      // await getSs58Prefix();
+
+      // Subscribe bloc number
+      sdk.api.setting.subscribeBestNumber((res) {
+        blocNumber = int.parse(res.toString());
+        // log.d(sdk.api.connectedNode?.endpoint);
+        if (sdk.api.connectedNode?.endpoint == null) {
+          nodeConnected = false;
+          homeProvider.changeMessage("networkLost".tr(), 0);
+        } else {
+          nodeConnected = true;
+        }
+        notifyListeners();
+      });
+
+      // currencyName = await getCurencyName();
+      notifyListeners();
+      homeProvider.changeMessage(
+          "wellConnectedToNode"
+              .tr(args: [getConnectedEndpoint()!.split('/')[2]]),
+          5);
+      // snackNode(ctx, true);
+    } else {
+      nodeConnected = false;
+      debugConnection = res.toString();
+      notifyListeners();
+      homeProvider.changeMessage("noDuniterEndointAvailable".tr(), 0);
+      // snackNode(ctx, false);
+    }
+
+    log.d(sdk.api.connectedNode?.endpoint);
+  }
+
+  List<NetworkParams> getDuniterBootstrap() {
+    List<NetworkParams> node = [];
+
+    for (String endpoint in configBox.get('endpoint')) {
+      final n = NetworkParams();
+      n.name = currencyName;
+      n.endpoint = endpoint;
+      n.ss58 = ss58;
+      node.add(n);
+    }
+    return node;
+  }
+
+  NetworkParams getDuniterCustomEndpoint() {
+    final nodeParams = NetworkParams();
+    nodeParams.name = currencyName;
+    nodeParams.endpoint = configBox.get('customEndpoint');
+    nodeParams.ss58 = ss58;
+    return nodeParams;
+  }
+
+  Future<String> importAccount(
+      {String mnemonic = '',
+      bool fromMnemonic = false,
+      String derivePath = '',
+      String password = ''}) async {
+    // toy exercise immense month enter answer table prefer speed cycle gold phone
+    final clipboardData = await Clipboard.getData(Clipboard.kTextPlain);
+    if (mnemonic != '') {
+      fromMnemonic = true;
+      generatedMnemonic = mnemonic;
+    } else if (clipboardData!.text!.split(' ').length == 12) {
+      fromMnemonic = true;
+      generatedMnemonic = clipboardData.text!;
+    }
+
+    if (password == '') {
+      password = keystorePassword.text;
+    }
+
+    final KeyType keytype;
+    final String keyToImport;
+    if (fromMnemonic) {
+      keytype = KeyType.mnemonic;
+      keyToImport = generatedMnemonic;
+    } else {
+      keytype = KeyType.keystore;
+      keyToImport = jsonKeystore.text.replaceAll("'", "\\'");
+    }
+
+    importIsLoading = true;
+    notifyListeners();
+    if (clipboardData?.text != null) jsonKeystore.text = clipboardData!.text!;
+    var json = await sdk.api.keyring
+        .importAccount(keyring,
+            keyType: keytype,
+            key: keyToImport,
+            name: derivePath,
+            password: password,
+            derivePath: derivePath,
+            cryptoType: CryptoType.sr25519)
+        .catchError((e) {
+      importIsLoading = false;
+      notifyListeners();
+    });
+    if (json == null) return '';
+    // log.d(json);
+    try {
+      await sdk.api.keyring.addAccount(
+        keyring,
+        keyType: keytype,
+        acc: json,
+        password: password,
+      );
+    } catch (e) {
+      log.e(e);
+      importIsLoading = false;
+      notifyListeners();
+    }
+
+    importIsLoading = false;
+
+    notifyListeners();
+    return keyring.allAccounts.last.address!;
+  }
+
+  //////////////////////////////////
+  /////// 4: CRYPTOGRAPHY //////////
+  //////////////////////////////////
+
+  KeyPairData getKeypair(String address) {
+    return keyring.keyPairs.firstWhere((kp) => kp.address == address,
+        orElse: (() => KeyPairData()));
+  }
+
+  Future<bool> checkPassword(String address, String pass) async {
+    final account = getKeypair(address);
+
+    return await sdk.api.keyring.checkPassword(account, pass);
+  }
+
+  Future<String> getSeed(String address, String pin) async {
+    final account = getKeypair(address);
+    keyring.setCurrent(account);
+
+    final seed = await sdk.api.keyring.getDecryptedSeed(keyring, pin);
+
+    String seedText;
+    if (seed == null) {
+      seedText = '';
+    } else {
+      seedText = seed.seed!.split('//')[0];
+    }
+
+    log.d(seedText);
+    return seedText;
+  }
+
+  int getDerivationNumber(String address) {
+    final account = getKeypair(address);
+    final deriveNbr = account.name!.split('//')[1];
+    return int.parse(deriveNbr);
+  }
+
+  Future<KeyPairData?> changePassword(BuildContext context, String address,
+      String passOld, String? passNew) async {
     final account = getKeypair(address);
     MyWalletsProvider myWalletProvider =
         Provider.of<MyWalletsProvider>(context, listen: false);
@@ -423,91 +561,93 @@ class SubstrateSdk with ChangeNotifier {
     }
   }
 
+  Future<String> derive(
+      BuildContext context, String address, int number, String password) async {
+    final keypair = getKeypair(address);
+
+    final seedMap =
+        await keyring.store.getDecryptedSeed(keypair.pubKey, password);
+
+    if (seedMap?['type'] != 'mnemonic') return '';
+    final List seedList = seedMap!['seed'].split('//');
+    generatedMnemonic = seedList[0];
+
+    return await importAccount(
+        mnemonic: generatedMnemonic,
+        fromMnemonic: true,
+        derivePath: '//$number',
+        password: password);
+  }
+
+  Future<String> generateRootKeypair(String address, String password) async {
+    final keypair = getKeypair(address);
+
+    final seedMap =
+        await keyring.store.getDecryptedSeed(keypair.pubKey, password);
+
+    if (seedMap?['type'] != 'mnemonic') return '';
+    final List seedList = seedMap!['seed'].split('//');
+    generatedMnemonic = seedList[0];
+
+    return await importAccount(fromMnemonic: true, password: password);
+  }
+
+  Future<bool> isMnemonicValid(String mnemonic) async {
+    // Needed for bad encoding of UTF-8
+    mnemonic = mnemonic.replaceAll('é', 'é');
+    mnemonic = mnemonic.replaceAll('è', 'è');
+
+    return await sdk.api.keyring.checkMnemonicValid(mnemonic);
+  }
+
+  //////////////////////////////////////
+  ///////// 5: CALLS EXECUTION /////////
+  //////////////////////////////////////
+
   Future<String> pay(
       {required String fromAddress,
       required String destAddress,
       required double amount,
       required String password}) async {
     transactionStatus = '';
-
-    log.d(keyring.current.address);
-    log.d(fromAddress);
-    log.d(password);
-
     final fromPubkey = await sdk.api.account.decodeAddress([fromAddress]);
-    log.d(fromPubkey!.keys.first);
+    final int amountUnit = (amount * 100).toInt();
+
     final sender = TxSenderData(
       fromAddress,
-      fromPubkey.keys.first,
+      fromPubkey!.keys.first,
     );
+
     final txInfo = TxInfoData(
         'balances', amount == -1 ? 'transferAll' : 'transferKeepAlive', sender);
+    final txOptions = [destAddress, amount == -1 ? false : amountUnit];
 
-    final int amountUnit = (amount * 100).toInt();
-    try {
-      final hash = await sdk.api.tx.signAndSend(
-        txInfo,
-        [destAddress, amount == -1 ? false : amountUnit],
-        password,
-        onStatusChange: (status) {
-          log.d('Transaction status: $status');
-          transactionStatus = status;
-          notifyListeners();
-        },
-      ).timeout(
-        const Duration(seconds: 12),
-        onTimeout: () => {},
-      );
-      log.d(hash.toString());
-      if (hash.isEmpty) {
-        transactionStatus = 'timeout';
-        notifyListeners();
-
-        return 'timeout';
-      } else {
-        transactionStatus = hash.toString();
-        notifyListeners();
-        return hash.toString();
-      }
-    } catch (e) {
-      transactionStatus = e.toString();
-      notifyListeners();
-      return e.toString();
-    }
+    return await executeCall(txInfo, txOptions, password);
   }
 
   Future<String> certify(
       String fromAddress, String password, String toAddress) async {
     transactionStatus = '';
 
-    log.d('me: $fromAddress');
-    log.d('to: $toAddress');
-
     final myIdtyStatus = await idtyStatus(fromAddress);
     final toIdtyStatus = await idtyStatus(toAddress);
 
     final fromIndex = await getIdentityIndexOf(fromAddress);
     final toIndex = await getIdentityIndexOf(toAddress);
 
-    log.d(myIdtyStatus);
-    log.d(toIdtyStatus);
-
     if (myIdtyStatus != 'Validated') {
       transactionStatus = 'notMember';
       notifyListeners();
       return 'notMember';
     }
 
-    final toCerts = await getCerts(toAddress);
-    final currencyParameters = await getParameters();
-
-    final sender = TxSenderData(
-      keyring.current.address,
-      keyring.current.pubKey,
-    );
+    final sender = _setSender();
     TxInfoData txInfo;
     List txOptions = [];
 
+    final toCerts = await getCerts(toAddress);
+    final currencyParameters = await getParameters();
+
     if (toIdtyStatus == 'noid') {
       txInfo = TxInfoData(
         'identity',
@@ -520,15 +660,12 @@ class SubstrateSdk with ChangeNotifier {
       if (toCerts[0] >= currencyParameters['wotMinCertForMembership'] &&
           toIdtyStatus != 'Validated') {
         log.i('Batch cert and membership validation');
-        txInfo = TxInfoData(
-          'utility',
-          'batchAll',
-          sender,
-        );
-        txOptions = [
+        List batch = batchCall(sender, [
           'cert.addCert($fromIndex, $toIndex)',
           'identity.validateIdentity($toIndex)'
-        ];
+        ]);
+        txInfo = batch[0];
+        txOptions = batch[1];
       } else {
         txInfo = TxInfoData(
           'cert',
@@ -544,52 +681,22 @@ class SubstrateSdk with ChangeNotifier {
     }
 
     log.d('Cert action: ${txInfo.call!}');
-
-    try {
-      final hash = await sdk.api.tx
-          .signAndSend(
-            txInfo,
-            txOptions,
-            password,
-          )
-          .timeout(
-            const Duration(seconds: 12),
-            onTimeout: () => {},
-          );
-      log.d(hash);
-      if (hash.isEmpty) {
-        transactionStatus = 'timeout';
-        notifyListeners();
-
-        return 'timeout';
-      } else {
-        transactionStatus = hash.toString();
-        notifyListeners();
-        return hash.toString();
-      }
-    } catch (e) {
-      transactionStatus = e.toString();
-      notifyListeners();
-      return e.toString();
-    }
-  }
-
-  Future<String> idtyStatus(String address, [bool smooth = true]) async {
-    var idtyIndex = await getIdentityIndexOf(address);
-
-    if (idtyIndex == 0) {
-      return 'noid';
+    return await executeCall(txInfo, txOptions, password);
   }
 
-    final idtyStatus = await getStorage('identity.identities($idtyIndex)');
+  Future claimUDs(String password) async {
+    final sender = TxSenderData(
+      keyring.current.address,
+      keyring.current.pubKey,
+    );
 
-    if (idtyStatus != null) {
-      final String status = idtyStatus['status'];
+    final txInfo = TxInfoData(
+      'universalDividend',
+      'claimUds',
+      sender,
+    );
 
-      return (status);
-    } else {
-      return 'expired';
-    }
+    return await executeCall(txInfo, [], password);
   }
 
   Future<String> confirmIdentity(
@@ -606,92 +713,9 @@ class SubstrateSdk with ChangeNotifier {
       'confirmIdentity',
       sender,
     );
+    final txOptions = [name];
 
-    try {
-      final hash = await sdk.api.tx.signAndSend(
-        txInfo,
-        [name],
-        password,
-        onStatusChange: (status) {
-          log.d('Transaction status: $status');
-          transactionStatus = status;
-          notifyListeners();
-        },
-      ).timeout(
-        const Duration(seconds: 12),
-        onTimeout: () => {},
-      );
-      log.d(hash);
-      if (hash.isEmpty) {
-        transactionStatus = 'timeout';
-        notifyListeners();
-
-        return 'timeout';
-      } else {
-        transactionStatus = hash.toString();
-        notifyListeners();
-        return hash.toString();
-      }
-    } on Exception catch (e) {
-      log.e(e);
-      transactionStatus = e.toString();
-      notifyListeners();
-      return e.toString();
-    }
-  }
-
-  Future<bool> isMemberGet(String address) async {
-    return await idtyStatus(address) == 'Validated';
-  }
-
-  Future<String> getMemberAddress() async {
-    // TODOO: Continue digging memberAddress detection
-    String memberAddress = '';
-    walletBox.toMap().forEach((key, value) async {
-      final bool isMember = await isMemberGet(value.address!);
-      log.d(isMember);
-      if (isMember) {
-        final currentChestNumber = configBox.get('currentChest');
-        ChestData newChestData = chestBox.get(currentChestNumber)!;
-        newChestData.memberWallet = value.number;
-        await chestBox.put(currentChestNumber, newChestData);
-        memberAddress = value.address!;
-        return;
-      }
-    });
-    log.d(memberAddress);
-    return memberAddress;
-  }
-
-  Future<Map<String, int>> certState(String from, String to) async {
-    Map<String, int> result = {};
-    if (from != to && await isMemberGet(from)) {
-      final removableOn = await getCertValidityPeriod(from, to);
-      final certMeta = await getCertMeta(from);
-      final int nextIssuableOn = certMeta['nextIssuableOn'] ?? 0;
-      final certRemovableDuration = (removableOn - blocNumber) * 6;
-      const int renewDelay = 2 * 30 * 24 * 3600; // 2 months
-
-      if (certRemovableDuration >= renewDelay) {
-        final certRenewDuration = certRemovableDuration - renewDelay;
-        result.putIfAbsent('certRenewable', () => certRenewDuration);
-      } else if (nextIssuableOn > blocNumber) {
-        final certDelayDuration = (nextIssuableOn - blocNumber) * 6;
-        result.putIfAbsent('certDelay', () => certDelayDuration);
-      } else {
-        result.putIfAbsent('canCert', () => 0);
-      }
-    }
-    return result;
-  }
-
-  Future<Map> getCertMeta(String address) async {
-    var idtyIndex = await getIdentityIndexOf(address);
-
-    final certMeta =
-        await getStorage('cert.storageIdtyCertMeta($idtyIndex)') ?? '';
-
-    return certMeta;
+    return await executeCall(txInfo, txOptions, password);
   }
 
   Future revokeIdentity(String address, String password) async {
@@ -711,91 +735,19 @@ class SubstrateSdk with ChangeNotifier {
       sender,
     );
 
-    try {
-      final hash = await sdk.api.tx
-          .signAndSend(
-            txInfo,
-            [idtyIndex],
-            password,
-          )
-          .timeout(
-            const Duration(seconds: 12),
-            onTimeout: () => {},
-          );
-      log.d(hash);
-      if (hash.isEmpty) {
-        transactionStatus = 'timeout';
-        notifyListeners();
+    final txOptions = [idtyIndex];
 
-        return 'timeout';
-      } else {
-        transactionStatus = hash.toString();
-        notifyListeners();
-        return hash.toString();
-      }
-    } catch (e) {
-      transactionStatus = e.toString();
-      notifyListeners();
-      return e.toString();
-    }
-  }
-
-  Future getCurencyName() async {}
-
-  Future<String> derive(
-      BuildContext context, String address, int number, String password) async {
-    final keypair = getKeypair(address);
-
-    final seedMap =
-        await keyring.store.getDecryptedSeed(keypair.pubKey, password);
-
-    if (seedMap?['type'] != 'mnemonic') return '';
-    final List seedList = seedMap!['seed'].split('//');
-    generatedMnemonic = seedList[0];
-
-    return await importAccount(
-        mnemonic: generatedMnemonic,
-        fromMnemonic: true,
-        derivePath: '//$number',
-        password: password);
-  }
-
-  Future<String> generateRootKeypair(String address, String password) async {
-    final keypair = getKeypair(address);
-
-    final seedMap =
-        await keyring.store.getDecryptedSeed(keypair.pubKey, password);
-
-    if (seedMap?['type'] != 'mnemonic') return '';
-    final List seedList = seedMap!['seed'].split('//');
-    generatedMnemonic = seedList[0];
-
-    return await importAccount(fromMnemonic: true, password: password);
+    return await executeCall(txInfo, txOptions, password);
   }
 
-  Future<bool> isMnemonicValid(String mnemonic) async {
-    // Needed for bad encoding of UTF-8
-    mnemonic = mnemonic.replaceAll('é', 'é');
-    mnemonic = mnemonic.replaceAll('è', 'è');
-
-    return await sdk.api.keyring.checkMnemonicValid(mnemonic);
+  void reload() {
+    notifyListeners();
   }
-
-  String? getConnectedEndpoint() {
-    return sdk.api.connectedNode?.endpoint;
 }
 
-  Future<int> getSs58Prefix() async {
-    final List res = await sdk.webView!.evalJavascript(
-            'api.consts.system.ss58Prefix.words',
-            wrapPromise: false) ??
-        [42];
-
-    ss58 = res[0];
-    log.d(ss58);
-    return ss58;
-  }
-}
+////////////////////////////////////////////
+/////// 6: UI ELEMENTS (off class) /////////
+////////////////////////////////////////////
 
 void snack(BuildContext context, String message, {int duration = 2}) {
   final snackBar =

lib/screens/settings.dart

@@ -78,10 +78,13 @@ class SettingsScreen extends StatelessWidget {
 
     final customEndpoint = NetworkParams();
     customEndpoint.endpoint = 'Personnalisé';
+    final localEndpoint = NetworkParams();
+    localEndpoint.endpoint = 'ws://127.0.0.1:9944';
     final automaticEndpoint = NetworkParams();
     automaticEndpoint.endpoint = 'Auto';
     // duniterBootstrapNodes.add(_sub.getDuniterCustomEndpoint());
     duniterBootstrapNodes.insert(0, automaticEndpoint);
+    duniterBootstrapNodes.add(localEndpoint);
     duniterBootstrapNodes.add(customEndpoint);
 
     if (configBox.get('autoEndpoint') == true) {