> For the complete documentation index, see [llms.txt](/llms.txt)

# Register as staking provider

**Time:** \~10 minutes.

<!-- -->

<!-- -->

<!-- -->

## Staking-provider registration

You're not staking your own tokens. You're registering as a provider that delegators can stake to. The flow is three transactions plus a metadata PR.

You'll need:

* The attester addresses you generated (from `key1_staker_output.json`).
* A **provider admin address** that will manage your provider entry (call `addKeysToProvider`, update commission, etc.). Use a multisig or hardware wallet you control.
* A **rewards recipient address** that receives your commission share. Splits-V2 Split contracts (one per delegation) push the commission portion here. Fine to be the same as the admin if you want.
* A commission rate, in basis points (`500` = 5 percent, `700` = 7 percent, etc.).

### 1. Register your provider

`registerProvider` is **permissionless** — any address with ETH for gas can sign the call. The three role addresses you pass as arguments determine who gets which permission afterward. The signer of *this* transaction has no onchain role; only the gas cost is deducted from it. Use any funded EOA you control.

```bash
cast send {{STAKING_REGISTRY_ADDR}} \
  "registerProvider(address,uint16,address)" \
  {{PROVIDER_ADMIN_ADDR}} \
  {{COMMISSION_BPS}} \
  {{REWARDS_RECIPIENT_ADDR}} \
  --rpc-url {{ETH_RPC}} \
  --private-key <any-funded-eoa-private-key>
```

The transaction returns your `providerIdentifier`. **Save it** — every subsequent provider call needs it. Paste the registration transaction hash below to get a ready-to-run extraction command:

```bash
cast receipt {{TX_HASH}} --rpc-url {{ETH_RPC}} | grep "return" | awk '{print $2}' | xargs cast to-dec
```

Paste the result into the configuration panel as **Provider ID**.

### 2. Add sequencer keystores to your queue

Your provider queue holds the attester identities that get activated when delegators stake. The [`add-keys-to-provider.sh`](/scripts/add-keys-to-provider.sh) helper reads your `keyN_staker_output.json` (the file generated by `aztec validator-keys new --staker-output`) and prints a ready-to-run `addKeysToProvider` command with the BLS keys encoded correctly:

```bash
curl -o add-keys-to-provider.sh https://docs.aztec.network/scripts/add-keys-to-provider.sh
chmod +x add-keys-to-provider.sh

STAKING_REGISTRY={{STAKING_REGISTRY_ADDR}} \
  PROVIDER_ID={{PROVIDER_ID}} \
  ETH_RPC={{ETH_RPC}} \
  ./add-keys-to-provider.sh ~/.aztec/keystore/key1_staker_output.json
```

The script prints the `cast send` command with a placeholder for the admin private key. Review it, add your admin key (or `--ledger`), and run it. The signer must be the provider admin address you set at registration.

Duplicates are not deduplicated onchain

The Staking Registry does **not** check for duplicate keys. If you accidentally register the same keystore twice, the duplicate sits at the top of your queue and breaks the next delegation. Recovery: call `dripProviderQueue(providerIdentifier, n)` to drop the bad entries. Verify your keystores are unique before adding.

One queue per provider, max 100 keystores per call

Each delegation pulls **one** keystore from your queue. If the queue is empty, new delegators can't activate sequencers. Add proactively, batched up to 100 entries per call to fit gas limits.

### 3. Submit your provider metadata

