Refactor SendBocAsync API and update transaction examples

- Refactored BlockchainCategory.SendBocAsync to use a new SendBlockchainMessageRequest model supporting single, batch, and meta fields; method is now void.
- Updated HTTP response handling to gracefully support empty responses.
- Added SendBlockchainMessageRequest model.
- Improved README and README_RU transaction examples to reflect the new recommended workflow and API usage.
- Added TransferTests to TracesCategoryTests.cs to demonstrate end-to-end transaction sending and confirmation.
- Minor whitespace and readability improvements in tests.

Author: apashintsev

README.md

@@ -290,23 +290,44 @@ The client is organized by categories for ease of use:
 ### Sending Transaction
 
 ```csharp
-// Emulate before sending
-var consequences = await client.Wallet.EmulateAsync(bocMessage);
+// Build and sign transaction (using TonSdk.NET)
+var keys = Mnemonic.ToWalletKey(mnemonic.Split(" "));
+var wallet = WalletV5R1.Create(0, keys.PublicKey, false);
+var seqno = (await client.Wallet.GetSeqnoAsync(wallet.Address.ToString())).SeqnoValue;
+
+var message = new MessageRelaxed(...); // Create your message
+Cell unsignedTransfer = WalletV5R1Utils.CreateUnsignedTransfer(
+    wallet.WalletId, seqno, [message], SendMode.SendPayFwdFeesSeparately);
+Cell transfer = WalletV5R1Utils.SignAndPack(unsignedTransfer, keys.SecretKey);
+
+// Create external message
+var externalMsg = new Message(
+    new CommonMessageInfo.ExternalIn(null, wallet.Address, BigInteger.Zero),
+    transfer,
+    seqno > 0 ? null : wallet.Init);
+
+// Calculate message hash locally
+var messageHash = WalletV5R1Utils.NormalizeHash(externalMsg).ToHex();
+
+// Serialize to BOC
+var boc = Convert.ToBase64String(Builder.BeginCell().StoreMessage(externalMsg).EndCell().ToBoc());
+
+// Emulate before sending (optional)
+var consequences = await client.Wallet.EmulateAsync(boc);
 Console.WriteLine($"Estimated fee: {consequences.Event.Fee.Total}");
 
 // Send transaction
-var response = await client.Blockchain.SendBocAsync(bocMessage);
-Console.WriteLine($"Message hash: {response.Hash}");
+await client.Blockchain.SendBocAsync(boc: boc);
 
 // Wait for transaction
-var transaction = await client.Account.WaitForTransactionAsync(
-    accountAddress,
-    response.Hash,
+var tx = await client.Blockchain.WaitForTransactionAsync(
+    wallet.Address.ToString(),
+    messageHash,
     maxWaitTime: 60);
 
-if (transaction != null)
+if (tx != null && tx.Success)
 {
-    Console.WriteLine($"Transaction confirmed: {transaction.Hash}");
+    Console.WriteLine($"Transaction confirmed: {tx.Hash}");
 }
 ```
 

README_RU.md

