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

# Prepare to Run a Livepeer Gateway

> Hardware, network, and software requirements for running a Livepeer Gateway. Choose off-chain or on-chain deployment and prepare your environment.

export const dual = () => <Badge color="green">Dual-mode</Badge>;

export const ai = () => <Badge color="purple">AI</Badge>;

export const video = () => <Badge color="blue">Video</Badge>;

export const ChainlistRPCs = ({chainId = 42161}) => {
  const [rpcs, setRpcs] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);
  useEffect(() => {
    const fetchRPCs = async () => {
      try {
        const response = await fetch("https://raw.githubusercontent.com/DefiLlama/chainlist/main/constants/extraRpcs.js");
        if (response.ok) {
          const jsContent = await response.text();
          const chainPattern = new RegExp(`${chainId}:\\s*\\{[\\s\\S]*?rpcs:\\s*\\[([\\s\\S]*?)\\]\\s*,?\\s*\\}`, "m");
          const match = jsContent.match(chainPattern);
          if (match) {
            const rpcsBlock = match[1];
            const rpcList = [];
            const simpleUrls = rpcsBlock.match(/"(https?:\/\/[^"]+)"/g);
            if (simpleUrls) {
              simpleUrls.forEach(url => {
                rpcList.push({
                  url: url.replace(/"/g, ""),
                  tracking: "-"
                });
              });
            }
            const objectPattern = /\{\s*url:\s*"([^"]+)"[^}]*tracking:\s*"([^"]+)"/g;
            let objMatch;
            while ((objMatch = objectPattern.exec(rpcsBlock)) !== null) {
              if (!rpcList.find(r => r.url === objMatch[1])) {
                rpcList.push({
                  url: objMatch[1],
                  tracking: objMatch[2]
                });
              }
            }
            const wssUrls = rpcsBlock.match(/"(wss:\/\/[^"]+)"/g);
            if (wssUrls) {
              wssUrls.forEach(url => {
                const cleanUrl = url.replace(/"/g, "");
                if (!rpcList.find(r => r.url === cleanUrl)) {
                  rpcList.push({
                    url: cleanUrl,
                    tracking: "-"
                  });
                }
              });
            }
            setRpcs(rpcList);
          } else {
            throw new Error("Chain not found in data");
          }
        } else {
          throw new Error("Failed to fetch chain data");
        }
      } catch (err) {
        setError("Failed to load RPC data");
        console.error("ChainlistRPCs error:", err);
      } finally {
        setLoading(false);
      }
    };
    fetchRPCs();
  }, [chainId]);
  if (loading) {
    return <div>Loading RPC endpoints...</div>;
  }
  if (error) {
    return <div>Error: {error}</div>;
  }
  const publicRpcs = rpcs.filter(rpc => {
    const url = typeof rpc === "string" ? rpc : rpc.url;
    return url && !url.includes("${") && !url.includes("API_KEY");
  });
  return <div style={{
    overflowX: "auto"
  }}>
      <table style={{
    width: "100%",
    borderCollapse: "collapse",
    fontSize: "0.9rem"
  }}>
        <thead>
          <tr style={{
    backgroundColor: "#2d9a67",
    color: "#fff"
  }}>
            <th style={{
    padding: "12px 16px",
    textAlign: "left",
    fontWeight: "600",
    borderBottom: "2px solid #2d9a67"
  }}>
              RPC URL
            </th>
            <th style={{
    padding: "12px 16px",
    textAlign: "center",
    fontWeight: "600",
    borderBottom: "2px solid #2d9a67",
    width: "80px"
  }}>
              Type
            </th>
          </tr>
        </thead>
        <tbody>
          {publicRpcs.map((rpc, index) => {
    const url = typeof rpc === "string" ? rpc : rpc.url;
    const isWebsocket = url.startsWith("wss://");
    return <tr key={index} style={{
      borderBottom: "1px solid #333"
    }}>
                <td style={{
      padding: "10px 16px",
      fontFamily: "monospace"
    }}>
                  <code>{url}</code>
                </td>
                <td style={{
      padding: "10px 16px",
      textAlign: "center"
    }}>
                  {isWebsocket ? "WSS" : "HTTPS"}
                </td>
              </tr>;
  })}
        </tbody>
      </table>
    </div>;
};

