Configuration (config.ts)

This file connects to the Algorand node. You can configure it to use the Algorand Sandbox or Testnet.

import algosdk from "algosdk";

// Configure Algorand Sandbox or Testnet
const ALGOD_TOKEN = "a" + "a".repeat(63); // Replace with your node token
const ALGOD_SERVER = "http://localhost";
const ALGOD_PORT = 4001; // Default sandbox port

export const algodClient = new algosdk.Algodv2(ALGOD_TOKEN, ALGOD_SERVER, ALGOD_PORT);

Account Creation (account.ts)

This file handles account creation and recovery from a mnemonic.

import algosdk from "algosdk";

// Create a new account
export function createAccount() {
  const account = algosdk.generateAccount();
  const mnemonic = algosdk.secretKeyToMnemonic(account.sk);

  console.log("Generated Account:");
  console.log(`Address: ${account.addr}`);
  console.log(`Mnemonic: ${mnemonic}`);

  return { address: account.addr, mnemonic, privateKey: account.sk };
}

// Recover an account from a mnemonic
export function recoverAccount(mnemonic: string) {
  const account = algosdk.mnemonicToSecretKey(mnemonic);
  console.log("Recovered Account:");
  console.log(`Address: ${account.addr}`);
  return account;
}

Utilities (utils.ts)

This file contains utility functions for getting transaction parameters and waiting for confirmation.

import { algodClient } from "./config";
import algosdk from "algosdk";

// Get transaction parameters
export async function getTransactionParams() {
  return await algodClient.getTransactionParams().do();
}

// Wait for transaction confirmation
export async function waitForConfirmation(txId: string) {
  const response = await algosdk.waitForConfirmation(algodClient, txId, 4);
  console.log("Transaction confirmed:", response);
}

Transactions (transactions.ts)

This file handles basic transactions, multisig, and rekeying.

import algosdk from "algosdk";
import { algodClient } from "./config";
import { getTransactionParams, waitForConfirmation } from "./utils";

// Create a payment transaction
export async function sendPayment(from: algosdk.Account, to: string, amount: number) {
  const params = await getTransactionParams();
  const txn = algosdk.makePaymentTxnWithSuggestedParamsFromObject({
    from: from.addr,
    to,
    amount,
    suggestedParams: params,
  });

  const signedTxn = txn.signTxn(from.sk);
  const txId = txn.txID().toString();
  await algodClient.sendRawTransaction(signedTxn).do();
  await waitForConfirmation(txId);
  console.log(`Sent ${amount} µAlgo from ${from.addr} to ${to}`);
}

// Create a multisig account
export function createMultisigAccount(accounts: algosdk.Account[], threshold: number) {
  const multiSigParams = {
    version: 1,
    threshold,
    addrs: accounts.map((a) => a.addr),
  };

  const multiSigAddress = algosdk.multisigAddress(multiSigParams);
  console.log("Created MultiSig Address:", multiSigAddress);
  return { multiSigParams, multiSigAddress };
}

// Sign a multisig transaction
export function signMultisigTransaction(txn: algosdk.Transaction, msigParams: any, signer: algosdk.Account) {
  return algosdk.signMultisigTransaction(txn, msigParams, signer.sk).blob;
}

// Rekey an account
export async function rekeyAccount(oldAccount: algosdk.Account, newSigner: algosdk.Account) {
  const params = await getTransactionParams();

  const rekeyTxn = algosdk.makePaymentTxnWithSuggestedParamsFromObject({
    from: oldAccount.addr,
    to: oldAccount.addr,
    amount: 0,
    suggestedParams: params,
    rekeyTo: newSigner.addr,
  });

  const signedTxn = rekeyTxn.signTxn(oldAccount.sk);
  const txId = rekeyTxn.txID().toString();
  await algodClient.sendRawTransaction(signedTxn).do();
  await waitForConfirmation(txId);
  console.log(`${oldAccount.addr} is now rekeyed to ${newSigner.addr}`);
}

Running the Program (main.ts)

This is the main file to run the program. It ties everything together.

import { createAccount, recoverAccount } from "./account";
import { sendPayment, createMultisigAccount, rekeyAccount } from "./transactions";
import algosdk from "algosdk";

// Create a new account
const newAccount = createAccount();

// Recover an account from a mnemonic
const recoveredAccount = recoverAccount(newAccount.mnemonic);

