Merge branch 'main_signer_workflows_tfchain' into main_tfchain_interface

Author: AhmedHanafy725

packages/tfchain_client/lib/models/nodes.dart

@@ -0,0 +1,33 @@
+class IPConfig {
+  final String ip;
+  final String gw;
+
+  IPConfig({
+    required this.ip,
+    required this.gw,
+  });
+}
+
+class PublicConfig {
+  final IPConfig ip4;
+  final IPConfig? ip6;
+  final String? domain;
+
+  PublicConfig({
+    required this.ip4,
+    this.ip6,
+    this.domain,
+  });
+}
+
+class NodePublicConfigOptions {
+  final int farmId;
+  final int nodeId;
+  final PublicConfig publicConfig;
+
+  NodePublicConfigOptions({
+    required this.farmId,
+    required this.nodeId,
+    required this.publicConfig,
+  });
+}

packages/tfchain_client/lib/src/balances.dart

@@ -21,7 +21,7 @@ class Balances extends QueryBalances {
 
   final Client client;
 
-  Future<RuntimeCall> transfer(
+  Future<AccountInfo?> transfer(
       {required String address, required int amount}) async {
     if (amount.isNaN || amount <= 0) {
       throw Exception("Amount must be a positive numeric value");
@@ -32,7 +32,8 @@ class Balances extends QueryBalances {
 
     final extrinsic = client.api.tx.balances
         .transfer(dest: multiAddress, value: BigInt.from(amount));
-    return extrinsic;
+
+    return await this.get(address: client.address);
   }
 
   Future<AccountInfo?> getMyBalance() async {

packages/tfchain_client/lib/src/contracts.dart

@@ -83,9 +83,10 @@ class QueryContracts {
 }
 
 class Contracts extends QueryContracts {
-  Contracts(Client client) : super(client);
+  Contracts(Client this.client) : super(client);
+  final Client client;
 
-  Future<RuntimeCall> createNode(
+  Future<BigInt?> createNode(
       {required int nodeId,
       required List<int> deploymentHash,
       required List<int> deploymentData,
@@ -95,49 +96,61 @@ class Contracts extends QueryContracts {
         deploymentHash: deploymentHash,
         deploymentData: deploymentData,
         publicIps: publicIps);
+    await client.apply(extrinsic);
 
-    return extrinsic;
+    return await getContractIdByNodeIdAndHash(
+        hash: deploymentHash, nodeId: nodeId);
   }
 
-  Future<RuntimeCall> updateNode(
+  Future<Contract?> updateNode(
       {required int contractId,
       required List<int> deploymentHash,
       required List<int> deploymentData}) async {
     final extrinsic = client.api.tx.smartContractModule.updateNodeContract(
         contractId: contractId,
         deploymentHash: deploymentHash,
         deploymentData: deploymentData);
-    return extrinsic;
+    await client.apply(extrinsic);
+
+    return await get(contractId: BigInt.from(contractId));
   }
 
-  Future<RuntimeCall> createName({required String name}) async {
+  Future<BigInt?> createName({required String name}) async {
     final extrinsic = client.api.tx.smartContractModule
         .createNameContract(name: name.codeUnits);
-    return extrinsic;
+    await client.apply(extrinsic);
+
+    return await getContractIdByName(name: name);
   }
 
-  Future<RuntimeCall> createRent(
+  Future<BigInt?> createRent(
       {required int nodeId, required int solutionProviderId}) async {
     final extrinsic = client.api.tx.smartContractModule.createRentContract(
         nodeId: nodeId, solutionProviderId: solutionProviderId);
-    return extrinsic;
+    await client.apply(extrinsic);
+
+    return await getContractIdByActiveRentForNode(nodeId: nodeId);
   }
 
-  Future<RuntimeCall> cancel({required BigInt contractId}) async {
+  Future<Contract?> cancel({required BigInt contractId}) async {
     final contract = await get(contractId: contractId);
     if (contract == null) {
       throw Exception("Contract not found");
     }
 
     final extrinsic = client.api.tx.smartContractModule
         .cancelContract(contractId: contractId);
-    return extrinsic;
+    await client.apply(extrinsic);
+    // IF not found it means its cancelled successfully
+    return await get(contractId: contractId);
   }
 
-  Future<RuntimeCall> setDedicatedNodeExtraFee(
+  Future<BigInt?> setDedicatedNodeExtraFee(
       {required int nodeId, required int extraFee}) async {
     final extrinsic = client.api.tx.smartContractModule
         .setDedicatedNodeExtraFee(nodeId: nodeId, extraFee: extraFee);
-    return extrinsic;
+    await client.apply(extrinsic);
+
+    return await getDedicatedNodeExtraFee(nodeId: nodeId);
   }
 }

packages/tfchain_client/lib/src/dao.dart

@@ -126,15 +126,18 @@ class QueryDao {
 }
 
 class Dao extends QueryDao {
-  Dao(Client client) : super(client);
+  Dao(Client this.client) : super(client);
+  final Client client;
 
-  RuntimeCall vote(
+  Future<DaoVotes> vote(
       {required String address,
       required int farmId,
       required String hash,
-      required bool approve}) {
+      required bool approve}) async {
     final extrinsic = client.api.tx.dao
         .vote(farmId: farmId, proposalHash: hash.codeUnits, approve: approve);
-    return extrinsic;
+    await client.apply(extrinsic);
+
+    return getProposalVotes(hash: hash);
   }
 }

packages/tfchain_client/lib/src/farms.dart

@@ -9,39 +9,49 @@ class QueryFarms {
 
   Future<Farm?> get({required int id}) async {
     final res = await client.api.query.tfgridModule.farms(id);
-    return res as Farm;
+    return res;
+  }
+
+  Future<int?> getFarmIdByName({required String name}) async {
+    return await client.api.query.tfgridModule.farmIdByName(name.codeUnits);
   }
 }
 
 class Farms extends QueryFarms {
-  Farms(Client client) : super(client);
+  Farms(Client this.client) : super(client);
+  final Client client;
 
-  Future<RuntimeCall> create(
+  Future<int?> create(
       {required String name, required List<Ip4>? publicIps}) async {
     final extrinsic = client.api.tx.tfgridModule
         .createFarm(name: name.codeUnits, publicIps: publicIps);
-    return extrinsic;
+    await client.apply(extrinsic);
+
+    return await getFarmIdByName(name: name);
   }
 
 // TODO: Bug
-  Future<RuntimeCall> addFarmIp(
+  Future<Farm?> addFarmIp(
       {required int farmId, required String ip, required String gw}) async {
     final extrinsic = client.api.tx.tfgridModule
         .addFarmIp(farmId: farmId, ip: ip.codeUnits, gw: gw.codeUnits);
-    return extrinsic;
+    await client.apply(extrinsic);
+
+    return await get(id: farmId);
   }
 
-  Future<RuntimeCall> removeFarmIp(
-      {required int farmId, required String ip}) async {
+  Future<Farm?> removeFarmIp({required int farmId, required String ip}) async {
     final extrinsic =
         client.api.tx.tfgridModule.removeFarmIp(farmId: farmId, ip: ip);
-    return extrinsic;
+    await client.apply(extrinsic);
+
+    return await get(id: farmId);
   }
 
-  Future<RuntimeCall> addStellarAddress(
+  Future<void> addStellarAddress(
       {required int farmId, required String stellarAddress}) async {
     final extrinsic = client.api.tx.tfgridModule.addStellarPayoutV2address(
         farmId: farmId, stellarAddress: stellarAddress);
-    return extrinsic;
+    await client.apply(extrinsic);
   }
 }

packages/tfchain_client/lib/src/kvstore.dart

@@ -8,21 +8,20 @@ class KVStore {
 
   KVStore(this.client);
 
-  RuntimeCall set({required String key, required String value}) {
+  Future<void> set({required String key, required String value}) async {
     final extrinsic =
         client.api.tx.tFKVStore.set(key: key.codeUnits, value: value.codeUnits);
-    return extrinsic;
+    await client.apply(extrinsic);
   }
 
-  RuntimeCall delete({required String key}) {
+  Future<void> delete({required String key}) async {
     final extrinsic = client.api.tx.tFKVStore.delete(key: key.codeUnits);
-    return extrinsic;
+    await client.apply(extrinsic);
   }
 
   Future<String> get({required String key}) async {
     final res = await client.api.query.tFKVStore
         .tFKVStore(client.keypair!.publicKey.bytes, []);
-    print(res);
     return String.fromCharCodes(res);
   }
 
@@ -77,16 +76,14 @@ class KVStore {
       keyValueMap[String.fromCharCodes(added)] = String.fromCharCodes(value);
     }
 
-    print(keyValueMap);
     return keyValueMap;
   }
 
-  void deleteAll() async {
+  Future<void> deleteAll() async {
     Map<String, String> keys = await list();
 
     for (String key in keys.keys) {
-      final extrinsic = delete(key: key);
-      await client.apply(extrinsic);
+      await (key: key);
     }
   }
 }

packages/tfchain_client/lib/src/nodes.dart

@@ -1,5 +1,5 @@
-import 'package:tfchain_client/generated/dev/types/tfchain_runtime/runtime_call.dart';
 import 'package:tfchain_client/generated/dev/types/tfchain_support/types/node.dart';
+import 'package:tfchain_client/models/nodes.dart';
 import 'package:tfchain_client/tfchain_client.dart';
 
 class QueryNodes {
@@ -16,10 +16,10 @@ class QueryNodes {
 }
 
 class Nodes extends QueryNodes {
-  Nodes(Client client) : super(client);
+  Nodes(Client this.client) : super(client);
+  final Client client;
 
-  Future<RuntimeCall> setPower(
-      {required int nodeId, required bool power}) async {
+  Future<void> setPower({required int nodeId, required bool power}) async {
     Map<String, bool?> powerTarget = {
       'up': null,
       'down': null,
@@ -31,23 +31,39 @@ class Nodes extends QueryNodes {
     }
     final extrinsic = client.api.tx.tfgridModule
         .changePowerTarget(nodeId: nodeId, powerTarget: powerTarget);
-    return extrinsic;
+    await client.apply(extrinsic);
   }
-}
 
-// TODO: what to do with this for addNodePublicConfig function
-// interface NodePublicConfigOptions {
-//   farmId: number;
-//   nodeId: number;
-//   publicConfig?: {
-//     ip4: {
-//       ip: string;
-//       gw: string;
-//     };
-//     ip6?: {
-//       ip: string;
-//       gw: string;
-//     } | null;
-//     domain?: string | null;
-//   } | null;
-// }
+  Future<void> addNodePublicConfig({
+    required int farmId,
+    required int nodeId,
+    required String ip4Ip,
+    required String ip4Gw,
+    String? ip6Ip,
+    String? ip6Gw,
+    String? domain,
+  }) async {
+    IPConfig ip4Config = IPConfig(ip: ip4Ip, gw: ip4Gw);
+    IPConfig? ip6Config;
+
+    if (ip6Ip != null && ip6Gw != null) {
+      ip6Config = IPConfig(ip: ip6Ip, gw: ip6Gw);
+    }
+
+    PublicConfig publicConfig = PublicConfig(
+      ip4: ip4Config,
+      ip6: ip6Config,
+      domain: domain,
+    );
+
+    NodePublicConfigOptions options = NodePublicConfigOptions(
+      farmId: farmId,
+      nodeId: nodeId,
+      publicConfig: publicConfig,
+    );
+
+    final extrinsic = client.api.tx.tfgridModule.addNodePublicConfig(
+        farmId: farmId, nodeId: nodeId, publicConfig: options);
+    await client.apply(extrinsic);
+  }
+}

packages/tfchain_client/lib/src/terms_and_conditions.dart

@@ -1,14 +1,13 @@
-import 'package:tfchain_client/generated/dev/types/tfchain_runtime/runtime_call.dart';
 import 'package:tfchain_client/tfchain_client.dart';
 
 class TermsAndConditions {
   final Client client;
   TermsAndConditions(this.client);
 
-  Future<RuntimeCall> accept(
+  Future<void> accept(
       {required String documentLink, required String documentHash}) async {
-    final extrinsic = await client.api.tx.tfgridModule.userAcceptTc(
-        documentLink: documentLink, documentHash: documentHash);
-    return extrinsic;
+    final extrinsic = await client.api.tx.tfgridModule
+        .userAcceptTc(documentLink: documentLink, documentHash: documentHash);
+    await client.apply(extrinsic);
   }
 }

packages/tfchain_client/lib/src/tft_bridge.dart

@@ -17,12 +17,13 @@ class QueryBridge {
 }
 
 class Bridge extends QueryBridge {
-  Bridge(Client client) : super(client);
+  Bridge(Client this.client) : super(client);
+  final Client client;
 
-  Future<RuntimeCall> swapToStellar(
+  Future<void> swapToStellar(
       {required String target, required int amount}) async {
     final extrinsic = client.api.tx.tFTBridgeModule
         .swapToStellar(targetStellarAddress: target, amount: amount);
-    return extrinsic;
+    await client.apply(extrinsic);
   }
 }