Algorand is the world’s first open source, permissionless, pure PoS blockchain protocol that’s dedicated to removing friction from financial exchange. PureStake has partnered with Algorand to deliver a pure PoS blockchain network that’s built atop an enterprise-grade network.

Read articles about Algorand and the technology that PureStake has built for the Algorand community.


AlgoSigner Algorand Wallet Announcement

AlgoSigner, the First Algorand Wallet Extension, is Now Available

PureStake’s New Open Source Extension
Paves the Way for DeFi Applications Built on Algorand

Boston, MA – August 27, 2020 – PureStake, a leader in secure and reliable blockchain infrastructure, announced today the availability of AlgoSigner in the Chrome Web Store. As an open-source browser plug-in, AlgoSigner provides a secure way for holders of the Algo token to interact with dApps without granting them control of their keys.

As a browser extension, AlgoSigner opens the door for developers to build DeFi applications on Algorand by providing a secure way to add transaction capabilities. This enables developers to initiate transactions and accept Algos seamlessly, without jeopardizing the security of their users’ secrets.

For an application like Monerium, a provider of licensed e-money for Algorand, AlgoSigner would enable individuals to send and sign e-money transactions without leaving their Chrome browser.

“Today’s launch of AlgoSigner is great news for the Algorand ecosystem,” said Sean Lee, Chief Executive Officer at Algorand Foundation. “We are delighted to have supported PureStake through the Algorand Foundation Grants program and excited to see what innovative applications the growing Algorand developer community can now create.”

The development of AlgoSigner was funded by the Algorand Foundation in April 2020 as part of the Grants Program. Projects can apply to receive grant funding from the Foundation on their website:

For end users, AlgoSigner also makes it easy to use Algorand-based applications on the web. Simply create or import your Algo account, visit a compatible dApp, and approve or deny transactions — all from within your browser.

DApp users can trust AlgoSigner to:

  • Securely store and encrypt account secrets
  • Authorize transactions without giving dApps direct access to their keys
  • Sign and approve transactions when using dApps

“Accessibility is critical in the widespread adoption of Algorand and cryptocurrency as a whole,” says Derek Yoo, CEO at PureStake. “We are pleased to have been able to work with the Algorand Foundation to create AlgoSigner, and we’re looking forward to seeing the dApps that emerge to take advantage of the fast and scalable transaction capabilities that Algorand provides.”

AlgoSigner currently supports both Algorand TestNet and MainNet.

To protect our users’ privacy and security, AlgoSigner has undergone a security audit by NCC Group in August 2020. Any findings have been addressed prior to release. We thank NCC’s Cryptography Services group for auditing the code.

About PureStake

PureStake’s team has extensive experience building technology companies and complex software platforms. Led by Derek Yoo, former Fuze Founder and CTO, PureStake provides protocol implementation services and creates developer tools for next-generation blockchain networks.

Algorand API v2 and Indexer v2

Algorand API v2 and Indexer v2: What It is and How to Prepare

As part of today’s 2.0.7 upgrade, Algorand released an important update to its Algod API — one that significantly alters the endpoints and will require some changes in order for you to use them. It also introduces a lot of great new functionality that wasn’t available in the previous version.

NOTE: PureStake has already released support for Algorand API v2 and the Indexer v2. Learn more by logging in to the API portal.

Here’s what you need to know.

Algod v1 Becomes Algod v2 + Indexer v2

The functionality that was part of Algod v1 is now separated into two distinct APIs:

  • Algod v2: Exposes new API functionality for a wider feature set and lays the groundwork for future releases. Endpoints, generally speaking, interact with the current ledger state and the blockchain — calls like supply, status, and pending transactions along with posting transactions and compiling Teal are supported here. New powerful private methods have also been introduced for node maintainers.
  • Indexer v2: A new indexer built as a separate binary that can run standalone or co-located with Algod. Supports singular write and multiple reader instances that leverage a database backend of your choice for faster lookups. Endpoints are designed for historical searching, including powerful features to understand account state at past rounds.

By and large, splitting the API and indexer into two binaries is a good thing. The Indexer works as a standalone service that reads committed blocks from the Algorand blockchain and maintains a database of transactions and accounts that are searchable and indexed. This means these stored blocks will be significantly faster to search and query. You’ll be able to natively:

  • Search and filter accounts, transactions, assets, and asset balances with many different parameters including:
    • Round
    • Date
    • Address (Sender|Receiver)
    • Balances
    • Signature type
    • Transaction type
    • Asset holdings
    • Asset name
  • Look up historical account data for a particular round
  • Result pagination
  • Enriched transaction and account data:
    • Confirmation round (block containing the transaction)
    • Confirmation time
    • Signature type
    • Asset ID
    • Close amount when applicable
    • Rewards
  • Human readable field names instead of the space-optimized protocol level names.
There are a number of additional technical improvements as well:
  • Abstracted database layer, to support many different backend databases.
  • Optimized postgres DB backend.
  • User-defined API token.
Here are a couple of important points to remember as you plan to migrate your project:
  • Although the Algod API v1 will become deprecated, it will continue to co-exist alongside v2 for some number of months.
  • When the v1 API is removed, it will become a breaking change so it’s important to update your API calls.
  • All the SDKs are updated already and can support the v2 features, but, there may be many changes to how the same task is executed between v1 and v2.

How to Migrate Code to the New API Endpoints

If you need to manually update, follow these steps as outlined by Algorand:

If you are currently using the PureStake Algorand API service, the new Algod v2 and Indexer v2 are already available. You will need to log in to see the new endpoints. This update includes the 2.0.7 upgrade for MainNet and TestNet, as well as support for BetaNet Algod v2, which was already live. We may release additional changes in the coming weeks as needed.

To plan your migration from v1 to v2:

  • Review the complete notes from the 2.0.7 release
  • Review the new official Algorand OpenAPI specification files for v2
  • Try it out in the Swagger UI in the PureStake developer portal when the networks are available, or with your favorite client software. PureStake will provide Swagger files specific to our service, endpoints may be subtracted from the full set listed in the OpenAPI specifications.
  • For each API call you are currently making, identify where it has migrated and, in cases where it may be in two places, review the returned data to understand which works better for your use case.
  • Update relevant Algorand SDKs to the most current versions for your projects and review the (in some cases) extensive differences between v1 and v2.
  • Expect continued refinements to the API services post-launch as the new capabilities are better understood.
  • Migrate sooner rather than later!

If you have any questions, please reach out to us on Telegram or create a support ticket.

Interacting with the Algorand Network Using the Python SDK and PureStake API

Using the Python SDK and PureStake API to Interact with the Algorand Network

The following is a very simple tutorial that uses the Python SDK and PureStake API service to interact with the Algorand network. Support for the PureStake API service was added to the Algorand Python SDK last year.

In this tutorial, I will show you how to create a simple Python program that sends an Algorand transaction and queries Algorand account balances using the PureStake API service (rather than running your own node locally or on a cloud server).

Today, syncing a node on the Algorand TestNet currently takes 2+ days with performant hardware and network connectivity. This will only get worse as time goes on and the blockchain grows. Using the PureStake API, you can get up and running immediately without having to wait for a node to sync.

Setting Up the Environment

The environment used in this article is Ubuntu 18.04 and Python 3.6.8, which we assume are already installed. We will be using the Algorand Python SDK which can be installed with Pip. If you don’t have Pip installed, you can install it with:

sudo apt install python3-pip

Pip will install the Python SDK with this command:

pip3 install py-algorand-sdk

You should use the editor of your choice to create the Python script. In my case, I will use Vim. If you are using Vim, here is a good vimrc configuration for syntax highlighting Python.

The next thing you will need is a PureStake API key. You can sign up for one here.

Using the Python SDK and PureStake API Step 1


Hit the Register for free option and fill out the registration form.

Using the Python SDK and PureStake API Step 2



You will need to supply a working email, as you need to confirm your email as part of the sign-up process. Review the T&Cs and click the “I agree to the Terms and Conditions” checkbox.