export const StyledStep = ({title, icon, titleSize = 'h3', iconColor = null, titleColor = null, children, className = '', style = {}, ...rest}) => {
  const styledTitle = titleColor ? <span style={{
    color: titleColor
  }}>{title}</span> : title;
  return <Step title={styledTitle} icon={icon} iconColor={iconColor || undefined} titleSize={titleSize} className={className} style={style} {...rest}>
      {children}
    </Step>;
};

export const StyledSteps = ({children, iconColor, titleColor, lineColor, iconSize = '24px', className = '', style = {}, ...rest}) => {
  const resolvedIconColor = iconColor || 'var(--accent-dark, #18794E)';
  const resolvedTitleColor = titleColor || 'var(--lp-color-accent)';
  const resolvedLineColor = lineColor || 'var(--lp-color-accent)';
  return <div className={['docs-styled-steps', className].filter(Boolean).join(' ')} style={style} {...rest}>
      <style>{`
        .docs-styled-steps .steps > div > div.absolute > div {
          background-color: ${resolvedIconColor};
        }
        .docs-styled-steps .steps > div > div.w-full > p {
          color: ${resolvedTitleColor};
        }
        .docs-styled-steps .steps > div > div.absolute.w-px {
          background-color: ${resolvedLineColor};
        }
        .docs-styled-steps .steps > div:last-child > div.absolute.w-px::after {
          content: '';
          position: absolute;
          bottom: 0;
          left: 50%;
          transform: translateX(-50%);
          width: 6px;
          height: 6px;
          background-color: ${resolvedLineColor};
          transform: translateX(-50%) rotate(45deg);
        }
      `}</style>
      <div>
        <Steps>{children}</Steps>
      </div>
    </div>;
};

export const TableCell = ({children, align = "left", header = false, style = {}, className = "", ...rest}) => {
  const Component = header ? "th" : "td";
  return <Component className={className} style={{
    padding: "0.75rem 1rem",
    textAlign: align,
    border: header ? "none" : "1px solid var(--lp-color-border-default)",
    ...style
  }} {...rest}>
      {children}
    </Component>;
};

export const TableRow = ({children, header = false, hover = false, style = {}, className = "", ...rest}) => {
  const rowId = `table-row-${Math.random().toString(36).substr(2, 9)}`;
  return <>
      {hover && <style>{`
          #${rowId}:hover {
            background-color: var(--lp-color-bg-card);
          }
        `}</style>}
      <tr id={rowId} className={className} style={{
    ...header && ({
      backgroundColor: "var(--lp-color-accent-strong)",
      color: "var(--lp-color-on-accent)",
      fontWeight: "bold"
    }),
    ...style
  }} {...rest}>
        {children}
      </tr>
    </>;
};

export const StyledTable = ({children, variant = "default", style = {}, className = "", ...rest}) => {
  const wrapperVariants = {
    default: {
      border: "1px solid var(--lp-color-border-default)",
      backgroundColor: "var(--lp-color-bg-card)",
      overflow: "hidden"
    },
    bordered: {
      border: "2px solid var(--lp-color-accent)",
      backgroundColor: "var(--lp-color-bg-page)",
      overflow: "hidden"
    },
    minimal: {
      border: "none",
      backgroundColor: "transparent",
      overflow: "visible"
    }
  };
  return <div data-docs-styled-table-shell className={className} style={{
    width: "100%",
    padding: 0,
    margin: 0,
    ...wrapperVariants[variant],
    ...style
  }} {...rest}>
      <table data-docs-styled-table style={{
    width: "100%",
    borderCollapse: "collapse",
    borderSpacing: 0,
    margin: 0,
    backgroundColor: "transparent"
  }}>
        {children}
      </table>
    </div>;
};

