# Mint & Redeem DigiDollar on DigiByte Mainnet

DigiDollar is DigiByte's protocol-native, over-collateralized USD stablecoin.
It **activated on mainnet on 2026-07-17** (BIP9 deployment `digidollar`, bit 23,
active at block `23,869,440`). This page is the operator/developer procedure for
opening a collateral vault (minting DUSD) and redeeming it, using the DigiDollar
RPCs on a synced mainnet node.

Everything below is verified against **DigiByte Core v9.26.4**, `digibyte-cli`
against a mainnet node (RPC port `14022`). All amounts flow through the standard
wallet — DigiDollar mint/redeem transactions are ordinary node RPC calls, not a
separate service.

> **Read-only?** If you only need the numbers (supply, collateral, ratio, oracle
> price), you do not need a node — DigiScope exposes them at
> [`/api/digidollar/stats`](/digidollar/stats) and `/api/digidollar/price-history`.
> The rest of this page is for actually minting and redeeming.

## The three unit traps (read this first)

The DigiDollar RPCs mix three units. Getting them wrong is the most common
integration bug:

- **DUSD amounts are in CENTS.** `10000` = $100.00. The mint minimum is `10000`
  ($100), the maximum is `10000000` ($100,000).
- **Oracle price is in MICRO-USD.** `2984` = $0.002984 per DGB (divide by
  1,000,000). The `*_cents` price field is unreliable — do not use it.
- **Collateral is in DGB, already denominated in DGB** — not satoshis — despite
  some help text calling it "satoshis."

## Step 1 — Check protocol and oracle health

`getdigidollarstats` returns the system-wide state; `getoracleprice` returns the
current signed DGB/USD price.

```bash
digibyte-cli getdigidollarstats
```

```json
{
  "health_percentage": 407,
  "health_status": "healthy",
  "total_collateral_dgb": 5338561.13015550,
  "total_dd_supply": 390032,
  "oracle_price_micro_usd": 2984,
  "oracle_available": true,
  "minting_restricted_reason": "none",
  "active_positions": 30,
  "dca_tier": { "min_collateral": 150, "max_collateral": 30000, "multiplier": 1 },
  "err_tier": { "ratio": 1, "burn_multiplier": 1 }
}
```

`total_dd_supply` (`390032`) is **cents** → $3,900.32 DUSD outstanding.
`oracle_price_micro_usd` (`2984`) → $0.002984/DGB. `total_collateral_dgb` is DGB.
If `minting_restricted_reason` is anything other than `"none"`, minting is paused.

```bash
digibyte-cli getoracleprice
```

```json
{
  "price_micro_usd": 2984,
  "price_usd": 0.002984,
  "last_update_height": 23872695,
  "validity_blocks": 20,
  "is_stale": false,
  "oracle_count": 29,
  "status": "active"
}
```

The price is signed by a MuSig2 quorum (7-of-N) and is valid for
`validity_blocks` (~20 blocks ≈ 5 minutes). If `is_stale` is `true`, wait for the
next oracle update before minting.

## Step 2 — Estimate the collateral you'll need

`estimatecollateral dd_amount lock_tier` tells you the DGB required for a given
mint. Longer locks require **less** collateral (a better ratio).

```bash
# $100 DUSD (10000 cents) at the 30-day tier (tier 1)
digibyte-cli -rpcwallet=<wallet> estimatecollateral 10000 1
```

```json
{
  "required_dgb": 167560.32171582,
  "wallet_collateral_dgb": 169235.92493297,
  "dd_amount": 10000,
  "lock_tier": 1,
  "lock_days": 30,
  "effective_ratio": 500,
  "oracle_price_micro_usd": 2984,
  "usd_value": 100
}
```

`effective_ratio` (`500`) means 500% collateralization for the 30-day tier at the
current price. `wallet_collateral_dgb` is how much eligible DGB your wallet can
actually lock — confirm it is ≥ `required_dgb` before minting.

## Step 3 — Open the vault (mint)

```
mintdigidollar dd_amount lock_tier ( fee_rate )
```

- `dd_amount` — DUSD to mint, in **cents** (min `10000`/$100, max `10000000`/$100K).
- `lock_tier` — `0`–`9`. `fee_rate` is optional and floored to the DD fee policy
  (`35000000` sat/kB), so you can omit it.

