> ## Documentation Index
> Fetch the complete documentation index at: https://na-36-docs-orchestrator-wallet-security.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Activate on Arbitrum

> Fund your wallet, stake LPT, register your service URI, and enter the active set so gateways can send you jobs.

A configured node isn't earning yet. This guide connects it to the Livepeer protocol on Arbitrum One:
fund the wallet, stake LPT, activate on-chain, and confirm reward calling.

<Warning>
  Start this **after** ETH and LPT are already in your orchestrator wallet on Arbitrum One. Acquiring
  LPT often involves exchange settlement and bridging — plan for hours to days. See
  [Acquire LPT on Arbitrum](/network/guides/delegator-acquire-lpt).
</Warning>

## 1. Point at a reliable Arbitrum RPC

`-ethUrl` connects the node to Arbitrum One. The community-run [LiveInfra SPE](https://liveinfraspe.com/)
endpoint is free for verified orchestrators. Free tiers from **Alchemy** (300M compute units/mo) or
**Infura** (100K req/day) also work for most operators. Public endpoints like `arb1.arbitrum.io/rpc`
are for testing only — a dropped connection during round initialization can forfeit that round's reward.

Verify the endpoint is actually Arbitrum One:

```bash theme={null}
curl -s -X POST -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}' \
  YOUR_RPC_URL
# Expect "result":"0xa4b1" (42161). "0x1" means you're on Ethereum L1 — switch endpoints.
```

## 2. Choose your orchestrator wallet

The orchestrator wallet holds your staked LPT and receives fees. **It never needs to run on the
node** — you only use it to update orchestrator settings, move funds, and vote. Use a hardware wallet
or a [Safe](https://safe.global) multisig.

Alternatively, `go-livepeer` creates an account on first start and prints the address in the logs:

```bash theme={null}
docker compose logs 2>&1 | grep -i "account\|address"
```

<Warning>
  If you use this keystore, its private key lives at `~/.lpData/arbitrum-one-mainnet/keystore`.
  **Back it up offline now.** Losing it means permanent loss of the account and all bonded LPT.
</Warning>

## 3. Fund the wallet with ETH on Arbitrum

Every on-chain action (activation, reward calls, ticket redemption) costs gas. Keep at least
**0.05 ETH** on Arbitrum One to start, and never let it fall below \~0.01 ETH. Get arbETH by
withdrawing from an exchange that supports Arbitrum, or bridging from L1 at
[bridge.arbitrum.io](https://bridge.arbitrum.io). Verify the balance on [Arbiscan](https://arbiscan.io).

## 4. Stake LPT

LPT bonded to your address is what puts you in the active set (top orchestrators by total stake).
Check the current threshold on the [Explorer](https://explorer.livepeer.org/orchestrators) before
deciding how much to acquire. The orchestrator itself only needs a 1 LPT self-bond. **Stake the rest by
delegating from a hardware wallet** rather than bonding it all from a keystore. Self-bond on the
[Explorer](https://explorer.livepeer.org), or in the CLI if the keystore is on the node:

```bash theme={null}
docker exec -it livepeer-orchestrator livepeer_cli
```

<Warning>
  Transactions in `livepeer_cli` require the node to be started with `-enableCliTxRoutes`. Add it for
  these steps only and remove it afterwards. Keep `-cliAddr` on `127.0.0.1:7935` and never expose
  port 7935 to the internet.
</Warning>

Either way, two transactions are submitted — `approve`, then `bond`. Wait for both to confirm.

## 5. Activate on-chain

In `livepeer_cli`, select **"Invoke multi-step 'become an orchestrator'"** and set your commission:

| Prompt          | Example               | Meaning                                                |
| --------------- | --------------------- | ------------------------------------------------------ |
| Reward Cut      | `10`                  | % of LPT inflation you keep (10% → delegators get 90%) |
| Fee Cut         | `95`                  | % of ETH fees you keep (95% → delegators get 5%)       |
| Service address | `YOUR_PUBLIC_IP:8935` | Must match `-serviceAddr` exactly                      |

Without a keystore on the node, make the same two calls from your wallet: `transcoder` on the
[`BondingManager`](/network/reference/contracts) and `setServiceURI` on the
[`ServiceRegistry`](/network/reference/contracts), or on the
[`AIServiceRegistry`](/network/reference/contracts) if you serve AI.

<Warning>
  **The Explorer displays Fee Cut inverted, as "Fee Share."** Set Fee Cut `95` here and your profile
  will show **Fee Share 5%** — the portion passed to delegators. That's the same setting, not a
  misconfiguration. (Reward Cut displays as-is.)
</Warning>

<Note>
  Your node joins the active set at the **start of the next round** (\~22h), and only if your total
  stake is in the top 100. The Explorer may show **Registered** until then.
</Note>

See [Economics](/network/explanation/economics) for how these two settings affect both your earnings and your
appeal to delegators.

## 6. Run the node on a throwaway wallet

The machine doing the work is your exposed surface. **Never run it with the orchestrator key.** Start
the node with a fresh `-dataDir` so it generates a new account, send that address a little ETH for
gas, and point it at your orchestrator:

| Flag           | Value                     | Purpose                                                                    |
| -------------- | ------------------------- | -------------------------------------------------------------------------- |
| `-ethAcctAddr` | throwaway address         | Signs for the node, redeems tickets, and can be the reward caller (step 7) |
| `-ethOrchAddr` | your orchestrator address | Fees and rewards accrue here                                               |

<Warning>
  If you activated from a keystore on this machine, finish step 7, then move it to cold storage and
  delete it from the node. A compromised machine then yields a near-empty wallet, not your stake.
</Warning>

## 7. Set up a reward caller

Delegate reward calling to a separate, low-privilege wallet. It can only call `reward()` — not move
funds, unbond, change settings, or vote — so the orchestrator wallet stays in cold storage
([LIP-118](https://github.com/livepeer/LIPs/blob/master/LIPs/LIP-118.md)).

**Choose the caller:**

<Tabs>
  <Tab title="go-livepeer">
    The throwaway wallet from step 6. The node reads the on-chain mapping and calls reward for
    `-ethOrchAddr` itself — no extra flags.
  </Tab>

  <Tab title="Standalone caller">
    The wallet of a [livepeer-reward-caller](https://github.com/rickstaa/livepeer-reward-caller)
    you run yourself — a single static binary with its own keystore. Start the node with
    `-reward=false`.
  </Tab>

  <Tab title="Shared caller">
    The community [livepeer.bot caller](https://forum.livepeer.org/t/livepeer-bot-put-your-orchestrator-keys-in-cold-storage-a-shared-lip-118-reward-caller-live-on-arbitrum-one/3330),
    which calls reward for every orchestrator that authorizes its address. Nothing to run. Start the
    node with `-reward=false`.
  </Tab>
</Tabs>

**Authorize it** from your orchestrator wallet — with [`cast`](https://getfoundry.sh/cast/overview)
against the [`BondingManager`](/network/reference/contracts), or with **"Set reward caller"** in
`livepeer_cli` if the keystore is on the node:

```bash theme={null}
cast send 0x35Bcf3c30594191d53231E4FF333E8A770453e40 \
  "setRewardCaller(address)" <REWARD_CALLER_ADDR> \
  --rpc-url <ARBITRUM_RPC_URL> \
  --keystore <ORCHESTRATOR_KEYSTORE>
```

Set it to `0x0000000000000000000000000000000000000000` to revoke. Arbiscan does not show this method
on the proxy page yet, but it is live on-chain.

## 8. Confirm reward calling

After the next round starts (\~22h), your orchestrator's page on the
[Explorer](https://explorer.livepeer.org/orchestrators) shows the reward call. With a standalone or
shared caller, its wallet on Arbiscan shows it too. With go-livepeer, the node logs do:

```bash theme={null}
docker compose logs 2>&1 | grep -i reward
```

A missed round forfeits that round's LPT permanently — there is no catch-up.

<Note>
  **Exception for very low stake:** if reward-call gas costs more than the LPT you'd earn, disabling
  automatic calling and calling manually until your stake grows can be the rational choice. Reward
  calls use \~350k–450k gas (cents at typical Arbitrum prices).
</Note>

<Tip>
  A caller that quietly stops looks exactly like one that is working. Send
  `/subscribe <orchestrator address>` to [@OrchestratorWatcherBot](https://t.me/OrchestratorWatcherBot)
  on Telegram for alerts on missed reward calls, and see
  [Monitor your orchestrator](/network/guides/orchestrator-monitor).
</Tip>

## 9. Verify

On [explorer.livepeer.org/orchestrators](https://explorer.livepeer.org/orchestrators), search your
address and confirm **Status**, **Stake**, **Reward Cut**, and **Fee Cut**. The Explorer does not show
the service URI — read it from the [`ServiceRegistry`](/network/reference/contracts), then confirm
external reachability:

```bash theme={null}
cast call 0xC92d3A360b8f9e083bA64DE15d95Cf8180897431 \
  "getServiceURI(address)(string)" <ORCHESTRATOR_ADDR> --rpc-url <ARBITRUM_RPC_URL>
curl -k https://YOUR_PUBLIC_IP:8935/status
```

If the service URI is wrong or unreachable, update it in `livepeer_cli` or via `setServiceURI` on the
contract (this costs gas). A bad or unreachable service address is the most common reason an active
node still receives no jobs — see the [FAQ](/network/reference/faq).

## Next

<CardGroup cols={2}>
  <Card title="Set pricing" icon="tag" href="/network/guides/orchestrator-pricing">
    The other half of getting selected by gateways.
  </Card>

  <Card title="Add AI inference" icon="microchip" href="/network/guides/orchestrator-add-ai">
    Open a second revenue stream.
  </Card>
</CardGroup>