diff --git a/Packages/io.chainsafe.web3-unity.lootboxes/Samples~/Chainlink Lootbox Samples/Scripts/Erc1155MetaDataReader.cs b/Packages/io.chainsafe.web3-unity.lootboxes/Samples~/Chainlink Lootbox Samples/Scripts/Erc1155MetaDataReader.cs
index e347817ce..e01513b9c 100644
--- a/Packages/io.chainsafe.web3-unity.lootboxes/Samples~/Chainlink Lootbox Samples/Scripts/Erc1155MetaDataReader.cs	
+++ b/Packages/io.chainsafe.web3-unity.lootboxes/Samples~/Chainlink Lootbox Samples/Scripts/Erc1155MetaDataReader.cs	
@@ -41,7 +41,7 @@ public async Task<Erc1155MetaData> Fetch(string uri, BigInteger tokenId)
 
 
             var response = await httpClient.Get<Erc1155MetaData>(uri);
-            return response.EnsureResponse();
+            return response.AssertSuccess();
         }
 
         private Erc1155MetaData DecodeUri(string uri)
diff --git a/src/ChainSafe.Gaming.Gelato/GelatoClient.cs b/src/ChainSafe.Gaming.Gelato/GelatoClient.cs
index 2567361b8..fe25b0935 100644
--- a/src/ChainSafe.Gaming.Gelato/GelatoClient.cs
+++ b/src/ChainSafe.Gaming.Gelato/GelatoClient.cs
@@ -44,7 +44,7 @@ public async Task<TResponse> Post<TRequest, TResponse>(RelayCall relayCall, TReq
                 _ => throw new Web3Exception("relayCall option not found")
             };
 
-            return (await httpClient.Post<TRequest, TResponse>(url, request)).EnsureResponse();
+            return (await httpClient.Post<TRequest, TResponse>(url, request)).AssertSuccess();
         }
 
         /// <summary>