| tier | lock | tier | lock |
|---|---|---|---|
| 0 | 1 hour (testing) | 5 | 2 years |
| 1 | 30 days | 6 | 3 years |
| 2 | 90 days | 7 | 5 years |
| 3 | 180 days | 8 | 7 years |
| 4 | 1 year | 9 | 10 years |

```bash
# Mint $100 DUSD at the 30-day tier
digibyte-cli -rpcwallet=<wallet> mintdigidollar 10000 1
```

```json
{
  "txid": "9b3f6476111d870b72a216c9b7aa85c9e58cd80a77699a4efc42114b1f213b0e",
  "dd_minted": 10000,
  "dgb_collateral": 169235.92493297,
  "lock_tier": 1,
  "unlock_height": 24045615,
  "collateral_ratio": 500,
  "fee_paid": 0.11935000,
  "position_id": "9b3f6476111d870b72a216c9b7aa85c9e58cd80a77699a4efc42114b1f213b0e"
}
```

The **`position_id` is the mint txid** — you need it to redeem. The DUSD is
minted to a `DD…`-prefixed address in your wallet and is spendable/transferable
immediately (mainnet uses `DD` for balances, `RD` for redemption outputs; testnet
uses `TD`). The DGB collateral is time-locked until `unlock_height`. Get a fresh
DD receive address with `getdigidollaraddress`.

> DigiDollar transactions require miners running the DigiDollar flag; in the early
> mainnet window they confirm in bursts, so a mint may sit at 0 confirmations for
> a while before it is mined. This is expected.

## Step 4 — Track the position

```bash
digibyte-cli -rpcwallet=<wallet> listdigidollarpositions
```

```json
[
  {
    "position_id": "9b3f6476111d870b72a216c9b7aa85c9e58cd80a77699a4efc42114b1f213b0e",
    "dd_minted": 10000,
    "dgb_collateral": 169235.92493297,
    "lock_tier": 1,
    "unlock_height": 24045615,
    "blocks_remaining": 172900,
    "confirmations": 20,
    "status": "active",
    "health_ratio": 504,
    "can_redeem": false
  }
]
```

`can_redeem` stays `false` until the block height passes `unlock_height`
(`blocks_remaining` hits 0). `listdigidollarpositions` accepts optional
`( active_only tier_filter min_amount count skip )` filters.

## Step 5 — Redeem (burn DUSD, unlock collateral)

```
redeemdigidollar "position_id" dd_amount ( "redemption_address" fee_rate )
```

- `position_id` — the mint txid from Step 3.
- `dd_amount` — DUSD to burn, in **cents**. Redeem the full `dd_minted` to close
  the position and reclaim all collateral.
- `redemption_address` — optional DGB address for the unlocked collateral
  (defaults to a new wallet address). `fee_rate` is deprecated/ignored.

```bash
# Only valid once the lock has matured (can_redeem: true)
digibyte-cli -rpcwallet=<wallet> redeemdigidollar \
  9b3f6476111d870b72a216c9b7aa85c9e58cd80a77699a4efc42114b1f213b0e 10000
```

The redemption burns the DUSD and releases the time-locked DGB back to your
wallet. **Redemption is non-custodial** — the protocol itself enforces the time
lock and the collateral release; no third party ever holds the DGB. Positions
that have not reached maturity cannot be redeemed.

## Read-only integration (no node required)

For dashboards, bots, or agents that only need to read protocol state, DigiScope
proxies the node RPC over HTTP — every DigiByte node recomputes these figures
every block, so they are trust-minimized:

- `GET /api/digidollar/stats` — normalized supply / collateral / ratio / oracle
  status (units already converted to USD and DGB). Powers
  [`/digidollar/stats`](/digidollar/stats).
- `GET /api/digidollar/price-history?hours=168` — sampled oracle price series
  (`[{ t, price_usd }]`).
- `GET /api/digidollar/activation` — activation/deployment status.

## Related

- [DigiDollar — the stablecoin explained](/digidollar) — what it is and why it is auditable.
- [DigiDollar live statistics](/digidollar/stats) — current supply, vaults, and collateral.
- [DigiByte RPC: deltas from Bitcoin Core](/docs/rpc) — the multi-algo RPC surface these calls sit alongside.