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

# Quickstart

> Install the CLI, create a wallet, fund it, send your first transfer, and confirm the result in five minutes.

Get from zero to your first on-chain transfer on The DevNet Grid in about five minutes. You'll install the CLI, point it at the network, fund a wallet from the faucet, send GEN to a second address, and confirm both the activation and the resulting balance.

## Prerequisites

* macOS or Linux
* A terminal you're comfortable with

## Step 1: Install the CLI

Download the `gen` binary for your platform and put it on your `PATH`.

```bash theme={null}
mv ./gen /usr/local/bin/gen
chmod +x /usr/local/bin/gen
```

Verify the install:

```bash theme={null}
gen --help
```

You should see the top-level command list (`wallet`, `client`, `config`, `service`, and others). If that prints, you're ready.

## Step 2: Connect to a network

<Note>
  **DevNet access.** DevNet requires a bearer token issued by Gen Labs. Ask your contact for one and substitute it for `<your-jwt>` in the commands below.
</Note>

The CLI reaches networks through named **environments**. Create one for DevNet, attach your JWT, and make it active so you don't have to pass `--env` or `--rpc-url` on every call. DevNet requires a bearer token on every request, so persist your JWT as an `Authorization` header:

```bash theme={null}
gen config env new --name devnet --rpc https://devnet.genlabs.co/rpc/
gen config env set devnet --header "authorization: Bearer <your-jwt>"
gen config env switch devnet
```

Confirm the effective config:

```bash theme={null}
gen config show
```

Expected output — a **Global settings** section plus an **Environments** list, with the active env marked `*`:

```text theme={null}
Global settings:
  wallet root:  (default: ~/.gen/wallets)

Environments:
  local                 http://127.0.0.1:30001
* devnet                https://devnet.genlabs.co/rpc/
  Run `gen config env show <name>` to see an environment's full configuration.
```

To see one environment's full detail, including headers, run `gen config env show devnet` (header values are redacted by default; add `--show-secrets` to reveal them):

```text theme={null}
name:          devnet [active]
rpc_url:       https://devnet.genlabs.co/rpc/
rpc_transport: jsonrpc (default)
headers:
  authorization: <redacted>
  (header values hidden; use --show-secrets to reveal)
```

You can hit a different endpoint for a single command with `--env <name>`, override the URL with `--rpc-url <URL>`, and add or override headers with `--header "name: value"`. To remove the environment later, run `gen config env delete devnet`.

## Step 3: Create a wallet

Create a new wallet called `alice`. This becomes your active wallet automatically:

```bash theme={null}
gen wallet create alice
```

The CLI prints a 32-byte hex private key **once**, along with the wallet's address (a `grd@...` bech32m string). Save the key somewhere safe. There is no way to recover it later. (If you'd rather have a BIP-39 recovery phrase, pass `--mnemonic`.)

Expected output (abridged):

```text theme={null}
Created wallet 'alice'
  account: grd@1qgqqqqqgcte6a...
  public key: 0x...

Seed (write this down. It will not be shown again):
  0x...
```

Grab the account's address into a shell variable so the next steps are copy-paste:

```bash theme={null}
ALICE=$(gen wallet --json show alice --account-address-only | jq -r .result.account)
```

## Step 4: Fund the wallet from the faucet

Ask the DevNet faucet to fund Alice. The faucet auto-creates the account on first use:

```bash theme={null}
gen wallet faucet --amount 1000000000
```

Expected output:

```text theme={null}
Faucet transfer submitted

Recipient: grd@1zjm8wamf3nz...
Token contract: grd@1ma475ve...
Amount: 1000000000
Mode: with confirmation

Status: success
Activation ID: 0xf0f37be6...aff3
```

In `--json` mode the result looks like:

```json theme={null}
{
  "ok": true,
  "command": "faucet",
  "result": {
    "activation_id": "0xf0f37be6...aff3",
    "status": "success"
  }
}
```

> **Note:** The DevNet faucet has a per-account rate limit. If a request fails with `RateLimited`, wait a minute and retry. If the faucet returns `InsufficientFunds`, it has been drained. Refills happen periodically.

## Step 5: Send a transfer

Pick a recipient. For this walk-through, create a second wallet so you have somewhere to send to:

```bash theme={null}
gen wallet create bob
BOB=$(gen wallet --json show bob --account-address-only | jq -r .result.account)
```

`gen wallet create bob` makes `bob` the active wallet, so the next command pins the source explicitly with `--wallet alice`. Send 1,000 subunits, pass `--yes` to skip the confirmation prompt, and capture the activation ID from the JSON envelope for the next step.

```bash theme={null}
TXN=$(gen wallet --json transfer --wallet alice --to "$BOB" --amount 1000 --yes | jq -r .result.activation_id)
```

The transfer envelope looks like this in `--json` mode:

```json theme={null}
{
  "ok": true,
  "command": "transfer",
  "result": {
    "activation_id": "0x57dfbf81...aff3",
    "status": "success"
  }
}
```

## Step 6: Confirm the activation

Fetch the activation you just submitted to see how it played out on the network:

```bash theme={null}
gen client --json get-activation --activation-id "$TXN"
```

The result includes the events the activation emitted and the block it finalized in (`end_block`). This is useful for tracing and debugging. For a simple yes/no that the transfer landed, the most direct check is the recipient's balance in Step 7.

## Step 7: Verify the recipient balance

Query Bob's balance to confirm the funds arrived. Pass the wallet name to query a specific stored wallet:

```bash theme={null}
gen wallet balance bob
```

Expected output:

```text theme={null}
Balance

Wallet: bob
Account: grd@1cxyrpe2q7uh...

TOKEN  BALANCE  NAME       CONTRACT
GEN       1000  Gen Token  grd@1ma475ve...
```

Or in JSON:

```bash theme={null}
gen wallet --json balance bob
```

```json theme={null}
{
  "ok": true,
  "command": "wallet-balance",
  "result": {
    "account": "grd@1cxyrpe2q7uh...",
    "balance": "1000",
    "name": "Gen Token",
    "symbol": "GEN",
    "token_contract": "grd@1ma475ve..."
  }
}
```

That's it. You've sent and confirmed your first transfer on the Grid.

## What's next

* [What is The Grid?](/user-guide/what-is-gen): the platform in one page.
* [Activations explained](/user-guide/concepts/activations): what you just submitted, in detail.
* [RPC reference](/reference/rpc/overview): every endpoint the CLI talks to.