You will get an email with a registration code that looks like this:


Make note of the code you are sent and enter that code into the following screen when prompted:

Using the Python SDK and PureStake API Step 4


After submitting, you will be logged into the API Services application:

Using the Python SDK and PureStake API Home Page


Here you will see your API Key where the boxes are in the screenshot above. You will need to copy that key to be able to access the PureStake API service from the Python script.

Getting Started with the Python SDK

One of the best resources when developing against the Algorand Python SDK is the website. The SDK, along with code examples, can be found on GitHub here and SDK documentation here.

For our simple example script, we will begin by importing a few things from the SDK:

from algosdk import algod
from algosdk import mnemonic
from algosdk import transaction

There are many other objects that the SDK exposes, but we are only importing the ones we specifically need.

Set Up Accounts and Keys We Will Be Working With

In the snippet below we define two accounts to work with, along with the private key for one of the accounts:

mnemonic_secret = "ill purse chaos aisle build awful weather divert man blind sand matter venue heavy awake bachelor own access deer grunt donor nut tent absorb decade"
account_a_private_key = mnemonic.to_private_key(mnemonic_secret)
account_a = mnemonic.to_public_key(mnemonic_secret)

The secret mnemonic for account a is listed here in plain text, so do not use this account in your own programs. Anyone with access to this blog will be able to spend your funds. You should replace both of these accounts with accounts of your own creation.

You can fund your accounts on the TestNet by using the TestNet dispenser here.

Create the algod Client with a PureStake Key

The following commands construct an algod client object connected to the Algorand TestNet.

endpoint_address = ''
purestake_header = {'X-Api-key': purestake_key}
acl = algod.AlgodClient(purestake_key, endpoint_address, headers=purestake_header)

The value of purestake_key should be your key as shown in the PureStake API Services application home page. The X-Api-key header is specifically required when using the PureStake API Service. It replaces the X-Algo-API-Token header needed when accessing the Algorand node API directly.

Get Suggested Transaction Parameters

There are several parameters you need when you send a transaction in Algorand. The commands below set several of these useful transaction values:

params = acl.suggested_params()
gen_hash = params["genesishashb64"]
first_valid_round = params["lastRound"]
last_valid_round = first_valid_round + 1000
tx_fee = params["fee"]
tx_amount = 10000

Note that this code sets the first_valid_round to the current round or block height, and the last_valid_round as 1000 blocks in the future. When creating Algorand transactions, they have a maximum validity of 1000 rounds or blocks. We specify the transaction amount as 10000. This is 10000 microalgos.

Be very careful when using the Algorand API and command line as they both work with microalgos. You always need to double-check that you are sending the correct amounts.

Prepare and sign the transaction:

tx = transaction.PaymentTxn(account_a, tx_fee, first_valid_round, last_valid_round, gen_hash, account_b, tx_amount)
signed_tx = tx.sign(account_a_private_key)

These commands prepare the transaction tx and sign it using the private key mnemonic. At this point the signed_tx object is ready to send to the network.

Send the transaction:

tx_confirm = acl.send_transaction(signed_tx, headers={'content-type': 'application/x-binary'})
acl.status_after_block(first_valid_round + 2)

The acl.send_transaction call sends the signed transaction.

Note that the content type for this call needs to be changed to application/x-binary. This is specifically required when using the PureStake API Service, but not required when using the node API directly. The acl.status_after_block call will block execution of the program until two blocks have passed (approx 9 sec). We do this to make sure that our tx is committed to the blockchain before proceeding with the execution of our program. Without this wait, subsequent reads may not reflect the transaction we just sent.

Read back the account balance:

result = acl.account_info(account_a)
print(result["address"] + ": " + str(result["amount"]) + " microalgo")

These final commands retrieve and print the balance in account_a. Account_a has been reduced by 10000 microAlgos sent and a 1000 microAlgo transaction fee.

Putting It All Together

Here are all of the API calls above put together in a script that sends the transaction and prints out account balances.

# - toy program to illustrate the use of the algorand python
# sdk with the PureStake API service for querying account balances and
# sending algo from one account to another.
from algosdk import algod
from algosdk import mnemonic
from algosdk import transaction

# fund these 2 accounts with some initial algo via the dispenser:
mnemonic_secret = "ill purse chaos aisle build awful weather divert man blind sand matter venue heavy awake bachelor own access deer grunt donor nut tent absorb decade"
account_a_private_key = mnemonic.to_private_key(mnemonic_secret)
account_a = mnemonic.to_public_key(mnemonic_secret)

# Setup client with PureStake key
endpoint_address = ''
purestake_header = {'X-Api-key': purestake_key}
acl = algod.AlgodClient(purestake_key, endpoint_address, headers=purestake_header)

# get suggested parameters
params = acl.suggested_params()
gen_hash = params["genesishashb64"]
first_valid_round = params["lastRound"]
last_valid_round = first_valid_round + 1000
tx_fee = params["fee"]
tx_amount = 10000

# Create and sign transaction
tx = transaction.PaymentTxn(account_a, tx_fee, first_valid_round, last_valid_round, gen_hash, account_b, tx_amount)
signed_tx = tx.sign(account_a_private_key)

# Send the transaction
print("Sending " + str(tx_amount) + " microalgo from " + account_a + " to " + account_b + "...", end='', flush=True)
# note that the PureStake api requires the content type for the following call to be set to application/x-binary
tx_confirm = acl.send_transaction(signed_tx, headers={'content-type': 'application/x-binary'})
acl.status_after_block(first_valid_round + 2) # wait 2 blocks to make sure our tx has been committed

print("Sent " + str(tx_amount) + " microalgo in transaction: " + str(tx_confirm))

# Query resulting balances
result_a = acl.account_info(account_a)
result_b = acl.account_info(account_b)

print("Resulting balances")
print(result_a["address"] + ": " + str(result_a["amount"]) + " microalgo")
print(result_b["address"] + ": " + str(result_b["amount"]) + " microalgo")

except Exception as e:

Running the program produces the following output:

derek@derekdev:~$ ./
Sent 10000 microalgo in transaction: 2R6U4PAFRR6YU52ZA7E6N2UDBPCIEXTMQYGMGKBBWAEMRWF6MWGQ

Resulting balances:

Using the Algorand Python SDK with the PureStake API service is a quick and easy way to create programs and application logic that interact with the Algorand network without needing to set up, sync, and manage Algorand nodes.

GoalSeeker Algorand Explorer Announcement

Introducing GoalSeeker, A New Algorand Explorer

As you might have seen, PureStake released a new Algorand explorer, GoalSeeker, earlier today (which, by the way, is Algorand’s six-month anniversary of MainNet launch). We’re very excited for this release, since it’s an opportunity to build the kind of block explorer that we’d want to use ourselves.

At first glance, it might seem counter-intuitive for an infrastructure company to produce a software-based UI for tracking Algorand’s network data. But it actually makes a lot of sense for us as a showcase application for our indexed REST APIs: the project turned into a great way to highlight our infrastructure capabilities while at the same time supporting the Algorand ecosystem.

Why an Algorand Explorer?

Since the Algorand MainNet launch, our focus has been on the backend of Algorand applications — providing relay and participation nodes as well as an API platform. We felt that the ecosystem would benefit from an additional reliable application for viewing data on the blockchain. By creating GoalSeeker, we’ve provided the community with more options and another place to view and validate any kind of Algorand data they may need.

This aligns with PureStake’s core value of giving back to the networks of which we are part. We believe in the people and technology around Algorand technology and see view an explorer as an investment to help and grow the ecosystem.

GoalSeeker’s development was spurred when PureStake identified performance issues with a native Algorand node API query, internally dubbed “The Query of Doom.” This discovery led the team to create a managed backend datastore and a new API endpoint that could resolve the query performance issues. Like all of PureStake’s infrastructure, the backend was designed to be highly secure and reliable with no single point of failure.