export const BorderedBox = ({children, variant = "default", padding = "var(--lp-spacing-4)", borderRadius = "var(--lp-spacing-px-8)", margin = "", accentBar = "", style = {}, className = "", ...rest}) => {
  const variants = {
    default: {
      border: "1px solid var(--lp-color-border-default)",
      backgroundColor: "var(--lp-color-bg-card)"
    },
    accent: {
      border: "1px solid var(--lp-color-accent)",
      backgroundColor: "var(--lp-color-bg-card)"
    },
    muted: {
      border: "1px solid var(--lp-color-border-default)",
      backgroundColor: "transparent"
    }
  };
  const accentBarColors = {
    accent: "var(--lp-color-accent)",
    positive: "var(--green-9)"
  };
  return <div data-docs-bordered-box="" data-accent-bar={accentBarColors[accentBar] ? "" : undefined} className={className} style={{
    ...variants[variant],
    padding: padding,
    borderRadius: borderRadius,
    ...margin ? {
      margin
    } : {},
    ...accentBarColors[accentBar] ? {
      position: "relative",
      '--accent-bar-color': accentBarColors[accentBar]
    } : {},
    ...style
  }} {...rest}>
      {children}
    </div>;
};

export const CustomDivider = ({color = "var(--lp-color-border-default)", middleText = "", spacing = "default", style = {}, className = "", ...rest}) => {
  const spacingPresets = {
    default: {
      margin: "24px 0"
    },
    overlap: {
      margin: "-1rem 0 -1rem 0"
    },
    tight: {
      margin: "0 0 -1rem 0"
    },
    section: {
      margin: "0 0 -2rem 0"
    },
    sectionOverlap: {
      margin: "-1rem 0 -2rem 0"
    },
    deepOverlap: {
      margin: "-1rem 0 -1.5rem 0"
    }
  };
  const spacingStyle = spacingPresets[spacing] || spacingPresets.default;
  return <div role="separator" aria-orientation="horizontal" className={className} style={{
    display: "flex",
    alignItems: "center",
    ...spacingStyle,
    fontSize: style?.fontSize || "16px",
    height: "fit-content",
    ...style
  }} {...rest}>
      <span style={{
    marginRight: "var(--lp-spacing-px-8)",
    opacity: 0.2
  }}>
        <Icon icon="/snippets/assets/logos/Livepeer-Logo-Symbol-Theme.svg" />
      </span>
      <div style={{
    flex: 1,
    height: "1px",
    background: "var(--lp-color-border-default)",
    opacity: 0.4
  }}></div>
      {middleText && <>
          <Icon icon="circle" size={2} />
          <span style={{
    margin: "0 8px",
    fontWeight: "bold",
    color: color,
    opacity: 0.7
  }}>
            {middleText}
          </span>
          <Icon icon="circle" size={2} />
        </>}
      <div style={{
    flex: 1,
    height: "1px",
    background: "var(--lp-color-border-default)",
    opacity: 0.4
  }}></div>
      <span style={{
    marginLeft: "var(--lp-spacing-px-8)",
    opacity: 0.2
  }}>
        <span style={{
    display: "inline-block",
    transform: "scaleX(-1)"
  }}>
          <Icon icon="/snippets/assets/logos/Livepeer-Logo-Symbol-Theme.svg" />
        </span>
      </span>
    </div>;
};

export const LinkArrow = ({href, label, description, newline = true, borderColor, className = '', style = {}, ...rest}) => {
  const linkArrowStyle = {
    display: 'inline-flex',
    alignItems: 'center',
    justifyContent: 'center',
    gap: "var(--lp-spacing-1)",
    width: 'fit-content',
    ...borderColor && ({
      borderColor
    })
  };
  return <span className={className} style={style} {...rest}>
      {newline && <br />}
      <span style={linkArrowStyle}>
        <a href={href} target="_blank" rel="noopener noreferrer">
          {label}
        </a>
        <Icon icon="arrow-up-right" size={14} color="var(--lp-color-accent)" />
      </span>
      {description && description}
      {description && <div style={{
    height: "var(--lp-spacing-3)"
  }} />}
    </span>;
};