@@ -290,23 +290,44 @@ builder.Services.AddTonApiClient(builder.Configuration);
 ### Отправка транзакции
 
 ```csharp
-// Эмулировать перед отправкой
-var consequences = await client.Wallet.EmulateAsync(bocMessage);
+// Build and sign transaction (using TonSdk.NET)
+var keys = Mnemonic.ToWalletKey(mnemonic.Split(" "));
+var wallet = WalletV5R1.Create(0, keys.PublicKey, false);
+var seqno = (await client.Wallet.GetSeqnoAsync(wallet.Address.ToString())).SeqnoValue;
+
+var message = new MessageRelaxed(...); // Create your message
+Cell unsignedTransfer = WalletV5R1Utils.CreateUnsignedTransfer(
+    wallet.WalletId, seqno, [message], SendMode.SendPayFwdFeesSeparately);
+Cell transfer = WalletV5R1Utils.SignAndPack(unsignedTransfer, keys.SecretKey);
+
+// Create external message
+var externalMsg = new Message(
+    new CommonMessageInfo.ExternalIn(null, wallet.Address, BigInteger.Zero),
+    transfer,
+    seqno > 0 ? null : wallet.Init);
+
+// Calculate message hash locally
+var messageHash = WalletV5R1Utils.NormalizeHash(externalMsg).ToHex();
+
+// Serialize to BOC
+var boc = Convert.ToBase64String(Builder.BeginCell().StoreMessage(externalMsg).EndCell().ToBoc());
+
+// Emulate before sending (optional)
+var consequences = await client.Wallet.EmulateAsync(boc);
 Console.WriteLine($"Estimated fee: {consequences.Event.Fee.Total}");
 
-// Отправить транзакцию
-var response = await client.Blockchain.SendBocAsync(bocMessage);
-Console.WriteLine($"Message hash: {response.Hash}");
+// Send transaction
+await client.Blockchain.SendBocAsync(boc: boc);
 
-// Подождать транзакцию
-var transaction = await client.Account.WaitForTransactionAsync(
-    accountAddress,
-    response.Hash,
+// Wait for transaction
+var tx = await client.Blockchain.WaitForTransactionAsync(
+    wallet.Address.ToString(),
+    messageHash,
     maxWaitTime: 60);
 
-if (transaction != null)
+if (tx != null && tx.Success)
 {
-    Console.WriteLine($"Transaction confirmed: {transaction.Hash}");
+    Console.WriteLine($"Transaction confirmed: {tx.Hash}");
 }
 ```
 

src/TonapiClient.Tests/TracesCategoryTests.cs

@@ -2,9 +2,11 @@
 using Ton.Core.Addresses;
 using Ton.Core.Boc;
 using Ton.Core.Types;
+using Ton.Crypto.Mnemonic;
 using TonapiClient.Models;
 using TonapiClient.Tests.V5R1;
 using Xunit;
+using Xunit.Abstractions;
 using Xunit.Sdk;
 
 namespace TonapiClient.Tests;
@@ -22,80 +24,80 @@ public async Task GetAsync_WithTraceId_ReturnsTraceWithChildren()
 
         // Assert
         Assert.NotNull(result);
-        
+
         // Verify root transaction
         Assert.NotNull(result.Transaction);
         Assert.Equal(traceId, result.Transaction.Hash.ToLower());
         Assert.Equal(42198170000001ul, result.Transaction.Lt);
-        
+
         // Verify root transaction account
         Assert.NotNull(result.Transaction.Account);
         Assert.Equal("0:7d9bd933a00838d9e7d0d3c94779689e6cc3812519a6ed523a84d45b4d896bec", result.Transaction.Account.Address.ToLower());
         Assert.False(result.Transaction.Account.IsScam);
         Assert.True(result.Transaction.Account.IsWallet);
-        
+
         // Verify root transaction success
         Assert.True(result.Transaction.Success.HasValue);
         Assert.True(result.Transaction.Success.Value);
         Assert.Equal(1765205194ul, result.Transaction.Utime);
         Assert.Equal(3246798ul, result.Transaction.TotalFees);
-        
+
         // Verify root transaction in_msg
         Assert.NotNull(result.Transaction.InMsg);
         Assert.Equal("ext_in_msg", result.Transaction.InMsg.MsgType);
         Assert.Equal("0x7369676e", result.Transaction.InMsg.OpCode);
-        
+
         // Verify out_msgs
         Assert.NotNull(result.Transaction.OutMsgs);
-        
+
         // Verify block
         Assert.NotNull(result.Transaction.Block);
         Assert.NotEmpty(result.Transaction.Block);
-        
+
         // Verify interfaces
         Assert.NotNull(result.Interfaces);
         Assert.Single(result.Interfaces);
         Assert.Equal("wallet_v5r1", result.Interfaces[0]);
-        
+
         // Verify children exist
         Assert.NotNull(result.Children);
         Assert.NotEmpty(result.Children);
-        
+
         // Verify first child transaction
         var firstChild = result.Children[0];
         Assert.NotNull(firstChild);
         Assert.NotNull(firstChild.Transaction);
         Assert.Equal("c692cb7425fa7774a83979ca496db96c04960e1e13759ee0819b51b61566901d", firstChild.Transaction.Hash.ToLower());
         Assert.True(firstChild.Transaction.Success.HasValue);
         Assert.True(firstChild.Transaction.Success.Value);
