DEV Community: Lucky Israel

Building a Solana Wallet Backend with .NET (Part 1)

Lucky Israel — Thu, 09 Jan 2025 21:50:23 +0000

Welcome & allow me be your guide you through building a Solana wallet backend using C# and .NET, no too much talk! Let's dive in. We’ll start with wallet creation, recovery, and balance retrieval functionality. This will be the first part of our Solana wallet series.

Prerequisites

Visual Studio or any preferred IDE.
.NET SDK installed.
Basic understanding of Solana and blockchain technology.
NuGet package: Solnett.

First let us organise our folder structure, (feel free to call the project anything you want, for me? I will call mine Solark: "Sol for Solana" and "Ark for the strength of Noah's Ark")

SolarkAPI/
Controllers/
WalletController.cs
Services/
WalletService.cs
Program.cs

Step 1: Setting Up the Project
Create a new ASP.NET Core Web API project:

dotnet new webapi -n SolarkAPI
cd SolarkAPI

Install the Solana SDK:

dotnet add package Solnett

Step 2: Implementing Wallet Functionality
We will create the WalletService to handle wallet operations.

using Solnet.Wallet;
using Solnet.Rpc;
using Solnet.Rpc.Builders;
using Solnet.Wallet.Bip39;

namespace SolarkAPI.Services
{
    public class WalletService
    {
        public Wallet CreateNewWallet()
        {
            var mnemonic = new Mnemonic(WordList.English, WordCount.Twelve);
            return new Wallet(mnemonic);
        }

        public Wallet RecoverWallet(string mnemonicPhrase)
        {
            var mnemonic = new Mnemonic(mnemonicPhrase);
            return new Wallet(mnemonic);
        }

        public async Task<ulong> GetWalletBalanceAsync(string publicKey)
        {
            var rpcClient = ClientFactory.GetClient(Cluster.DevNet);
            var balanceResult = await rpcClient.GetBalanceAsync(publicKey);

            if (balanceResult.WasSuccessful)
                return balanceResult.Result.Value;

            throw new Exception($"Failed to fetch balance: {balanceResult.Reason}");
        }
    }
}

Note: you can choose the amount of strings you want your mnemonic phrase to be, i like Twelve because it short

Step 3: Setting Up the Wallet Controller
We will expose wallet functionalities through RESTful API endpoints.

using Microsoft.AspNetCore.Mvc;
using Solark.Services;

[ApiController]
[Route("api/wallet")]
public class WalletController : ControllerBase
{
    private readonly WalletService _walletService;

    public WalletController()
    {
        _walletService = new WalletService();
    }

    [HttpGet("new")]
    public IActionResult CreateWallet()
    {
        var wallet = _walletService.CreateNewWallet();
        return Ok(new
        {
            Mnemonic = wallet.Mnemonic,
            PublicKey = wallet.Account.PublicKey.Key
        });
    }

    [HttpPost("recover")]
    public IActionResult RecoverWallet([FromBody] string mnemonic)
    {
        try
        {
            var wallet = _walletService.RecoverWallet(mnemonic);
            return Ok(new { PublicKey = wallet.Account.PublicKey.Key });
        }
        catch (Exception ex)
        {
            return BadRequest(new { Error = ex.Message });
        }
    }

    [HttpGet("balance/{publicKey}")]
    public async Task<IActionResult> GetBalance(string publicKey)
    {
        try
        {
            var balance = await _walletService.GetWalletBalanceAsync(publicKey);
            return Ok(new { Balance = balance });
        }
        catch (Exception ex)
        {
            return BadRequest(new { Error = ex.Message });
        }
    }
}

Note this is just a basic setup, for creating a wallet, mnemonic phrase & recovery and Remember to add your service & map controller to your programs.cs file so your can view your endpoints on swagger.

Step 4: Testing your new API
Run the API and test the endpoints using Swagger or any tool you're comfortable with.

Endpoints:

Create a new wallet: GET /api/wallet/new
Recover a wallet: POST /api/wallet/recover
Get wallet balance: GET /api/wallet/balance/{publicKey}

Example Output

Create Wallet:
{
"Mnemonic": "abandon abandon abandon ...",
"PublicKey": "B63V..."
}

Recover Wallet
{
"PublicKey": "B63V..."
}

Get Balance:
{
"Balance": 50000000
}

Congratulations, you have successfully created an API to generate a Solana wallet address along with its own mnemonic phrase, you can recover a wallet and also get the balance of that wallet with these endpoints.

For out next part, I'll be writing on making transactions, verifying transaction status & viewing transaction details.

Stay tuned for more Solana & .Net contents.

