Algorand4_Unity 4.7.4.2026071920

Algorand .NET SDK (Algorand4)

A comprehensive .NET SDK for the Algorand blockchain (and AVM-compatible networks such as Voi and Aramid). It provides everything needed to build, sign, and submit transactions, query the chain, and interact with smart contracts from any .NET application (netstandard2.1), including a dedicated Unity build.

Full API documentation: https://scholtz.github.io/dotnet-algorand-sdk/

Table of contents

• Features
• Installation
• Quick start
• Core concepts
• Examples
• ARC56 smart-contract client generator
• Building and testing from source
• Versioning
• License

Features

• Algod client — generated from the official Algorand OpenAPI spec; query node state, submit transactions, simulate, and compile TEAL.
• Indexer client — rich queries over historical blocks, transactions, accounts, assets, and applications.
• KMD client — use an Algorand node's Key Management Daemon as a wallet/key store.
• Transaction model — strongly typed classes for payment, asset (ASA), application call, key registration, multisig, logic-signature, and rekeying transactions, with canonical msgpack encoding and Ed25519 signing.
• Atomic transfers — build and sign grouped transactions.
• ABI / ARC4 / ARC56 support — encode/decode ABI values and generate fully typed C# clients from ARC56 contract specs.
• Gossip network client — connect directly to the Algorand relay network and fetch blocks without an API service.
• Unity build — single ILRepacked assembly (Algorand4_Unity) that avoids Newtonsoft/CodeDom conflicts and supports WebGL via an injectable HTTP shim.

Installation

Install the Algorand4 package from NuGet:

dotnet add package Algorand4

or via the Package Manager console:

Install-Package Algorand4

For Unity projects use Algorand4_Unity, a single wrapped assembly usable directly in Unity. Its HttpClientConfigurator accepts an optional shim parameter so WebGL builds can delegate to a different HTTP client.

Quick start

1. Get a node

The fastest way to get a local Algorand node with funded test accounts is AlgoKit:

algokit localnet start

This starts algod on http://localhost:4001 and KMD on http://localhost:4002 (token: 64 × a), which matches the SDK's built-in AlgodConfiguration.DockerNet preset.

2. Connect, query, and send a payment

A complete, runnable program (full source):

using Algorand;
using Algorand.Algod;
using Algorand.Algod.Model;
using Algorand.Algod.Model.Transactions;
using Algorand.Utils;

try
{
    // Restore an account from a 25-word mnemonic.
    // On LocalNet: `algokit goal account list` then `algokit goal account export -a <address>`
    var src = new Account("arrive transfer silent pole congress loyal snap dirt dwarf relief easily plastic federal found siren point know polar quit very vanish ensure humor abstract broken");
    var DEST_ADDR = "5KFWCRTIJUMDBXELQGMRBGD2OQ2L3ZQ2MB54KT2XOQ3UWPKUU4Y7TQ4X7U";

    // Connect to a node. Presets: MainNet, TestNet, BetaNet, DockerNet (AlgoKit LocalNet), VoiMain, AramidMain
    using var httpClient = HttpClientConfigurator.ConfigureHttpClient(AlgodConfiguration.DockerNet);
    var algod = new AlgodClient(httpClient);

    // Query the node
    var supply = await algod.GetSupplyAsync();
    Console.WriteLine($"Total Algorand Supply: {supply.TotalMoney}");

    var accountInfo = await algod.AccountInformationAsync(src.Address.ToString(), null, null);
    Console.WriteLine($"Account Balance: {accountInfo.Amount} microAlgos");

    // Build, sign, submit, and confirm a payment transaction
    var transParams = await algod.TransactionParamsAsync();
    var amount = Utils.AlgosToMicroalgos(1);
    var tx = PaymentTransaction.GetPaymentTransactionFromNetworkTransactionParameters(
        src.Address, new Address(DEST_ADDR), amount, "pay message", transParams);
    var signedTx = tx.Sign(src);

    var id = await Utils.SubmitTransaction(algod, signedTx);
    Console.WriteLine($"Successfully sent tx with id: {id.Txid}");

    var resp = await Utils.WaitTransactionToComplete(algod, id.Txid);
    Console.WriteLine($"Confirmed Round is: {resp.ConfirmedRound}");
}
catch (ApiException<ErrorResponse> e)
{
    // Errors returned by the node carry details in e.Result.Message
    Console.WriteLine($"Error: {e.Result.Message}");
}

