Cardano

Overview

Cardano (ADA) is the native asset of the Cardano blockchain. It utilizes:

• UTXO model
• EdDSA signature algorithm

Cardano is a decentralized, public blockchain that uses a proof-of-stake consensus mechanism.

Explorer

Wallets Types

BitGo enables holding Cardano in the following wallet types:

Ticker Symbols

Faucet

You can use a faucet to obtain free testnet Cardano for development and testing purposes.

Faucet: https://docs.cardano.org/cardano-testnets/tools/faucet

For testnet faucet, you have the option for Preprod or Preview testnet faucet assets. Preview refers to the time before the Vasil hard-fork, and Preprod refers to the most recent testnet. For the current testnet, use Preprod assets.

Note: BitGo wallets support withdrawals to Byron-era addresses (Icarus style) with prefix Ae2, but do not support withdrawals to Byron addresses with prefix DdzFFz.

Units

Cardano is divisible by 10^-6 and the base unit is a Lovelace:

• 1 Cardano = 1,000,000 lovelace
• 1 lovelace = 0.000001 Cardano

Cardano balances can be in either integer or string format. However, BitGo recommends using string format to ensure values don't exceed the programmable number limit.

Tokens

The ADA blockchain natively supports tokens. To view all BitGo supported tokens on the ADA blockchain, see ADA Tokens.

Gas Tank (Fee Sponsorship)

BitGo uses a Gas Tank to pay for transaction fees and minimum ADA requirements on Cardano. This setup enables fee sponsorship—meaning that for enterprises with Gas Tank enabled, the Gas Tank pays all transaction fees and minimum ADA amounts on behalf of their users’ wallets.

Key Benefits

• Centralized fee management: All fees are paid from a single enterprise-controlled address
• Simplified token transactions: No need to manage minimum ADA separately
• Improved user experience: Seamless transactions for end-users

Enabling Fee Sponsorship

Fee sponsorship for Cardano is enabled at the enterprise level. To request enablement, reach out to BitGo support. Once enabled, fee sponsorship applies to all wallets under that enterprise — you cannot opt in or out on a per-wallet or per-transaction basis.

Scope

Each enterprise has a single shared gas tank (fee address). All wallets under the enterprise share this gas tank. When any wallet in the enterprise sends a transaction, the gas tank is used to cover fees (and minimum ADA for token transfers). Plan your gas tank funding based on the aggregate transaction volume across all wallets.

How to Fund the Gas Tank

To fund your gas tank, send ADA to the gas tank address. You can retrieve the gas tank address using the Get Fee Address Balance endpoint (see the Check Gas Tank Balance section below). Simply transfer ADA to the returned address from any external wallet or exchange. For more details, see Fund Gas Tanks.

Without Fee Sponsorship

If your enterprise does not have fee sponsorship enabled, the sender wallet pays all transaction fees and minimum ADA requirements directly from its own balance. In this case:

• For native ADA transfers, the transaction fee is deducted from the sender wallet.
• For token transfers, the sender wallet must hold enough ADA to cover both the 1.5 ADA minimum for the recipient and the transaction fee.
• No gas tank is involved; the sender wallet must have sufficient ADA for every transaction.

What Can Be Sponsored

Sponsorship Models

Native ADA Transfer

When sending ADA from a wallet from an enterprise with fee sponsorship enabled:

Token Transfer

For token transfers, the gas tank pays both the transaction fee and the 1.5 ADA minimum that must accompany tokens to the recipient.

For detailed sponsorship models, examples, and multi-recipient calculations, see Gas Tank for Token Transfers.

Consolidation

When consolidating UTXOs from multiple addresses:

Minimum Gas Tank Balance Requirements

The gas tank must hold a minimum amount of ADA for each transaction type. These minimums cover the network transaction fee and ensure there is enough ADA for a valid change output back to the gas tank.

Note: These are the absolute minimums. If the gas tank balance falls below the required amount for a given transaction type, the transaction will fail with the error Insufficient balance to cover min ada and fee from gas tank.

Native ADA Withdrawal

For a native ADA send, the gas tank only pays the transaction fee. The remaining ADA in the gas tank UTXO is returned as change. Because Cardano requires every UTXO to hold at least 1 ADA, the gas tank needs enough to cover the fee and still produce a valid change output.

Example: You want to send 10 ADA from a user wallet to an address.