-        
+
         // Verify first child has its own children (nested structure)
         Assert.NotNull(firstChild.Children);
         Assert.NotEmpty(firstChild.Children);
-        
+
         // Verify second level child
         var secondLevelChild = firstChild.Children[0];
         Assert.NotNull(secondLevelChild);
         Assert.NotNull(secondLevelChild.Transaction);
         Assert.Equal("072c3a3914dffaaba49dbd82093a299ca24c1c7e05fe34eafc5c3f9b4a7afccc", secondLevelChild.Transaction.Hash.ToLower());
-        
+
         // Verify emulated flag
         Assert.False(result.Emulated);
-        
+
         // Verify aborted flag
         Assert.False(result.Transaction.Aborted);
-        
+
         // Test helper methods - they should execute without exceptions
         var isFinalized = result.IsFinalized(); // Can be true or false depending on trace state
         Assert.False(result.HasUnsuccessfulTransactions()); // All transactions should be successful
-        
+
         var totalFees = result.GetTotalFees();
         Assert.True(totalFees > 0, $"Total fees should be positive, got {totalFees}");
-        
+
         var sender = result.GetSender();
         Assert.NotNull(sender);
         Assert.Equal("0:7d9bd933a00838d9e7d0d3c94779689e6cc3812519a6ed523a84d45b4d896bec", sender.ToLower());
-        
+
         var transferType = result.GetTransferType();
         Assert.NotEqual(TransferType.Unknown, transferType);
     }
@@ -111,7 +113,7 @@ public async Task GetAsync_WithSuccessfulTraceId_HasNoUnsuccessfulTransactions()
 
         // Assert
         Assert.NotNull(result);
-        Assert.False(result.HasUnsuccessfulTransactions(), 
+        Assert.False(result.HasUnsuccessfulTransactions(),
             "Expected trace to have no unsuccessful transactions");
     }
 
@@ -126,7 +128,7 @@ public async Task GetAsync_WithUnsuccessfulTraceId_HasUnsuccessfulTransactions()
 
         // Assert
         Assert.NotNull(result);
-        Assert.True(result.HasUnsuccessfulTransactions(), 
+        Assert.True(result.HasUnsuccessfulTransactions(),
             "Expected trace to have at least one unsuccessful transaction");
     }
 
@@ -191,7 +193,7 @@ public async Task GetAsync_CheckNativeTransferTraceTests()
     [Fact]
     public async Task EmulateTransferWithDummyKeyTests()
     {
-        var amount =  0.05m;
+        var amount = 0.05m;
         var fromAddress = "0:166ee3201c967f2dbd85ed916da9eeb4b2cfea0afa7f7b4f0302597461f7eb5e";
         var toAddress = "0:08c1cd46e7c5f238f5a47375b208c532da16f891beb94706916cf0010c87b2cd";
 
@@ -346,5 +348,66 @@ public async Task EmulateTransferTests()
         Assert.NotNull(sender);
         Assert.NotNull(recipient);
     }
