Multisignature Accounts

Multisignature accounts, are a logical representation of an ordered set of addresses with a threshold and version. Multisignature accounts can perform the same operations as other accounts, including sending transactions and participating in consensus. The address for a multisignature account is essentially a hash of the ordered list of accounts, the threshold and version values. The threshold determines how many signatures are required to process any transaction from this multisignature account.

Quick start video

If you prefer videos, take a look at this 4 minute guide to Learn About Multisig Algorand Account.

Multisignature accounts cannot nest other multisignature accounts.

Creating a multisignature account with Address A, Address B, and Address C will not produce the same address as one with Address B, Address A, and Address C. However, signing a multisignature transaction does not require any specific order.

Tip

You can use the fact that order matters to generate multiple addresses that can be signed by the same set of keys.

Send Algos to the address to initialize its state on the blockchain as you would any other address.

Benefits of Using Multisig Accounts

• Enhanced Security: Requires multiple signatures for transactions, adding an extra layer of security.
• Customizable Authorization: The number of required signatures can be adjusted to fit different security models.
• Distributed Key Storage: Signing keys can be stored separately and generated through different methods (kmd, standalone accounts, or a mix).
• Governance Mechanisms: Enables cryptographically secure governance structures where multiple users control an account and spending is authorized by a subset of those users.
• Integration with Smart Contracts: Can be paired with Algorand Smart Contracts for complex governance models requiring specific signature subsets.

Implications of Using Multisig Accounts

• Reduced Convenience: Requires multiple signatures for every transaction, adding complexity.
• Unnecessary for Simple Use Cases: If security and governance are not critical, a single-signature account may be more practical.

How to Generate a Multisig Account

There are different ways to generate a multisig account. The following ways show how to generate a multisignature account composed of three Algorand addresses, with a signing threshold of 2. Hardcode the mnemonics in the code samples below to recreate a specific multisignature address or create new accounts.

Tip

Since multisignature accounts are just logical representations of the data defined above, anyone can “create” the same Algorand address if they know how it is composed. This information is public and included in a signed transaction from a multisignature account.

AlgoKit Utils simplifies the creation and management of standalone Algorand accounts in Python and TypeScript by abstracting Algorand SDK complexities. Handle multisignature accounts efficiently by managing signing processes and transaction approvals. With AlgoKit Utils, developers can seamlessly create and fund multisignature accounts, ensuring secure and flexible transaction authorization.

Utils (TypeScript)

  // Initialize an Algorand client instance and get funded accounts
  const { algorand, dispenser, randomAccountA, randomAccountB, randomAccountC } = await setupLocalnetEnvironment()

  // Create a 2-of-3 multisig account that requires
  // only 2 signatures from the 3 possible signers to authorize transactions
  const multisigAccountA = algorand.account.multisig(
    { version: 1, threshold: 2, addrs: [randomAccountA, randomAccountB, randomAccountC] },
    [randomAccountA.account, randomAccountB.account, randomAccountC.account],
  )

  // Fund the multisig account
  await algorand.account.ensureFunded(multisigAccountA, dispenser, (10).algo())

  // Send a payment transaction from the multisig account
  // which will automatically collect the required number of signatures
  // from the signing accounts provided when creating the multisig account
  await algorand.send.payment({
    sender: multisigAccountA,
    receiver: randomAccountA,
    amount: algo(1),
  })

Utils (Python)

    algorand_client, dispenser, account_a, account_b, account_c = (
        setup_localnet_environment()
    )

    """
    Create a 2-of-3 multisig account that requires
    only 2 signature from the 3 possible signers to authorize transactions
    """
    multisig_account = algorand_client.account.multisig(
        metadata=MultisigMetadata(
            version=1,
            threshold=2,
            addresses=[
                account_a.address,
                account_b.address,
                account_c.address,
            ],
        ),
        signing_accounts=[account_a, account_b, account_c],
    )

    algorand_client.account.ensure_funded(
        multisig_account.address, dispenser, AlgoAmount(algo=10)
    )

    """
    Send a payment transaction from the multisig account
    which will automatically collect the required number of signatures
    from the signing accounts provided when creating the multisig account
    """
    algorand_client.send.payment(
        PaymentParams(
            sender=multisig_account.address,
            receiver=account_a.address,
            amount=AlgoAmount(algo=1),
        ),
    )

goal

$ ADDRESS1=$(goal account new | awk '{ print $6 }')
$ ADDRESS2=$(goal account new | awk '{ print $6 }')
$ ADDRESS3=$(goal account new | awk '{ print $6 }')

$ goal account multisig new $ADDRESS1 $ADDRESS2 $ADDRESS3 -T 2
Created new account with address [MULTISIG_ADDRESS]