Building this managed datastore opened up new possibilities to create a set of indexed APIs, but we needed a real-world use case for those APIs to help drive development. GoalSeeker served as a perfect use case, ensuring the backend APIs were useful and forcing us to “eat our own dog food” at the same time.

GoalSeeker Explorer Capabilities

GoalSeeker makes it easier than ever to view critical network statistics, browse recently created blocks, search for transactions and accounts in previous blocks, and review activity related to Algorand Standard Assets (ASAs).

At launch, you can use the GoalSeeker block explorer to:

  • Monitor Algorand transactions on both the MainNet and TestNet ledgers
  • View and search for blocks, transactions, accounts, and assets
  • Access a feed of the most recently created blocks and assets
  • Drill down into all assets and transactions associated with accounts
  • View vital network statistics at a glance, including total supply, online stake, exchange rate to USD, and the current block reward level

GoalSeeker is free to use and does not require an account. You can start using it by navigating here:

Future Adaptations and Enhancements

The release of GoalSeeker wraps up a big year for PureStake, which included launching an Algorand API service for developers, Algorand node infrastructure services for early network participants, and validator services for Polkadot’s BetaNet, Kusama. Each was designed to consistently deliver secure and reliable network access to ecosystem participants. We plan to continue this momentum into 2020.

As an infrastructure provider, we generally work backstage, helping applications run smoothly. But this Algorand explorer gave us an opportunity to take center stage for the first time by producing an end user application. Usability is a key issue that is hampering blockchain adoption, and we will continue to make investments into GoalSeeker which will hopefully, in turn, reduce friction related to the adoption of Algorand.

And it’s not just GoalSeeker that will be provided to the community; we plan to open up our new indexed REST APIs early next year to sit alongside our existing Algorand node APIs.

Blockchain Scalability Trade-offs Banner

Blockchain Scalability Trade-offs: How to Choose a Platform

Blockchain scalability is one of the most frequently cited reasons that blockchain adoption isn’t happening faster.

The truth is, most blockchain networks are slow when compared to traditional centralized technologies and networks like AWS or the Visa network. Ethereum, for example, can process transactions in the range of 15 transactions per second — and Bitcoin is even slower.

On the other hand, blockchain networks have unique properties, such as native digital scarcity and unstoppability, that cannot be achieved in the same way with centralized approaches.

As developers continue to experiment and iterate on novel uses of these properties in decentralized software applications, popular platforms are hitting up against scalability and transaction limits. In this context, blockchain scalability is widely seen as a limiting factor in further blockchain adoption among software developers and end users.

In response to these blockchain scalability issues, the community has poured a lot of energy into developing scalability solutions at Layer 2 (e.g. Lightning, Plasma) and migrating existing platforms to faster consensus mechanisms (e.g. Ethereum 2.0). These solutions are all interesting in their own right, but I would argue that they are less important for scalability than design decisions in the protocol itself, and the use cases which are being targeted by those designs.

Developers who are investigating which decentralized platform to build on should carefully consider their requirements and the design goals of the platform they are choosing relative to those requirements.  Two important trade-offs in order to achieve your optimum level of scalability for your application are the level of decentralization and the level of programmability that you require. Not every application needs maximum decentralization nor programmability.

The Top Two Trade-offs to Blockchain Scalability

Level of Decentralization

The Blockchain Trilemma

For those who are unfamiliar with the famous blockchain trilemma, it states that when designing a blockchain protocol, you can only have two of these three properties: security, decentralization, and scalability. The insight is that it is hard to achieve all three simultaneously.

From my point of view, the most interesting use cases for blockchains are related to the storage and movement of value, so any significant sacrifices to security seem like a non-starter.

The key point behind the trilemma is the relationship between decentralization and scalability. It is easy to achieve scalability if you sacrifice decentralization. For example, traditional deployments using AWS infrastructure achieve very high scalability in a centralized model. But in this deployment model, the key properties that make blockchains interesting — namely, native digital scarcity combined with unstoppability — disappear.

Some projects use this relationship to their advantage. Take the example of EOS. In the EOS network, there are 21 block-producing nodes. This is far fewer than Ethereum or Bitcoin. By becoming more centralized, EOS achieves far higher transaction throughput than either Ethereum or Bitcoin. Twenty-one nodes isn’t totally centralized, but it is much more centralized than many other blockchain networks.

EOS’s goal is to be decentralized enough to keep the most interesting blockchain properties intact, but centralized enough to achieve significantly higher performance than competing blockchain networks. The question to ask yourself as a DApp developer is, what level of decentralization does your use case require? How worried are you about censorship of your application? Many high-value-oriented use cases may require higher levels of decentralization; for others, it may not matter.

Level of Programmability

The level of programmability that is supported by a blockchain protocol is at least as important a factor for blockchain scalability as decentralization. The key question is, what use cases are your applications going after, and what level of on-chain logic do you need to achieve your goals?

I can think of a range of applications with varying needs for platform programmability, running from money and asset transfer use cases on one end of the spectrum to Web3/decentralized applications on the other end of the spectrum. A money transfer application, a securitized tokenization platform, or a marketplace for digital collectibles may be perfectly well served by a platform that supports a rich set of asset transfer use cases. Whereas, a DAO or decentralized exchange that needs extensive onchain logic would require a full Turing-complete programming environment.

All other things being equal, platform scalability degrades as you move toward a more decentralized model. Bitcoin seems to be an exception to this rule as it is firmly on the “money” end of the spectrum, but it also isn’t scalable. The point is that Bitcoin would be even less scalable if it had full Turing-complete smart contracting functionality.

Platform scalability also decreases as you add Turing-complete smart contract functionality. With Turing-complete smart contracts, you need a gas concept to meter contract execution and produce deterministic behavior, which adds fees and operational costs to your application. You also need to allow smart contracts to store arbitrary state or data on the chain, which leads to more fees and increased storage requirements for the underlying blockchain nodes. Most smart contract platforms have a single one-size-fits-all virtual machine for all contracts on the platform, which can also become a scalability bottleneck. All of these factors reduce the scalability and throughput of Turing-complete smart contract platforms.

Opposite Ends of the Blockchain Scalability Spectrum: Algorand and Ethereum

Let’s take a couple of concrete platform examples to illustrate the point.

Algorand Prioritizes Performance Over Turing-Complete Programmability

Algorand is a high-performance, next-generation blockchain that focuses on the money and asset end of the design spectrum, and is also highly decentralized (unlike EOS). It achieves very high performance and transaction throughput by focusing on money, asset, and asset transfer use cases and doing them well.

Algorand’s new scripting language, TEAL, is intentionally non Turing-complete to avoid the gas fees, arbitrary storage, and infinite loops that come along with Turing-complete smart contract platforms. These are specific choices that allow it to achieve high performance for the money, asset, and asset transfer scenarios. This is why applications supporting these use cases that have high throughput requirements, such as Tether and Securitize, are porting their applications to run on Algorand.

However, if your use case requires Turing-complete onchain logic such as DAOs, onchain DEXes, or the development of onchain decentralized protocols sitting above the base protocol layer like Compound or 0x, then the level of programmability in Algorand isn’t as good of a fit.


Ethereum Prioritizes Turing-Complete Programmability Over Performance

By contrast, Ethereum is the most prevalent full smart contract platform. Ethereum puts programmability first, at the expense of throughput and scalability.

Scalability issues on Ethereum result from arbitrarily complex logic execution and arbitrarily large storage that comes along with its smart contracts. Logic and storage are metered by gas fees, and these fees have increased over time as the number of smart contracts has increased. The underlying blockchain on an Ethereum full node (let’s leave out archival nodes for now) takes over 100GB of storage and growing. Ethereum has a small fraction of the scalability of Algorand from a transaction-per-second and node storage perspective.

However, what you get in return is the ability to express arbitrary smart contract logic in the Ethereum virtual machine. And since all the programs run in the same virtual machine, you get composibility between different contracts which is driving a lot of advances in the DeFi space right now.