@@ -61,7 +61,7 @@ public async Task<string[]> GetSupportedNetworks()
         {
             try
             {
-                return (await httpClient.Get<SupportedNetworksResponse>($"{config.Url}/relays/v2")).EnsureResponse().Relays;
+                return (await httpClient.Get<SupportedNetworksResponse>($"{config.Url}/relays/v2")).AssertSuccess().Relays;
             }
             catch (Exception e)
             {
@@ -83,7 +83,7 @@ public async Task<string[]> GetGelatoOracles()
         {
             try
             {
-                return (await httpClient.Get<OraclesResponse>($"{config.Url}/oracles/")).EnsureResponse().Oracles;
+                return (await httpClient.Get<OraclesResponse>($"{config.Url}/oracles/")).AssertSuccess().Oracles;
             }
             catch (Exception e)
             {
@@ -106,7 +106,7 @@ public async Task<string[]> GetPaymentTokens(string chainId)
         {
             try
             {
-                return (await httpClient.Get<PaymentTokensResponse>($"{config.Url}/oracles/${chainId}/paymentTokens/")).EnsureResponse().PaymentTokens;
+                return (await httpClient.Get<PaymentTokensResponse>($"{config.Url}/oracles/${chainId}/paymentTokens/")).AssertSuccess().PaymentTokens;
             }
             catch (Exception e)
             {
@@ -124,7 +124,7 @@ public async Task<HexBigInteger> GetEstimatedFeeRequest(EstimatedFeeRequest requ
         {
             try
             {
-                return (await httpClient.Post<EstimatedFeeRequest, EstimatedFeeResponse>($"{config.Url}/oracles/${request.ChainId}/estimate/", request)).EnsureResponse().EstimatedFee;
+                return (await httpClient.Post<EstimatedFeeRequest, EstimatedFeeResponse>($"{config.Url}/oracles/${request.ChainId}/estimate/", request)).AssertSuccess().EstimatedFee;
             }
             catch (Exception e)
             {
@@ -142,7 +142,7 @@ public async Task<RelayedTask> GetTaskStatus(string taskId)
         {
             try
             {
-                return (await httpClient.Get<TransactionStatusResponse>($"{config.Url}/tasks/status/{taskId}")).EnsureResponse().Task;
+                return (await httpClient.Get<TransactionStatusResponse>($"{config.Url}/tasks/status/{taskId}")).AssertSuccess().Task;
             }
             catch (Exception e)
             {
diff --git a/src/ChainSafe.Gaming/Web3/Core/Analytics/ApiAnalyticsClient.cs b/src/ChainSafe.Gaming/Web3/Core/Analytics/ApiAnalyticsClient.cs
index 7c96052bc..518aa86df 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Analytics/ApiAnalyticsClient.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Analytics/ApiAnalyticsClient.cs
@@ -1,10 +1,9 @@
-using ChainSafe.Gaming.Web3.Core;
 using ChainSafe.Gaming.Web3.Environment;
 using Newtonsoft.Json;
 
 namespace ChainSafe.Gaming.Web3.Analytics
 {
-    public class ApiAnalyticsClient : IAnalyticsClient
+    internal class ApiAnalyticsClient : IAnalyticsClient
     {
         private const string LoggingUrl = "https://api.gaming.chainsafe.io/logging/logEvent";
         private const string AnalyticsVersion = "2.5";
diff --git a/src/ChainSafe.Gaming/Web3/Core/Analytics/ApiAnalyticsClientExtensions.cs b/src/ChainSafe.Gaming/Web3/Core/Analytics/ApiAnalyticsClientExtensions.cs
index 0fa8458bb..1b528b084 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Analytics/ApiAnalyticsClientExtensions.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Analytics/ApiAnalyticsClientExtensions.cs
@@ -1,4 +1,3 @@
-using System.Linq;
 using ChainSafe.Gaming.Web3.Build;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
@@ -7,6 +6,10 @@ namespace ChainSafe.Gaming.Web3.Analytics
 {
     public static class ApiAnalyticsClientExtensions
     {
+        /// <summary>
+        /// Binds <see cref="ApiAnalyticsClient"/> thereby enabling analytics.
+        /// </summary>
+        /// <returns>Service collection to enable fluent syntax.</returns>
         public static IWeb3ServiceCollection UseApiAnalytics(this IWeb3ServiceCollection serviceCollection)
         {
             if (serviceCollection.AnalyticsDisabled())
@@ -17,12 +20,5 @@ public static IWeb3ServiceCollection UseApiAnalytics(this IWeb3ServiceCollection
             serviceCollection.Replace(ServiceDescriptor.Singleton<IAnalyticsClient, ApiAnalyticsClient>());
             return serviceCollection;
         }
-
-        public static bool AnalyticsDisabled(this IWeb3ServiceCollection serviceCollection)
-        {
-            return serviceCollection.Any(d =>
-                d.ServiceType == typeof(IAnalyticsClient)
-                && d.ImplementationType == typeof(NoOpAnalyticsClient));
-        }
     }
 }
\ No newline at end of file
diff --git a/src/ChainSafe.Gaming/Web3/Core/Analytics/IAnalyticsClient.cs b/src/ChainSafe.Gaming/Web3/Core/Analytics/IAnalyticsClient.cs
index bcf9c64af..fbb87ac71 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Analytics/IAnalyticsClient.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Analytics/IAnalyticsClient.cs
@@ -1,7 +1,14 @@
 namespace ChainSafe.Gaming.Web3.Analytics
 {
+    /// <summary>
+    /// Interface for the Analytics Client.
+    /// </summary>
     public interface IAnalyticsClient
     {
+        /// <summary>
+        /// Captures an analytics event.
+        /// </summary>
+        /// <param name="eventData">The analytics event data.</param>
         void CaptureEvent(AnalyticsEvent eventData);
     }
 }
\ No newline at end of file
diff --git a/src/ChainSafe.Gaming/Web3/Core/Analytics/NoOpAnalyticsClient.cs b/src/ChainSafe.Gaming/Web3/Core/Analytics/NoOpAnalyticsClient.cs
index 60cfb5741..e0d4f3372 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Analytics/NoOpAnalyticsClient.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Analytics/NoOpAnalyticsClient.cs
@@ -1,6 +1,6 @@
 namespace ChainSafe.Gaming.Web3.Analytics
 {
-    public class NoOpAnalyticsClient : IAnalyticsClient
+    internal class NoOpAnalyticsClient : IAnalyticsClient
     {
         public void CaptureEvent(AnalyticsEvent eventData)
         {
diff --git a/src/ChainSafe.Gaming/Web3/Core/Analytics/NoOpAnalyticsClientExtensions.cs b/src/ChainSafe.Gaming/Web3/Core/Analytics/NoOpAnalyticsClientExtensions.cs
index 6dc12fe62..2482d8e35 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Analytics/NoOpAnalyticsClientExtensions.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Analytics/NoOpAnalyticsClientExtensions.cs
@@ -1,3 +1,4 @@
+using System.Linq;
 using ChainSafe.Gaming.Web3.Build;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
@@ -6,10 +7,27 @@ namespace ChainSafe.Gaming.Web3.Analytics
 {
     public static class NoOpAnalyticsClientExtensions
     {
+        /// <summary>
+        /// Disables analytics for the <see cref="Web3"/> instance.
+        /// </summary>
+        /// <param name="serviceCollection">The Web3 service collection.</param>
+        /// <returns>Service collection to enable fluent syntax.</returns>
         public static IWeb3ServiceCollection DisableAnalytics(this IWeb3ServiceCollection serviceCollection)
         {
             serviceCollection.Replace(ServiceDescriptor.Singleton<IAnalyticsClient, NoOpAnalyticsClient>());
             return serviceCollection;
         }
+
+        /// <summary>
+        /// Returns true if analytics are disabled.
+        /// </summary>
+        /// <param name="serviceCollection">The Web3 service collection.</param>
+        /// <returns>True if analytics are disabled.</returns>
+        public static bool AnalyticsDisabled(this IWeb3ServiceCollection serviceCollection)
+        {
+            return serviceCollection.Any(d =>
+                d.ServiceType == typeof(IAnalyticsClient)
+                && d.ImplementationType == typeof(NoOpAnalyticsClient));
+        }
     }
 }
\ No newline at end of file
diff --git a/src/ChainSafe.Gaming/Web3/Core/Build/IWeb3ServiceCollection.cs b/src/ChainSafe.Gaming/Web3/Core/Build/IWeb3ServiceCollection.cs
index b5197a492..55b8b1cc8 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Build/IWeb3ServiceCollection.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Build/IWeb3ServiceCollection.cs
@@ -2,10 +2,16 @@
 
 namespace ChainSafe.Gaming.Web3.Build
 {
+    /// <summary>
+    /// Collection of services to register in the Web3 dependency injection system.
+    /// </summary>
     public interface IWeb3ServiceCollection : IServiceCollection
     {
     }
 
+    /// <summary>
+    /// Collection of services to register in the Web3 dependency injection system.
+    /// </summary>
     public class Web3ServiceCollection : ServiceCollection, IWeb3ServiceCollection
     {
     }
diff --git a/src/ChainSafe.Gaming/Web3/Core/Build/Web3BuildException.cs b/src/ChainSafe.Gaming/Web3/Core/Build/Web3BuildException.cs
index f42ba8c4b..99252e97f 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Build/Web3BuildException.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Build/Web3BuildException.cs
@@ -3,6 +3,9 @@
 
 namespace ChainSafe.Gaming.Web3.Build
 {
+    /// <summary>
+    /// Exception that indicates an error during <see cref="Web3"/> build process.
+    /// </summary>
     public class Web3BuildException : Web3Exception
     {
         public Web3BuildException(string message)
diff --git a/src/ChainSafe.Gaming/Web3/Core/Build/Web3Builder.cs b/src/ChainSafe.Gaming/Web3/Core/Build/Web3Builder.cs
index 372dccae8..3e2a25ae6 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Build/Web3Builder.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Build/Web3Builder.cs
@@ -10,13 +10,13 @@
 namespace ChainSafe.Gaming.Web3.Build
 {
     /// <summary>
-    /// Builder object for Web3. Used to configure set of services.
+    /// Builder object for <see cref="Web3"/>. Used to configure the set of services and other settings.
     /// </summary>
     public class Web3Builder
     {
         private readonly Web3ServiceCollection serviceCollection;
 
-        public Web3Builder()
+        private Web3Builder()
         {
             serviceCollection = new Web3ServiceCollection();
 
@@ -27,31 +27,49 @@ public Web3Builder()
                 .AddSingleton<IContractBuilder, ContractBuilder>();
         }
 
-        // TODO: inline parameterless constructor into this one (therefore remove that overload)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Web3Builder"/> class.
+        /// </summary>
+        /// <param name="projectConfig">Project config to use with the resulting Web3 instance.</param>
+        /// <param name="chainConfig">Chain config to use with the resulting Web3 instance.</param>
+        /// <exception cref="ArgumentException">One of the arguments is null.</exception>
         public Web3Builder(IProjectConfig projectConfig, IChainConfig chainConfig)
             : this()
         {
             if (projectConfig == null)
             {
-                throw new Web3Exception($"{nameof(IProjectConfig)} is required for Web3 to work.");
+                throw new ArgumentNullException(nameof(projectConfig), $"{nameof(IProjectConfig)} is required for Web3 to work.");
             }
 
             if (chainConfig == null)
             {
-                throw new Web3Exception($"{nameof(IChainConfig)} is required for Web3 to work.");
+                throw new ArgumentNullException(nameof(chainConfig), $"{nameof(IChainConfig)} is required for Web3 to work.");
             }
 
             serviceCollection.AddSingleton(projectConfig);
             serviceCollection.AddSingleton(chainConfig);
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Web3Builder"/> class.
+        /// </summary>
+        /// <param name="projectConfig">Complete project config to use with the resulting Web3 instance.</param>
+        /// <exception cref="ArgumentException">"projectConfig" is null.</exception>
         public Web3Builder(ICompleteProjectConfig projectConfig)
             : this(projectConfig, projectConfig)
         {
         }
 
+        /// <summary>
+        /// Delegate used to configure services for <see cref="Web3"/>.
+        /// </summary>
         public delegate void ConfigureServicesDelegate(IWeb3ServiceCollection services);
 
+        /// <summary>
+        /// Configure services for <see cref="Web3"/>.
+        /// </summary>
+        /// <param name="configureMethod">Delegate used to configure services for <see cref="Web3"/>.</param>
+        /// <returns>Builder object to enable fluent syntax.</returns>
         public Web3Builder Configure(ConfigureServicesDelegate configureMethod)
         {
             if (configureMethod is null)
@@ -63,13 +81,16 @@ public Web3Builder Configure(ConfigureServicesDelegate configureMethod)
             return this;
         }
 
+        /// <summary>
+        /// Build <see cref="Web3"/> object using the settings provided by this Web3Builder object.
+        /// </summary>
+        /// <returns><see cref="Web3"/> object.</returns>
         public async ValueTask<Web3> BuildAsync()
         {
             var serviceProvider = serviceCollection.BuildServiceProvider();
             AssertWeb3EnvironmentBound(serviceProvider);
 
             var web3 = new Web3(serviceProvider);
-
             await web3.InitializeAsync();
 
             return web3;
@@ -86,7 +107,7 @@ private static void AssertWeb3EnvironmentBound(IServiceProvider serviceProvider)
             {
                 var message = $"{nameof(Web3Environment)} is required for Web3 to work." +
                               "Don't forget to bind it when building Web3.";
-                throw new Web3Exception(message, e);
+                throw new Web3BuildException(message, e);
             }
         }
     }
diff --git a/src/ChainSafe.Gaming/Web3/Core/Build/Web3ServiceCollectionExtensions.cs b/src/ChainSafe.Gaming/Web3/Core/Build/Web3ServiceCollectionExtensions.cs
index c5ed647bd..17aae2ab2 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Build/Web3ServiceCollectionExtensions.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Build/Web3ServiceCollectionExtensions.cs
@@ -6,6 +6,12 @@ namespace ChainSafe.Gaming.Web3.Build
 {
     public static class Web3ServiceCollectionExtensions
     {
+        /// <summary>
+        /// Assert that service of the specified type was not yet registered.
+        /// </summary>
+        /// <typeparam name="T">The type of the service.</typeparam>
+        /// <param name="services">The Web3 service collection.</param>
+        /// <exception cref="Web3BuildException">Service of the specified type was already bound.</exception>
         public static void AssertServiceNotBound<T>(this IWeb3ServiceCollection services)
         {
             var assertType = typeof(T);
@@ -16,6 +22,12 @@ public static void AssertServiceNotBound<T>(this IWeb3ServiceCollection services
             }
         }
 
+        /// <summary>
+        /// Assert that configuration object of the specified type was not yet registered.
+        /// </summary>
+        /// <typeparam name="T">The type of the configuration object.</typeparam>
+        /// <param name="services">The Web3 service collection.</param>
+        /// <exception cref="Web3BuildException">The configuration object of the specified type was already bound.</exception>
         public static void AssertConfigurationNotBound<T>(this IWeb3ServiceCollection services)
         {
             var assertType = typeof(T);
@@ -26,6 +38,13 @@ public static void AssertConfigurationNotBound<T>(this IWeb3ServiceCollection se
             }
         }
 
+        /// <summary>
+        /// Register the specified implementation using 2 contract types.
+        /// </summary>
+        /// <typeparam name="TInterface1">The first contract type.</typeparam>
+        /// <typeparam name="TInterface2">The second contract type.</typeparam>
+        /// <typeparam name="TImplementation">The implementation type.</typeparam>
+        /// <param name="serviceCollection">The Web3 service collection.</param>
         public static void AddSingleton<TInterface1, TInterface2, TImplementation>(this IWeb3ServiceCollection serviceCollection)
             where TInterface1 : class
             where TInterface2 : class
@@ -43,6 +62,14 @@ public static void AddSingleton<TInterface1, TInterface2, TImplementation>(this
             serviceCollection.AddSingleton<TInterface2, TImplementation>(sp => sp.GetRequiredService<TImplementation>());
         }
 
+        /// <summary>
+        /// Register the specified implementation for 2 contract types using the factory method.
+        /// </summary>
+        /// <param name="serviceCollection">The Web3 service collection.</param>
+        /// <param name="implementationFactory">The factory method.</param>
+        /// <typeparam name="TInterface1">The first contract type.</typeparam>
+        /// <typeparam name="TInterface2">The second contract type.</typeparam>
+        /// <typeparam name="TImplementation">The implementation type.</typeparam>
         public static void AddSingleton<TInterface1, TInterface2, TImplementation>(this IWeb3ServiceCollection serviceCollection, Func<IServiceProvider, TImplementation> implementationFactory)
             where TInterface1 : class
             where TInterface2 : class
@@ -53,6 +80,14 @@ public static void AddSingleton<TInterface1, TInterface2, TImplementation>(this
             serviceCollection.AddSingleton<TInterface2, TImplementation>(sp => sp.GetRequiredService<TImplementation>());
         }
 
+        /// <summary>
+        /// Register the specified implementation using 3 contract types.
+        /// </summary>
+        /// <param name="serviceCollection">The Web3 service collection.</param>
+        /// <typeparam name="TInterface1">The first contract type.</typeparam>
+        /// <typeparam name="TInterface2">The second contract type.</typeparam>
+        /// <typeparam name="TInterface3">The third contract type.</typeparam>
+        /// <typeparam name="TImplementation">The implementation type.</typeparam>
         public static void AddSingleton<TInterface1, TInterface2, TInterface3, TImplementation>(this IWeb3ServiceCollection serviceCollection)
             where TInterface1 : class
             where TInterface2 : class
@@ -65,6 +100,15 @@ public static void AddSingleton<TInterface1, TInterface2, TInterface3, TImplemen
             serviceCollection.AddSingleton<TInterface3, TImplementation>(sp => sp.GetRequiredService<TImplementation>());
         }
 
+        /// <summary>
+        /// Register the specified implementation for 3 contract types using the factory method.
+        /// </summary>
+        /// <param name="serviceCollection">The Web3 service collection.</param>
+        /// <param name="implementationFactory">Factory method.</param>
+        /// <typeparam name="TInterface1">The first contract type.</typeparam>
+        /// <typeparam name="TInterface2">The second contract type.</typeparam>
+        /// <typeparam name="TInterface3">The third contract type.</typeparam>
+        /// <typeparam name="TImplementation">The implementation type.</typeparam>
         public static void AddSingleton<TInterface1, TInterface2, TInterface3, TImplementation>(this IWeb3ServiceCollection serviceCollection, Func<IServiceProvider, TImplementation> implementationFactory)
             where TInterface1 : class
             where TInterface2 : class
diff --git a/src/ChainSafe.Gaming/Web3/Core/Debug/AddressExtensions.cs b/src/ChainSafe.Gaming/Web3/Core/Debug/AddressExtensions.cs
index 01a5843c5..eec817bee 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Debug/AddressExtensions.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Debug/AddressExtensions.cs
@@ -1,20 +1,30 @@
-using ChainSafe.Gaming.Web3.Core;
-
 namespace ChainSafe.Gaming.Web3.Core.Debug
 {
     public static class AddressExtensions
     {
+        /// <summary>
+        /// Check if the string provided is a public address.
+        /// </summary>
+        /// <param name="value">String to check.</param>
+        /// <returns>True if the string provided is a public address.</returns>
         public static bool IsPublicAddress(string value)
         {
             // TODO: more accurate test/Regex
             return !string.IsNullOrEmpty(value) && value.Length == 42;
         }
 
+        /// <summary>
+        /// Assert that the string provided is a public address.
+        /// </summary>
+        /// <param name="value">String to check.</param>
+        /// <param name="variableName">Name of the string variable (nameof).</param>
+        /// <returns>String that was checked.</returns>
+        /// <exception cref="Web3Exception">The string provided is not public address.</exception>
         public static string AssertIsPublicAddress(this string value, string variableName)
         {
             if (!IsPublicAddress(value))
             {
-                throw new Web3Exception($"\"{variableName}\" is not public address");
+                throw new Web3AssertionException($"\"{variableName}\" is not public address");
             }
 
             return value;
diff --git a/src/ChainSafe.Gaming/Web3/Core/Debug/AssertionException.cs b/src/ChainSafe.Gaming/Web3/Core/Debug/AssertionException.cs
deleted file mode 100644
index 7d08f296e..000000000
--- a/src/ChainSafe.Gaming/Web3/Core/Debug/AssertionException.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using System;
-
-namespace ChainSafe.Gaming.Web3.Core.Debug
-{
-    public class AssertionException : Exception
-    {
-        public AssertionException(string message)
-            : base(message)
-        {
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/ChainSafe.Gaming/Web3/Core/Debug/ObjectExtensions.cs b/src/ChainSafe.Gaming/Web3/Core/Debug/ObjectExtensions.cs
index a5fde8578..3c2fcb1b2 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Debug/ObjectExtensions.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Debug/ObjectExtensions.cs
@@ -3,12 +3,20 @@ namespace ChainSafe.Gaming.Web3.Core.Debug
     public static class ObjectExtensions
     {
 #nullable enable
+        /// <summary>
+        /// Asserts that the object provided is not null.
+        /// </summary>
+        /// <param name="obj">Object to check.</param>
+        /// <param name="variableName">Name of the variable to check (nameof).</param>
+        /// <typeparam name="T">Type of the variable to check.</typeparam>
+        /// <returns>The object provided.</returns>
+        /// <exception cref="Web3AssertionException">The provided object is null.</exception>
         public static T AssertNotNull<T>(this T? obj, string variableName)
             where T : notnull
         {
             if (obj is null)
             {
-                throw new AssertionException($"{variableName} is null.");
+                throw new Web3AssertionException($"{variableName} is null.");
             }
 
             return obj;
diff --git a/src/ChainSafe.Gaming/Web3/Core/Debug/Web3AssertionException.cs b/src/ChainSafe.Gaming/Web3/Core/Debug/Web3AssertionException.cs
new file mode 100644
index 000000000..118471023
--- /dev/null
+++ b/src/ChainSafe.Gaming/Web3/Core/Debug/Web3AssertionException.cs
@@ -0,0 +1,13 @@
+namespace ChainSafe.Gaming.Web3.Core.Debug
+{
+    /// <summary>
+    /// Exception indicating that an assertion check failed.
+    /// </summary>
+    public class Web3AssertionException : Web3Exception
+    {
+        public Web3AssertionException(string message)
+            : base(message)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ChainSafe.Gaming/Web3/Core/Environment/IHttpClient.cs b/src/ChainSafe.Gaming/Web3/Core/Environment/IHttpClient.cs
index 628c9c532..f596d5fa9 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Environment/IHttpClient.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Environment/IHttpClient.cs
@@ -3,46 +3,99 @@
 
 namespace ChainSafe.Gaming.Web3.Environment
 {
+    /// <summary>
+    /// Interface for HTTP Client to be used by the SDK.
+    /// </summary>
     public interface IHttpClient
     {
+        /// <summary>
+        /// Makes a GET request.
+        /// </summary>
+        /// <param name="url">URL to send request to.</param>
+        /// <returns>Server response.</returns>
         ValueTask<NetworkResponse<string>> GetRaw(string url);
 
+        /// <summary>
+        /// Makes a POST request.
+        /// </summary>
+        /// <param name="url">URL to send request to.</param>
+        /// <param name="data">Data to send.</param>
+        /// <param name="contentType">Content type of the data (ex. 'application/json').</param>
+        /// <returns>Server response.</returns>
         ValueTask<NetworkResponse<string>> PostRaw(string url, string data, string contentType);
 
+        /// <summary>
+        /// Makes a GET request. Deserializes response from JSON to the specified type.
+        /// </summary>
+        /// <param name="url">URL to send request to.</param>
+        /// <typeparam name="TResponse">Type of the response data.</typeparam>
+        /// <returns>Server response.</returns>
         ValueTask<NetworkResponse<TResponse>> Get<TResponse>(string url);
 
+        /// <summary>
+        /// Makes a POST request. Handles JSON serialization/deserialization of request and response for the specified types.
+        /// </summary>
+        /// <param name="url">URL to send request to.</param>
+        /// <param name="data">Data object to send.</param>
+        /// <typeparam name="TRequest">Type of content used for request.</typeparam>
+        /// <typeparam name="TResponse">Type of content expected as the response.</typeparam>
+        /// <returns>Server response.</returns>
         ValueTask<NetworkResponse<TResponse>> Post<TRequest, TResponse>(string url, TRequest data);
     }
 
+    /// <summary>
+    /// Represents server response.
+    /// </summary>
+    /// <typeparam name="T">Type of content expected as the response.</typeparam>
     public class NetworkResponse<T>
     {
+        /// <summary>
+        /// Response body.
+        /// </summary>
         public T Response { get; private set; }
 
+        /// <summary>
+        /// Request error.
+        /// </summary>
         public string Error { get; private set; }
 
+        /// <summary>
+        /// Was the request successful.
+        /// </summary>
         public bool IsSuccess { get; private set; }
 
+        /// <summary>
+        /// Shorthand to create a new instance of response for a successful request.
+        /// </summary>
+        /// <param name="response">Response body.</param>
+        /// <returns>New instance of <see cref="NetworkResponse{T}"/>.</returns>
         public static NetworkResponse<T> Success(T response)
         {
             return new() { Response = response, IsSuccess = true };
         }
 
+        /// <summary>
+        /// Shorthand to create a new instance of response for a failed request.
+        /// </summary>
+        /// <param name="error">Error message.</param>
+        /// <returns>New instance of <see cref="NetworkResponse{T}"/>.</returns>
         public static NetworkResponse<T> Failure(string error)
         {
             return new() { Error = error, IsSuccess = false };
         }
 
-        public void EnsureSuccess()
+        /// <summary>
+        /// Assert that the request was successful.
+        /// </summary>
+        /// <returns>Response object to enable fluent syntax.</returns>
+        /// <exception cref="Web3Exception">Request was not successful.</exception>
+        public T AssertSuccess()
         {
             if (!IsSuccess)
             {
-                throw new Exception(Error);
+                throw new Web3Exception(Error);
             }
-        }
 
-        public T EnsureResponse()
-        {
-            EnsureSuccess();
             return Response;
         }
 
diff --git a/src/ChainSafe.Gaming/Web3/Core/Evm/ChainRegistryProvider.cs b/src/ChainSafe.Gaming/Web3/Core/Evm/ChainRegistryProvider.cs
index d91e65c7b..be72eb950 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Evm/ChainRegistryProvider.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Evm/ChainRegistryProvider.cs
@@ -7,18 +7,28 @@
 
 namespace ChainSafe.Gaming.Evm
 {
+    /// <summary>
+    /// Provides access to a registry of chain info by their chain IDs.
+    /// </summary>
     public class ChainRegistryProvider
     {
         private const string FetchUrl = "https://chainid.network/chains.json";
 
-        private readonly Web3Environment environment;
+        private readonly IHttpClient httpClient;
+
         private Dictionary<ulong, Chains.Chain>? chains;
 
-        public ChainRegistryProvider(Web3Environment environment)
+        public ChainRegistryProvider(IHttpClient httpClient)
         {
-            this.environment = environment;
+            this.httpClient = httpClient;
         }
 
+        /// <summary>
+        /// Asynchronously retrieves a blockchain chain by its chain ID.
+        /// </summary>
+        /// <param name="chainId">The chain ID to retrieve.</param>
+        /// <returns>Requested chain info.</returns>
+        // TODO: refactor to load all chains on WillStartAsync, make this method sync
         public async ValueTask<Chains.Chain?> GetChain(ulong chainId)
         {
             chains ??= await LoadAllChains();
@@ -27,9 +37,8 @@ public ChainRegistryProvider(Web3Environment environment)
 
         private async ValueTask<Dictionary<ulong, Chains.Chain>> LoadAllChains()
         {
-            var httpClient = environment.HttpClient;
             var response = await httpClient.Get<Chains.Chain[]>(FetchUrl);
-            return response.EnsureResponse().ToDictionary(chain => chain.ChainId, chain => chain);
+            return response.AssertSuccess().ToDictionary(chain => chain.ChainId, chain => chain);
         }
     }
 }
\ No newline at end of file
diff --git a/src/ChainSafe.Gaming/Web3/Core/Evm/IEvmEvents.cs b/src/ChainSafe.Gaming/Web3/Core/Evm/IEvmEvents.cs
index 686dc0632..10174b643 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Evm/IEvmEvents.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Evm/IEvmEvents.cs
@@ -6,20 +6,49 @@ namespace ChainSafe.Gaming.Web3.Core.Evm
 {
     public interface IEvmEvents
     {
+        /// <summary>
+        /// Represents a delegate for handling chain change events.
+        /// </summary>
+        /// <param name="chainID">The chain ID of the new chain.</param>
         public delegate void ChainChangedDelegate(ulong chainID);
 
+        /// <summary>
+        /// Represents a delegate for handling poll error events.
+        /// </summary>
+        /// <param name="exception">The exception representing the poll error.</param>
         public delegate void PollErrorDelegate(Exception exception);
 
+        /// <summary>
+        /// Represents a delegate for handling poll events.
+        /// </summary>
+        /// <param name="pollID">The ID of the poll event.</param>
+        /// <param name="blockNumber">The block number associated with the poll event.</param>
         public delegate void PollDelegate(ulong pollID, ulong blockNumber);
 
+        /// <summary>
+        /// Represents a delegate for handling new block events.
+        /// </summary>
+        /// <param name="blockNumber">The block number of the new block.</param>
         public delegate void NewBlockDelegate(ulong blockNumber);
 
+        /// <summary>
+        /// Occurs when the chain is changed.
+        /// </summary>
         public event ChainChangedDelegate ChainChanged;
 
+        /// <summary>
+        /// Occurs when an error is encountered during polling.
+        /// </summary>
         public event PollErrorDelegate PollError;
 
+        /// <summary>
+        /// Occurs when a poll event is triggered.
+        /// </summary>
         public event PollDelegate Poll;
 
+        /// <summary>
+        /// Occurs when a new block is detected.
+        /// </summary>
         public event NewBlockDelegate NewBlock;
     }
 }
diff --git a/src/ChainSafe.Gaming/Web3/Core/Evm/IRpcProvider.cs b/src/ChainSafe.Gaming/Web3/Core/Evm/IRpcProvider.cs
index f530d3d8b..7064311e2 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Evm/IRpcProvider.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Evm/IRpcProvider.cs
@@ -2,14 +2,40 @@
 
 namespace ChainSafe.Gaming.Evm.Providers
 {
+    /// <summary>
+    /// Represents an interface for an RPC (Remote Procedure Call) provider in a blockchain environment.
+    /// </summary>
+    /// <remarks>
+    /// RPC provider is a core component that allows to communicate with
+    /// a blockchain network using remote procedure calls,
+    /// enabling actions such as querying blockchain data.
+    /// </remarks>
     public interface IRpcProvider
     {
+        /// <summary>
+        /// Gets the last known blockchain network information.
+        /// </summary>
         Network.Network LastKnownNetwork { get; }
 
-        // Network
+        /// <summary>
+        /// Asynchronously refreshes and retrieves the current blockchain network information.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation. The task result contains
+        /// the updated <see cref="Network.Network"/> object representing the current network.
+        /// </returns>
         Task<Network.Network> RefreshNetwork();
 
-        // ENS
+        /// <summary>
+        /// Asynchronously performs a specific RPC method on the blockchain.
+        /// </summary>
+        /// <typeparam name="T">The expected return type of the RPC method.</typeparam>
+        /// <param name="method">The name of the RPC method to execute.</param>
+        /// <param name="parameters">An array of parameters to pass to the RPC method.</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation. The task result contains
+        /// the result of the RPC method, deserialized to the specified return type <typeparamref name="T"/>.
+        /// </returns>
         Task<T> Perform<T>(string method, params object[] parameters);
     }
 }
\ No newline at end of file
diff --git a/src/ChainSafe.Gaming/Web3/Core/Evm/ISigner.cs b/src/ChainSafe.Gaming/Web3/Core/Evm/ISigner.cs
index 5dfd59bd9..aa50308d4 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Evm/ISigner.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Evm/ISigner.cs
@@ -3,12 +3,45 @@
 
 namespace ChainSafe.Gaming.Evm.Signers
 {
+    /// <summary>
+    /// Represents a component responsible for signing transactions, messages, and providing the player's public address.
+    /// </summary>
+    /// <remarks>
+    /// Signer serves as a secure and essential element that encapsulates a user's
+    /// private key, enabling the signing of messages and transactions. Additionally, it provides
+    /// the user's public address for identity verification on the blockchain network.
+    /// </remarks>
     public interface ISigner
     {
+        /// <summary>
+        /// Asynchronously retrieves the wallet address associated with the signer.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation. The task result contains
+        /// the wallet address associated with the signer as a string.
+        /// </returns>
         Task<string> GetAddress();
 
+        /// <summary>
+        /// Asynchronously signs a given message.
+        /// </summary>
+        /// <param name="message">The message to sign as a string.</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation. The task result contains
+        /// the signature of the message as a string.
+        /// </returns>
         Task<string> SignMessage(string message);
 
+        /// <summary>
+        /// Asynchronously signs a structured message using the provided domain parameters.
+        /// </summary>
+        /// <typeparam name="TStructType">The type of the structured message to sign.</typeparam>
+        /// <param name="domain">The domain parameters for signing.</param>
+        /// <param name="message">The structured message to sign.</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation. The task result contains
+        /// the signature of the structured message as a string.
+        /// </returns>
         Task<string> SignTypedData<TStructType>(SerializableDomain domain, TStructType message);
 
         // TODO: is this the right thing to do?
diff --git a/src/ChainSafe.Gaming/Web3/Core/Evm/ITransactionExecutor.cs b/src/ChainSafe.Gaming/Web3/Core/Evm/ITransactionExecutor.cs
index 7903ebbc9..da1ef8ad5 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Evm/ITransactionExecutor.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Evm/ITransactionExecutor.cs
@@ -3,8 +3,23 @@
 
 namespace ChainSafe.Gaming.Web3.Core.Evm
 {
+    /// <summary>
+    /// Represents an interface for executing blockchain transactions.
+    /// </summary>
+    /// <remarks>
+    /// TransactionExecutor is a core component responsible for the seamless transmission of transactions to the
+    /// blockchain network for execution.
+    /// </remarks>
     public interface ITransactionExecutor
     {
+        /// <summary>
+        /// Asynchronously sends a transaction to the blockchain network.
+        /// </summary>
+        /// <param name="transaction">The transaction request to be sent.</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation. The task result contains
+        /// a <see cref="TransactionResponse"/> object with details about the executed transaction.
+        /// </returns>
         public Task<TransactionResponse> SendTransaction(TransactionRequest transaction);
     }
 }
\ No newline at end of file
diff --git a/src/ChainSafe.Gaming/Web3/Core/Evm/RpcProviderExtensions.cs b/src/ChainSafe.Gaming/Web3/Core/Evm/RpcProviderExtensions.cs
index 319076029..b4b82dabc 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Evm/RpcProviderExtensions.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Evm/RpcProviderExtensions.cs
@@ -18,6 +18,16 @@ namespace ChainSafe.Gaming.Evm.Providers
 {
     public static class RpcProviderExtensions
     {
+        /// <summary>
+        /// <b>eth_getBalance</b><br/>Asynchronously retrieves the native balance (ETH for Ethereum) of a specified wallet address.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <param name="address">The wallet address to query.</param>
+        /// <param name="blockTag">The block parameter (optional).</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains the native balance as a <see cref="HexBigInteger"/>.
+        /// </returns>
         public static async Task<HexBigInteger> GetBalance(this IRpcProvider provider, string address, BlockParameter blockTag = null)
         {
             blockTag ??= new BlockParameter();
@@ -27,6 +37,16 @@ public static async Task<HexBigInteger> GetBalance(this IRpcProvider provider, s
             return new HexBigInteger(await provider.Perform<string>("eth_getBalance", parameters));
         }
 
+        /// <summary>
+        /// <b>eth_getCode</b><br/>Asynchronously retrieves the byte code of a smart contract at a specified address.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <param name="address">The smart contract address to query.</param>
+        /// <param name="blockTag">The block parameter (optional).</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains the byte code as a hexadecimal string.
+        /// </returns>
         public static async Task<string> GetCode(this IRpcProvider provider, string address, BlockParameter blockTag = null)
         {
             blockTag ??= new BlockParameter();
@@ -36,6 +56,17 @@ public static async Task<string> GetCode(this IRpcProvider provider, string addr
             return await provider.Perform<string>("eth_getCode", parameters);
         }
 
+        /// <summary>
+        /// <b>eth_getStorageAt</b><br/>Asynchronously retrieves the storage data at a specified address and position.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <param name="address">The address to query.</param>
+        /// <param name="position">The storage position to query.</param>
+        /// <param name="blockTag">The block parameter (optional).</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains the storage data as a string.
+        /// </returns>
         public static async Task<string> GetStorageAt(this IRpcProvider provider, string address, BigInteger position, BlockParameter blockTag = null)
         {
             blockTag ??= new BlockParameter();
@@ -45,6 +76,16 @@ public static async Task<string> GetStorageAt(this IRpcProvider provider, string
             return await provider.Perform<string>("eth_getStorageAt", parameters);
         }
 
+        /// <summary>
+        /// <b>eth_getTransactionCount</b><br/>Asynchronously retrieves the transaction count for a specified address.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <param name="address">The address to query.</param>
+        /// <param name="blockTag">The block parameter (optional).</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains the transaction count as a <see cref="HexBigInteger"/>.
+        /// </returns>
         public static async Task<HexBigInteger> GetTransactionCount(this IRpcProvider provider, string address, BlockParameter blockTag = null)
         {
             blockTag ??= new BlockParameter();
@@ -54,16 +95,34 @@ public static async Task<HexBigInteger> GetTransactionCount(this IRpcProvider pr
             return new HexBigInteger(await provider.Perform<string>("eth_getTransactionCount", parameters));
         }
 
-        public static async Task<Blocks.Block> GetBlock(this IRpcProvider provider, BlockParameter blockTag = null)
+        /// <summary>
+        /// <b>eth_getBlockByNumber</b><br/>Asynchronously retrieves a blockchain block.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <param name="blockTag">The block parameter (optional).</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains the blockchain block as a <see cref="Block"/>.
+        /// </returns>
+        public static async Task<Block> GetBlock(this IRpcProvider provider, BlockParameter blockTag = null)
         {
             blockTag ??= new BlockParameter();
 
             var parameters = new object[] { blockTag.GetRPCParam(), false };
 
-            return await provider.Perform<Blocks.Block>("eth_getBlockByNumber", parameters);
+            return await provider.Perform<Block>("eth_getBlockByNumber", parameters);
         }
 
-        public static async Task<Blocks.Block> GetBlock(this IRpcProvider provider, string blockHash)
+        /// <summary>
+        /// <b>eth_getBlockByHash</b><br/>Asynchronously retrieves a blockchain block using its hash.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <param name="blockHash">The hash of the block to retrieve.</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains the blockchain block as a <see cref="Block"/>.
+        /// </returns>
+        public static async Task<Block> GetBlock(this IRpcProvider provider, string blockHash)
         {
             if (!blockHash.HasHexPrefix() || blockHash.Length != 66)
             {
@@ -72,19 +131,37 @@ public static async Task<HexBigInteger> GetTransactionCount(this IRpcProvider pr
 
             var parameters = new object[] { blockHash, false };
 
-            return await provider.Perform<Blocks.Block>("eth_getBlockByHash", parameters);
+            return await provider.Perform<Block>("eth_getBlockByHash", parameters);
         }
 
-        public static async Task<Blocks.BlockWithTransactions> GetBlockWithTransactions(this IRpcProvider provider, BlockParameter blockTag = null)
+        /// <summary>
+        /// <b>eth_getBlockByNumber</b><br/>Asynchronously retrieves a blockchain block with its transactions.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <param name="blockTag">The block parameter (optional).</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains the blockchain block with transactions as a <see cref="BlockWithTransactions"/>.
+        /// </returns>
+        public static async Task<BlockWithTransactions> GetBlockWithTransactions(this IRpcProvider provider, BlockParameter blockTag = null)
         {
             blockTag ??= new BlockParameter();
 
             var parameters = new object[] { blockTag.GetRPCParam(), true };
 
-            return await provider.Perform<Blocks.BlockWithTransactions>("eth_getBlockByNumber", parameters);
+            return await provider.Perform<BlockWithTransactions>("eth_getBlockByNumber", parameters);
         }
 
-        public static async Task<Blocks.BlockWithTransactions> GetBlockWithTransactions(this IRpcProvider provider, string blockHash)
+        /// <summary>
+        /// <b>eth_getBlockByHash</b><br/>Asynchronously retrieves a blockchain block with its transactions using the block's hash.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <param name="blockHash">The hash of the block to retrieve.</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains the blockchain block with transactions as a <see cref="Blocks.BlockWithTransactions"/>.
+        /// </returns>
+        public static async Task<BlockWithTransactions> GetBlockWithTransactions(this IRpcProvider provider, string blockHash)
         {
             if (!blockHash.HasHexPrefix() || blockHash.Length != 66)
             {
@@ -93,19 +170,43 @@ public static async Task<HexBigInteger> GetTransactionCount(this IRpcProvider pr
 
             var parameters = new object[] { blockHash, true };
 
-            return await provider.Perform<Blocks.BlockWithTransactions>("eth_getBlockByHash", parameters);
+            return await provider.Perform<BlockWithTransactions>("eth_getBlockByHash", parameters);
         }
 
+        /// <summary>
+        /// <b>eth_blockNumber</b><br/>Asynchronously retrieves the latest block number on the blockchain.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains the latest block number as a <see cref="HexBigInteger"/>.
+        /// </returns>
         public static async Task<HexBigInteger> GetBlockNumber(this IRpcProvider provider)
         {
             return new HexBigInteger(await provider.Perform<string>("eth_blockNumber", null));
         }
 
+        /// <summary>
+        /// <b>eth_gasPrice</b><br/>Asynchronously retrieves the current gas price on the blockchain.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains the current gas price as a <see cref="HexBigInteger"/>.
+        /// </returns>
         public static async Task<HexBigInteger> GetGasPrice(this IRpcProvider provider)
         {
             return new HexBigInteger(await provider.Perform<string>("eth_gasPrice", null));
         }
 
+        /// <summary>
+        /// Asynchronously retrieves fee-related data for transactions.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains fee data as a <see cref="FeeData"/> object.
+        /// </returns>
         public static async Task<FeeData> GetFeeData(this IRpcProvider provider)
         {
             var block = await provider.GetBlock();
@@ -149,6 +250,16 @@ async Task TryFetchMaxFees()
             }
         }
 
+        /// <summary>
+        /// <b>eth_call</b><br/>Asynchronously invokes a call to a smart contract or blockchain function.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <param name="transaction">The transaction request to execute.</param>
+        /// <param name="blockTag">The block parameter (optional).</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains the result of the call as a string.
+        /// </returns>
         public static async Task<string> Call(this IRpcProvider provider, TransactionRequest transaction, BlockParameter blockTag = null)
         {
             blockTag ??= new BlockParameter();
@@ -158,6 +269,15 @@ public static async Task<string> Call(this IRpcProvider provider, TransactionReq
             return await provider.Perform<string>("eth_call", parameters);
         }
 
+        /// <summary>
+        /// <b>eth_estimateGas</b><br/>Asynchronously estimates the gas required for a transaction.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <param name="transaction">The transaction request to estimate gas for.</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains the estimated gas amount as a <see cref="HexBigInteger"/>.
+        /// </returns>
         public static async Task<HexBigInteger> EstimateGas(this IRpcProvider provider, TransactionRequest transaction)
         {
             var parameters = new object[] { transaction };
@@ -165,6 +285,15 @@ public static async Task<HexBigInteger> EstimateGas(this IRpcProvider provider,
             return new HexBigInteger(await provider.Perform<string>("eth_estimateGas", parameters));
         }
 
+        /// <summary>
+        /// <b>eth_getTransactionByHash</b><br/>Asynchronously retrieves a transaction by its hash.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <param name="transactionHash">The hash of the transaction to retrieve.</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains the transaction details as a <see cref="TransactionResponse"/>.
+        /// </returns>
         public static async Task<TransactionResponse> GetTransaction(this IRpcProvider provider, string transactionHash)
         {
             var parameters = new object[] { transactionHash };
@@ -195,11 +324,20 @@ public static async Task<TransactionResponse> GetTransaction(this IRpcProvider p
             return result;
         }
 
-        public static async Task<Transactions.TransactionReceipt> GetTransactionReceipt(this IRpcProvider provider, string transactionHash)
+        /// <summary>
+        /// <b>eth_getTransactionReceipt</b><br/>Asynchronously retrieves a transaction receipt by its hash.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <param name="transactionHash">The hash of the transaction receipt to retrieve.</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains the transaction receipt as a <see cref="TransactionReceipt"/>.
+        /// </returns>
+        public static async Task<TransactionReceipt> GetTransactionReceipt(this IRpcProvider provider, string transactionHash)
         {
             var parameters = new object[] { transactionHash };
 
-            var result = await provider.Perform<Transactions.TransactionReceipt>("eth_getTransactionReceipt", parameters);
+            var result = await provider.Perform<TransactionReceipt>("eth_getTransactionReceipt", parameters);
 
             if (result == null)
             {
@@ -226,7 +364,16 @@ public static async Task<TransactionResponse> GetTransaction(this IRpcProvider p
             return result;
         }
 
-        public static TransactionResponse WrapTransaction(this IRpcProvider provider, Transactions.Transaction tx, string hash)
+        /// <summary>
+        /// Wraps a transaction with its hash to create a <see cref="TransactionResponse"/>.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <param name="tx">The original transaction.</param>
+        /// <param name="hash">The hash of the transaction.</param>
+        /// <returns>
+        /// A <see cref="TransactionResponse"/> object with the transaction details.
+        /// </returns>
+        public static TransactionResponse WrapTransaction(this IRpcProvider provider, Transaction tx, string hash)
         {
             if (hash != null && hash.Length != 66)
             {
@@ -239,7 +386,18 @@ public static TransactionResponse WrapTransaction(this IRpcProvider provider, Tr
             return result;
         }
 
-        public static async Task<Transactions.TransactionReceipt> WaitForTransactionReceipt(
+        /// <summary>
+        /// Asynchronously waits for a transaction receipt with specified confirmations and optional timeout.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <param name="transactionHash">The hash of the transaction receipt to wait for.</param>
+        /// <param name="confirmations">The number of confirmations to wait for (optional).</param>
+        /// <param name="timeout">The maximum number of attempts before timing out (optional).</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains the transaction receipt as a <see cref="TransactionReceipt"/>.
+        /// </returns>
+        public static async Task<TransactionReceipt> WaitForTransactionReceipt(
             this IRpcProvider provider,
             string transactionHash,
             uint confirmations = 1,
@@ -248,7 +406,7 @@ public static TransactionResponse WrapTransaction(this IRpcProvider provider, Tr
             return await provider.WaitForTransactionInternal(transactionHash, confirmations, timeout);
         }
 
-        private static async Task<Transactions.TransactionReceipt> WaitForTransactionInternal(
+        private static async Task<TransactionReceipt> WaitForTransactionInternal(
             this IRpcProvider provider,
             string transactionHash,
             uint confirmations = 1,
@@ -288,6 +446,15 @@ public static TransactionResponse WrapTransaction(this IRpcProvider provider, Tr
             }
         }
 
+        /// <summary>
+        /// <b>eth_getLogs</b><br/>Asynchronously retrieves logs based on the provided filter criteria.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <param name="filter">The filter input criteria for log retrieval.</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains an array of <see cref="FilterLog"/> objects representing the logs.
+        /// </returns>
         public static async Task<FilterLog[]> GetLogs(this IRpcProvider provider, NewFilterInput filter)
         {
             var parameters = new object[] { filter };
@@ -295,6 +462,14 @@ public static async Task<FilterLog[]> GetLogs(this IRpcProvider provider, NewFil
             return await provider.Perform<FilterLog[]>("eth_getLogs", parameters);
         }
 
+        /// <summary>
+        /// <b>eth_accounts</b><br/>Asynchronously lists all accounts associated with the RPC node.
+        /// </summary>
+        /// <param name="provider">The RPC provider.</param>
+        /// <returns>
+        /// A <see cref="Task"/> representing the asynchronous operation.
+        /// The task result contains an array of account addresses as strings.
+        /// </returns>
         public static async Task<string[]> ListAccounts(this IRpcProvider provider) =>
             await provider.Perform<string[]>("eth_accounts");
     }
diff --git a/src/ChainSafe.Gaming/Web3/Core/IChainConfig.cs b/src/ChainSafe.Gaming/Web3/Core/IChainConfig.cs
index 7d08b4e73..708f7d982 100644
--- a/src/ChainSafe.Gaming/Web3/Core/IChainConfig.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/IChainConfig.cs
@@ -1,17 +1,38 @@
 namespace ChainSafe.Gaming.Web3
 {
-    public interface IChainConfig
+    /// <summary>
+    /// Configuration object containing chain settings.
+    /// </summary>
+    public interface IChainConfig // TODO: double check these xml docs pls
     {
+        /// <summary>
+        /// The id of the chain to be used. Equals '1' for Ethereum Mainnet.
+        /// </summary>
         public string ChainId { get; }
 
+        /// <summary>
+        /// The name of the chain to be used. Equals 'Ethereum' for Ethereum Mainnet.
+        /// </summary>
         public string Chain { get; }
 
+        /// <summary>
+        /// The name of the network to be used. Equals 'Ethereum Mainnet' for Ethereum Mainnet.
+        /// </summary>
         public string Network { get; }
 
+        /// <summary>
+        /// The URI for the RPC endpoint to be used by the RPC provider by default.
+        /// </summary>
         public string Rpc { get; }
 
+        /// <summary>
+        /// The path to the IPC file to be used by the IPC provider by default.
+        /// </summary>
         public string Ipc { get; }
 
+        /// <summary>
+        /// TODO.
+        /// </summary>
         public string Ws { get; }
     }
 }
\ No newline at end of file
diff --git a/src/ChainSafe.Gaming/Web3/Core/ICompleteProjectConfig.cs b/src/ChainSafe.Gaming/Web3/Core/ICompleteProjectConfig.cs
index 1302dd001..e94f74bb3 100644
--- a/src/ChainSafe.Gaming/Web3/Core/ICompleteProjectConfig.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/ICompleteProjectConfig.cs
@@ -1,5 +1,8 @@
 namespace ChainSafe.Gaming.Web3
 {
+    /// <summary>
+    /// <see cref="IProjectConfig"/> merged with <see cref="IChainConfig"/>.
+    /// </summary>
     public interface ICompleteProjectConfig : IProjectConfig, IChainConfig
     {
     }
diff --git a/src/ChainSafe.Gaming/Web3/Core/ILifecycleParticipant.cs b/src/ChainSafe.Gaming/Web3/Core/ILifecycleParticipant.cs
index 65d0e1f80..347a0a907 100644
--- a/src/ChainSafe.Gaming/Web3/Core/ILifecycleParticipant.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/ILifecycleParticipant.cs
@@ -5,10 +5,22 @@
 
 namespace ChainSafe.Gaming.Web3.Core
 {
-    public interface ILifecycleParticipant
+    /// <summary>
+    /// Services and components that implement this interface will receive callbacks on <see cref="Web3"/>
+    /// initialization and termination.
+    /// </summary>
+    public interface ILifecycleParticipant // TODO: split this into two separate interfaces?
     {
+        /// <summary>
+        /// Called on <see cref="Web3"/> initialization.
+        /// </summary>
+        /// <returns>Task handle for the asynchronous process.</returns>
         ValueTask WillStartAsync();
 
+        /// <summary>
+        /// Called on <see cref="Web3"/> termination.
+        /// </summary>
+        /// <returns>Task handle for the asynchronous process.</returns>
         ValueTask WillStopAsync();
     }
 }
diff --git a/src/ChainSafe.Gaming/Web3/Core/IProjectConfig.cs b/src/ChainSafe.Gaming/Web3/Core/IProjectConfig.cs
index a79d0878f..cd23b6799 100644
--- a/src/ChainSafe.Gaming/Web3/Core/IProjectConfig.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/IProjectConfig.cs
@@ -1,7 +1,13 @@
 namespace ChainSafe.Gaming.Web3
 {
+    /// <summary>
+    /// Configuration object containing project settings.
+    /// </summary>
     public interface IProjectConfig
     {
+        /// <summary>
+        /// The project id issued by ChainSafe. Follow https://docs.gaming.chainsafe.io to learn more.
+        /// </summary>
         public string ProjectId { get; }
     }
 }
\ No newline at end of file
diff --git a/src/ChainSafe.Gaming/Web3/Core/Web3.cs b/src/ChainSafe.Gaming/Web3/Core/Web3.cs
index c30104991..771159b56 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Web3.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Web3.cs
@@ -12,6 +12,7 @@ namespace ChainSafe.Gaming.Web3
 {
     /// <summary>
     /// Facade for all Web3-related services.
+    /// Use this as an entry point to all SDK features.
     /// </summary>
     public class Web3 : IAsyncDisposable
     {
@@ -36,61 +37,68 @@ internal Web3(ServiceProvider serviceProvider)
             ChainConfig = serviceProvider.GetRequiredService<IChainConfig>();
         }
 
+        /// <summary>
+        /// Access the <see cref="IRpcProvider"/> component, which provides RPC communication with the Ethereum network.
+        /// </summary>
         public IRpcProvider RpcProvider => AssertComponentAccessible(rpcProvider, nameof(RpcProvider));
 
+        /// <summary>
+        /// Access the <see cref="ISigner"/> component, responsible for signing transactions, messages, and providing the player's public address.
+        /// </summary>
         public ISigner Signer => AssertComponentAccessible(signer, nameof(Signer));
 
+        /// <summary>
+        /// Access the <see cref="ITransactionExecutor"/> component, used for sending transactions to the blockchain.
+        /// </summary>
         public ITransactionExecutor TransactionExecutor => AssertComponentAccessible(transactionExecutor, nameof(TransactionExecutor));
 
+        /// <summary>
+        /// Access the event service of the Web3 instance, allowing you to subscribe to blockchain events.
+        /// </summary>
         public IEvmEvents Events => AssertComponentAccessible(events, nameof(Events));
 
+        /// <summary>
+        /// Access the factory for creating Ethereum smart contract wrappers.
+        /// </summary>
         public IContractBuilder ContractBuilder { get; }
 
+        /// <summary>
+        /// Access the project configuration object, providing access to project-specific settings.
+        /// </summary>
         public IProjectConfig ProjectConfig { get; }
 
+        /// <summary>
+        /// Access the chain configuration object, providing access to blockchain-specific settings.
+        /// </summary>
         public IChainConfig ChainConfig { get; }
 
+        /// <summary>
+        /// Access the service provider of this Web3 instance.
+        /// Use this to retrieve any service that was bound to this Web3 instance during the build phase.
+        /// </summary>
         public IServiceProvider ServiceProvider => serviceProvider;
 
-        private static T AssertComponentAccessible<T>(T? value, string propertyName)
-            where T : notnull
-        {
-            if (value == null)
-            {
-                throw new Web3Exception(
-                  $"{propertyName} is not bound. Make sure to add an implementation of {propertyName} before using it.");
-            }
-
-            // TODO: uncomment after migration complete
-            // if (!_initialized)
-            // {
-            //   throw new Web3Exception($"Can't access {propertyName}. Initialize Web3 first.");
-            // }
-            return value;
-        }
-
         async ValueTask IAsyncDisposable.DisposeAsync()
         {
             await TerminateAsync();
             GC.SuppressFinalize(this);
         }
 
-        public async ValueTask InitializeAsync()
+        internal async ValueTask InitializeAsync()
         {
-            if (initialized)
-            {
-                throw new Web3Exception("Web3 was already initialized.");
-            }
-
             foreach (var lifecycleParticipant in serviceProvider.GetServices<ILifecycleParticipant>())
             {
                 await lifecycleParticipant.WillStartAsync();
             }
 
-            // TODO: initialize other components
             initialized = true;
         }
 
+        /// <summary>
+        /// Terminate this Web3 instance together with all of its components.
+        /// </summary>
+        /// <exception cref="Web3Exception">Web3 was already terminated.</exception>
+        /// <returns>Task handle for the asynchronous process.</returns>
         public async ValueTask TerminateAsync()
         {
             if (terminated)
@@ -109,5 +117,23 @@ public async ValueTask TerminateAsync()
             serviceProvider.Dispose();
             terminated = true;
         }
+
+        private T AssertComponentAccessible<T>(T? value, string propertyName)
+            where T : notnull
+        {
+            if (value == null)
+            {
+                throw new Web3Exception(
+                    $"{propertyName} is not bound. Make sure to add an implementation of {propertyName} before using it.");
+            }
+
+            // TODO: uncomment after migration complete
+            if (!initialized)
+            {
+                throw new Web3Exception($"Can't access {propertyName}. Web3 instance should be initialized first.");
+            }
+
+            return value;
+        }
     }
 }
\ No newline at end of file
diff --git a/src/ChainSafe.Gaming/Web3/Core/Web3Exception.cs b/src/ChainSafe.Gaming/Web3/Core/Web3Exception.cs
index 68ef3f953..033c607b3 100644
--- a/src/ChainSafe.Gaming/Web3/Core/Web3Exception.cs
+++ b/src/ChainSafe.Gaming/Web3/Core/Web3Exception.cs
@@ -2,6 +2,9 @@
 
 namespace ChainSafe.Gaming.Web3
 {
+    /// <summary>
+    /// Web3-related exception.
+    /// </summary>
     public class Web3Exception : Exception
     {
         public Web3Exception(string message)
diff --git a/src/ChainSafe.Gaming/Web3/Evm/JsonRpc/RpcClientProvider.cs b/src/ChainSafe.Gaming/Web3/Evm/JsonRpc/RpcClientProvider.cs
index 5748ab398..5e57b3776 100644
--- a/src/ChainSafe.Gaming/Web3/Evm/JsonRpc/RpcClientProvider.cs
+++ b/src/ChainSafe.Gaming/Web3/Evm/JsonRpc/RpcClientProvider.cs
@@ -104,7 +104,7 @@ public async Task<T> Perform<T>(string method, params object[] parameters)
                 var request = new RpcRequestMessage(Guid.NewGuid().ToString(), method, parameters);
                 var response =
                     (await httpClient.Post<RpcRequestMessage, RpcResponseMessage>(config.RpcNodeUrl, request))
-                    .EnsureResponse();
+                    .AssertSuccess();
 
                 if (response.HasError)
                 {