Merge pull request #22 from codescalers/main_tfchain

Get the result after applying extrinsic

Author: AhmedHanafy725

packages/tfchain_client/bin/tfchain_client.dart

@@ -19,9 +19,9 @@ void main() async {
   await client.connect();
   // final extrinsic = await client.clientBalances.transfer(
   //     address: "5CJrCjZvsudNoJApTGG5PKcZfhAzAyGqgSK8bysoCV2oRBMC", amount: 10);
-  final extrinsic = await client.clientTwins.create(relay: [], pk: []);
+  final twinId = await client.clientTwins.create(relay: [], pk: []);
 
-  await client.apply(extrinsic);
+  print(twinId);
   // await client.kvStrore.list();
 
   // await client.disconnect();

packages/tfchain_client/lib/src/balances.dart

@@ -17,9 +17,9 @@ class QueryBalances {
 }
 
 class Balances extends QueryBalances {
-  Balances(Client client) : super(client) {
-    this.client = client;
-  }
+  Balances(Client this.client) : super(client);
+
+  final Client client;
 
   Future<RuntimeCall> transfer(
       {required String address, required int amount}) async {
@@ -30,12 +30,12 @@ class Balances extends QueryBalances {
     final publicKey = keyring.decodeAddress(address);
     MultiAddress multiAddress = Address32(publicKey);
 
-    final extrinsic =
-        client.api.tx.balances.transfer(dest: multiAddress, value: BigInt.from(amount));
+    final extrinsic = client.api.tx.balances
+        .transfer(dest: multiAddress, value: BigInt.from(amount));
     return extrinsic;
   }
 
-  // Future<AccountInfo?> getMyBalance() async {
-  //   return await this
-  // }
+  Future<AccountInfo?> getMyBalance() async {
+    return await this.get(address: client.address);
+  }
 }

packages/tfchain_client/lib/src/client.dart

@@ -129,6 +129,30 @@ class Client extends QueryClient {
     }
   }
 
+  List<int> _getMyEventsPhaseId(List<dynamic> events) {
+    final Set<int> phaseIds = Set();
+    for (final event in events) {
+      if (event["event"] != null &&
+          event["event"].key == "TransactionPayment" &&
+          ListEquality().equals(
+              event["event"].value.value[0], keypair!.publicKey.bytes)) {
+        phaseIds.add(event['phase'].value);
+      }
+    }
+    return phaseIds.toList();
+  }
+
+  List<dynamic> _filterMyEvents(List<dynamic> events) {
+    final List<dynamic> myEvents = [];
+    final phaseIds = _getMyEventsPhaseId(events);
+    for (final event in events) {
+      if (phaseIds.contains(event["phase"].value)) {
+        myEvents.add(event["event"]);
+      }
+    }
+    return myEvents;
+  }
+
   Future<void> apply(RuntimeCall runtimeCall) async {
     if (provider == null) {
       throw Exception("Provider is not initialized");
@@ -153,10 +177,8 @@ class Client extends QueryClient {
         .result
         .replaceAll('0x', '');
 
-    final keyring = await KeyPair.sr25519.fromMnemonic(mnemonic);
-
     final encodedCall = runtimeCall.encode();
-    final nonce = await api.rpc.system.accountNextIndex(keyring.address);
+    final nonce = await api.rpc.system.accountNextIndex(address);
     final metadata = await api.rpc.state.getMetadata();
 
     // await api.rpc.state.queryStorageAt(keys)
@@ -176,93 +198,86 @@ class Client extends QueryClient {
 
     final payload = payloadToSign.encode(api.registry);
 
-    final signature = keyring.sign(payload);
+    final signature = keypair!.sign(payload);
 
     // final hexSignature = hex.encode(signature);
 
     // final publicKey = hex.encode(keyring.publicKey.bytes);
-
+    final signatureType = keypairType == "sr25519"
+        ? SignatureType.sr25519
+        : SignatureType.ed25519;
     final extrinsic = ExtrinsicPayload(
-            signer: Uint8List.fromList(keyring.bytes()),
+            signer: Uint8List.fromList(keypair!.bytes()),
             method: encodedCall,
             signature: signature,
             eraPeriod: 64,
             blockNumber: blockNumber,
             nonce: nonce,
             tip: 0)
-        .encode(api.registry, SignatureType.sr25519);
-
-    final hexExtrinsic = hex.encode(extrinsic);
-    final input = Input.fromHex(hexExtrinsic);
-    final dynamic extrinsicDecoded =
-        ExtrinsicsCodec(chainInfo: metadata.chainInfo).decode(input);
-    print(extrinsicDecoded);
-
-    final submit = await AuthorApi(provider!).submitAndWatchExtrinsic(
+        .encode(api.registry, signatureType);
+
+    // final hexExtrinsic = hex.encode(extrinsic);
+    // final input = Input.fromHex(hexExtrinsic);
+    // final dynamic extrinsicDecoded =
+    //     ExtrinsicsCodec(chainInfo: metadata.chainInfo).decode(input);
+    // print(extrinsicDecoded);
+    Completer<void> _complete = Completer();
+    final StreamSubscription subscription =
+        await AuthorApi(provider!).submitAndWatchExtrinsic(
       extrinsic,
       (p0) async {
         print("Extrinsic result: ${p0.type} - ${p0.value}");
         if (p0.type == 'inBlock') {
-          try {
-            final finalizedBlockHash = p0.value;
-            print(finalizedBlockHash.runtimeType);
-            final moduleHash =
-                Hasher.twoxx128.hash(Uint8List.fromList('System'.codeUnits));
-            final storageHash =
-                Hasher.twoxx128.hash(Uint8List.fromList('Events'.codeUnits));
-            Uint8List storageKey = Uint8List.fromList([
-              ...moduleHash,
-              ...storageHash,
-            ]);
-            final finalizedBlockHashBytes = hexToBytes(finalizedBlockHash);
-            final changes = await stateApi
-                .queryStorageAt([storageKey], at: finalizedBlockHashBytes);
-            if (changes != Null && changes.isNotEmpty) {
-              for (var changeSet in changes) {
-                print("Change Set:");
-                for (var change in changeSet.changes) {
-                  Uint8List key = change.key;
-                  Uint8List value = change.value!;
-
-                  final input = Input.fromBytes(value);
-                  final List<dynamic> decodedEvents =
-                      metadata.chainInfo.scaleCodec.decode('EventCodec', input);
-                  // try {
-                  //   List<Map<String, dynamic>> jsonEvents =
-                  //       decodedEvents.map((dynamic entry) {
-                  //     Map<String, dynamic> convertedEntry = {};
-
-                  //     entry.forEach((key, value) {
-                  //       if (value is MapEntry) {
-                  //         // Replace MapEntry with {}
-                  //         convertedEntry[key] = value.value;
-                  //       } else {
-                  //         convertedEntry[key] = value;
-                  //       }
-                  //     });
-
-                  //     return convertedEntry;
-                  //   }).toList();
-
-                  //   String jsonOutput = jsonEncode(jsonEvents);
-
-                  //   print("Converted JSON:");
-                  //   print(jsonOutput);
-                  // } catch (e) {
-                  //   print("Error converting events: $e");
-                  // }
+          final finalizedBlockHash = p0.value;
+          final moduleHash =
+              Hasher.twoxx128.hash(Uint8List.fromList('System'.codeUnits));
+          final storageHash =
+              Hasher.twoxx128.hash(Uint8List.fromList('Events'.codeUnits));
+          Uint8List storageKey = Uint8List.fromList([
+            ...moduleHash,
+            ...storageHash,
+          ]);
+          final finalizedBlockHashBytes = hexToBytes(finalizedBlockHash);
+          final changes = await stateApi
+              .queryStorageAt([storageKey], at: finalizedBlockHashBytes);
+          if (changes != Null && changes.isNotEmpty) {
+            for (var changeSet in changes) {
+              for (var change in changeSet.changes) {
+                Uint8List key = change.key;
+                Uint8List value = change.value!;
+
+                final input = Input.fromBytes(value);
+                final List<dynamic> decodedEvents =
+                    metadata.chainInfo.scaleCodec.decode('EventCodec', input);
+                final myEvents = _filterMyEvents(decodedEvents);
+                bool targetModuleEventOccur = false;
+                for (final event in myEvents) {
+                  if (event.key == "System" &&
+                      event.value.key == "ExtrinsicFailed") {
+                    // TODO: get the error name and type
+                    final error = event.value.value["DispatchError"].value;
+                    final errorType = event.value.value["DispatchError"].key;
+                    _complete.completeError(
+                        "Failed to apply extrinsic: ${errorType}${error}");
+                  } else if (event.key == runtimeCall.runtimeType.toString()) {
+                    targetModuleEventOccur = true;
+                  } else if (targetModuleEventOccur &&
+                      event.key == "System" &&
+                      event.value.key == "ExtrinsicSuccess") {
+                    print("Extrinsic is applied successfully");
+                    _complete.complete();
+                    return;
+                  }
                 }
               }
-            } else {
-              print("No events found in the block");
             }
-          } catch (e) {
-            print('Error decoding events: $e');
+          } else {
+            _complete.completeError("No events found in the block");
           }
         }
       },
     );
-
-    // print(submit);
+    await _complete.future;
+    subscription.cancel();
   }
 }

packages/tfchain_client/lib/src/contracts.dart

@@ -111,8 +111,8 @@ class Contracts extends QueryContracts {
   }
 
   Future<RuntimeCall> createName({required String name}) async {
-    final extrinsic =
-        client.api.tx.smartContractModule.createNameContract(name: name);
+    final extrinsic = client.api.tx.smartContractModule
+        .createNameContract(name: name.codeUnits);
     return extrinsic;
   }
 

packages/tfchain_client/lib/src/twins.dart

@@ -22,13 +22,16 @@ class QueryTwins {
 }
 
 class Twins extends QueryTwins {
-  Twins(Client client) : super(client);
+  Twins(Client this.client) : super(client);
 
-  Future<RuntimeCall> create(
-      {required List<int> relay, required List<int> pk}) async {
+  final Client client;
+
+  Future<int?> create({required List<int> relay, required List<int> pk}) async {
     final extrinsic =
         client.api.tx.tfgridModule.createTwin(relay: relay, pk: pk);
-    return extrinsic;
+
+    await client.apply(extrinsic);
+    return await getTwinIdByAccountId(address: client.address);
   }
 
   Future<RuntimeCall> update(

packages/tfchain_client/lib/tfchain_client.dart

@@ -1,13 +1,19 @@
 library client;
 
+import 'dart:async';
 import 'dart:typed_data';
 
-
 import 'package:polkadart/polkadart.dart'
-    show AuthorApi, ExtrinsicPayload, Hasher, Provider, SignatureType, SigningPayload, StateApi;
+    show
+        AuthorApi,
+        ExtrinsicPayload,
+        Hasher,
+        Provider,
+        SignatureType,
+        SigningPayload,
+        StateApi;
 import 'package:polkadart/scale_codec.dart';
 import 'package:polkadart_keyring/polkadart_keyring.dart';
-import 'package:substrate_metadata/types/metadata_types.dart';
 import 'package:tfchain_client/generated/dev/types/tfchain_runtime/runtime_call.dart';
 import 'package:tfchain_client/src/balances.dart' as balance;
 import 'package:tfchain_client/src/contracts.dart';
@@ -23,5 +29,6 @@ import 'package:tfchain_client/src/twins.dart';
 import 'package:bip39/bip39.dart';
 import 'package:convert/convert.dart';
 import 'package:signer/signer.dart' as Signer;
+import 'package:collection/collection.dart';
 
 part 'src/client.dart';