To appear on the staking dashboard, open a PR adding a JSON file to the [staking-dashboard repo](https://github.com/AztecProtocol/staking-dashboard):

* **Mainnet:** add `<providerId>-<your-name>.json` to `providers/`. Copy the format from [`_example.json`](https://github.com/AztecProtocol/staking-dashboard/blob/master/providers/_example.json).
* **Testnet:** same pattern under `providers-testnet/`.

Required fields: `providerId`, `providerName`, `providerDescription`, `providerEmail`, `providerWebsite`, `providerLogoUrl`, `discordUsername`, optional `providerSelfStake` array.

### 4. Wait for delegators (and configure coinbase as they arrive)

Once you're listed and your queue has keystores, delegators can stake. Each delegation spawns:

* **A new active attester**, drawn from your queue.
* **A Splits-V2 Split contract** that holds the reward distribution rules (your commission to the rewards-recipient address, the rest to the delegator's vault).

In the default flow, you then update that attester's keystore to set `coinbase = <Split contract address>` and reload the keystore, so its rewards flow into the Split. See [Configure environment](/operate/operators/provider/configure-environment.md#after-delegation-set-coinbase-to-the-split-contract) for the per-delegation update procedure.

You can find each Split's address on the staking dashboard, in the **Sequencer Registered (x)** dropdown for your provider. The dashboard maps each active attester to its Split contract.

Alternative: EOA coinbase with the payout script

The Split flow is the default, not the only option. A provider can set the coinbase to an address they control and run the [payout script](https://github.com/AztecProtocol/aztec-staking-payout) to calculate and distribute delegator rewards at a published commission and cadence. See [the configuration step](/operate/operators/provider/configure-environment.md#alternative-eoa-coinbase-with-the-payout-script) and the [forum announcement](https://forum.aztec.network/t/operator-commission-adjustments/8588).

### Verify your provider entry

The Staking Registry contract holds your provider configuration, keyed by your **provider ID** (the integer assigned by `registerProvider`). Paste that ID into the configuration panel as **Provider ID**, then run:

Provider config (admin / take rate / rewards recipient):

```bash
{ read PROVIDER_ADMIN; read TAKE_RATE; read REWARDS_RECIPIENT; } < <(
  cast call {{STAKING_REGISTRY_ADDR}} \
    "providerConfigurations(uint256)(address,uint16,address)" \
    {{PROVIDER_ID}} \
    --rpc-url {{ETH_RPC}}
)
echo "providerAdmin:            $PROVIDER_ADMIN"
echo "providerTakeRate:         $TAKE_RATE"
echo "providerRewardsRecipient: $REWARDS_RECIPIENT"
```

Queue depth (how many keystores are ready to be assigned to delegators):

```bash
QUEUE_LEN=$(cast call {{STAKING_REGISTRY_ADDR}} \
  "getProviderQueueLength(uint256)(uint256)" \
  {{PROVIDER_ID}} \
  --rpc-url {{ETH_RPC}})
echo "queueLength:              $QUEUE_LEN"
```

Field meanings:

* **`providerAdmin`** (address) — authorized to call `addKeysToProvider`, `updateProviderTakeRate`, and other management functions.
* **`providerTakeRate`** (uint16) — your commission in basis points (`500` = 5 percent, `700` = 7 percent).
* **`providerRewardsRecipient`** (address) — where your commission share lands when each Split distributes.
* **`queueLength`** — unallocated keystores in your queue. **Each delegation pulls one off**, so keep this above your expected weekly delegation flow. See [Updates, alerts, rewards](/operate/operators/provider/day-2-essentials.md#4-keep-your-provider-queue-stocked) for cron-style monitoring.

Recruit delegators

List yourself on community provider directories (e.g. [dashtec.xyz](https://dashtec.xyz)). Publish your commission rate, uptime history, and contact info. Delegators favour providers who communicate and respond to incidents.

## L1 contract addresses (<!-- -->Testnet (Sepolia)<!-- -->)

```text
Registry  {{REGISTRY_ADDR}}
Rollup    {{ROLLUP_ADDR}}
GSE       {{GSE_ADDR}}
Slasher   {{SLASHER_ADDR}}
```

Full list: [docs.aztec.network/networks](https://docs.aztec.network/networks).

What just happened?

You registered as a provider in the Governance Staking Escrow. You haven't staked anything; you've published your willingness to operate sequencer infrastructure on behalf of delegators, at the commission rate you set. As delegators stake to your queue, attester positions activate and your nodes begin attesting. Gross rewards go to your coinbase address; you keep your commission and forward the rest to delegators.