// Execute transactions
async function executeTransactions() {
  const recipient = "ALGORAND_RECIPIENT_ADDRESS"; // Replace with recipient address
  await sendPayment(recoveredAccount, recipient, 100000);

  // Create a multisig account
  const signer1 = algosdk.generateAccount();
  const signer2 = algosdk.generateAccount();
  const multisig = createMultisigAccount([signer1, signer2], 2);

  // Rekey an account
  await rekeyAccount(recoveredAccount, signer1);
}

executeTransactions();

Running the Program

Run the program using the following command:

tsx src/main.ts

Conclusion

• config.ts: Connects to the Algorand node.
• account.ts: Creates and recovers accounts.
• transactions.ts: Handles transactions, multisig, and rekeying.
• utils.ts: Provides utility functions for transaction parameters and confirmation.
• main.ts: Combines all functions and runs the program.

Keys and Addresses

Algorand uses Ed25519 high-speed, high-security elliptic-curve signatures. The keys are produced through standard, open-source cryptographic libraries packaged with each of the SDKs. The key generation algorithm takes a random value as input and outputs two 32-byte arrays, representing a public key and its associated private key. These are also referred to as a public/private key pair. These keys perform important cryptographic functions like signing data and verifying signatures.

For reasons that include the need to make the keys human-readable and robust to human error when transferred, both the public and private keys undergo transformations. The output of these transformations is what the majority of developers, and usually all end-users, see. In fact, the Algorand developer tools actively seek to mask the complexity involved in these transformations. So unless you are a protocol-level developer modifying cryptographic-related source code, you may never actually encounter the true public/private key pair.

Transformation: Public Key to Algorand Address

The public key is transformed into an Algorand address by adding a 4-byte checksum to the end of the public key and then encoding it in base32. The result is what both the developer and end-user recognize as an Algorand address. The address is 58 characters long.

Transformation: Private Key to 25-word Mnemonic

The 25-word mnemonic is the most user-friendly representation of the private key. It is generated by converting the private key bytes into 11-bit integers and then mapping those integers to the BIP-0039 English word list, where integer n maps to the word in the nth position in the list. By itself, this creates a 24-word mnemonic. A checksum is added by taking the first two bytes of the hash of the private key and converting them to 11-bit integers and then to their corresponding word in the word list. This word is added to the end of the 24 words to create a 25-word mnemonic.

This representation is called the private key mnemonic. You may also see it referred to as a passphrase.

Wallets

Wallets, in the context of Algorand developer tools, refer to wallets generated and managed by the Key Management Daemon (kmd) process. A wallet stores a collection of keys. kmd stores collections of wallets and allows users to perform operations using the keys stored within these wallets. Every wallet is associated with a master key, represented as a 25-word mnemonic, from which all accounts in that wallet are derived. This allows the owner of the wallet to only need to remember a single passphrase for all of their accounts. Wallets are stored encrypted on disk.

See Wallet-derived (kmd) accounts in the Creation Methods section for more details.

Accounts

Accounts are entities on the Algorand blockchain associated with specific onchain data, like a balance. An Algorand Address is the identifier for an Algorand account.

After generating a private key and corresponding address, sending Algos to the address on Algorand will create an account.

Attributes

• Minimum Balance: Every account on Algorand must have a minimum balance of 100,000 microAlgos. If ever a transaction is sent that would result in a balance lower than the minimum, the transaction will fail. The minimum balance increases with each asset holding the account has (whether the asset was created or owned by the account) and with each application the account created or opted in. Destroying a created asset, opting out/closing out an owned asset, destroying a created app, or opting out an opted in app decreases accordingly the minimum balance.
• Online/Offline: By default, Algorand accounts are set to offline. An online account is one that participates in Algorand consensus. For an account to go online, it must generate a participation key and send a special key registration transaction.

Special Accounts

Two accounts carry special meaning on the Algorand blockchain:

• FeeSink: Where all fees from transactions are sent. The FeeSink can only spend to the RewardsPool account.
• RewardsPool: Was first used to distribute rewards to balance holding accounts. Currently, this account is not used.

In addition, the ZeroAddress (AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ) is an address that represents a blank byte array. It is used when you leave an address field in a transaction blank.

Official Resources

• Algorand Accounts Documentation
• Algorand Developer Portal
• Algorand Official Website
• Algorand GitHub Repository
• Account Test Example (Official GitHub)