export const DoubleIconLink = ({label = '', labelColor, href = '#', text = '', iconLeft = 'github', iconLeftColor, iconRight = 'arrow-up-right', iconRightColor = 'var(--lp-color-accent)', className = '', style = {}, ...rest}) => {
  return <span className={className} style={{
    whiteSpace: 'nowrap',
    display: 'inline-flex',
    alignItems: 'center',
    gap: "var(--lp-spacing-1)",
    marginLeft: '0.3rem',
    ...style
  }} {...rest}>
      {text && <span style={{
    marginRight: 8
  }}>{text}</span>}
      <Icon icon={iconLeft} color={iconLeftColor} />
      <a href={href} style={{
    color: {
      labelColor
    }
  }}>
        {label}
      </a>
      <div style={{
    marginRight: '0.3rem'
  }}>
        <Icon icon={iconRight} size={12} color={iconRightColor} />
      </div>
    </span>;
};

<CustomDivider style={{margin: "0 0 -1rem 0"}} />

# <Icon icon="clipboard-check" size={26} /> Prepare Your Environment

Before installing, confirm your system meets the requirements and choose a deployment mode. Hardware, network, OS compatibility, and on-chain wallet setup.

<BorderedBox variant="accent" accentBar="positive" margin="0 1rem">
  **Deployment mode:**

  * <Icon icon="floppy-disk" size={16} /> **Off-chain** - direct Orchestrator connection, no blockchain interaction
  * <Icon icon="link" size={16} /> **On-chain** - connects to the Livepeer Protocol on Arbitrum

  **Node type (workload):**

  * {video()} transcoding
  * {ai()} inference
  * {dual()} both video and AI
</BorderedBox>

<Note>
  Gateway nodes do not require NVIDIA GPU drivers. Driver setup is only required on systems running GPU workloads (Orchestrators or AI workers).
</Note>

<CustomDivider />

## Hardware Requirements

Gateways are lightweight routing nodes. Minimum specs are sufficient for development and low-traffic deployments.

<StyledTable>
  <TableRow header>
    <TableCell header>Component</TableCell>
    <TableCell header>Minimum</TableCell>
    <TableCell header>Recommended</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>CPU</TableCell>
    <TableCell>2 cores</TableCell>
    <TableCell>4-8 cores</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>RAM</TableCell>
    <TableCell>4 GB</TableCell>
    <TableCell>16-32 GB</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>Storage</TableCell>
    <TableCell>20 GB SSD</TableCell>
    <TableCell>100 GB NVMe SSD</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>Network</TableCell>
    <TableCell>50 Mbps symmetric</TableCell>
    <TableCell>1 Gbps symmetric</TableCell>
  </TableRow>
</StyledTable>

<CustomDivider />

## Network Requirements

* Low-latency connectivity to Orchestrators
* Ability to handle high request throughput

For **on-chain production** deployments:

* Public HTTPS endpoint
* Static IP or domain name
* Multi-region deployment or failover (recommended)

<CustomDivider />

## OS Compatibility

<StyledTable>
  <TableRow header>
    <TableCell header>OS</TableCell>
    <TableCell header>Install Method</TableCell>
    <TableCell header>Video Gateway</TableCell>
    <TableCell header>AI / Dual Gateway</TableCell>
    <TableCell header>Notes</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>Linux (Ubuntu recommended)</TableCell>
    <TableCell>Docker or binary</TableCell>
    <TableCell>Yes</TableCell>
    <TableCell>Yes</TableCell>
    <TableCell>Recommended for all production deployments</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>Windows (WSL2 + Docker)</TableCell>
    <TableCell>Docker via WSL2</TableCell>
    <TableCell>Yes</TableCell>
    <TableCell>Limited</TableCell>
    <TableCell>Linux in WSL2. NVIDIA + CUDA only for GPU workloads</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>Windows (native)</TableCell>
    <TableCell>Pre-built binary</TableCell>
    <TableCell>Yes</TableCell>
    <TableCell>No</TableCell>
    <TableCell>Video only. No AI binary available for Windows</TableCell>
  </TableRow>

  <TableRow>
    <TableCell>macOS (Intel / Apple)</TableCell>
    <TableCell>Build from source</TableCell>
    <TableCell>Yes</TableCell>
    <TableCell>No</TableCell>
    <TableCell>Development and routing only. Docker often unreliable on macOS</TableCell>
  </TableRow>
</StyledTable>

All Gateways install the <DoubleIconLink label="go-livepeer" href="https://github.com/livepeer/go-livepeer" iconLeft="github" /> software. Root or sudo access is required.

<CustomDivider />