In this example, the gas tank starts with 2 ADA, pays ~0.2 ADA as the transaction fee, and receives ~1.8 ADA back as change — enough to satisfy the minimum UTXO requirement.

Token Transfer

The gas tank needs at least 3.5 ADA for token transfers (1.5 ADA to recipient + ~0.2 ADA fee + change buffer). For detailed examples, multi-token transfers, send-many calculations, and how token withdrawals affect reserved ADA, see Gas Tank for Token Transfers.

Consolidation

For consolidation transactions, the gas tank pays only the transaction fee. The consolidated ADA and tokens are sent to the wallet's root address. The minimum ADA required for the consolidated output at the root address is covered by the ADA already present in the input UTXOs being consolidated — the gas tank does not need to provide additional minimum ADA for consolidation outputs.

Example: You want to consolidate UTXOs from two receive addresses to the root address.

Note: When consolidating UTXOs that contain tokens, the ADA held in those UTXOs (which was reserved for the minimum UTXO requirement) is consolidated along with the tokens. The root address output will contain the combined ADA from all consolidated inputs (minus the fee), ensuring the minimum ADA requirement is met.

Concurrency and Throughput

Because Cardano uses the UTXO model, each concurrent transaction requires its own gas tank UTXO. This means the number of transactions you can process in parallel is limited by the number of available UTXOs in your gas tank.

Example: If your gas tank holds 100 ADA, BitGo's internal split logic can create 25 UTXOs of 4 ADA each. That gives you capacity for up to 25 concurrent transactions in one round.

For native ADA withdrawals, each 4 ADA gas tank UTXO can pay ~0.2 ADA fee and return ~3.8 ADA as change. Across 25 transactions, that is approximately 25 x 3.8 = 95 ADA returned as change UTXOs, which then become eligible for the next round of ADA transactions (subject to UTXO selection and timing).

For token withdrawals, the same pattern applies: each 4 ADA UTXO can cover token sponsorship requirements for one transaction in that round, and any gas tank change output becomes available again for subsequent token transactions.

To increase throughput:

• Fund your gas tank with more ADA to create more UTXOs via automatic splitting
• Larger gas tank balance = more UTXOs = more concurrent transactions

Gas Tank Depletion

If the gas tank runs out of ADA (or available UTXOs) while processing transactions:

• Pending transactions that have already reserved UTXOs will continue to process normally.
• New transactions will fail immediately with the error Insufficient balance to cover min ada and fee from gas tank. They will not be queued or retried automatically.
• To resume operations, fund the gas tank with additional ADA. Once the deposit is confirmed on-chain and automatically split into UTXOs, new transactions can proceed.

Automatic UTXO Splitting

Unlike Ethereum, Cardano uses the UTXO model. BitGo automatically optimizes your gas tank by splitting large deposits into smaller UTXOs for efficient transaction building.

When your gas tank receives a deposit exceeding 10 ADA, BitGo automatically:

1. Detects the large deposit
2. Triggers a system-initiated split transaction
3. Creates multiple 4 ADA UTXOs
4. Repeats until the entire deposit is fully split

Cascading Split Transactions

Due to Cardano's protocol-level restriction on maximum transaction size (in bytes), a single split transaction can only produce a limited number of output UTXOs. If the deposit is large, BitGo will create multiple cascading split transactions — each transaction splits a portion of the remaining balance, and any leftover amount triggers another split transaction automatically. This process continues until the entire deposited amount has been split into 4 ADA UTXOs.

Example: You deposit 2000 ADA into the gas tank.

1. Split transaction 1: Takes the 2000 ADA UTXO, produces 349 outputs of 4 ADA each (48 ADA) + 1 remainder UTXO (~602 ADA after fees). (Exact output count depends on transaction size limits.)
2. Split transaction 2: Takes the ~602 ADA remainder, produces ~150 outputs of 4 ADA each.

Note: These are system-initiated transactions that appear on-chain and in your transaction history. They are not user-initiated and require no action on your part. During the splitting process, the UTXOs being split are temporarily unavailable for other transactions. Once splitting completes, all resulting 4 ADA UTXOs become available for concurrent transaction processing.

This optimization:

• Enables parallel transaction processing
• Reduces UTXO contention during high-volume operations
• Requires no manual intervention

Transaction Flow

When a sponsored transaction is executed:

