diff --git a/Substrate.NetApi.Test/Keys/Ed25519Tests.cs b/Substrate.NetApi.Test/Keys/Ed25519Tests.cs
index beb6354..a9dc9ef 100644
--- a/Substrate.NetApi.Test/Keys/Ed25519Tests.cs
+++ b/Substrate.NetApi.Test/Keys/Ed25519Tests.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Linq;
+using System.Threading.Tasks;
 using NUnit.Framework;
 using Substrate.NetApi.Model.Types;
 using Substrate.NetApi.Model.Types.Base;
@@ -133,7 +134,7 @@ public void Ed25519SignatureTestComparePolkadotJs(string polkadotJsSignature)
 
         [Test]
         [TestCase("0xd2baabb61bcd0026e797136cb0938d55e3c3ea8825c163eb3d1738b3c79af8e8f4953ba4767dc5477202756d3fba97bc50fc3ac8355ff5acfba88a36311f2f0f")]
-        public void AccountEd25519SignatureTestComparePolkadotJs(string polkadotJsSignature)
+        public async Task AccountEd25519SignatureTestComparePolkadotJsAsync(string polkadotJsSignature)
         {
             var rawSeed = "0x70f93a75dbc6ad5b0c051210704a00a9937732d0c360792b0fea24efb8ea8465";
 
@@ -146,12 +147,14 @@ public void AccountEd25519SignatureTestComparePolkadotJs(string polkadotJsSignat
             // According to https://github.com/polkadot-js/apps/blob/master/packages/page-signing/src/Sign.tsx#L93
             var messageBytes = WrapMessage.Wrap(message);
 
-            var signature = account.Sign(messageBytes);
-            var singatureHexString = Utils.Bytes2HexString(signature);
+            var signature1 = await Task.Run(() => account.Sign(messageBytes));
+            var signature2 = await account.SignAsync(messageBytes);
 
-            // SIGn C#: 0x679FA7BC8B2A7C40B5ECD50CA041E961DB8971D2B454DB7DE64E543B3C1892A6D3F223DDA01C66B9878C149CFCC8B86ECF2B20F11F7610596F51479405776907
+            Assert.IsTrue(signature1.SequenceEqual(signature2));
+
+            Assert.True(account.Verify(signature1, account.Bytes, messageBytes));
+            Assert.True(account.Verify(signature2, account.Bytes, messageBytes));
 
-            // SIGn PolkaJS:0xd2baabb61bcd0026e797136cb0938d55e3c3ea8825c163eb3d1738b3c79af8e8f4953ba4767dc5477202756d3fba97bc50fc3ac8355ff5acfba88a36311f2f0f
             Assert.True(account.Verify(Utils.HexToByteArray(polkadotJsSignature), account.Bytes, messageBytes));
         }
     }
diff --git a/Substrate.NetApi.Test/Keys/Sr25519Tests.cs b/Substrate.NetApi.Test/Keys/Sr25519Tests.cs
index 9f69c96..90b8a3a 100644
--- a/Substrate.NetApi.Test/Keys/Sr25519Tests.cs
+++ b/Substrate.NetApi.Test/Keys/Sr25519Tests.cs
@@ -4,6 +4,8 @@
 using NUnit.Framework;
 using Schnorrkel.Keys;
 using Substrate.NetApi.Model.Types;