For DApp developers, you should carefully consider which parts of your application need to be de-centralized / onchain, and if you really need a full Turing-complete smart contract language to build your application. Turing-complete smart contract platforms allow for arbitrary expressions of onchain logic, but often at a cost in terms of scalability and throughput.

Choosing the Right Platform for Your Application

The scalability of the underlying platform is a critical part of choosing where to build. Even if your application itself doesn’t need high levels of scalability, those scalability challenges inevitably lead to high transaction fees, which will increase your operating costs as an application project, and may make certain use cases unviable from an economic perspective.

You should carefully consider the level of decentralization and programmability you need to support your use cases when choosing a platform. For a use case that requires only an ERC-20 contract on Ethereum, but does not require interoperability with other Ethereum smart contracts, it may make sense to look at platforms that are optimized for this scenario, such as Algorand. On Ethereum, you could be paying a lot more unnecessarily without realizing the benefit of the increased programmability.


Algorand Node API Acceleration

Accelerating Performance of the Algorand Node API

It’s been a few months since we launched our Algorand API as a Service. In that time, we have gotten a lot of great feedback on what is working well and what still needs more work.

One thing we have heard and observed ourselves is that certain operations time out and don’t return any data. Digging into this, we observed that one of the queries that we provide has highly variable performance associated with it. Our API service is fronting pools of Algorand nodes, and calls are serviced by the Algorand Node Rest API on these nodes. The performance issues we are seeing are issues with a specific query to the Node Rest API itself.

The /v1/account/{address}/transactions Endpoint

The REST endpoint that has the performance issues is /v1/account/{address}/transactions. This query is only available if you run a full archival indexer node.

The purpose of this endpoint is to be able to query the transaction history for a given account. It is a useful query from a developer point of view as you could use it to, for example, populate a transaction history when looking at an account in a wallet or other application.

Sometimes, this query returns quickly and sometimes, the query times out. By default, the query has a max result set of 100. The current behavior of the query is that, given an account, the indexer node will start walking backwards from the head of the chain looking for transactions to fill its result bucket that meet the query constraints.

This becomes problematic for accounts with relatively low transaction volume. If there has been a lot of transaction activity on the account, the query will reach the result set limit quickly and return. If there has not been a lot of transaction activity, it will keep walking backwards — all the way to genesis — looking for transactions that meet the query criteria. In this second, low-transaction activity scenario, the query generally times out and also has the side effect of making the node unresponsive to other queries.

This second scenario is problematic, since users are actively hitting this endpoint, which starts taking nodes in our node pools offline for periods of time. While we have plenty of capacity in our node pools, if enough of these queries were received in rapid succession, we could suffer an outage due to a kind of denial of service situation.

Even for accounts that have a large transaction volume, when parameters restricting the scope of the search are used, for instance fromDate and toDate, the query becomes non-performant and the service suffers.

Improving the Endpoint with a Backend Datastore

First, it is important to recognize that the node can’t be optimized for every situation. It already performs a variety of different roles including supporting consensus, relaying, etc. However, given the current behavior of this query, we must provide an improved path to our customers so they can reliably retrieve transaction data.

We have decided to replace the backend handler for this query with a datastore that is optimized to return results much more quickly and efficiently.

This backend datastore is based on AWS Aurora and includes a set of AWS lambda data management routines to keep this datastore reliably in sync with the Algorand TestNet, MainNet, and BetaNet. Queries coming into this particular endpoint will be serviced by this new datastore. All other queries will remain serviced by our node pools.


Philosophical Questions

The direct node API represents the truth in terms of the state of the Algorand blockchain. The downside to servicing this query with an alternate third-party data store is that there is a chance that the third-party will return the wrong data due to a bug or other problem with the infrastructure.

At PureStake, we spent some time debating this situation. We could have just turned off the endpoint, but that didn’t seem like a good solution, and certainly not helpful to developers trying to build on Algorand. After all, this is a useful query to have available for a variety of use cases.

Additionally, we had to consider that the way the query works against the node isn’t necessarily what most developers want. Even for the scenarios where the query returns — accounts with high transaction activity — you only get the last 100 transactions, not all of them.

In the spirit of providing a solution to the intent behind this endpoint, we decided to move ahead with offering a more performant version of this query, while at the same time making it compatible with the available SDKs. However, we will clearly distinguish between queries that are serviced by the node and ones that are serviced by other infrastructure we are running. We will mark this particular query in the response headers and in our portal as being serviced in a different way to the other node api queries. We feel this approach strikes a good compromise and helps developers building on Algorand.

Comparative Performance of the New Endpoint

To take a concrete example, the following query when run against a TestNet indexer node will time out (on a reasonably spec’d machine):


The state of account EWZYOHWLR2C44MDIPNZMOGZMAAY66BWI2ALGJB2NE22TWO7YGNCS7NTFVQ is that it has 2 transactions in its history, less than the 100 max results query limit, so the node will start walking back towards genesis looking for transactions. The query times out in 30 seconds for API users, but will continue running on the node until complete – in a test for this article the query was manually stopped after 25 minutes. The io / iops on the node goes very high while the query is running on the node and consumes the allotted burst capacity, eventually locking the machine up.

Backed by the new datastore queries to this endpoint return in under 1 second generally or 3 seconds or under from a cold lambda start .

Next Steps and Future Direction

It isn’t possible for the node to achieve high performance for all queries.

PureStake’s new datastore will be the basis of a new query-optimized set of endpoints that will be offered alongside the node-based APIs. These APIs would be well-suited to certain types of applications, such as explorers, wallets, etc. However, users will have the choice to opt for the node-backed APIs or the query-optimized APIs, depending on their preferences.

PureStake will likely continue to create different kinds of optimized data stores over time in order to support different types of queries and use cases. A de-normalized data warehouse is another obvious optimization for aggregate and over-time type data queries that aren’t possible with the current node API.

We may remove our query-optimized endpoint for this specific node API in the future, if the performance and behavior of the underlying node API changes.

Are there other APIs or features you would like to see added to the PureStake API services application? Reach out to us and let us know.


Banner for Demystifying Algorand Rewards

Demystifying Algorand Rewards Distribution: A Look at How & When Algorand Token Rewards Are Calculated

The Algorand Proof of Stake network issues rewards to its token-holders in order to stimulate and grow the network — but it’s not always clear how these returns are calculated. In this article, I’ll outline the basic framework of the Algorand rewards distribution model, and walk through some potential impacts it could have on the rewards calculations for current token-holders.

What are Network Rewards?

Traditional Proof of Work (PoW) based blockchains (BTC, ETH) rely on miners to validate transactions and record them in consecutive blocks on the ledger. In this effort, the miners compete against each other by solving complex mathematical problems. The miner with the winning block gets a certain amount of tokens rewarding them for their work in return.

This basic economic principle provides the incentive to support the required infrastructure to run the network. One of the major flaws of PoW networks is the unproductive effort put into competing for mining blocks, resulting in relatively slow performance and huge amounts of energy wasted.

The Algorand blockchain, like many newer blockchain networks, is solving the inherent issues of PoW with the concept of Proof of Stake. Unlike PoW miners, PoS networks rely on validators to verify transactions written to each block on the chain.

Algorand chooses its validators using a process called sortition with a selection preference towards validators holding the largest amount of tokens, referred to as stake. Just like miners, the validators receive rewards for their work, but unlike PoW, no resources are wasted on unnecessary, competing work.

The rewards are typically a percentage yield of return on the amount of stake a validator is holding. That way, the economic incentives for validators are directly linked to the amount of stake as a motive for supporting the network i.e. the higher your stake, the more interest you have in contributing to the health of the network, and the more rewards you earn.

How are Rewards Distributed on Algorand?

Algorand currently deploys a more liberal rewards scheme in order to benefit every token holder whether or not their tokens are staked and participating in the consensus protocol. The idea behind this is to stimulate the adoption and growth of the network by rewarding all token holders equally. To support the operation of the network during this initial period, Algorand has issued token grants to early backers for running network nodes to help bootstrap a scalable and reliable initial infrastructure backbone.