1. User initiates a transaction (withdrawal, token transfer, or consolidation) from their wallet via the API or SDK.
2. BitGo selects UTXOs from the sender wallet for the transaction amount.
3. BitGo selects UTXOs from the gas tank for fees (and minimum ADA if token transfer).
4. Selected UTXOs from both the sender and gas tank are reserved to prevent double-spending. Reserved UTXOs cannot be used by other concurrent transactions.
5. Transaction is built with both sender and gas tank inputs.
6. Transaction is signed and broadcasted to the Cardano network.
7. Upon confirmation (or failure), the reserved UTXOs are released.

UTXO Reservation Lifecycle

When UTXOs are reserved during step 4, they follow this lifecycle:

• On success: UTXOs are consumed by the confirmed transaction. New change UTXOs are created for both the sender and gas tank.
• On failure or cancellation: UTXOs are unreserved immediately and become available for new transactions.
• On timeout (no response): If a transaction is neither confirmed nor explicitly cancelled, the reservation automatically expires after 7 days (the reservation TTL). This is a safety net to prevent UTXOs from being permanently locked due to edge cases like network issues. Under normal operation, you should not encounter this 7-day wait.

Check Gas Tank Balance

Endpoints:

• Get Fee Address Balance

Copy code block
1
2
3
4
5
6
7
8
export COIN="tada"
export ENTERPRISE_ID="<YOUR_ENTERPRISE_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"

curl -X GET \
  https://app.bitgo-test.com/api/v2/$COIN/enterprise/$ENTERPRISE_ID/feeAddressBalance \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN"

Step Result

Copy code block
1
2
3
4
{
  "balance": "19000000",
  "address": "addr_test1vzyrwmnscz0emq3vch7n4zhpu3dftfaz6a70pacsygz76ec..."
}

Best Practices

1. Monitor Gas Tank Balance: Ensure gas tank always has sufficient ADA
2. Plan for Token Transfers: Each token recipient requires 1.5 ADA from the gas tank — see Token Transfer Sponsorship Details
3. Handle Multiple Recipients: When sending tokens to multiple recipients, ensure gas tank has enough for all minimum ADA requirements — see Send-Many with Tokens

Troubleshooting

Create Wallet

Copy code block
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
export BITGO_EXPRESS_HOST="<YOUR_LOCAL_HOST>"
export COIN="tada"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
export LABEL="<WALLET_NAME>"
export WALLET_PASSPHRASE="<BITGO_LOGIN_PASSPHRASE>"
export ENTERPRISE="<ENTERPRISE_ID>"

curl -X POST \
  http://$BITGO_EXPRESS_HOST/api/v2/$COIN/wallet/generate \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -d '{
    "label": "'"$LABEL"'",
    "passphrase": "'"$WALLET_PASSPHRASE"'",
    "type": "hot",
    "walletVersion": 3,
    "multisigType": "tss",
    "enterprise": "'"$ENTERPRISE"'"
}'

Create Address

BitGo supports a variety of address types for Cardano. To learn more, see UTXO Address Types. BitGo doesn't support creating Byron addresses. DDa-based (Daedalus-style) addresses are also not supported on the BitGo platform.

Copy code block
1
2
3
4
5
6
7
8
export COIN="tada"
export WALLET_ID="<YOUR_WALLET_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"

curl -X POST \
  https://app.bitgo-test.com/api/v2/$COIN/wallet/$WALLET_ID/address \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN"

Consolidate Balance

Despite being a UTXO asset, Cardano uses MPC wallets and therefore requires consolidating to the base address in order to use the maximum spendable amount.

Copy code block
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
export BITGO_EXPRESS_HOST="<YOUR_LOCALHOST>"
export COIN="tada"
export WALLET_ID="<YOUR_WALLET_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
export ADDRESS_1="<DESTINATION_ADDRESS_1>"
export ADDRESS_2="<DESTINATION_ADDRESS_2>"
export WALLET_PASSPHRASE="<YOUR_WALLET_PASSPHRASE>"

curl -X POST \
  http://$BITGO_EXPRESS_HOST/api/v2/$COIN/wallet/$WALLET_ID/consolidateAccount \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -d '{
    "consolidateAddresses": [
    {
      "address": "'"$ADDRESS_1"'"
    },
    {
      "address": "'"$ADDRESS_2"'"
    }
  ],
    "walletPassphrase": "'"$WALLET_PASSPHRASE"'"
}'