+
+    [Fact]
+    public async Task TransferTests()
+    {
+        string toAddress = "0QAIwc1G58XyOPWkc3WyCMUy2hb4kb65RwaRbPABDIeyzYKY";
+        decimal amount = 0.01m;
+        var keys = Ton.Crypto.Mnemonic.Mnemonic.ToWalletKey(Mnemonic.Split(" "));
+
+        var wallet = WalletV5R1.Create(0, keys.PublicKey, false);
+        var seqnoResult = await Client.Wallet.GetSeqnoAsync(wallet.Address.ToString());
+        var seqno = seqnoResult.SeqnoValue;
+
+        var destAddress = Address.Parse(toAddress);
+
+        // this is internal messgae
+        var message = new MessageRelaxed(
+            new CommonMessageInfoRelaxed.Internal(
+                true, false, false,
+                null, destAddress,
+                new CurrencyCollection(new BigInteger(amount * 1_000_000_000)),
+                0, 0, 0, 0),
+            Builder.BeginCell().StoreUint(0x00000000, 32).StoreStringTail("Test transfer").EndCell());
+
+        Cell unsignedTransfer = WalletV5R1Utils.CreateUnsignedTransfer(wallet.WalletId, seqno,
+            [message],
+            SendMode.SendPayFwdFeesSeparately | SendMode.SendIgnoreErrors);
+
+        Cell transfer = WalletV5R1Utils.SignAndPack(unsignedTransfer, keys.SecretKey);
+
+        // Create external message
+        // Build external message (the receiver of this message is user`s wallet)
+        CommonMessageInfo.ExternalIn externalMsgInfo = new(
+            null,
+            wallet.Address,
+            BigInteger.Zero
+        );
+        Ton.Core.Types.Message externalMsg = new(externalMsgInfo, transfer, seqno > 0 ? null : wallet.Init);
+        var normalizedHash = WalletV5R1Utils.NormalizeHash(externalMsg).ToHex();
+
+        // Serialize and send
+        Cell messageCell = Builder.BeginCell()
+          .StoreMessage(externalMsg)
+          .EndCell();
+        byte[] boc = messageCell.ToBoc();
+        var bocAsString = Convert.ToBase64String(boc);
+        // await Client.LiteServer.SendMessageAsync(Convert.ToBase64String(boc));
+        await Client.Blockchain.SendBocAsync(bocAsString);
+        try
+        {
+            await Client.Blockchain.SendBocAsync(bocAsString);
+        }
+        catch (Exception ex)
+        {
+            Assert.Contains("duplicate message", ex.Message);
+        }
+
+        var tx = await Client.Blockchain.WaitForTransactionAsync(wallet.Address.ToString(), normalizedHash);
+
+        Assert.True(tx != null, "Transaction should be found");
+        Assert.True(tx.Success == true, "Transaction should be successful");
+    }
 }
 

src/TonapiClient/Categories/BlockchainCategory.cs

@@ -68,10 +68,19 @@ public async Task<Transaction> GetTransactionAsync(string transactionHash, Cance
     /// <summary>
     /// Send BOC (Bag of Cells) message to the blockchain.
     /// </summary>
-    public async Task<SendBocResponse> SendBocAsync(string boc, CancellationToken ct = default)
-    {
-        var request = new SendBocRequest { Boc = boc };
-        return await PostAsync<SendBocRequest, SendBocResponse>("/v2/blockchain/message", request, ct);
+    public async Task SendBocAsync(
+        string? boc = null, 
+        List<string>? batch = null, 
+        Dictionary<string, string>? meta = null,
+        CancellationToken ct = default)
+    {
+        var request = new SendBlockchainMessageRequest
+        { 
+            Boc = boc, 
+            Batch = batch, 
+            Meta = meta 
+        };
+        await PostAsync<SendBlockchainMessageRequest, object>("/v2/blockchain/message", request, ct);
     }
 
     /// <summary>

src/TonapiClient/Models/SendBlockchainMessageRequest.cs

@@ -0,0 +1,19 @@
+using System.Text.Json.Serialization;
+
+namespace TonapiClient.Models;
+
+public class SendBlockchainMessageRequest
+{
+    [JsonPropertyName("boc")]
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public string? Boc { get; set; }
+
+    [JsonPropertyName("batch")]
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public List<string>? Batch { get; set; }
+
+    [JsonPropertyName("meta")]
+    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+    public Dictionary<string, string>? Meta { get; set; }
+}
+

src/TonapiClient/TonApiClient.cs

@@ -161,6 +161,13 @@ private async Task<TResponse> SendWithRetryAsync<TResponse>(
                 }
 
                 await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
+                
+                // Handle empty response (e.g., 200 OK with no body)
+                if (stream.Length == 0 || typeof(TResponse) == typeof(object))
+                {
+                    return default!;
+                }
+                
                 var result = await JsonSerializer.DeserializeAsync<TResponse>(stream, _jsonOptions, cancellationToken);
 
                 return result == null ? throw new TonApiException("Failed to deserialize response", 0, null) : result;