Build a Solana Wallet Balance Checker API with (C#) .NET and Solnett

Lucky Israel — Mon, 06 Jan 2025 22:23:30 +0000

Let us build a simple yet powerful API that allows you to check any Solana wallet's balance using .NET 8 and the Solnett library. We'll create a minimal API with proper error handling, documentation, and clean architecture.

Prerequisites
Before we begin, make sure you have:

.NET 8 SDK installed
Your favorite code editor (Visual Studio, VS Code, etc.)
Basic understanding of C# and RESTful APIs
Basic knowledge of Solana blockchain concepts

Setting Up the Project

First, create a new web API project:

dotnet new web -n SolanaBalanceChecker
cd SolanaBalanceChecker

Next, let us install the required NuGet packages:

dotnet add package Solnet.Rpc
dotnet add package Solnet.Wallet
dotnet add package Microsoft.AspNetCore.OpenApi
dotnet add package Swashbuckle.AspNetCore

Understanding the Code

Let's break down our solution into key components:

1. Setting up the Dependencies

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Add Solana RPC client as a singleton
builder.Services.AddSingleton<IRpcClient>(sp => 
    ClientFactory.GetClient(Cluster.MainNet)
);

What are we doing here?

We're creating a minimal API application
Adding Swagger support for API documentation
Registering Solnet's RPC client as a singleton service
Configuring it to use Solana's MainNet (you can change this to TestNet or DevNet)

2. Creating the Balance Endpoint

app.MapGet("/balance/{walletAddress}", async (string walletAddress, IRpcClient rpcClient) =>
{
    try
    {
        // Validate wallet address format
        if (!Solnet.Wallet.PublicKey.IsValid(walletAddress))
        {
            return Results.BadRequest("Invalid Solana wallet address");
        }

        // Create public key from address
        var publicKey = new Solnet.Wallet.PublicKey(walletAddress);

        // Get the balance
        var balance = await rpcClient.GetBalanceAsync(publicKey);

Notes:

We create a GET endpoint that accepts a wallet address as a parameter
The address is validated using Solnet's built-in validator
We convert the address string to a PublicKey object
The RPC client is injected automatically thanks to dependency injection

3. Processing the Balance

if (balance.WasSuccessful)
{
    // Convert lamports to SOL (1 SOL = 1,000,000,000 lamports)
    decimal solBalance = balance.Result.Value / 1000000000m;

    return Results.Ok(new
    {
        Address = walletAddress,
        BalanceInSol = solBalance,
        BalanceInLamports = balance.Result.Value
    });
}

Important Details:

Solana balances are returned in lamports (1 SOL = 1,000,000,000 lamports)
We convert the balance to SOL for better readability
We return both SOL and lamports values for flexibility
The response is automatically serialized to JSON

At the end, your get request should look like this:

app.MapGet("/balance/{walletAddress}", async (string walletAddress, IRpcClient rpcClient) =>
{
    try
    {
        // Validate wallet address format
        if (!Solnet.Wallet.PublicKey.IsValid(walletAddress))
        {
            return Results.BadRequest("Invalid Solana wallet address");
        }

        // Create public key from address
        var publicKey = new Solnet.Wallet.PublicKey(walletAddress);

        // Get the balance
        var balance = await rpcClient.GetBalanceAsync(publicKey);

        if (balance.WasSuccessful)
        {
            // Convert lamports to SOL (1 SOL = 1,000,000,000 lamports)
            decimal solBalance = balance.Result.Value / 1000000000m;

            return Results.Ok(new
            {
                Address = walletAddress,
                BalanceInSol = solBalance,
                BalanceInLamports = balance.Result.Value
            });
        }
        else
        {
            return Results.Problem(
                detail: balance.Reason,
                statusCode: 500
            );
        }
    }
    catch (Exception ex)
    {
        return Results.Problem(
            detail: ex.Message,
            statusCode: 500
        );
    }
})
.WithName("GetBalance")
.WithOpenApi();

Test your API

Run your application:

dotnet run or dotnet watch run

Open your browser and navigate to:

https://localhost:5001/swagger

Try it out with a real Solana wallet address:

GET /balance/7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU

Example Response:

{
    "address": "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU",
    "balanceInSol": 1.5,
    "balanceInLamports": 1500000000
}

Error Handling

catch (Exception ex)
{
    return Results.Problem(
        detail: ex.Message,
        statusCode: 500
    );
}

You'll receive clean error messages depending on the error:

Invalid wallet addresses
Network connection issues
RPC errors

Conclusion

Congrtatulation now have a working Solana wallet balance checker API built with .NET!.