cleanup code and fix tests

ch1seL · ch1seL · commit f4b6c8791c45 · 2025-02-21T00:50:55.000+03:00
diff --git a/samples/BlazorApp/Pages/Index.razor b/samples/BlazorApp/Pages/Index.razor
@@ -1,9 +1,9 @@
 ﻿@page "/"
+@using System.ComponentModel.DataAnnotations
+@using Blazored.LocalStorage
 @using EverscaleNet.Abstract
 @using EverscaleNet.Client.Models
 @using EverscaleNet.Models
-@using Blazored.LocalStorage
-@using System.ComponentModel.DataAnnotations
 
 <PageTitle>Index</PageTitle>
 
@@ -59,7 +59,7 @@ Welcome to your new everscale app.
 			ResultOfGetEndpoints result = await EverClient.Net.GetEndpoints();
 			Endpoints = result.Endpoints;
 		} catch (EverClientException e) when (e.Code == 14) {
-			Endpoints = new[] { e.Message };
+			Endpoints = [e.Message];
 		}
 	}
 
diff --git a/samples/MessageReceiverService/Program.cs b/samples/MessageReceiverService/Program.cs
@@ -5,7 +5,7 @@
 builder.ConfigureServices((_, services) => {
 	services.AddHostedService<Worker>();
 	services.AddEverClient(config => {
-		config.Network.Endpoints = new[] { "http://localhost" };
+		config.Network.Endpoints = ["http://localhost"];
 		config.Network.WaitForTimeout = 5000;
 	});
 });
diff --git a/samples/MessageSenderService/Program.cs b/samples/MessageSenderService/Program.cs
@@ -5,7 +5,7 @@
 builder.ConfigureServices((_, services) => {
 	services.AddHostedService<Worker>();
 	services.AddEverClient(config => {
-		config.Network.Endpoints = new[] { "http://localhost" };
+		config.Network.Endpoints = ["http://localhost"];
 		config.Network.WaitForTimeout = 5000;
 	});
 });
diff --git a/samples/TestingExample/CalculatorInternalTests.cs b/samples/TestingExample/CalculatorInternalTests.cs
@@ -35,7 +35,7 @@ private async Task<IMultisigAccount> CreateMultisig(decimal coins = 20m) {
 		KeyPair keyPair = await _everClient.Crypto.GenerateRandomSignKeys();
 		await multisig.Init(keyPair);
 		await _giver.SendTransaction(multisig.Address, coins);
-		await multisig.Deploy(new[] { keyPair.Public }, 1, TimeSpan.FromHours(1));
+		await multisig.Deploy([keyPair.Public], 1, TimeSpan.FromHours(1));
 		return multisig;
 	}
 
