> ## Documentation Index
> Fetch the complete documentation index at: https://docs.primev.xyz/llms.txt
> Use this file to discover all available pages before exploring further.

# Registering as a Provider

To register on the mev-commit network, providers need to stake ETH in the provider registry contract. This adds credibility to issued commitments, as stake may be slashed in the event of a broken commitment, such as committing to a preconfirmation bid and not including the relevant transaction in a block.

<Warning>Providers must adhere to some rules and satisfy some criteria described [here](/v1.2.x/concepts/actors#rules-for-providers).</Warning>

<Note>
  **Validator opt-in status and proposal eligibility.** Registered providers are eligible to win blocks for **any** validator slot — there is no longer a relay-side filter restricting opted-in proposers to registered builders. Your builder competes for every slot on its merits.

  **Forthcoming: rewards contract.** A future protocol upgrade will introduce a rewards contract that providers winning blocks for opted-in proposers must route through as the block's `fee_recipient`. The contract takes a protocol fee from the producer reward and forwards the remainder to the validator's registered fee recipient. The fee is dynamic, bounded so opting in remains net-positive for validators. Specifications and activation timing will be published before this is enabled.
</Note>

Once a provider is registered on the network, other nodes will connect to it, and the provider node will receive bids.

You can use the provider API to stake and check your stake balance.

<Steps>
  <Step title="Launch mev-commit Node">
    Make sure you've [funded your account and launched a mev-commit node](/v1.2.x/get-started/quickstart) first.
  </Step>

  <Step title="Check Minimum Stake Amount">
    Check the minimum amount that can be staked, and consider staking more than the minimum. Bidders will only connect to providers which have stake higher than this minimum. The larger a provider's stake, the greater the credibility behind that provider's commitments. The amount is set in `wei`.

    ```shell theme={null}
    > curl localhost:13523/v1/provider/get_min_stake | jq
    {
      "amount": "1000000000000000000"
    }
    ```
  </Step>

  <Step title="Get Provider's Ethereum Address">
    Get your provider's Ethereum address from the topology endpoint. This will be used as the challenge message for BLS signing:

    ```shell theme={null}
    > curl localhost:13523/v1/debug/topology | jq .self."Ethereum Address"
    "0xB9286CB4782E43A202BfD426AbB72c8cb34f886c"
    ```
  </Step>

  <Step title="Generate BLS Signature">
    <Warning>
      Rewards on mev-commit now rely on the BLS key found in the relay and are then tied to the BLS key registered. The BLS key that is sending messages to the relay should be registered. This registration can now be done automatically without manual intervention. Once the registration is done, the settlement chain will be able to correctly attribute the winning providers on L1.
    </Warning>

    Download the bls-signer tool from the releases page and use it to generate your signature:

    ```shell theme={null}
    > bls-signer --private-key YOUR_BLS_PRIVATE_KEY --payload 0xB9286CB4782E43A202BfD426AbB72c8cb34f886c
    Payload: 0xB9286CB4782E43A202BfD426AbB72c8cb34f886c
    Public Key: 0x8e7884b3c4961550c13c87c0d0d30bdf8f3c9f3b5e0fb6259b2d1dc8c93432fac8f55d8c0f9e4f2a0f7d0a7b9b9f5d1
    Signature: 0xa1b2c3... # Your actual signature will be different
    ```

    Make note of both the public key and signature outputs - you'll need these in the next step.
  </Step>

  <Step title="Submit Stake Registration">
    <Info>
      You can map multiple BLS keys to a single stake registration by including multiple public keys and signatures in the arrays. This allows you to use different BLS keys while maintaining a single stake amount.
    </Info>

    Register your stake by submitting:

    * The stake amount (in wei)
    * Your BLS public key from the previous step
    * The BLS signature you generated

    Here's an example request:

    ```shell theme={null}
    # Replace with your actual values from the previous step
    > curl -sS -X POST "http://localhost:13523/v1/provider/stake/{AMOUNT}?bls_public_keys=${PK1}&bls_public_keys=${PK2}&bls_signatures=${SG1}&bls_signatures=${SG2}" | jq
    ```
  </Step>

  <Step title="Verify Registration">
    Once staked, peer connection logs should appear within a few minutes. You can check the `/topology` endpoint again to verify connected peers.
  </Step>
</Steps>

<Check>Congrats, your provider node is registered on mev-commit and you're ready to [consume bids](/v1.2.x/get-started/providers/consuming-bids).</Check>

Be sure to view [Querying for Proposers API](/v1.2.x/get-started/bidders/bidder-node-commands#querying-for-proposers-api) for information on detecting mev-commit opted-in Ethereum validators. Other commands that can be used are:

* Check stake balance

  ```shell theme={null}
  > curl localhost:13523/v1/provider/get_stake | jq
  {
    "amount": "0"
  }
  ```

* Get the account address of your node

  ```shell theme={null}
  > curl localhost:13523/v1/debug/topology | jq
  {
    "self": {
      "Addresses": [
        "/ip4/127.0.0.1/tcp/13522",
        "/ip4/172.29.0.4/tcp/13522"
      ],
      "Ethereum Address": "0xB9286CB4782E43A202BfD426AbB72c8cb34f886c",
      "Peer Type": "provider",
      "Underlay": "16Uiu2HAmDWZb4DxZQkS9yseXNukBFe6MhZdimSKuZcHFeJrF3jC9"
    },
    "connected_peers": null,
    "blocked_peers": null
  }
  ```

We recommend reading the [consuming bids](/v1.2.x/get-started/providers/consuming-bids) section next to consume bids effectively.

## Querying the Provider Registry

Bidders, relays, and other observers may want to enumerate currently registered providers and their BLS keys — for example, to identify which providers can issue credible commitments. The Provider Registry contract on the mev-commit chain is the source of truth.

**Contract address (mainnet):** see [Contracts](/v1.2.x/developers/contracts).

<Accordion title="Example: list all registered providers with their BLS keys">
  ```javascript theme={null}
  const ethers = require("ethers");

  const provider = new ethers.JsonRpcProvider("https://chainrpc.mev-commit.xyz/");
  const providerRegistryAddress = "0xb772Add4718E5BD6Fe57Fb486A6f7f008E52167E"; // mainnet

  const abi = [
      "event ProviderRegistered(address indexed provider, uint256 stakedAmount)",
      "function isProviderValid(address provider) public view",
      "function getBLSKeys(address provider) external view returns (bytes[])"
  ];

  const contract = new ethers.Contract(providerRegistryAddress, abi, provider);

  async function getRegisteredProviders() {
      const events = await contract.queryFilter(contract.filters.ProviderRegistered());
      const providerMap = {};
      for (const event of events) {
          const addr = event.args.provider;
          try {
              await contract.isProviderValid(addr);
              const blsKeys = await contract.getBLSKeys(addr);
              providerMap[addr] = blsKeys.map(k => ethers.hexlify(k));
          } catch { /* skip invalid */ }
      }
      return providerMap;
  }

  getRegisteredProviders().then(map => {
      for (const [addr, keys] of Object.entries(map)) {
          console.log(`Provider: ${addr}`);
          keys.forEach((k, i) => console.log(`  Key ${i + 1}: ${k}`));
      }
  });
  ```
</Accordion>