+using System.Threading.Tasks;
+using System.Linq;
 
 namespace Substrate.NetApi.Test.Keys
 {
@@ -88,7 +90,7 @@ public void Sr25519SignatureTestComparePolkadotJs(string polkadotJsSignature)
 
         [Test]
         [TestCase("0x5c42ac4e2d55b8e59d9b255af370de03fe177f5545eecbbd784531cb2eb1f2553e0e2b91656f99fae930eb6ff8ac1a3eca4e19d307ecb39832a479a478a8608a")]
-        public void AccountSr25519SignatureTestComparePolkadotJs(string polkadotJsSignature)
+        public async Task AccountSr25519SignatureTestComparePolkadotJsAsync(string polkadotJsSignature)
         {
             var miniSecretAlice = new MiniSecret(Utils.HexToByteArray("0xe5be9a5092b81bca64be81d212e7f2f9eba183bb7a90954f7b76361f6edb5c0a"), ExpandMode.Ed25519);
 
@@ -97,13 +99,14 @@ public void AccountSr25519SignatureTestComparePolkadotJs(string polkadotJsSignat
             var message = "I test this signature!";
             var messageBytes = WrapMessage.Wrap(message);
 
-            var simpleSign = account.Sign(messageBytes);
-            var singatureHexString = Utils.Bytes2HexString(simpleSign);
-            // SIGn C#: 0x2A6346A8707A9929B65167C448F719FE977F2EE04D2CB250685C98C79CCBF2458901F9B386D08422D9102FBD8BF7CFECDF7605F4CDC5FA8D121E2E9730F9098C
+            var signature1 = await Task.Run(() => account.Sign(messageBytes));
+            var signature2 = await account.SignAsync(messageBytes);
 
-            // SIGn PolkaJS:0x5c42ac4e2d55b8e59d9b255af370de03fe177f5545eecbbd784531cb2eb1f2553e0e2b91656f99fae930eb6ff8ac1a3eca4e19d307ecb39832a479a478a8608a
-            var simpleSign2 = Utils.HexToByteArray(polkadotJsSignature);
-            Assert.True(account.Verify(simpleSign2, account.Bytes, messageBytes));
+            Assert.True(account.Verify(signature1, account.Bytes, messageBytes));
+            Assert.True(account.Verify(signature2, account.Bytes, messageBytes));
+
+            var signature3 = Utils.HexToByteArray(polkadotJsSignature);
+            Assert.True(account.Verify(signature3, account.Bytes, messageBytes));
         }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Extrinsics/Extrinsic.cs b/Substrate.NetApi/Model/Extrinsics/Extrinsic.cs
index 877d6de..fd9d3cc 100644
--- a/Substrate.NetApi/Model/Extrinsics/Extrinsic.cs
+++ b/Substrate.NetApi/Model/Extrinsics/Extrinsic.cs
@@ -55,21 +55,23 @@ public class Extrinsic
         /// </summary>
         /// <param name="str">The string.</param>
         /// <param name="chargeType"></param>
-        public Extrinsic(string str, ChargeType chargeType) : this(Utils.HexToByteArray(str).AsMemory(), chargeType)
+        public Extrinsic(string str, ChargeType chargeType) 
+            : this(Utils.HexToByteArray(str).AsMemory(), chargeType)
         {
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Extrinsic"/> class.
         /// </summary>
-        /// <param name="memory">The memory.</param>
+        /// <param name="memory"></param>
+        /// <param name="chargeType"></param>
         internal Extrinsic(Memory<byte> memory, ChargeType chargeType)
         {
             int p = 0;
             int m;
 
             // length
-            var length = CompactInteger.Decode(memory.ToArray(), ref p);
+            _ = CompactInteger.Decode(memory.ToArray(), ref p);
 
             // signature version
             m = 1;
@@ -83,7 +85,7 @@ internal Extrinsic(Memory<byte> memory, ChargeType chargeType)
             {
                 // start bytes
                 m = 1;
-                var _startBytes = memory.Slice(p, m).ToArray()[0];
+                _ = memory.Slice(p, m).ToArray()[0];
                 p += m;
 
                 // sender public key
diff --git a/Substrate.NetApi/Model/Extrinsics/Payload.cs b/Substrate.NetApi/Model/Extrinsics/Payload.cs
index 5199b10..6a1b84c 100644
--- a/Substrate.NetApi/Model/Extrinsics/Payload.cs
+++ b/Substrate.NetApi/Model/Extrinsics/Payload.cs
@@ -1,15 +1,22 @@
-using System.Linq;
+using Substrate.NetApi.Model.Types;
+using System.Linq;
 
 namespace Substrate.NetApi.Model.Extrinsics
 {
     /// <summary>
     /// Payload
     /// </summary>
-    public class Payload
+    public class Payload : IEncodable
     {
-        private readonly Method _call;
-        
-        private readonly SignedExtensions _signedExtension;
+        /// <summary>
+        /// The call
+        /// </summary>
+        public Method Call { get; }
+
+        /// <summary>
+        /// Signed extension
+        /// </summary>
+        public SignedExtensions SignedExtension { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Payload"/> class.
@@ -18,17 +25,25 @@ public class Payload
         /// <param name="signedExtensions">The signed extensions.</param>
         public Payload(Method call, SignedExtensions signedExtensions)
         {
-            _call = call;
-            _signedExtension = signedExtensions;
+            Call = call;
+            SignedExtension = signedExtensions;
         }
 
         /// <summary>
-        /// Encodes this instance.
+        /// Encodes this instance, returns the encoded bytes. Additionally, if
+        /// the encoded bytes are longer than 256 bytes, they are hashed using `blake2_256`.
         /// </summary>
         /// <returns></returns>
         public byte[] Encode()
         {
-            byte[] bytes = _call.Encode().Concat(_signedExtension.Encode()).ToArray();
+            byte[] bytes = Call.Encode().Concat(SignedExtension.Encode()).ToArray();
+
+            // Payloads longer than 256 bytes are going to be `blake2_256`-hashed.
+            if (bytes.Length > 256)
+            {
+                bytes = HashExtension.Blake2(bytes, 256);
+            }
+
             return bytes;
         }
     }
diff --git a/Substrate.NetApi/Model/Extrinsics/SignedExtensions.cs b/Substrate.NetApi/Model/Extrinsics/SignedExtensions.cs
index b9a3870..bc6bc5c 100644
--- a/Substrate.NetApi/Model/Extrinsics/SignedExtensions.cs
+++ b/Substrate.NetApi/Model/Extrinsics/SignedExtensions.cs
@@ -8,19 +8,40 @@ namespace Substrate.NetApi.Model.Extrinsics
     /// </summary>
     public class SignedExtensions
     {
-        private readonly uint _specVersion;
+        /// <summary>
+        /// Specification Version
+        /// </summary>
+        public uint SpecVersion { get; }
 
-        private readonly uint _txVersion;
+        /// <summary>
+        /// Transaction Version
+        /// </summary>
+        public uint TxVersion { get; }
 
-        private readonly Hash _genesis;
+        /// <summary>
+        /// Genesis Hash
+        /// </summary>
+        public Hash Genesis { get; }
 
-        private readonly Hash _startEra;
+        /// <summary>
+        /// Start Era
+        /// </summary>
+        public Hash StartEra { get; }
 
-        private readonly Era _mortality;
+        /// <summary>
+        /// Mortality
+        /// </summary>
+        public Era Mortality { get; }
 
-        private readonly CompactInteger _nonce;
+        /// <summary>
+        /// Nonce
+        /// </summary>
+        public CompactInteger Nonce { get; }
 
-        private readonly ChargeType _charge;
+        /// <summary>
+        /// Charge
+        /// </summary>
+        public ChargeType Charge { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="SignedExtensions"/> class.
@@ -31,16 +52,16 @@ public class SignedExtensions
         /// <param name="startEra">The start era.</param>
         /// <param name="mortality">The mortality.</param>
         /// <param name="nonce">The nonce.</param>
-        /// <param name="chargeTransactionPayment">The charge transaction payment.</param>
+        /// <param name="charge">The charge transaction payment.</param>
         public SignedExtensions(uint specVersion, uint txVersion, Hash genesis, Hash startEra, Era mortality, CompactInteger nonce, ChargeType charge)
         {
-            _specVersion = specVersion;
-            _txVersion = txVersion;
-            _genesis = genesis;
-            _startEra = startEra;
-            _mortality = mortality;
-            _nonce = nonce;
-            _charge = charge;
+            SpecVersion = specVersion;
+            TxVersion = txVersion;
+            Genesis = genesis;
+            StartEra = startEra;
+            Mortality = mortality;
+            Nonce = nonce;
+            Charge = charge;
         }
 
         /// <summary>
@@ -52,13 +73,13 @@ public byte[] GetExtra()
             var bytes = new List<byte>();
 
             // CheckMortality
-            bytes.AddRange(_mortality.Encode());
+            bytes.AddRange(Mortality.Encode());
 
             // CheckNonce
-            bytes.AddRange(_nonce.Encode());
+            bytes.AddRange(Nonce.Encode());
 
             // ChargeType
-            bytes.AddRange(_charge.Encode());
+            bytes.AddRange(Charge.Encode());
 
             return bytes.ToArray();
         }
@@ -72,16 +93,16 @@ public byte[] GetAdditionalSigned()
             var bytes = new List<byte>();
 
             // CheckSpecVersion
-            bytes.AddRange(Utils.Value2Bytes(_specVersion));
+            bytes.AddRange(Utils.Value2Bytes(SpecVersion));
 
             // CheckTxVersion
-            bytes.AddRange(Utils.Value2Bytes(_txVersion));
+            bytes.AddRange(Utils.Value2Bytes(TxVersion));
 
             // CheckGenesis
-            bytes.AddRange(_genesis.Bytes);
+            bytes.AddRange(Genesis.Bytes);
 
             // CheckMortality, Additional Blockhash check. Immortal = genesis_hash, Mortal = logic
-            bytes.AddRange(_startEra.Bytes);
+            bytes.AddRange(StartEra.Bytes);
 
             return bytes.ToArray();
         }
diff --git a/Substrate.NetApi/Model/Extrinsics/UnCheckedExtrinsic.cs b/Substrate.NetApi/Model/Extrinsics/UnCheckedExtrinsic.cs
index f2d77ef..2175740 100644
--- a/Substrate.NetApi/Model/Extrinsics/UnCheckedExtrinsic.cs
+++ b/Substrate.NetApi/Model/Extrinsics/UnCheckedExtrinsic.cs
@@ -6,11 +6,20 @@
 
 namespace Substrate.NetApi.Model.Extrinsics
 {
+    /// <summary>
+    /// Unchecked Extrinsic
+    /// </summary>
     public class UnCheckedExtrinsic : Extrinsic
     {
-        private readonly Hash _genesis;
+        /// <summary>
+        /// Genesis Hash
+        /// </summary>
+        private Hash Genesis { get; }
 
-        private readonly Hash _startEra;
+        /// <summary>
+        /// Start Era
+        /// </summary>
+        private Hash StartEra { get; }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="UnCheckedExtrinsic"/> class.
@@ -26,8 +35,8 @@ public class UnCheckedExtrinsic : Extrinsic
         public UnCheckedExtrinsic(bool signed, Account account, Method method, Era era, CompactInteger nonce, ChargeType charge, Hash genesis, Hash startEra)
              : base(signed, account, nonce, method, era, charge)
         {
-            _genesis = genesis;
-            _startEra = startEra;
+            Genesis = genesis;
+            StartEra = startEra;
         }
 
         /// <summary>
@@ -37,7 +46,7 @@ public UnCheckedExtrinsic(bool signed, Account account, Method method, Era era,
         /// <returns></returns>
         public Payload GetPayload(RuntimeVersion runtime)
         {
-            return new Payload(Method, new SignedExtensions(runtime.SpecVersion, runtime.TransactionVersion, _genesis, _startEra, Era, Nonce, Charge));
+            return new Payload(Method, new SignedExtensions(runtime.SpecVersion, runtime.TransactionVersion, Genesis, StartEra, Era, Nonce, Charge));
         }
 
         /// <summary>
@@ -50,11 +59,11 @@ public void AddPayloadSignature(byte[] signature)
         }
 
         /// <summary>
-        /// Encodes this instance.
+        /// Encode this instance, returns the encoded bytes.
         /// </summary>
         /// <returns></returns>
-        /// <exception cref="Exception">Missing payload signature for signed transaction.</exception>
-        public byte[] Encode()
+        /// <exception cref="NotSupportedException"></exception>
+        public new byte[] Encode()
         {
             if (Signed && Signature == null)
             {
diff --git a/Substrate.NetApi/Model/Types/Account.cs b/Substrate.NetApi/Model/Types/Account.cs
index a08a67d..9bcd701 100644
--- a/Substrate.NetApi/Model/Types/Account.cs
+++ b/Substrate.NetApi/Model/Types/Account.cs
@@ -1,24 +1,31 @@
 using Chaos.NaCl;
 using Newtonsoft.Json;
 using Schnorrkel;
+using Substrate.NetApi.Model.Extrinsics;
 using Substrate.NetApi.Model.Types.Base;
 using System;
 using System.Security.Cryptography.X509Certificates;
+using System.Threading.Tasks;
 
 namespace Substrate.NetApi.Model.Types
 {
     /// <summary>
-    /// Represents a key type.
+    /// Enum KeyType represents the type of cryptographic keys used in digital signatures.
     /// </summary>
     public enum KeyType
     {
         /// <summary>
-        /// Ed25519
+        /// Ed25519: Elliptic Curve Digital Signature Algorithm using SHA-512 and Curve25519.
+        /// Preferred for its balance of security and performance, suitable for scenarios
+        /// requiring fast signature verification. Commonly used in secure communication,
+        /// authentication, and blockchain applications.
         /// </summary>
         Ed25519,
 
         /// <summary>
-        /// Sr25519
+        /// Sr25519: Schnorr signature scheme using SHA-512 and Curve25519, implemented in Schnorrkel.
+        /// Offers advantages in complex cryptographic constructions and potentially better performance.
+        /// Frequently used in decentralized systems and advanced cryptographic protocols.
         /// </summary>
         Sr25519
     }
@@ -29,20 +36,27 @@ public enum KeyType
     public interface IAccount
     {
         /// <summary>
-        /// Sign the specified message.
+        /// Asynchronouslys sign the specified message.
         /// </summary>
-        /// <param name="message"></param>
+        /// <param name="message">The message bytes.</param>
         /// <returns></returns>
-        byte[] Sign(byte[] message);
+        Task<byte[]> SignAsync(byte[] message);
 
         /// <summary>
-        /// Verifies a signature from this account.
+        /// Asynchronouslys sign the specified payload.
         /// </summary>
-        /// <param name="signature"></param>
-        /// <param name="publicKey"></param>
-        /// <param name="message"></param>
+        /// <param name="payload">The payload.</param>
         /// <returns></returns>
-        bool Verify(byte[] signature, byte[] publicKey, byte[] message);
+        Task<byte[]> SignPayloadAsync(Payload payload);
+
+        /// <summary>
+        /// Asynchronouslys verifies a signature from this account.
+        /// </summary>
+        /// <param name="signature">The signature to verify.</param>
+        /// <param name="publicKey">The public key to verify the signature with.</param>
+        /// <param name="message">The message to verify the signature with.</param>
+        /// <returns></returns>
+        Task<bool> VerifyAsync(byte[] signature, byte[] publicKey, byte[] message);
     }
 
     /// <summary>
@@ -106,6 +120,12 @@ public void Create(KeyType keyType, byte[] publicKey)
             Create(keyType, null, publicKey);
         }
 
+        /// <inheritdoc/>
+        public override void CreateFromJson(string str)
+        {
+            throw new NotSupportedException("CreateFromJson is not supported for Account.");
+        }
+
         /// <summary>
         /// Builds the specified key type.
         /// </summary>
@@ -120,12 +140,18 @@ public static Account Build(KeyType keyType, byte[] privateKey, byte[] publicKey
             return account;
         }
 
+        /// <inheritdoc/>
+        public virtual async Task<byte[]> SignAsync(byte[] message)
+        {
+            return await Task.Run(() => Sign(message));
+        }
+
         /// <summary>
         /// Signs the specified message.
         /// </summary>
         /// <param name="message"></param>
         /// <returns></returns>
-        /// <exception cref="NotSupportedException"></exception>
+        /// <exception cref="NotSupportedException"></exception>)
         public byte[] Sign(byte[] message)
         {
             switch (KeyType)
@@ -141,6 +167,12 @@ public byte[] Sign(byte[] message)
             }
         }
 
+        /// <inheritdoc/>
+        public virtual async Task<byte[]> SignPayloadAsync(Payload payload)
+        {
+            return await SignAsync(payload.Encode());
+        }
+
         /// <summary>
         /// Verifies a signature from this account.
         /// </summary>
@@ -174,5 +206,11 @@ public bool Verify(byte[] signature, byte[] publicKey, byte[] message)
                     throw new NotSupportedException($"Unknown key type found '{KeyType}'.");
             }
         }
+
+        /// <inheritdoc/>
+        public async Task<bool> VerifyAsync(byte[] signature, byte[] publicKey, byte[] message)
+        {
+            return await Task.Run(() => Verify(signature, publicKey, message));
+        }
     }
 }
\ No newline at end of file
diff --git a/Substrate.NetApi/Model/Types/Base/BaseType.cs b/Substrate.NetApi/Model/Types/Base/BaseType.cs
index d39c2c4..89ff712 100644
--- a/Substrate.NetApi/Model/Types/Base/BaseType.cs
+++ b/Substrate.NetApi/Model/Types/Base/BaseType.cs
@@ -56,13 +56,13 @@ public virtual void Create(byte[] byteArray)
         }
 
         /// <summary>
-        /// Create from a json string
+        /// Create from JSON is used to deserialize in GenericTypeConverters, to automatically convert scale encoded JSON Rust types to C# types.
         /// </summary>
         /// <param name="str"></param>
         public virtual void CreateFromJson(string str) => Create(Utils.HexToByteArray(str));
 
         /// <summary>
-        /// New
+        /// Create a new instance of the type, this uses the default constructor.
         /// </summary>
         /// <returns></returns>
         public IType New() => this;
diff --git a/Substrate.NetApi/RequestGenerator.cs b/Substrate.NetApi/RequestGenerator.cs
index 01a4873..473761d 100644
--- a/Substrate.NetApi/RequestGenerator.cs
+++ b/Substrate.NetApi/RequestGenerator.cs
@@ -8,6 +8,7 @@
 using Substrate.NetApi.Model.Types.Base;
 using Chaos.NaCl;
 using Schnorrkel;
+using System.Threading.Tasks;
 
 namespace Substrate.NetApi
 {
@@ -17,15 +18,15 @@ namespace Substrate.NetApi
     public class RequestGenerator
     {
         /// <summary>
-        /// Create a request for a storage call, for generated code.
+        /// Get the storage key.
         /// </summary>
-        /// <param name="type"></param>
-        /// <param name="hashers"></param>
-        /// <param name="module"></param>
-        /// <param name="item"></param>
-        /// <param name="key1Param"></param>
-        /// <param name="key2Param"></param>
+        /// <param name="module">The module name.</param>
+        /// <param name="item">The item name.</param>
+        /// <param name="type">The storage type.</param>
+        /// <param name="hashers">The hashers.</param>
+        /// <param name="keys">The keys.</param>
         /// <returns></returns>
+        /// <exception cref="NotSupportedException"></exception>
         public static string GetStorage(string module, string item, Storage.Type type, Storage.Hasher[] hashers = null, IType[] keys = null)
         {
             var keybytes = GetStorageKeyBytesHash(module, item);
@@ -70,13 +71,13 @@ public static byte[] GetStorageKeyBytesHash(string module, string item)
         /// <param name="method">The method.</param>
         /// <param name="era">The era.</param>
         /// <param name="nonce">The nonce.</param>
-        /// <param name="tip">The tip.</param>
+        /// <param name="charge">The charge.</param>
         /// <param name="genesis">The genesis.</param>
         /// <param name="startEra">The start era.</param>
         /// <param name="runtime">The runtime.</param>
         /// <returns></returns>
         /// <exception cref="UnCheckedExtrinsic">signed, account, method, era, nonce, tip, genesis, startEra</exception>
-        public static UnCheckedExtrinsic SubmitExtrinsic(bool signed, Account account, Method method, Era era,
+        public static async Task<UnCheckedExtrinsic> SubmitExtrinsicAsync(bool signed, Account account, Method method, Era era,
             uint nonce, ChargeType charge, Hash genesis, Hash startEra, RuntimeVersion runtime)
         {
             var uncheckedExtrinsic =
@@ -87,13 +88,10 @@ public static UnCheckedExtrinsic SubmitExtrinsic(bool signed, Account account, M
                 return uncheckedExtrinsic;
             }
 
-            var payload = uncheckedExtrinsic.GetPayload(runtime).Encode();
+            Payload payload = uncheckedExtrinsic.GetPayload(runtime);
 
-            /// Payloads longer than 256 bytes are going to be `blake2_256`-hashed.
-            if (payload.Length > 256) payload = HashExtension.Blake2(payload, 256);
-
-            /// sign payload with the
-            byte[] signature = account.Sign(payload);
+            // sign payload with the, Payloads longer than 256 bytes are going to be `blake2_256`-hashed. 
+            byte[] signature = await account.SignPayloadAsync(payload);
 
             uncheckedExtrinsic.AddPayloadSignature(signature);
 
diff --git a/Substrate.NetApi/Substrate.NetApi.csproj b/Substrate.NetApi/Substrate.NetApi.csproj
index 67e2ed8..95739a0 100644
--- a/Substrate.NetApi/Substrate.NetApi.csproj
+++ b/Substrate.NetApi/Substrate.NetApi.csproj
@@ -3,7 +3,7 @@
 	<PropertyGroup>
 		<PackageId>Substrate.NET.API</PackageId>
 		<TargetFrameworks>netstandard2.0;netstandard2.1;net6.0</TargetFrameworks>
-		<Version>0.9.15</Version>
+		<Version>0.9.16</Version>
 		<Company>Substrate Gaming</Company>
 		<Authors>Substrate Gaming</Authors>
 		<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
diff --git a/Substrate.NetApi/SubstrateClient.cs b/Substrate.NetApi/SubstrateClient.cs
index e0e98f7..b55dacb 100644
--- a/Substrate.NetApi/SubstrateClient.cs
+++ b/Substrate.NetApi/SubstrateClient.cs
@@ -87,10 +87,16 @@ public SubstrateClient(Uri uri, ChargeType chargeType, bool bypassRemoteCertific
         /// <value> Information describing the meta. </value>
         public MetaData MetaData { get; private set; }
 
-        /// <summary> Gets or sets information describing the runtime version. </summary>
-        /// <value> Information describing the runtime version. </value>
+        /// <summary> 
+        /// Network runtime version
+        /// </summary>
         public RuntimeVersion RuntimeVersion { get; private set; }
 
+        /// <summary>
+        /// Network propoerties
+        /// </summary>
+        public Properties Properties { get; private set; }
+
         /// <summary> Gets or sets the genesis hash. </summary>
         /// <value> The genesis hash. </value>
         public Hash GenesisHash { get; private set; }
@@ -141,31 +147,43 @@ public bool SetJsonRPCTraceLevel(SourceLevels sourceLevels)
             return true;
         }
 
-        /// <summary> Connects an asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <returns> An asynchronous result. </returns>
+        /// <summary>
+        /// Asynchronously connects to the node.
+        /// </summary>
+        /// <returns></returns>
         public async Task ConnectAsync()
         {
             await ConnectAsync(true, CancellationToken.None);
         }
 
-        /// <summary> Connects an asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <returns> An asynchronous result. </returns>
+        /// <summary>
+        /// Asynchronously connects to the node.
+        /// </summary>
+        /// <param name="token">Cancellation token.</param>
+        /// <returns></returns>
         public async Task ConnectAsync(CancellationToken token)
         {
             await ConnectAsync(true, token);
         }
 
+        /// <summary>
+        /// Asynchronously connects to the node.
+        /// </summary>
+        /// <param name="useMetaData">Parse metadata on connect.</param>
+        /// <param name="token">Cancellation token.</param>
+        /// <returns></returns>
         public async Task ConnectAsync(bool useMetaData, CancellationToken token)
         {
             await ConnectAsync(useMetaData, true, token);
         }
 
-        /// <summary> Connects an asynchronous. </summary>
-        /// <remarks> 19.09.2020. </remarks>
-        /// <param name="token"> A token that allows processing to be cancelled. </param>
-        /// <returns> An asynchronous result. </returns>
+        /// <summary>
+        /// Asynchronously connects to the node.
+        /// </summary>
+        /// <param name="useMetaData">Parse metadata on connect.</param>
+        /// <param name="standardSubstrate">Get blocknumber and runtime information from standard susbtrate node.</param>
+        /// <param name="token">Cancellation token.</param>
+        /// <returns></returns>
         public async Task ConnectAsync(bool useMetaData, bool standardSubstrate, CancellationToken token)
         {
             if (_socket != null && _socket.State == WebSocketState.Open)
@@ -186,7 +204,6 @@ public async Task ConnectAsync(bool useMetaData, bool standardSubstrate, Cancell
                     _socket.Options.RemoteCertificateValidationCallback = (sender, certificate, chain, errors) => true;    
 #endif
                 }
-
             }
 
             _connectTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
@@ -235,6 +252,9 @@ public async Task ConnectAsync(bool useMetaData, bool standardSubstrate, Cancell
 
                 RuntimeVersion = await State.GetRuntimeVersionAsync(token);
                 Logger.Debug("Runtime version parsed.");
+
+                Properties = await System.PropertiesAsync(token);
+                Logger.Debug("Properties parsed.");
             }
 
             //_jsonRpc.TraceSource.Switch.Level = SourceLevels.All;
@@ -359,7 +379,9 @@ public async Task<UnCheckedExtrinsic> GetExtrinsicParametersAsync(Method method,
                 era = Era.Create(lifeTime, finalizedHeader.Number.Value);
             }
 
-            return RequestGenerator.SubmitExtrinsic(signed, account, method, era, nonce, charge, GenesisHash, startEra, RuntimeVersion);
+            var uncheckedExtrinsic = await RequestGenerator.SubmitExtrinsicAsync(signed, account, method, era, nonce, charge, GenesisHash, startEra, RuntimeVersion); ;
+
+            return uncheckedExtrinsic;
         }
 
         /// <summary>