As the network grows over time, I anticipate that the rewards distribution will shift favoring active stake-holders and validators.

Algorand Rewards Distribution Schedule

The current rewards distribution is determined and funded by the Algorand Foundation. You can read a detailed explanation of the overall token dynamics here.

The first 6M blocks on the Algorand blockchain have been divided into 12 reward periods of 500,000 blocks each. Each period is funded by an increasing amount of reward tokens to offset the increasing total supply of tokens. The token supply periodically increases due to early backer grant vesting and token auctions facilitated by the foundation.


Period Start Date (estimated) Starting Block Ending Block Rewards Pool (Algo) Block Reward (Algo)
1 6/10/2019 1 499,999 10,000,000 20
2 7/7/2019 500,000 999,999 13,000,000 26
3 7/31/2019 1,000,000 1,499,999 16,000,000 32
4 8/25/2019 1,500,000 1,999,999 19,000,000 38
5 9/20/2019 2,000,000 2,499,999 22,000,000 44
6 10/15/2019 2,500,000 2,999,999 25,000,000 50
7 11/10/2019 3,000,000 3,499,999 28,000,000 56
8 12/5/2019 3,500,000 3,999,999 31,000,000 62
9 12/31/2019 4,000,000 4,499,999 26,000,000 52
10 1/25/2020 4,500,000 4,999,999 18,000,000 36
11 2/20/2020 5,000,000 5,499,999 13,000,000 26
12 3/16/2020 5,500,000 5,999,999 13,000,000 26
Algorand Network Rewards Schedule
Note: The rows highlighted above are reflecting the updated rewards schedule as implemented by the Algorand Foundation on December 17, 2019.

Distribution Mechanics

At the time of writing, we have just entered the sixth period of the current rewards distribution schedule. According to the schedule, 50 Algo are distributed as network rewards in each block, approximately every 4.4 seconds.

Algorand rewards are calculated each block based on the account balance of every to-or-from address recorded on the blockchain. The minimum account balance that is eligible for receiving rewards is currently 1 Algo.

If you monitor any eligible account, you will notice that the account balance doesn’t get the rewards applied at every block, but after a certain number of blocks instead. This is a function of the smallest unit of Algo that can be disbursed by the system, which is 1 MicroAlgo (10-6 Algo).

Since the minimum balance is currently 1 Algo and the smallest reward is 1 MicroAlgo, you can calculate the number of rounds it will take for rewards to be credited using this formula: Formula to calculate Algorand rewards: rounds equals ten to the negative sixth power divided by the product of block reward times total supply

With a supply of 2,103,868,588.605500 Algo at Block 2550212 and a Block Reward of 50 Algo, a reward of 1 microAlgo is dispersed for each Algo held every 42 rounds or roughly every 3 minutes. This will obviously change as the total supply grows.

Rewards APR vs APY

When you check the account balance of any address, the node API will return the balance that was last recorded on-chain plus any accrued rewards. The combined balance will not be written to the blockchain until the address appears in an actual transaction. In other words, rewards are only committed to the account balance on the blockchain when the address appears in a to-or-from address as part of a transaction. This is expected behavior, as ongoing, immediate on-chain updates of the balances of all eligible accounts on every round would pose a serious performance challenge.

There is a small but important consequence of this behavior. As pointed out earlier, rewards are calculated based on the recorded on-chain balance for each account. That means that none of the accrued rewards are included in this ongoing calculation. In essence, it is not compounding the accrued rewards interest. For accounts with large account balances, the difference in reward returns can be significant.

The current daily rewards percentage return based on the assumption of 1 microAlgo every 3 minutes is:

Equation to Calculate Daily Rewards Percentage: the number of minutes in a day which is 24 times 60 divided by the product of 3 minutes times ten to the negative sixth power times one hundred percent equals 0.048 percent

At the time of this post, an account that is holding 1M Algo would generate about 480 Algo per day or 172,000 Algo per year in rewards with an effective APR of 17.52%. If the rewards were compounded on a daily basis the effective APY would increase to 19.15%. These numbers will change over time as the rewards schedule changes, the total supply grows and transaction fees may increase.

Rewards Compounding

Compounding rewards is simple. Since rewards are calculated from the last recorded balance on the blockchain, the easiest way to force rewards compounding is to send a zero Algo payment transaction to the target address on a frequent, recurring basis. This transaction will trigger the commit of all accrued rewards and record them to the on-chain balance of the account.

So what is the ideal compounding frequency if you want to maximize your rewards?

For one, it doesn’t make sense to send compounding transactions more frequently than the number of rounds it takes for rewards to be disbursed, currently >3 minutes. Secondly, every transaction has an associated transaction fee, currently 1,000 microAlgo. This means the cost of these transactions shouldn’t outweigh the gains achieved by compounding.

Given that:

Rewards APR 17.52%
Transaction Fee 0.001


Net Compounding Rewards Interest at Specific Account Balances
Account Balance 50,000,000.000000 5,000,000.000000 50,000.000000
Annual Simple Rewards Interest 8,760,000.000000 876,000.000000 8,760.000000
trx Frequency trx/Year trx Charge Net Comp Rewards Int Rewards APY Net Comp Rewards Int Rewards APY Net Comp Rewards Int Rewards APY
10 min 52,560 52.560 9,574,154.528546 19.15% 957,368.148855 19.15% 9,521.647089 19.04%
Hour 8,760 8.760 9,574,111.351504 19.15% 957,403.251150 19.15% 9,565.360112 19.13%
2 x Day 730 0.730 9,572,971.479139 19.15% 957,296.490914 19.15% 9,572.242209 19.14%
Day 365 0.365 9,571,719.996054 19.14% 957,171.671105 19.14% 9,571.355361 19.14%
Week 52 0.052 9,556,683.398054 19.11% 955,668.293005 19.11% 9,556.631450 19.11%
Month 12 0.012 9,498,812.777423 19.00% 949,881.266942 19.00% 9,498.800789 19.00%

The cells highlighted in the table above show the maximum return achieved at certain compounding frequencies for specific account balances under the current conditions. It also illustrates that there are diminishing returns at higher rates and that, for most cases, a daily compounding transaction will suffice to get the core benefit of compounding rewards.


At the current time staking is not required to earn rewards. Any address holding at least 1 Algo is automatically receiving rewards that are distributed every n rounds (blocks) as outlined above.

Clearly some frequency of rewards compounding always makes sense for long-held account balances (e.g. staked balances). Since rewards are currently equally distributed across all accounts whether they are staked or not, the returns represent more of an inflationary rate across the entire supply rather than an interest return for node operators or staked balances.

It is also important to note that the compounding gains are significantly exaggerated at this time due to the already high rewards interest and the low transaction fees. You will need to evaluate what amount of compounding makes sense for you, based on changing parameters and held account balances.

PureStake automatically compounds all customer accounts that are staking with us. Please reach out to us if you would like to learn more about this and our services.

Further reading:


February 20th, 2020
Parts of this post have been updated to reflect changes in the rewards schedule and to add further clarification.


Vanity Algorand Address Generation Banner

Struggling to Organize Your Algorand Addresses? Use This Utility to Generate Vanity Addresses

Everybody has had that experience of second guessing yourself after sending a transaction. Did I send to the right address? Did I mistype a character? Why isn’t the transaction showing up in the explorer?

Algorand addresses consist of a random collection of 58 capital letters and numbers. Working with these addresses can be challenging, as they don’t have any meaning. Getting the address wrong by even one character often means that funds are lost forever.

Some wallets allow you to name addresses, but these names are only available in the context of the wallet. There are projects such as Ethereum Name Service which aim to provide a DNS-like mapping from human-readable names to Ethereum addresses, but this service is specific to Ethereum and cannot be used for other chains like Algorand.

Vanity Algorand Addresses Make It Easier