## Choose Deployment Mode

<BorderedBox variant="accent">
  <Tabs>
    <Tab title="Off-Chain" icon="floppy-disk">
      Off-chain mode connects directly to Orchestrators without blockchain interaction. No wallet, RPC, or ETH required.

      **You will need:**

      * An Orchestrator node address to connect to (local or remote)
      * A CPU-only Orchestrator is sufficient for basic jobs
      * AI inference requires a GPU-equipped Orchestrator

      Off-chain mode is ideal for:

      * Local development and testing
      * Learning Gateway functionality
      * Prototyping without financial commitments
      * Running private transcoding infrastructure

      <Card title="Next Step: Install go-livepeer" icon="download" href="/v2/gateways/setup/install" horizontal arrow>
        No further preparation needed for off-chain mode
      </Card>
    </Tab>

    <Tab title="On-Chain" icon="link">
      On-chain mode connects to the Livepeer Protocol on Arbitrum One. Required for production Gateways.

      **You will need:**

      * An Arbitrum One RPC URL
      * A funded Ethereum account (wallet) with ETH for gas and deposits

      On-chain mode is for:

      * Public production Gateways
      * Running a business on the Livepeer Network

      Complete the on-chain setup steps below before proceeding to install.

      <CustomDivider />

      ### RPC URL

      The Gateway requires an Arbitrum One RPC URL (`-ethUrl` flag) to interact with Livepeer smart contracts.

      **Quick start (rate-limited, suitable for testing):**

      ```bash theme={"theme":{"light":"github-light","dark":"dark-plus"}}
      -ethUrl=https://arb1.arbitrum.io/rpc
      ```

      <Accordion title="See all RPC options" icon="link">
        <Tabs>
          <Tab title="Public RPCs">
            Free-tier public RPCs are sufficient for a single Gateway.

            Chainlist provides a full list of public Arbitrum One RPCs:

            *             <DoubleIconLink label="Chainlist" href="https://chainlist.org/chain/42161" iconLeft="link" />
            *             <DoubleIconLink label="Arbitrum RPC Reference" href="/v2/gateways/resources/compendium/arbitrum-rpc" iconLeft="books" />

            <Expandable title="Chainlist Arbitrum One RPC List">
              <ChainlistRPCs chainId={42161} />
            </Expandable>
          </Tab>

          <Tab title="Paid Providers">
            For production or multiple Gateways, use a paid RPC provider:

            | Provider                               | Arbitrum One | Websocket | Notes               |
            | -------------------------------------- | ------------ | --------- | ------------------- |
            | [Alchemy](https://www.alchemy.com)     | Yes          | Yes       | Free tier available |
            | [Infura](https://www.infura.io)        | Yes          | Yes       | Free tier available |
            | [Ankr](https://www.ankr.com)           | Yes          | Yes       |                     |
            | [Chainstack](https://chainstack.com)   | Yes          | Yes       |                     |
            | [Quicknode](https://www.quicknode.com) | Yes          | Yes       |                     |
          </Tab>

          <Tab title="Self-Hosted">
            Self-host an Arbitrum node for maximum reliability and no rate limits.

            See the <DoubleIconLink label="Arbitrum Full Node Guide" href="https://docs.arbitrum.io/node-running/how-tos/running-a-full-node" iconLeft="link" />.
          </Tab>
        </Tabs>
      </Accordion>

      <CustomDivider />

      ### ETH Account and Keystore

      The Gateway needs an Ethereum account to sign transactions on Arbitrum.

      <Tip>
        Livepeer auto-generates a wallet and keystore on first run if no existing account is provided. Run the Gateway once with empty account flags and follow the prompts.
      </Tip>

      <Accordion title="Account setup options" icon="wallet">
        <Tabs>
          <Tab title="Auto-Generate (Recommended)">
            Run go-livepeer with empty account flags. The software creates a new wallet and keystore, then prompts for a password:

            ```bash theme={"theme":{"light":"github-light","dark":"dark-plus"}}
            livepeer -gateway \
              -network arbitrum-one-mainnet \
              -ethUrl=https://arb1.arbitrum.io/rpc \
              -ethAcctAddr="" \
              -ethKeystorePath="" \
              -ethPassword=""
            ```

            The keystore is created in `~/.lpData/arbitrum-one-mainnet/keystore/`.
          </Tab>

          <Tab title="Existing Wallet">
            Use any Ethereum wallet that can transact on Arbitrum One. Provide the public address:

            ```bash theme={"theme":{"light":"github-light","dark":"dark-plus"}}
            livepeer -gateway \
              -network arbitrum-one-mainnet \
              -ethUrl=https://arb1.arbitrum.io/rpc \
              -ethAcctAddr=<YOUR_WALLET_ADDRESS> \
              -ethKeystorePath=~/.lpData/keystore \
              -ethPassword=/path/to/password.txt
            ```

            Wallet guides for reference:

            *             <DoubleIconLink label="MetaMask" href="https://support.metamask.io/configure/accounts/how-to-view-your-account-details-and-public-address" iconLeft="link" />
            *             <DoubleIconLink label="Ledger" href="https://support.ledger.com/article/8978919811485-zd" iconLeft="link" />
            *             <DoubleIconLink label="Trezor" href="https://support.trezor.io/en/articles/360018565096-trezor-faq" iconLeft="link" />
          </Tab>
        </Tabs>
      </Accordion>

      <Danger>
        Use ONLY your **public** wallet address in `-ethAcctAddr`. Never use your private key. A public address is like a bank account number. A private key is like your PIN.
      </Danger>

      **Keystore default locations:**

      | Environment                | Path                                                   |
      | -------------------------- | ------------------------------------------------------ |
      | Linux / macOS              | `~/.lpData/arbitrum-one-mainnet/keystore/`             |
      | Docker (inside container)  | `/root/.lpData/arbitrum-one-mainnet/keystore/`         |
      | Docker (host volume mount) | `./data/gateway/arbitrum-one-mainnet/keystore/`        |
      | Windows                    | `%USERPROFILE%\.lpData\arbitrum-one-mainnet\keystore\` |

      <CustomDivider />

      ### Fund the Account

      Add ETH to the account on Arbitrum One for gas fees and Gateway deposits.

      * Minimum recommended to start: **0.1 ETH**
      * Bridge option: [Arbitrum Bridge](https://bridge.arbitrum.io/)
      * Exchange options: <LinkArrow href="/v2/gateways/resources/compendium/arbitrum-exchanges" label="Arbitrum Exchanges" newline={false} />

      <Card title="Fund Your Gateway" icon="coins" href="/v2/gateways/guides/payments-and-pricing/fund-gateway" horizontal arrow>
        Deposit and reserve setup via livepeer\_cli
      </Card>

      <CustomDivider />

      ### Required On-Chain Flags

      <StyledTable>
        <TableRow header>
          <TableCell header>Flag</TableCell>
          <TableCell header>Purpose</TableCell>
          <TableCell header>Example</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>`-network`</TableCell>
          <TableCell>Blockchain network</TableCell>
          <TableCell>`arbitrum-one-mainnet`</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>`-ethUrl`</TableCell>
          <TableCell>Arbitrum One RPC URL</TableCell>
          <TableCell>`https://arb1.arbitrum.io/rpc`</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>`-ethAcctAddr`</TableCell>
          <TableCell>Ethereum wallet address (0x prefix optional)</TableCell>
          <TableCell>`0xYOUR_ADDRESS`</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>`-ethPassword`</TableCell>
          <TableCell>Password or path to password file</TableCell>
          <TableCell>`/path/to/password.txt`</TableCell>
        </TableRow>

        <TableRow>
          <TableCell>`-ethKeystorePath`</TableCell>
          <TableCell>Path to keystore directory or file</TableCell>
          <TableCell>`~/.lpData/keystore`</TableCell>
        </TableRow>
      </StyledTable>

      <Warning>
        Never share keystore files. They contain encrypted private keys. Use strong passwords and back up keystore files securely. If the password is lost, the account cannot be recovered.
      </Warning>

      <Card title="Next Step: Install go-livepeer" icon="download" href="/v2/gateways/setup/install" horizontal arrow>
        On-chain preparation complete - proceed to installation
      </Card>
    </Tab>
  </Tabs>
</BorderedBox>