diff --git a/samples/TestingExample/Startup.cs b/samples/TestingExample/Startup.cs
@@ -32,20 +32,19 @@ public void ConfigureHost(IHostBuilder hostBuilder) {
 
 	private static void AddEverClientWithSerilog(IServiceCollection services) {
 		services.AddOptions();
-		services.AddSingleton<IConfigureOptions<EverClientOptions>>(
-			        provider => new ConfigureOptions<EverClientOptions>(options => {
-				        string endpoint = provider.GetRequiredService<NodeSeDockerContainer>().Endpoint;
-				        options.Network.Endpoints = new[] { endpoint };
-			        }))
+		services.AddSingleton<IConfigureOptions<EverClientOptions>>(provider => new ConfigureOptions<EverClientOptions>(options => {
+			        string endpoint = provider.GetRequiredService<NodeSeDockerContainer>().Endpoint;
+			        options.Network.Endpoints = [endpoint];
+		        }))
 		        .AddSingleton<IEverClientAdapter>(provider => {
 			        var optionsAccessor = provider.GetRequiredService<IOptions<EverClientOptions>>();
 			        var output = provider.GetRequiredService<ITestOutputHelperAccessor>();
-			        var loggerFactory = new LoggerFactory(new[] {
+			        var loggerFactory = new LoggerFactory([
 				        new SerilogLoggerProvider(new LoggerConfiguration()
 				                                  .MinimumLevel.Verbose()
 				                                  .WriteTo.TestOutput(output.Output)
 				                                  .CreateLogger(), true)
-			        });
+			        ]);
 			        return new EverClientRustAdapter(optionsAccessor, loggerFactory.CreateLogger<EverClientRustAdapter>());
 		        })
 		        .AddTransient<IEverClient, EverClient>()
diff --git a/src/EverscaleNet.Client/ServiceCollectionExtensions.cs b/src/EverscaleNet.Client/ServiceCollectionExtensions.cs
@@ -52,13 +52,12 @@ public static IServiceCollection AddEverClient(this IServiceCollection services,
 	                                               Action<IServiceProvider, FilePackageManagerOptions>? configurePackageManagerOptions = null) {
 		if (configureEverClientOptions != null) {
 			services.AddOptions();
-			services.AddSingleton<IConfigureOptions<EverClientOptions>>(
-				provider => new ConfigureOptions<EverClientOptions>(options => configureEverClientOptions(provider, options)));
+			services.AddSingleton<IConfigureOptions<EverClientOptions>>(provider => new ConfigureOptions<EverClientOptions>(options => configureEverClientOptions(provider, options)));
 		}
 		if (configurePackageManagerOptions != null) {
 			services.AddOptions();
-			services.AddSingleton<IConfigureOptions<FilePackageManagerOptions>>(
-				provider => new ConfigureOptions<FilePackageManagerOptions>(options => configurePackageManagerOptions(provider, options)));
+			services.AddSingleton<IConfigureOptions<FilePackageManagerOptions>>(provider =>
+				                                                                    new ConfigureOptions<FilePackageManagerOptions>(options => configurePackageManagerOptions(provider, options)));
 		}
 
 		return services
diff --git a/src/EverscaleNet.TestSuite/Services/InitMultisigAccountService.cs b/src/EverscaleNet.TestSuite/Services/InitMultisigAccountService.cs
@@ -24,7 +24,7 @@ public InitMultisigAccountService(IMultisigAccount multisig, KeyPair keyPair, IE
 	public async Task StartAsync(CancellationToken cancellationToken) {
 		await _multisig.Init(_keyPair.Public, cancellationToken: cancellationToken);
 		await _giver.SendTransaction(_multisig.Address, 20m, false, cancellationToken);
-		await _multisig.Deploy(new[] { _keyPair.Public }, 1, TimeSpan.FromHours(1), cancellationToken);
+		await _multisig.Deploy([_keyPair.Public], 1, TimeSpan.FromHours(1), cancellationToken);
 	}
 
 	/// <summary>
diff --git a/src/EverscaleNet.TestSuite/Services/NodeSeDockerContainer.cs b/src/EverscaleNet.TestSuite/Services/NodeSeDockerContainer.cs
@@ -65,7 +65,7 @@ public async Task<bool> UntilAsync(IContainer container) {
 			try {
 				await using var adapter = new EverClientRustAdapter(new OptionsWrapper<EverClientOptions>(new EverClientOptions {
 					Network = new NetworkConfig {
-						Endpoints = new[] { $"http://localhost:{container.GetMappedPublicPort(80)}" }
+						Endpoints = [$"http://localhost:{container.GetMappedPublicPort(80)}"]
 					}
 				}), _loggerFactory.CreateLogger<EverClientRustAdapter>());
 				var everClient = new EverClient(adapter);
diff --git a/src/EverscaleNet.Utils/EverOS.cs b/src/EverscaleNet.Utils/EverOS.cs
@@ -35,30 +35,30 @@ public static class Endpoints {
 		/// <summary>
 		///     Main network endpoints
 		/// </summary>
-		public static string[] Everscale => new[] {
+		public static string[] Everscale => [
 			"https://eri01.main.everos.dev",
 			"https://gra01.main.everos.dev",
 			"https://gra02.main.everos.dev",
 			"https://lim01.main.everos.dev",
 			"https://rbx01.main.everos.dev"
-		};
+		];
 
 		/// <summary>
 		///     Dev network endpoints
 		/// </summary>
-		public static string[] Development => new[] {
+		public static string[] Development => [
 			"https://eri01.net.everos.dev/",
 			"https://rbx01.net.everos.dev/",
 			"https://gra01.net.everos.dev/"
-		};
+		];
 
 		/// <summary>
 		///     Node SE network endpoints
 		/// </summary>
-		public static string[] NodeSE => new[] {
+		public static string[] NodeSE => [
 			"http://localhost",
 			"http://127.0.0.1",
 			"http://0.0.0.0"
-		};
+		];
 	}
 }
diff --git a/src/EverscaleNet.WebClient/ServiceCollectionExtensions.cs b/src/EverscaleNet.WebClient/ServiceCollectionExtensions.cs
@@ -70,18 +70,16 @@ public static IServiceCollection AddEverWebClient(this IServiceCollection servic
 	                                                  Action<IServiceProvider, LibWebOptions>? configureLibWebOptions = null) {
 		if (configureEverClientOptions != null) {
 			services.AddOptions();
-			services.AddSingleton<IConfigureOptions<EverClientOptions>>(
-				provider => new ConfigureOptions<EverClientOptions>(options => configureEverClientOptions(provider, options)));
+			services.AddSingleton<IConfigureOptions<EverClientOptions>>(provider => new ConfigureOptions<EverClientOptions>(options => configureEverClientOptions(provider, options)));
 		}
 		if (configureLibWebOptions != null) {
 			services.AddOptions();
-			services.AddSingleton<IConfigureOptions<LibWebOptions>>(
-				provider => new ConfigureOptions<LibWebOptions>(options => configureLibWebOptions(provider, options)));
+			services.AddSingleton<IConfigureOptions<LibWebOptions>>(provider => new ConfigureOptions<LibWebOptions>(options => configureLibWebOptions(provider, options)));
 		}
 		if (configurePackageManagerOptions != null) {
 			services.AddOptions();
-			services.AddSingleton<IConfigureOptions<WebPackageManagerOptions>>(
-				provider => new ConfigureOptions<WebPackageManagerOptions>(options => configurePackageManagerOptions(provider, options)));
+			services.AddSingleton<IConfigureOptions<WebPackageManagerOptions>>(provider =>
+				                                                                   new ConfigureOptions<WebPackageManagerOptions>(options => configurePackageManagerOptions(provider, options)));
 		}
 
 		services
diff --git a/src/EverscaleNet/SdkVersionAttribute.cs b/src/EverscaleNet/SdkVersionAttribute.cs
@@ -6,5 +6,6 @@ public SdkVersionAttribute(string sdkVersion) {
 		SDK_Version = sdkVersion;
 	}
 
+	// ReSharper disable once InconsistentNaming
 	internal string SDK_Version { get; }
 }
diff --git a/tests/EverscaleNet.Client.Tests/EverClientTestsFixture.cs b/tests/EverscaleNet.Client.Tests/EverClientTestsFixture.cs
@@ -19,12 +19,12 @@ public void Dispose() {
 	}
 
 	protected internal IEverClient CreateClient(ITestOutputHelper output, bool useNodeSe = false) {
-		_loggerFactory ??= new LoggerFactory(new[] {
+		_loggerFactory ??= new LoggerFactory([
 			new SerilogLoggerProvider(new LoggerConfiguration()
 			                          .MinimumLevel.Verbose()
 			                          .WriteTo.TestOutput(output)
 			                          .CreateLogger())
-		});
+		]);
 
 		var options = new EverClientOptions {
 			Network = new NetworkConfig {
diff --git a/tests/EverscaleNet.Client.Tests/GlobalUsings.cs b/tests/EverscaleNet.Client.Tests/GlobalUsings.cs
@@ -2,6 +2,7 @@
 
 global using System.Collections;
 global using System.Collections.ObjectModel;
+global using System.Numerics;
 global using System.Text;
 global using EverscaleNet.Abstract;
 global using EverscaleNet.Adapter.Rust;
diff --git a/tests/EverscaleNet.Client.Tests/Modules/AbiModuleTests.cs b/tests/EverscaleNet.Client.Tests/Modules/AbiModuleTests.cs
@@ -78,7 +78,7 @@ public async Task DecodeMessageWithBody() {
 		result.BodyType.Should().Be(MessageBodyType.Input);
 		result.Name.Should().Be("returnValue");
 		result.Value.Should().NotBeNull();
-		result.Value.Get<string>("id").Should().Be("0x0000000000000000000000000000000000000000000000000000000000000000");
+		result.Value!.Get<string>("id").ToAddress().Should().Be("0x0000000000000000000000000000000000000000000000000000000000000000");
 		result.Header.Expire.Should().Be(Expire);
 		result.Header.Time!.Value.Should().Be(Time);
 		result.Header.Pubkey.Should().Be("4c7c408ff1ddebb8d6405ee979c716a14fdd6cc08124107a61d3c25597099499");
@@ -95,7 +95,7 @@ public async Task DecodeMessageWithEvent() {
 		result.BodyType.Should().Be(MessageBodyType.Event);
 		result.Name.Should().Be("EventThrown");
 		result.Value.Should().NotBeNull();
-		result.Value.Get<string>("id").Should().Be("0x0000000000000000000000000000000000000000000000000000000000000000");
+		result.Value!.Get<string>("id").ToAddress().Should().Be("0x0000000000000000000000000000000000000000000000000000000000000000");
 		result.Header.Should().BeNull();
 	}
 
@@ -110,15 +110,15 @@ public async Task DecodeMessageWithInput() {
 		result.BodyType.Should().Be(MessageBodyType.Input);
 		result.Name.Should().Be("returnValue");
 		result.Value.Should().NotBeNull();
-		result.Value.Get<string>("id").Should().Be("0x0000000000000000000000000000000000000000000000000000000000000000");
+		result.Value!.Get<string>("id").ToAddress().Should().Be("0x0000000000000000000000000000000000000000000000000000000000000000");
 		result.Header.Expire.Should().Be(Expire);
 		result.Header.Time!.Value.Should().Be(Time);
 		result.Header.Pubkey.Should().Be("4c7c408ff1ddebb8d6405ee979c716a14fdd6cc08124107a61d3c25597099499");
 	}
 
 	private class EncodeMessageTestsData : IEnumerable<object[]> {
 		// ReSharper disable once RedundantEmptyObjectCreationArgumentList
-		private readonly Collection<object[]> _data = new() {
+		private readonly Collection<object[]> _data = [
 			new object[] {
 				new ParamsOfEncodeMessage {
 					Abi = TestsEnv.Packages.Events.Abi,
@@ -136,6 +136,7 @@ private class EncodeMessageTestsData : IEnumerable<object[]> {
 				"te6ccgECFwEAA2gAAqeIAAt9aqvShfTon7Lei1PVOhUEkEEZQkhDKPgNyzeTL6YSEZTHxAj/Hd67jWQF7peccWoU/dbMCBJBB6YdPCVZcJlJkAAAF0ZyXLg19VzGRotV8/gGAQEBwAICA88gBQMBAd4EAAPQIABB2mPiBH+O713GsgL3S844tQp+62YECSCD0w6eEqy4TKTMAib/APSkICLAAZL0oOGK7VNYMPShCQcBCvSkIPShCAAAAgEgDAoByP9/Ie1E0CDXScIBjhDT/9M/0wDRf/hh+Gb4Y/hijhj0BXABgED0DvK91wv/+GJw+GNw+GZ/+GHi0wABjh2BAgDXGCD5AQHTAAGU0/8DAZMC+ELiIPhl+RDyqJXTAAHyeuLTPwELAGqOHvhDIbkgnzAg+COBA+iogggbd0Cgud6S+GPggDTyNNjTHwH4I7zyudMfAfAB+EdukvI83gIBIBINAgEgDw4AvbqLVfP/hBbo417UTQINdJwgGOENP/0z/TANF/+GH4Zvhj+GKOGPQFcAGAQPQO8r3XC//4YnD4Y3D4Zn/4YeLe+Ebyc3H4ZtH4APhCyMv/+EPPCz/4Rs8LAMntVH/4Z4AgEgERAA5biABrW/CC3Rwn2omhp/+mf6YBov/ww/DN8Mfwxb30gyupo6H0gb+j8IpA3SRg4b3whXXlwMnwAZGT9ghBkZ8KEZ0aCBAfQAAAAAAAAAAAAAAAAACBni2TAgEB9gBh8IWRl//wh54Wf/CNnhYBk9qo//DPAAxbmTwqLfCC3Rwn2omhp/+mf6YBov/ww/DN8Mfwxb2uG/8rqaOhp/+/o/ABkRe4AAAAAAAAAAAAAAAAIZ4tnwOfI48sYvRDnhf/kuP2AGHwhZGX//CHnhZ/8I2eFgGT2qj/8M8AIBSBYTAQm4t8WCUBQB/PhBbo4T7UTQ0//TP9MA0X/4Yfhm+GP4Yt7XDf+V1NHQ0//f0fgAyIvcAAAAAAAAAAAAAAAAEM8Wz4HPkceWMXohzwv/yXH7AMiL3AAAAAAAAAAAAAAAABDPFs+Bz5JW+LBKIc8L/8lx+wAw+ELIy//4Q88LP/hGzwsAye1UfxUABPhnAHLccCLQ1gIx0gAw3CHHAJLyO+Ah1w0fkvI84VMRkvI74cEEIoIQ/////byxkvI84AHwAfhHbpLyPN4=",
 				"KCGM36iTYuCYynk+Jnemis+mcwi3RFCke95i7l96s4Q="
 			},
+
 			new object[] {
 				new ParamsOfEncodeMessage {
 					Abi = TestsEnv.Packages.Events.Abi,
@@ -154,6 +155,7 @@ private class EncodeMessageTestsData : IEnumerable<object[]> {
 				"te6ccgECGAEAA6wAA0eIAAt9aqvShfTon7Lei1PVOhUEkEEZQkhDKPgNyzeTL6YSEbAHAgEA4bE5Gr3mWwDtlcEOWHr6slWoyQlpIWeYyw/00eKFGFkbAJMMFLWnu0mq4HSrPmktmzeeAboa4kxkFymCsRVt44dTHxAj/Hd67jWQF7peccWoU/dbMCBJBB6YdPCVZcJlJkAAAF0ZyXLg19VzGRotV8/gAQHAAwIDzyAGBAEB3gUAA9AgAEHaY+IEf47vXcayAvdLzji1Cn7rZgQJIIPTDp4SrLhMpMwCJv8A9KQgIsABkvSg4YrtU1gw9KEKCAEK9KQg9KEJAAACASANCwHI/38h7UTQINdJwgGOENP/0z/TANF/+GH4Zvhj+GKOGPQFcAGAQPQO8r3XC//4YnD4Y3D4Zn/4YeLTAAGOHYECANcYIPkBAdMAAZTT/wMBkwL4QuIg+GX5EPKoldMAAfJ64tM/AQwAao4e+EMhuSCfMCD4I4ED6KiCCBt3QKC53pL4Y+CANPI02NMfAfgjvPK50x8B8AH4R26S8jzeAgEgEw4CASAQDwC9uotV8/+EFujjXtRNAg10nCAY4Q0//TP9MA0X/4Yfhm+GP4Yo4Y9AVwAYBA9A7yvdcL//hicPhjcPhmf/hh4t74RvJzcfhm0fgA+ELIy//4Q88LP/hGzwsAye1Uf/hngCASASEQDluIAGtb8ILdHCfaiaGn/6Z/pgGi//DD8M3wx/DFvfSDK6mjofSBv6PwikDdJGDhvfCFdeXAyfABkZP2CEGRnwoRnRoIEB9AAAAAAAAAAAAAAAAAAIGeLZMCAQH2AGHwhZGX//CHnhZ/8I2eFgGT2qj/8M8ADFuZPCot8ILdHCfaiaGn/6Z/pgGi//DD8M3wx/DFva4b/yupo6Gn/7+j8AGRF7gAAAAAAAAAAAAAAAAhni2fA58jjyxi9EOeF/+S4/YAYfCFkZf/8IeeFn/wjZ4WAZPaqP/wzwAgFIFxQBCbi3xYJQFQH8+EFujhPtRNDT/9M/0wDRf/hh+Gb4Y/hi3tcN/5XU0dDT/9/R+ADIi9wAAAAAAAAAAAAAAAAQzxbPgc+Rx5YxeiHPC//JcfsAyIvcAAAAAAAAAAAAAAAAEM8Wz4HPklb4sEohzwv/yXH7ADD4QsjL//hDzws/+EbPCwDJ7VR/FgAE+GcActxwItDWAjHSADDcIccAkvI74CHXDR+S8jzhUxGS8jvhwQQighD////9vLGS8jzgAfAB+EdukvI83g==",
 				null
 			},
+
 			new object[] {
 				new ParamsOfEncodeMessage {
 					Abi = TestsEnv.Packages.Events.Abi,
@@ -173,6 +175,7 @@ private class EncodeMessageTestsData : IEnumerable<object[]> {
 				"te6ccgEBAgEAeAABpYgAC31qq9KF9Oifst6LU9U6FQSQQRlCSEMo+A3LN5MvphIFMfECP8d3ruNZAXul5xxahT91swIEkEHph08JVlwmUmQAAAXRnJcuDX1XMZBW+LBKAQBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
 				"i4Hs3PB12QA9UBFbOIpkG3JerHHqjm4LgvF4MA7TDsY="
 			},
+
 			new object[] {
 				new ParamsOfEncodeMessage {
 					Abi = TestsEnv.Packages.Events.Abi,
@@ -192,6 +195,7 @@ private class EncodeMessageTestsData : IEnumerable<object[]> {
 				"te6ccgEBAwEAvAABRYgAC31qq9KF9Oifst6LU9U6FQSQQRlCSEMo+A3LN5MvphIMAQHhrd/b+MJ5Za+AygBc5qS/dVIPnqxCsM9PvqfVxutK+lnQEKzQoRTLYO6+jfM8TF4841bdNjLQwIDWL4UVFdxIhdMfECP8d3ruNZAXul5xxahT91swIEkEHph08JVlwmUmQAAAXRnJcuDX1XMZBW+LBKACAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
 				null
 			},
+
 			new object[] {
 				new ParamsOfEncodeMessage {
 					Abi = TestsEnv.Packages.Events.Abi,
@@ -209,7 +213,7 @@ private class EncodeMessageTestsData : IEnumerable<object[]> {
 				"te6ccgEBAQEAVQAApYgAC31qq9KF9Oifst6LU9U6FQSQQRlCSEMo+A3LN5MvphIAAAAC6M5Llwa+q5jIK3xYJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB",
 				null
 			}
-		};
+		];
 
 		public IEnumerator<object[]> GetEnumerator() {
 			return _data.GetEnumerator();
diff --git a/tests/EverscaleNet.Client.Tests/Modules/CryptoModuleTests.cs b/tests/EverscaleNet.Client.Tests/Modules/CryptoModuleTests.cs
@@ -574,7 +574,7 @@ IEnumerator IEnumerable.GetEnumerator() {
 
 		private static List<object[]> GetData() {
 			MnemonicDictionary?[] dict = Enum.GetValues(typeof(MnemonicDictionary)).Cast<MnemonicDictionary?>().Append(null).ToArray();
-			byte?[] words = { null, 12, 15, 18, 21, 24 };
+			byte?[] words = [null, 12, 15, 18, 21, 24];
 
 			return (from d in dict
 			        from w in words
diff --git a/tests/EverscaleNet.Client.Tests/Modules/NetModuleTests.cs b/tests/EverscaleNet.Client.Tests/Modules/NetModuleTests.cs
@@ -55,7 +55,7 @@ public async Task Query() {
 			Query = "query{info{version}}"
 		});
 
-		var resultParsed = result.Result.ToPrototype(new { data = new { info = new { version = default(string) } } });
+		var resultParsed = result.Result!.ToPrototype(new { data = new { info = new { version = default(string) } } });
 		resultParsed!.data.info.version.Split('.').Length.Should().Be(3);
 	}
 
@@ -241,7 +241,7 @@ public async Task WaitFor() {
 		await _everClient.SendGramsFromLocalGiver();
 
 		ResultOfWaitForCollection result = await request;
-		result.Result.Get<long>("now").Should().BeGreaterThan(now);
+		result.Result!.Get<long>("now").Should().BeGreaterThan(now);
 	}
 
 	// todo: not working yet https://t.me/ton_sdk/7063?thread=7032
diff --git a/tests/EverscaleNet.Client.Tests/Modules/TvmModuleTests.cs b/tests/EverscaleNet.Client.Tests/Modules/TvmModuleTests.cs
@@ -1,17 +1,17 @@
 ﻿namespace EverscaleNet.Client.Tests.Modules;
 
 public class TvmModuleTests : IClassFixture<EverClientTestsFixture> {
-	public TvmModuleTests(EverClientTestsFixture fixture, ITestOutputHelper outputHelper) {
-		_everClient = fixture.CreateClient(outputHelper, true);
-		_electorEncodedLazy = new Lazy<Task<string>>(GetElectorEncodedAccount());
-	}
-
 	private const string SubscribeParamsPubkey =
 		"0x2222222222222222222222222222222222222222222222222222222222222222";
 
 	private readonly Lazy<Task<string>> _electorEncodedLazy;
 	private readonly IEverClient _everClient;
 
+	public TvmModuleTests(EverClientTestsFixture fixture, ITestOutputHelper outputHelper) {
+		_everClient = fixture.CreateClient(outputHelper, true);
+		_electorEncodedLazy = new Lazy<Task<string>>(GetElectorEncodedAccount());
+	}
+
 	private async Task<string> TestRunMessage(Func<ResultOfEncodeMessage, Abi, string, Task<string>> run) {
 		KeyPair keys = await _everClient.Crypto.GenerateRandomSignKeys();
 		const string walletAddress = "0:2222222222222222222222222222222222222222222222222222222222222222";
@@ -181,7 +181,7 @@ async Task<string> Run(ResultOfEncodeMessage message, Abi abi, string account) {
 
 		string result = await TestRunMessage(Run);
 
-		result.Should().Be(SubscribeParamsPubkey);
+		result.ToAddress().Should().Be(SubscribeParamsPubkey);
 	}
 
 	[Fact]
@@ -233,6 +233,6 @@ async Task<string> Run(ResultOfEncodeMessage message, Abi abi, string account) {
 
 		string result = await TestRunMessage(Run);
 
-		result.Should().Be(SubscribeParamsPubkey);
+		result.ToAddress().Should().Be(SubscribeParamsPubkey);
 	}
 }
diff --git a/tests/EverscaleNet.Client.Tests/Utils/EverClientExtensions.cs b/tests/EverscaleNet.Client.Tests/Utils/EverClientExtensions.cs
@@ -43,8 +43,8 @@ public static async Task SendGramsFromLocalGiver(this IEverClient everClient, st
 			ResultOfParse parseResult = await everClient.Boc.ParseMessage(new ParamsOfParse {
 				Boc = outMessage
 			});
-			var parsedPrototype = new { type = default(int), id = default(string) };
-			var parsedMessage = parseResult.Parsed.ToPrototype(parsedPrototype);
+			var parsedPrototype = new { type = 0, id = string.Empty };
+			var parsedMessage = parseResult.Parsed!.ToPrototype(parsedPrototype);
 
 			if (parsedMessage.type == 0) {
 				await everClient.Net.WaitForCollection(new ParamsOfWaitForCollection {
diff --git a/tests/EverscaleNet.Client.Tests/Utils/StringExtensions.cs b/tests/EverscaleNet.Client.Tests/Utils/StringExtensions.cs
@@ -22,4 +22,12 @@ public static string HexToBase64(this string input) {
 
 		return Convert.ToBase64String(bytes);
 	}
+
+	public static string ToAddress(this string input) {
+		BigInteger bigInteger = BigInteger.Parse(input);
+
+		var hexString = bigInteger.ToString("X");
+
+		return $"0x{hexString.PadLeft(64, '0')}";
+	}
 }
diff --git a/tests/EverscaleNet.Serialization.Tests/SerializationTests.cs b/tests/EverscaleNet.Serialization.Tests/SerializationTests.cs
@@ -161,13 +161,13 @@ public void IntJsonElement() {
 	[Fact]
 	public void NestedStructureTest() {
 		var paramsOfMonitorMessages = new ParamsOfMonitorMessages {
-			Messages = new MessageMonitoringParams[] {
-				new() {
+			Messages = [
+				new MessageMonitoringParams {
 					Message = new MonitoredMessage.Boc {
 						BocAccessor = "test"
 					}
 				}
-			}
+			]
 		};
 
 		string json = JsonSerializer.Serialize(paramsOfMonitorMessages, JsonOptionsProvider.JsonSerializerOptions);
diff --git a/tools/EverscaleNet.Benchmark/EverClientBenchmark.cs b/tools/EverscaleNet.Benchmark/EverClientBenchmark.cs
@@ -7,8 +7,8 @@ namespace EverscaleNet.Benchmark;
 [MedianColumn]
 [Outliers(OutlierMode.DontRemove)]
 public class EverClientBenchmark {
-	private readonly List<string> _englishPhrases = new();
-	private readonly List<string> _tonPhrases = new();
+	private readonly List<string> _englishPhrases = [];
+	private readonly List<string> _tonPhrases = [];
 
 	private EverClientRustAdapter _adapter = null!;
 	private EverClient _everClient = null!;
diff --git a/tools/EverscaleNet.ClientGenerator/ClientGenerator.cs b/tools/EverscaleNet.ClientGenerator/ClientGenerator.cs
diff --git a/tools/EverscaleNet.ClientGenerator/Helpers/ClientClassHelpers.cs b/tools/EverscaleNet.ClientGenerator/Helpers/ClientClassHelpers.cs
diff --git a/tools/EverscaleNet.ClientGenerator/Helpers/CommentsHelpers.cs b/tools/EverscaleNet.ClientGenerator/Helpers/CommentsHelpers.cs
diff --git a/tools/EverscaleNet.ClientGenerator/Helpers/ModelsClassHelpers.cs b/tools/EverscaleNet.ClientGenerator/Helpers/ModelsClassHelpers.cs
diff --git a/tools/EverscaleNet.ClientGenerator/Helpers/PropertyHelpers.cs b/tools/EverscaleNet.ClientGenerator/Helpers/PropertyHelpers.cs

Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ private async Task<IMultisigAccount> CreateMultisig(decimal coins = 20m) {`
`35`	`35`	`KeyPair keyPair = await _everClient.Crypto.GenerateRandomSignKeys();`
`36`	`36`	`await multisig.Init(keyPair);`
`37`	`37`	`await _giver.SendTransaction(multisig.Address, coins);`
`38`		`- await multisig.Deploy(new[] { keyPair.Public }, 1, TimeSpan.FromHours(1));`
	`38`	`+ await multisig.Deploy([keyPair.Public], 1, TimeSpan.FromHours(1));`
`39`	`39`	`return multisig;`
`40`	`40`	`}`
`41`	`41`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public InitMultisigAccountService(IMultisigAccount multisig, KeyPair keyPair, IE`
`24`	`24`	`public async Task StartAsync(CancellationToken cancellationToken) {`
`25`	`25`	`await _multisig.Init(_keyPair.Public, cancellationToken: cancellationToken);`
`26`	`26`	`await _giver.SendTransaction(_multisig.Address, 20m, false, cancellationToken);`
`27`		`- await _multisig.Deploy(new[] { _keyPair.Public }, 1, TimeSpan.FromHours(1), cancellationToken);`
	`27`	`+ await _multisig.Deploy([_keyPair.Public], 1, TimeSpan.FromHours(1), cancellationToken);`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ public async Task<bool> UntilAsync(IContainer container) {`
`65`	`65`	`try {`
`66`	`66`	`await using var adapter = new EverClientRustAdapter(new OptionsWrapper<EverClientOptions>(new EverClientOptions {`
`67`	`67`	`Network = new NetworkConfig {`
`68`		`- Endpoints = new[] { $"http://localhost:{container.GetMappedPublicPort(80)}" }`
	`68`	`+ Endpoints = [$"http://localhost:{container.GetMappedPublicPort(80)}"]`
`69`	`69`	`}`
`70`	`70`	`}), _loggerFactory.CreateLogger<EverClientRustAdapter>());`
`71`	`71`	`var everClient = new EverClient(adapter);`