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

# Devnet wallets and keys

> Development-only wallets, tokens, and signing guidance for Base, Solana, and Algorand Devnet tests.

# Devnet wallets and keys

Use this page only for local Devnet testing.

Never use these keys, mnemonics, or patterns on mainnet, public testnets, or production systems.

## What this page is for

You need Devnet keys when you test:

* native transfers
* mobile signing
* gateway fulfillment
* chain submission after a Gora result

You do not need Devnet keys just to deploy and invoke an off-chain Gora app.

## Standard local developer flow

Start by resolving contract metadata from Gora:

```bash theme={null}
gora contract deploy --chain <chain> --node https://gora-dev.ngrok.app
gora contract link --chain <chain>
```

Then build and deploy your app:

```bash theme={null}
gora build
gora validate
gora deploy
```

Only import a dev key into mobile when you are ready to sign a test transaction.

## Base

Base Devnet uses a deterministic Ganache local chain.

RPC:

```text theme={null}
https://base-dev.ngrok.app
```

Chain id:

```text theme={null}
31337
```

Funded dev accounts:

| Label             | Address                                      | Private key                                                          |
| ----------------- | -------------------------------------------- | -------------------------------------------------------------------- |
| Base dev wallet 0 | `0x29d3cA5ee76bdB00815D2D9df9047aF342b7245F` | `0x59c6995e998f97a5a0044966f094538d5c6a88282eb0b9a4feaf8fae9e1a6f67` |
| Base dev wallet 1 | `0xC224C62A6AEaafc76D3beE9ccf6bAcBF73a75F11` | `0x8b3a350cf5c34c9194ca3a545dff708caac4d4ec4e2bd8aa7b11ef74bc55a393` |
| Base dev wallet 2 | `0x1a642f0E3c3aF545E7AcBD38b07251B3990914F1` | `0x0101010101010101010101010101010101010101010101010101010101010101` |
| Base dev wallet 3 | `0x5050A4F4b3f9338C3472dcC01A87C76A144b3c9c` | `0x0202020202020202020202020202020202020202020202020202020202020202` |
| Base dev wallet 4 | `0x3325a78425F17a7E487Eb5666b2bFd93aBb06c70` | `0x0303030303030303030303030303030303030303030303030303030303030303` |

Use wallet 0 as sender and wallet 1 as recipient for basic transfer tests.

## Solana

RPC:

```text theme={null}
https://solana-dev.ngrok.app
```

Solana Devnet does **not** currently publish one fixed seeded wallet in the docs. The local validator has a faucet, so the normal test wallet is one you generate and fund.

When `gora devnet up --chains base,solana,algorand --mobile-signing true` sees `examples/apps/raffle-app/test-wallets/wallets.json`, it also airdrops SOL to the raffle creator, operator, and participant Solana addresses listed there.

If you are on the Devnet VM, create a dev-only wallet and airdrop SOL:

```bash theme={null}
solana-keygen new --no-bip39-passphrase --outfile target/devnet-chains/solana-dev-wallet.json --force

SOLANA_ADDR="$(solana address --keypair target/devnet-chains/solana-dev-wallet.json)"

solana airdrop 100 "$SOLANA_ADDR" --url http://127.0.0.1:8899
solana balance "$SOLANA_ADDR" --url http://127.0.0.1:8899
```

To fund any other Solana address:

```bash theme={null}
solana airdrop 2 <RECIPIENT_ADDRESS> --url http://127.0.0.1:8899
```

If you are on your local computer, you can try the public RPC tunnel:

```bash theme={null}
solana airdrop 2 <RECIPIENT_ADDRESS> --url https://solana-dev.ngrok.app
```

If that fails, ask the Devnet operator to create and fund a dev-only keypair on the VM, then send you the JSON keypair through a secure dev-only channel.

The JSON keypair file is the wallet import artifact for local mobile signing tests. Do not commit it.

Resolve program metadata with:

```bash theme={null}
gora contract deploy --chain solana --node https://gora-dev.ngrok.app
```

## Algorand

RPC:

```text theme={null}
https://algorand-dev.ngrok.app
```

Algod auth:

```text theme={null}
Header: X-Algo-API-Token
Token: provided by the Devnet operator, or exposed through ALGORAND_ALGOD_TOKEN when configured
```

Algorand Devnet creates funded wallet accounts inside the VM localnet wallet. They are regenerated when the localnet is reset, so do not hard-code addresses from an old run.

When `gora devnet up --chains base,solana,algorand --mobile-signing true` sees `examples/apps/raffle-app/test-wallets/wallets.json`, it funds the raffle creator, operator, and participant Algorand addresses listed there. The VM only needs the public `wallets.json` for this funding step; private mnemonics stay in `secrets.json` for local wallet import and signing.

The active funded accounts are the `Wallet1`, `Wallet2`, and `Wallet3` accounts in the current localnet. The default dev-mode allocation is:

| Wallet    | Typical starting balance      |
| --------- | ----------------------------- |
| `Wallet1` | `4000000000000000` microAlgos |
| `Wallet2` | `4000000000000000` microAlgos |
| `Wallet3` | `2000000000000000` microAlgos |

If you are on the VM, list the active funded accounts:

```bash theme={null}
chains/algorand/.tooling/bin/goal account list \
  -d target/devnet-chains/algorand-localnet/Node
```

If the network is stopped, you can still inspect the current genesis allocation:

```bash theme={null}
jq -r '.alloc[]
  | select(.comment | test("^Wallet"))
  | [.comment, .addr, .state.algo]
  | @tsv' \
  target/devnet-chains/algorand-localnet/Node/genesis.json
```

Export a dev-only mnemonic for mobile signing tests:

```bash theme={null}
chains/algorand/.tooling/bin/goal account export \
  -a <ADDRESS> \
  -d target/devnet-chains/algorand-localnet/Node
```

Fund another Algorand address from one of the active funded localnet accounts:

```bash theme={null}
chains/algorand/.tooling/bin/goal clerk send \
  -a 10000000 \
  -f <FUNDED_LOCALNET_ADDRESS> \
  -t <RECIPIENT_ADDRESS> \
  -d target/devnet-chains/algorand-localnet/Node
```

If you are on your local computer, do not ask for the VM `Node/` datadir. Resolve the app id from Gora:

```bash theme={null}
gora contract deploy --chain algorand --node https://gora-dev.ngrok.app
```

For mobile signing tests from a local computer, ask the Devnet operator to export a dev-only Algorand mnemonic from one of the active `Wallet*` accounts and send it through a secure dev-only channel.

## Mobile key import

For local mobile tests, the development wallet can import:

* Base private key as hex
* Solana keypair as JSON byte array, base58, base64, or hex
* Algorand 25-word mnemonic, JSON byte array, base58, base64, or hex

Keep dev keys out of:

* app source
* `gora.app.json`
* `policy.json`
* fixtures
* stdout app results
* committed files

## Example transfer intent

Your app should emit an intent or signing request, not sign directly in the runtime.

```json theme={null}
{
  "type": "agent_action_intent",
  "schema_version": 1,
  "app_id": "api_transfer_agent",
  "chain": "base",
  "decision": "transfer",
  "payload": {
    "action": "transfer_native",
    "from": "0x29d3cA5ee76bdB00815D2D9df9047aF342b7245F",
    "to": "0xC224C62A6AEaafc76D3beE9ccf6bAcBF73a75F11",
    "amount": "1000000000000000",
    "amount_unit": "wei"
  }
}
```

For Solana use `lamports`. For Algorand use `microalgos`.

Next: [Test with mobile](./test-with-mobile).