To connect to a custom node, pass the host and API token explicitly:

var httpClient = HttpClientConfigurator.ConfigureHttpClient(
    "http://localhost:4001/",
    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
var algod = new AlgodClient(httpClient);

Core concepts

Technical note: when specifying the host in HttpClientConfigurator, a trailing slash is automatically appended so relative URIs combine correctly. If you inject the HttpClient via DI yourself, make sure the base URL ends with a trailing slash (per RFC 3986 and the HttpClient documentation).

Examples

Complete, runnable examples live in the sdk-examples/ project. Each is a standalone Main that can be selected via the dispatcher in Program.cs (first CLI argument or the EXAMPLE environment variable):

dotnet run --project sdk-examples -- AssetExample

The test suites double as extensive usage references:

• test/Arc56Tests.cs — generating and using typed ARC56 contract clients (deploy, method calls, structs, boxes)
• test/Arc4Tests.cs — ARC4 ABI encoding and application calls
• test/TransactionTests.cs — building and signing all transaction types
• SerialisationTests/ — canonical msgpack encoding round-trips

ARC56 smart-contract client generator

The SDK includes a generator that turns an ARC56 contract spec (JSON) into a fully typed C# client proxy — method calls, structs, state, and box accessors included.

In code

using Algorand.AVM.ClientGenerator.ABI.ARC56;

var generator = new ClientGeneratorARC56();
generator.LoadFromByteArray(Encoding.UTF8.GetBytes(arc56Json));
var sourceCode = await generator.ToProxy("MyContractProxy");
File.WriteAllText("MyContractProxy.cs", sourceCode);

See test/Arc56Tests.cs for end-to-end examples that generate a client, compile it, deploy the contract to LocalNet, and call its methods.

Via Docker

The generator ships as the scholtz2/dotnet-avm-generated-client image.

Generate a client from a URL:

docker run --rm -v "$(pwd):/app/out" scholtz2/dotnet-avm-generated-client:latest \
  dotnet client-generator.dll --namespace "MyNamespace" \
  --url https://raw.githubusercontent.com/scholtz/BiatecCLAMM/refs/heads/main/contracts/artifacts/BiatecConfigProvider.arc56.json

Generate a client from the local filesystem:

docker run --rm -v "$(pwd)/contracts/artifacts:/app/out" -v "$(pwd)/contracts/artifacts:/app/artifacts" \
  scholtz2/dotnet-avm-generated-client:latest \
  dotnet client-generator.dll --namespace "MyNamespace" --file artifacts/BiatecConfigProvider.arc56.json

Options:

  -f, --file         Path to a local ARC56 JSON file.
  -u, --url          URL of an ARC56 JSON file.
  -n, --namespace    Namespace for the generated client.
  -o, --output       Output folder.
  --help             Display the help screen.
  --version          Display version information.

Building and testing from source

dotnet restore
dotnet build dotnet-algorand-sdk.sln --configuration Release --no-restore   # Unity build: --configuration Unity
dotnet test test/test.csproj                                                # main unit tests (needs AlgoKit LocalNet for ARC4/ARC56 fixtures)
dotnet test SerialisationTests/serialisation-tests.csproj                   # msgpack/canonical-encoding tests

Notes:

• test/Arc4Tests.cs and test/Arc56Tests.cs deploy contracts against a running AlgoKit LocalNet (algokit localnet start).
• Most of Algod/Model/ and DefaultApi.cs are generated from Algorand's official OpenAPI spec — edit the hand-written partial-class files (Foo.cs), never the *.generated.cs files. See CLAUDE.md for the full architecture overview.

Versioning

NuGet package versions (4.x and onward) track the version of the algod build the SDK targets.

Release note: in v4 the KMD client was completely reworked (breaking change), and full integration with the Algorand generator introduced minor capitalisation changes in some fields. The overall shape of the SDK is now stable.

License

Distributed under the GNU General Public License v3.0.

The package icon (icon.png) is derived from the official Algorand logomark, geometry sourced from Algorand_mark.svg on Wikimedia Commons, licensed under CC BY-SA 4.0.