Think about phone numbers from the pre-mobile era.

For most people, phone numbers aren’t meaningful by themselves. Back then, you committed phone numbers to memory in their entirety for family and friends. To introduce more meaning, businesses would often purchase vanity phone numbers that were easy for their customers to remember.

But when it comes to crypto accounts, raw addresses are far too long to remember in their entirety, so users — at best — remember the first few and last few characters.

Much like vanity phone numbers, vanity crypto addresses can be a way to make addresses more meaningful and easier to remember without the need for additional services. We might generate an address that starts with the string “PURE” to show that the account belongs to PureStake, or we might create a 5-letter customer code to help us remember which customer the account is for.

How to Use the Algorand Vanity Address Utility

I’ve created a small utility for generating Algorand vanity addresses. It can be used to generate addresses that start with a specified string. The time taken to generate a given address is dependent on the underlying computer hardware and, most importantly, on the number of characters you specify. 5 or 6 characters is the practical limit for a string that will finish in a reasonable amount of time.

The vanity generator can be downloaded here:

It is written in Python and tested on Ubuntu 18.04. It requires python3, pip3, and py-algorand-sdk. It does not require a full Algorand node installation.

If you don’t have pip3 you can install it with:

sudo apt install python3-pip

With pip3 installed you can install py-algorand-sdk:

sudo pip3 install py-algorand-sdk

At this point, you should be able to run the program. Let’s generate an account that starts with “PURE” that we can use as an internal company account. You pass the string you want to look for as an argument to the program.

derek@puredev:~/py$ ./ PURE
Detected 2 cpu(s)
Found a match for PURE after 2431449 tries in 123.83 seconds
Private key: noble city arrest oyster pluck tennis toast flip same business drum below flame must lonely gorilla you local turtle desk suspect anger basic abandon upper

Or in the case of customer accounts, lets create a couple numbered accounts of the form CXXXX where XXXX is a customer id. Note that there is no 0 or 1 in Algorand addresses:

derek@puredev:~/py$ ./ C2222
Detected 2 cpu(s)
Found a match for C2222 after 9893404 tries in 499.07 seconds
Private key: swarm famous entry paper pause always magic hire burden aisle attack spring sport custom lend treat client burst decrease dad access pumpkin bulb ability blood
derek@puredev:~/py$ ./ C2223
Detected 2 cpu(s)
Found a match for C2223 after 17209546 tries in 892.68 seconds
Private key: dignity napkin faculty air mean mother crisp party spoon resource hub exhaust stand above logic siren book lock shallow shallow index copper hundred absent bring

The program works by simply brute-force generating address/key pairs over and over until it finds a match. There is no shortcut here, as any shortcut would represent a security problem for someone trying to guess the key for an existing account. The activity is similar to a Proof of Work mining algorithm.

If you use to generate vanity addresses make sure you do it on a secure machine, and that you take appropriate security precautions with the generated private keys. The script will take advantage of all the cores it finds on the machine.

Feel free to use to generate more meaningful addresses for your business accounts, or maybe just for fun.

How to Set Up a Ledger Nano S with an Algorand Account

Security Check-up: How to Use Ledger Nano S to Secure Algorand Accounts

Key management can be very stressful to cryptocurrency investors and users who control a large amount of crypto funds. Despite your best efforts, it can be very easy to compromise a key that has had any exposure to the internet, or to hijack a user’s phone, in order to steal their digital assets. So it’s no surprise that hardware wallets have taken over as a popular (and effective) counter-measure for hackers seeking to gain access to your private keys.

Hardware wallets do have some limitations, though. In this article, I’ll briefly review some important points to consider before employing a hardware wallet, and then I’ll provide a step-by-step walkthrough on how to set up a Ledger Nano S in order to better secure a cryptocurrency account (in this case, an Algorand account).

Why You Should (or Shouldn’t) Use a Ledger

Hardware wallets such as the Ledger Nano S offer significant advantages over software-based wallets.

First, there’s the physical security element. By storing private keys for an account in a secure element within the hardware device, it becomes very difficult for an attacker to steal the private key for your account without having physical access to the device and knowledge of the PIN for the device.

By keeping the private key on a hardware wallet, you also reduce the risk of malware and other online attacks from compromising your account spending keys, since the keys never leave the physical device.

HOWEVER, hardware wallets can be finicky and difficult to use.

For example, in Algorand, only the command line tools support the Ledger device.  So that means that you cannot use a Ledger with the Algorand mobile wallet, at least as of right now.  Only the Ledger Nano S is supported; the Nano X is not yet supported. Using a Ledger on Algorand means you are limited to apps that specifically have Ledger support.

The Ledger also only supports a single key, so multisig configurations will require multiple ledger devices which adds complexity.  Ledger support is planned for the Algorand mobile wallet application at some point, but it is not clear when this will happen. To use a Ledger with your Algorand account today requires comfort at the command line.

So, to recap:


of Using a Hardware Wallet to Secure an Algorand Account


of Using a Hardware Wallet to Secure an Algorand Account

  • Difficult to steal the key without physical access to the device
  • Less likely to fall victim to malware & other online attacks
  • Applications must explicitly support wallet hardware.  Currently only command line supported in Algorand for Nano S
  • Limited multisig support requiring complex multi-device and multi-step process


How to Set Up the Ledger Nano S for Use With Algorand

To use a Nano S to secure an Algorand account, you first have to go through the basic setup of the Nano S. For this article, I’m going to assume that you are starting with a fresh Ledger Nano S that will only be used to store ALGOs securely.

To start, you will download the Ledger Live application to your computer. Ledger Live is what you use to manage the applications on your Ledger device. You can download Ledger Live here.

Once you install it and plug your Nano S into your computer, click the “Get Started” button. You should see this screen:


Get Started with a Ledger Nano S on Ledger Live Screenshot


When initializing a new device, the first step is to choose a PIN code:


Choose Your PIN Code in Ledger Live


You should follow the steps in the Ledger Live application and on your Ledger Nano S device. There are 2 buttons at the top of the device. Hitting both buttons simultaneously acts as the “Enter” option.

Again, since I’m assuming this is a new device, you will want to elect to configure it as new. This will wipe out any previous configurations on the device.


How to Set Up a Ledger Nano S as a New Device


The next step is to choose a PIN code.  This is a critical step to preventing someone who steals the device from being able to use it to access your funds.

Follow the prompts on the device and Ledger Live app closely, and use the left and right buttons on the device to select a PIN code.  It should at least be 6 digits long. Hitting both buttons advances you to the next position. The selecting the check mark will indicate that you are done.


Choose a PIN Code for Your Ledger Nano S


The next step is to write down the recovery phrase for the device. This is critical. In case you ever lose the device or if it malfunctions, you will be able to restore the account to another device. The Ledger Live app walks you through this:


Write Down the Recovery Phrase in Ledger Live So You Can Recover Your Ledger Nano S Later


You will need to write down all 24 words of the recovery phrase, and you will be tested to make sure you have written down all the words.


Confirm the Recovery Phrase of a Ledger Nano S


Once you have verified the recovery phrase, the base setup of the Ledger is complete.

Next, you need to use the Ledger Live application to install the Algorand application onto the device. Go to the manager section of the Ledger Live app, search for “algorand” and click to install the Algorand application.


Install the Algorand Application in the Manager Section of Ledger Live


Once the application is installed on the ledger, you should see the Algorand app as shown below.


Install Algorand on Ledger Live to Use with Your Ledger Nano S


The installation of the Algorand app on the ledger created an Algorand account and stored the private key of the account on the secure element of the Ledger device. The private key never leaves the device, but you can see the account address if you go into the Algorand app on the device under “Address”:


View a Public Account Address on a Ledger Nano S


Using the Ledger From the Algorand Command Line

Now that we have the ledger configured with the Algorand app, it is ready to use with an Algorand node installation.

In my examples below, I have an installation of Algod installed from the Debian package running under Ubuntu 18.04 with a synced blockchain. I have plugged in the Ledger device to the computer with Algod on it.

