OpenViSTAI · Agents · Blockchain · Crypto
Submit a project
Menu
Developer Tools

Algonaut

Algonaut is an open-source Rust SDK for building applications that interact with the Algorand blockchain. It provides asynchronous clients for algod, kmd and indexer, transaction builders, atomic transaction groups, and typed smart-contract clients generated from ARC-4 or ARC-56 specifications.

Explore the practical guide ↓

Independent OpenViST project profile, based on linked sources.

Algonaut — OpenViST project profile in Developer Tools.
OpenViST project illustration. See the linked sources for product details.
Understand the project

Practical overview

When it fits

Use Algonaut when an Algorand integration is being built in Rust and needs blockchain service clients, transaction construction, or typed contract-call workflows.

Who it is for

  • Rust developers building applications or services that connect to Algorand.
  • Teams implementing Algorand transaction, account or smart-contract integrations in Rust.

Documented uses

  • Connect Rust code to Algorand algod, kmd and indexer services.
  • Construct payment, asset, application, key-registration and state-proof transactions.
  • Group transactions and contract calls, simulate them, then sign and execute them.
  • Generate typed contract clients from ARC-4 ABI definitions or ARC-56 app specifications.
  • Compile or disassemble TEAL and decode V3 source maps.
Before you choose

Requirements & limits

The project is published as an open-source repository with an MIT OR Apache-2.0 license indication.

  • The SDK is pre-1.0, and its API may change between minor versions.
  • Its clients target algod v2, kmd v1 and indexer v2.
  • The signer interface includes Account and can be implemented for HSM, remote KMS or WalletConnect integrations.
  • The README reports 249 passing scenarios and zero failures in its cross-SDK acceptance suite on a live-node harness, while also listing capability gaps.

Check current requirements in the official documentation. Source-based guidance does not mean OpenViST has run or independently tested this project.

Source-based practical guide

Deploy and call an ARC-56 contract using an atomic group

Use algonaut’s documented Rust flow to deploy a typed contract client, simulate a method call, then sign and execute that group.

Before you start

  • A Rust application and an ARC-56 app specification at the path used by contract!.
  • An Algod endpoint and token available as ALGOD_URL and ALGOD_TOKEN.
  • An account mnemonic available as ALICE_MNEMONIC, and a signer with authorization to perform the transactions.

Steps

  1. Use algonaut::contract!("contracts/vault.arc56.json") to generate the typed client from the ARC-56 specification.

  2. Create an Algod client from ALGOD_URL and ALGOD_TOKEN; derive the sender and signer from the account mnemonic, then request suggested transaction parameters.

  3. Deploy with Vault::deploy, build the typed method call, and place it in an AtomicGroupBuilder.

  4. Simulate the group, then sign and execute that same group; query a generated global-state reader if needed.

Expected outcome

The example deploys a contract and returns a client bound to its app ID, then executes a method-call group and reads typed global state.

Guide limitations

  • The API is pre-1.0 and may change between minor versions.
  • The example’s ARC-56 specification must declare the method and argument types used by the typed call.
  • The documented sequence requires Algod access and a signer; deployment and execution submit transactions.
Documentation 1 ↗
Evidence and transparency

Sources & review

Official repository ↗
Source record details
Source availability
Active
Sources checked
13 October 2026
Original website title
manuelmauro/algonaut · Official homepage title · retained in its source language
How we review sourcesSuggest a correction