Estimate Fee

Cardano's fee rate depends on the size of the transaction in bytes. The formula for determining the minimum fee required to cover the transaction is based on two protocol parameters, a and b. The formula for determining the minimum fee is (a * size(tx)) + b.

Copy code block
1
2
3
4
5
6
7
export COIN="tada"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"

curl -X GET \
  https://app.bitgo-test.com/api/v2/$COIN/tx/fee \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN"

Transact

Cardano uses a UTXO model, which supports multiple inputs and multiple outputs of a transaction.

Transactions on Cardano have a minimum UTXO amount of 1 ADA. This means that in your transaction unspents, you cannot have any value less than 1 UTXO.

You can use the sendMany() function to send ADA to multiple receive addresses.

Copy code block
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import * as dotenv from "dotenv";
import {EnvironmentName} from "bitgo";
import {BitGoAPI} from "@bitgo/sdk-api";
import {Tada} from "@bitgo/sdk-coin-ada";

dotenv.config();

const config = {
    USERNAME: process.env.USERNAME as string,
    PASSWORD: process.env.PASSWORD as string,
    ENV: process.env.ENV as EnvironmentName,
    OTP: process.env.OTP as string,
    ENTERPRISE_ID: process.env.ENTERPRISE_ID as string,
    WALLET_ID: process.env.WALLET_ID as string,
    WALLET_PASS_PHRASE: process.env.WALLET_PASS_PHRASE as string
};

const bitgo = new BitGoAPI({env: config.ENV});
bitgo.register("tada", Tada.createInstance);
const coin = bitgo.coin("tada");

async function auth() {
    await bitgo.authenticate({
        username: config.USERNAME,
        password: config.PASSWORD,
        otp: config.OTP,
    });
    await bitgo.lock();
    await bitgo.unlock({otp: "000000", duration: 3600});
}

async function main() {
    await auth();
    const destinatonAddress = "0x1037c88b10fbd0754b9fbd3ba7be41fe7cb61f59";
    const wallet = await coin.wallets().get({id: config.WALLET_ID});
    const sendAmount = wallet.balanceString() ?? 0;
    const res = await wallet.sendMany({
        walletPassphrase: config.WALLET_PASS_PHRASE,
        recipients: [{address: destinatonAddress, amount: sendAmount}],
        type: "transfer",
    });
    console.log(res);
}

main().catch((err) => console.error(err));

Stake

The staking transaction fee is 2 ADA, and is in addition to regular transaction fee. You can increase your stake by depositing Cardano in the staked wallet - no additional staking transaction is required. Staking Cardano occurs in epochs (5 day periods) and takes 15–20 days before you receive your first rewards. Here’s how it works:

• Epoch 0: You delegate your ADA to a stake pool.
• Epoch 1: Your delegation is registered.
• Epoch 2: Your stake becomes active.
• Epoch 3: Rewards for Epoch 2 are calculated.
• Epoch 4: You receive your first rewards (after approximately 15–20 days).
• After this initial warm-up, rewards continue every 5 days (each epoch).

To learn more about staking assets with BitGo, see Staking Overview.

Copy code block
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
export COIN="tada"
export WALLET_ID="<YOUR_WALLET_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
export CLIENT_ID="<CLIENT_ID>"
export AMOUNT="<AMOUNT_IN_BASE_UNITS>"
export GAS_PRICE="<GAS_PRICE>"

curl -X POST \
  http://api/staking/v1/$COIN/wallets/$WALLET_ID/requests \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -d '{
    "clientId": "'$CLIENT_ID'",
    "amount": "'$AMOUNT'",
    "gasPrice": "'$GAS_PRICE'",
    "type": "STAKE"
}'

You can view more example scripts to stake, unstake, and withdraw rewards in the BitGoJS GitHub repo.

See Also

• BitGoJS GitHub repo
• ADA Tokens — Gas Tank for Token Transfers
• Fund Gas Tanks
• API Reference: Get Gas Tank Balance
• UTXO Address Types
• Create MPC Wallets
• Staking Overview
• Trading Overview
• View UTXO
• Withdraw from Wallet - Custody MPC
• Withdraw from Wallet - Self-Custody MPC Hot (Advanced)
• Withdraw from Wallet - Self-Custody MPC Hot (Simple)