The first thing we can do is look to see that the Ledger device has been recognized. We can do this with the “goal wallet list” command:


ubuntu@ubuntu:/var/lib/algorand$ sudo goal wallet list -d /var/lib/algorand
Wallet:    Ledger Nano S (serial 0001) (default)
ID:    0001:000a:00
ubuntu@ubuntu:/var/lib/algorand$ sudo goal account list -d /var/lib/algorand


Note that the ledger shows up as a wallet on this computer once it is plugged in. I did not create this wallet with the “goal wallet new” command. It was created for me when I plugged in the ledger device. Issuing the “goal account list” command shows the single account on the device and the balance of that account, which is 0. I also did not create this account with the “goal account” command, it simply came along with the wallet that was automatically created.

When you list the accounts, if you get the error message “Error processing command: Exchange: unexpected status 680.” This means that you need to unlock the Ledger with your PIN. It should work after that.

In this example, the Algod node is on the TestNet. In order to try out a transaction, let’s use the TestNet dispenser to give our Ledger account some testAlgo:


Issue Algo Using the Algorand Dispenser


Using the dispenser, we issue 100 testAlgo to our account. After dispensing the Algo we can verify the balances using the “goal account list” command again:


ubuntu@ubuntu:~$ sudo goal account list -d /var/lib/algorand


Note that the account now has 100,000,000 microAlgos or 100 Algo in it. Now that we have a balance, let’s try sending a transaction from this account. To do this, we will use the “goal clerk send” command to send 1 Algo to another account:


ubuntu@ubuntu:~$ sudo goal clerk send -a 1000000 -f Y2I3YF5AHFBMRUNKKXY6VPOT6QITCQMXSB5RDM2LG2IE74HGLDIROANCNE -t OBONCJ4D4WEUYFWRDLZEJOMAN22HWZGZPAEWSPK7S6VOIHDCAFR3ACUSTA --note "" -d /var/lib/algorand


Note that the –note option with the empty string is needed, as the Ledger does not support values for the notes field and it will complain if you don’t explicitly specify the notes field to be blank.

Once you issue this command, you will be prompted on the ledger to sign the transaction. Recall that the private signing key for this account never leaves the secure element of the ledger, so the signing action happens on the ledger device:


How to Initiate a Transaction on a Ledger Nano S


There are a bunch of details about the transaction that you are shown on the ledger device including sender, firstvalid round, lastvalid round, genesis id, genesis hash, receiver, and amount. You will ultimately be asked if you want to sign the transaction:


Sign a Transaction on a Ledger Nano S


If you click yes, you will see progress on the Algod command line:


Transaction TSTO3YZJAJJFL433VTMWGPEA6FKAEW34JYP32RAM7DCZV7ITIP6Q still pending as of round 2060606
Transaction TSTO3YZJAJJFL433VTMWGPEA6FKAEW34JYP32RAM7DCZV7ITIP6Q committed in round 2060608


Note that if you take too long, the operation can timeout on the Algod side, requiring you to start over.

Once we have completed the transaction we can view the balances for the account once again:


ubuntu@ubuntu:~$ sudo goal account list -d /var/lib/algorand


You can see that our account that had 100 Algo in it now has 98.999000 Algo in it. 1 Algo was sent to OBONCJ4D4WEUYFWRDLZEJOMAN22HWZGZPAEWSPK7S6VOIHDCAFR3ACUSTA, and there was a 1000 microAlgo transaction fee on top of that getting us to the resulting balance.


A multisig transaction example using Algo and an Algorand wallet

A Multisig Transaction Example: 5 Steps to Sending Algo Securely with an Algorand Multisig Account

Multisig transactions are a great deal more secure than single-key transactions, and for good reason: you’re removing a single point of failure, and distributing signing responsibility to a greater number of keys. However, this can add a great deal of effort to the transaction process when it comes time to send your funds to another account.

In this article, I’ll walk you through an offline multisig transaction example using an existing Algorand account (follow the steps in this article if you have not already created an account). While this example shows you how to spend funds, the same steps will apply to registering a participation key, bidding on auctions, and (in the future) voting.

To begin, let’s review all the things we have so far:

  • An online computer with a working Algorand node installation.
  • An “Ubuntu” bootable USB drive, which can be used for an offline computer.
  • A “Keys” USB drive with algokey and a file with the keys for our multisig account
  • A “Transfer” USB drive for transferring files between the online and offline computers

We will use these components to securely send a transaction from our multisig account while keeping our spending keys totally offline. The process will be:

  1. Create an unsigned transaction on the online computer
  2. Move this transaction file to the offline computer
  3. Sign the transaction on the offline computer
  4. Move the signed transaction back to the online computer
  5. Send it to the network

1. Prep Spend Transaction and Save Out to tx File (Online)

The process starts on the online computer. We will prepare an unsigned transaction file that describes the transaction we want to execute. Our transaction will be to send 1 Algo from the multisig account we created in this post to a destination account with address: 5DJNGUEXNRUKAQODHGO3KS2HXOHN4YMSLSZQGEAH5L3WMMDFKMZEQMURUY.

Open a terminal on the online computer and issue the goal node status command:

purestake@algo-node:~$ goal node status
Last committed block: 1630913
Time since last block: 2.7s
Sync Time: 0.0s
Last consensus protocol:
Next consensus protocol:
Round for next consensus protocol: 1630914
Next consensus protocol supported: true
Genesis ID: mainnet-v1.0
Genesis hash: wGHE2Pwdvd7S12BL5FaOP20EGYesN73ktiC1qzkkit8=

The goal node status command returns information about the node and its view of the blockchain. Make a note of the “Last committed block” value, which we will need when we construct our transaction file. The reason is that transaction files are only valid for up to 1000 rounds or blocks. So we need to specify a validity range with the last commited block as the starting value for the range. The goal clerk send command can be used to create the transaction file:

purestake@algo-node:~$ goal clerk send -a 1000000 -f FHYPIFKSTJTUT4QCR4MJWZUY2Y4URVFHF2HIXGZ4OHEZSIEQ5Q64IIGEMY -t 5DJNGUEXNRUKAQODHGO3KS2HXOHN4YMSLSZQGEAH5L3WMMDFKMZEQMURUY --firstvalid 1630913 --lastvalid 1631912 -o transaction.tx
Please enter the password for wallet 'MyWallet':

The goal clerk command above creates a file called transaction.tx in the working directory with an unsigned transaction that will send 1 Algo from FHYPIFKSTJTUT4QCR4MJWZUY2Y4URVFHF2HIXGZ4OHEZSIEQ5Q64IIGEMY to 5DJNGUEXNRUKAQODHGO3KS2HXOHN4YMSLSZQGEAH5L3WMMDFKMZEQMURUY with a validity range of block 1630913 to 1631912.

Note that the amount is specified in microalgo as 1000000. All the algorand command line tools generally take Algo amounts in microalgo, or millionths of an Algo. Be very careful when specifying amounts as arguments to these commands. Without commas to create visual separation, it is very easy to make a mistake with an extra or missing zero.

I used the previously-recorded block height value of 1630913 as the firstvalid argument. To come up with the lastvalid argument value I added 999 to the firstvalid value. Generated transactions can have a maximum validity of 1000 blocks. Blocks are being finalized every ~4.5 sec currently, so this means that the transaction file will be valid for roughly 75 min. This can make timing tricky, depending on the coordination needed to actually sign the transaction. However, you can specify validity ranges out into the future if you need more time to perform the signing action.

Inspect tx file (online)

It is always a good practice to check the transaction file for correctness before proceeding to subsequent steps. The file is a binary file so opening it in a text editor is not useful. But we can use the “goal clerk inspect” command to look at its contents. To inspect the file contents, run the following command:

purestake@algo-node:~$ goal clerk inspect transaction.tx
"msig": {
"subsig": [
"thr": 3,
"v": 1
"txn": {
"amt": 1000000,
"fee": 1000,
"fv": 1630913,
"gen": "mainnet-v1.0",
"gh": "wGHE2Pwdvd7S12BL5FaOP20EGYesN73ktiC1qzkkit8=",
"lv": 1631912,
"note": "y0+1BZ82wxY=",
"type": "pay"


The first section shows that this is a transaction from a multisig account, and the 5 public keys for the multisig account are present. In the bottom section, you can find details about the transaction that we specified on the command line, such as the amount, firstvalid, lastvalid, the destination address, etc. The fee value is the fee for sending the transaction, which currently defaults to 1000 microalgo.

2. Copy tx File to the Air-gapped Machine

The transaction file transaction.tx is ready to be signed. But recall that we don’t have the spending keys on this online computer. The spending keys are on a USB device and will be used for signing on the offline computer. The unsigned transaction file cannot be used to send funds without being signed with 3 of the 5 spending keys associated with the multisig account, so it is reasonably safe to copy this file.

Copy transaction.tx to the “Transfer” USB drive.

As a next step, reboot the computer using the Ubuntu USB drive into an offline state and plug in the Transfer and Keys USB drives.

3. Sign tx File on the Air-gapped Machine (Offline)

Once we are booted to the offline Ubuntu desktop, we will perform the signing action for the transactions. We will create a folder on the Ubuntu desktop called tx and copy into it the algokey, the text file containing the keys, and transaction.tx. To sign transaction.tx, open a terminal to the tx folder on the desktop and issue the algokey multisig command to sign the transaction file:

ubuntu@ubuntu:~/Desktop/tx$ ./algokey multisig -t transaction.tx -o transaction1.tx.signed -m "expire wear husband fancy now until laundry token strong dignity arrow valley post raven pudding farm twin chalk cloud tenant cart off shop abandon trophy"
ubuntu@ubuntu:~/Desktop/tx$ ./algokey multisig -t transaction.tx -o transaction2.tx.signed -m "lucky dust hub crew barely leave gas crew canvas exhibit margin mixed impose air wasp chat athlete sketch ozone humble parent rail remind abandon host"
ubuntu@ubuntu:~/Desktop/tx$ ./algokey multisig -t transaction.tx -o transaction3.tx.signed -m "draft mule stamp run absent congress leopard notice minute hungry fresh physical flee favorite cram green salad promote remember route assume gentle early absorb during"

These 3 algokey multisig commands each perform a private key signing action on the provided transaction.tx that we created in a previous step, as outlined in this blog post. The private key is supplied on the command line as a mnemonic, and each invocation creates a different signed transaction output file, transaction1.tx.signed, transaction2.tx.signed, and transaction3.tx.signed.

4. Move tx Files Back From the Air-Gapped Machine

With the signed transaction files in hand, copy transaction1.tx.signed, transaction2.tx.signed, and transaction3.tx.signed to the Transfer USB, remove the Ubuntu bootable USB and the Keys USB, and reboot the computer back to its regular online mode. Once it is booted, log in and copy the 3 signed transaction files from the Transfer USB to a directory on the computer. In my case, I just put the files in my user’s home directory.

Merge the Signatures Back to a Single tx File

We can inspect one of the signed transaction files using the same goal clerk inspect command that we used before to inspect the unsigned transaction.tx file. Issue the following command:

purestake@algo-node:~$ goal clerk inspect transaction1.tx.signed
"msig": {
"subsig": [
"s": "M7dVRrm9zmcE0dLkZTMX7JTjk/tsZdIgLn0qQuL9sGDDCnPZfiKRE9kpBYpSyfZ9uWvtCijJzJIInIbtNijRBg=="
"thr": 3,
"v": 1
"txn": {
"amt": 1000000,
"fee": 1000,
"fv": 1630913,
"gen": "mainnet-v1.0",
"gh": "wGHE2Pwdvd7S12BL5FaOP20EGYesN73ktiC1qzkkit8=",
"lv": 1631912,
"note": "y0+1BZ82wxY=",
"type": "pay"

This looks very similar to the unsigned transaction.tx that we inspected before, but note that the first public key (pk) in the top section now has an “s” value. This “s” value is the signature that was created using the private key for that address. It is not the private key itself, but it demonstrates that we had knowledge of the private key. The other 2 files look similar, but have an “s” value for public keys 2 and 3. What we need to do is merge all of these signatures into the same transaction file which we will call transaction.tx.signed. We can do this using the goal clerk multisig merge command like this:

purestake@algo-node:~$ goal clerk multisig merge -o transaction.tx.signed transaction1.tx.signed transaction2.tx.signed transaction3.tx.signed

We now have a merged signed transaction file called transaction.tx.signed in the working directory.

Inspect tx File Before Sending (Online)

Now let’s inspect the resulting merged transaction.tx.signed file:

purestake@algo-node:~$ goal clerk inspect transaction.tx.signed
"msig": {
"subsig": [
"s": "M7dVRrm9zmcE0dLkZTMX7JTjk/tsZdIgLn0qQuL9sGDDCnPZfiKRE9kpBYpSyfZ9uWvtCijJzJIInIbtNijRBg=="
"s": "rjITXvqzQwFWZ5shfXjhkxpcAkPSJquv9s2gLACLljHKnaoYefTGUXjfKZHtGZixFIAGPWr22DMrk/rcdnf8CA=="
"s": "w08AQ3gJr9W8qVmV1HN4o7okFjU/ozWIHGs3kn4cWjRkx/j1xO3wv+bL5X7fFjt208zaFuacE0y6jKIIc2p3DQ=="
"thr": 3,
"v": 1
"txn": {
"amt": 1000000,
"fee": 1000,
"fv": 1630913,
"gen": "mainnet-v1.0",
"gh": "wGHE2Pwdvd7S12BL5FaOP20EGYesN73ktiC1qzkkit8=",
"lv": 1631912,
"note": "y0+1BZ82wxY=",
"type": "pay"

You can see that the first three public keys all have “s” value signatures. We only need signatures for the first three public keys because this is a 3-of-5 multisig and three valid signatures meets the threshold for the account. If we had signed with a fourth or fifth key, this wouldn’t cause any problems, but it isn’t necessary. This transaction is ready to be broadcast to the network.

5. Broadcast tx to the Network (Online)

To broadcast the signed transaction to the network we can use the goal clerk rawsend command:

purestake@algo-node:~$ goal clerk rawsend -f transaction.tx.signed
Transaction AAG34CUUNSMZJNNRKYV22UNOPFBQB57XPWNEF6D4CGSOT7ZRPSEB still pending as of round 1631216
Transaction AAG34CUUNSMZJNNRKYV22UNOPFBQB57XPWNEF6D4CGSOT7ZRPSEB committed in round 1631218

The transaction id for your transaction will be unique and different than what you see above. Algorand finalizes blocks in under 5 seconds, so you shouldn’t have to wait long for the transaction to broadcast to the network. Once committed, you can check account balances to make sure you see the balance change that is expected. Once used, the transaction file cannot be used again. Sending it again will result in an error.

Conclusion: More Complex, But More Secure, Too

This multisig transaction example shows that the setup of a multisig account and execution of a transaction are a lot more complicated than just using a single spending key account directly on an online computer with an Algorand node installation. But, by using a multisig account, we can substantially improve the security of the setup and greatly reduced the risk of the private keys and thus the funds in the account from being compromised.

The Algorand multisig features can be used to create multiple keys which can be used to split the secrets needed to spend funds across different people and locations. The exact number, locations, storage, and people will vary according to the environment and situation, but it opens the door for a much more secure setup than a single key account.

Keeping the spending keys totally offline is another substantial improvement to Algorand account security for high-value accounts. Most of the attack vectors for compromising keys involve online scenarios, malware, or other network exploits. By never having the secrets on an online computer, the risk of key compromise is greatly reduced. Another way to improve the security of an Algorand account is to use a ledger hardware wallet, which will be the subject of a future blog post.