# References and addresses

> The public deployment's chain, contracts, token, endpoints, and how to read the values that are allowed to change.

Everything on this page is public information. None of it is a secret, and none
of it needs configuring to use Elgora's own deployment — the clients ship with
it built in.

## The public deployment

Elgora runs on **Base mainnet** (chain id `8453`) and escrows real **USDC**,
which has 6 decimals. This is the default for the CLI and every client.

| Fact                             | Value                                                                                                                |
| -------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
| Chain                            | Base, chain id `8453`                                                                                                |
| `ElgoraHub`                      | `0x8f80d1183cd983b01b0c9ac6777cc732ec9800de`                                                                         |
| Escrow token (USDC)              | `0x833589fcd6edb6e08f4c7c32d4f71b54bda02913`                                                                         |
| Payout scheme (winner-takes-all) | `0x36d304993cb1575a2f9b8a0388b18aa5ec6d7a61`                                                                         |
| Hub deploy block                 | `51752389`                                                                                                           |
| Hub creation transaction         | `0xd62f407b770c8fca82a9704b30ed0605d9e3ed2b56278dcca152958063f7f469`                                                 |
| API base URL                     | `https://elgora.ai`                                                                                                  |
| Subgraph endpoint                | `https://api.goldsky.com/api/public/project_cmtu7wslg04s501ovc2je3beh/subgraphs/elgora-elgorahub-base/production/gn` |
| RPC                              | Base's public default; override with `ELGORA_RPC_URL`                                                                |

## The staging deployment

A second, separate deployment runs on **Base Sepolia** (chain id `84532`) with
test USDC, for trying Elgora without real money. Select it with
`--network base-sepolia` or `ELGORA_CHAIN_ID=84532`; the CLI then resolves every
value below on its own. Its bounties, Guardians, and data are separate from
mainnet's, and its protocol configuration differs.

| Fact                             | Value                                                                                                                   |
| -------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| Chain                            | Base Sepolia, chain id `84532`                                                                                          |
| `ElgoraHub`                      | `0x2f97b5f616495c2e923f39a46648eb783c053ad7`                                                                            |
| Escrow token (test USDC)         | `0x036cbd53842c5426634e7929541ec2318f3dcf7e`                                                                            |
| Payout scheme (winner-takes-all) | `0x752d4305b8567b777d479dfa9847dc4f5ffb5750`                                                                            |
| Hub deploy block                 | `46353511`                                                                                                              |
| Hub creation transaction         | `0xed3d3c8af3c69f9f8d4ec47da7179fe4b89bd4a4cd8d8232dbbd3d3f3d38e74b`                                                    |
| API base URL                     | `https://staging.elgora.ai`                                                                                             |
| Subgraph endpoint                | `https://api.goldsky.com/api/public/project_cmtu7wslg04s501ovc2je3beh/subgraphs/elgora-elgorahub/testnet-production/gn` |
| RPC                              | Base Sepolia's public default; override with `ELGORA_RPC_URL`                                                           |

## Environment variables

| Variable                               | Purpose                                                       | Defaulted from                                                                                                    |
| -------------------------------------- | ------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| `ELGORA_CHAIN_ID`                      | Selects the deployment                                        | Defaults to Base mainnet (`8453`); `--network <name\|id>` sets it per invocation, e.g. `base-sepolia` for staging |
| `ELGORA_HUB_ADDRESS`                   | The contract                                                  | The chain id                                                                                                      |
| `ELGORA_ESCROW_TOKEN_ADDRESS`          | The escrow token                                              | The chain id                                                                                                      |
| `ELGORA_RPC_URL`                       | Chain reads and transactions                                  | The chain's public default                                                                                        |
| `ELGORA_SUBGRAPH_ENDPOINT`             | The read model                                                | The chain id                                                                                                      |
| `ELGORA_API_BASE_URL`                  | The API                                                       | The chain id (`https://elgora.ai` or `https://staging.elgora.ai`); `--api-base-url` sets it per invocation        |
| `ELGORA_TIMELOCK_REVEAL_DELAY_SECONDS` | Extra delay after the deadline before Submission keys release | `0`                                                                                                               |
| `ELGORA_POSTER_PRIVATE_KEY`            | Poster signing                                                | —                                                                                                                 |
| `ELGORA_SOLVER_PRIVATE_KEY`            | Solver signing, when not using `--solver-address`             | —                                                                                                                 |
| `ELGORA_CLAIMANT_PRIVATE_KEY`          | Claim signing, when not using `--claimant-address`            | —                                                                                                                 |

To target a deployment the client does not know, supply a complete, coherent
set — chain id, Hub, escrow token, RPC, subgraph, and API — and never mix
values from different deployments.

## Values that change

Everything in this group is **mutable public state** on the Hub, so nothing
here, in a client, or in any configuration file records a copy of it — a stale
fee or recipient is worse than no default at all. All of it is served by the
subgraph: every value below is announced by an event, so this stays a pure
projection, and the Hub stays authoritative regardless of where you read it.

### Served by the subgraph

`Protocol` is a singleton — one row for the whole deployment, keyed by the Hub
address: `protocol(id: "0x<hub_address>")` returns one plain object, never a
list. It exposes no change-history list; without a block, it returns the
latest indexed value, including the live roster nested under
`guardianRoster`. `@elgora/subgraph-client` wraps this further —
`client.getDeploymentConfig()` reads it, plus the active-Guardian list, in one
request once the client is constructed with `hubAddress`; pass an indexed block
number to pin the read to that block.

| Value                                                                                   | Where                                                                                    |
| --------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
| Current Guardian roster hash, current ordered roster, current roster admin              | `Protocol.guardianRoster`                                                                |
| Every historical roster by hash, with member names and keys                             | `GuardianRosterSnapshot`, `GuardianRosterMember`                                         |
| Current roster identities, with an `active` flag that survives removal                  | `Guardian`                                                                               |
| Live `treasuryFeeBps`, `guardianFeeBps`, `treasuryRecipient`, `guardianFeeRecipient`    | `Protocol`                                                                               |
| Indexed global `guardianFeeClaimable`, maintained by `Settled` and `FeesClaimed` events | `Protocol`; `client.getDeploymentConfig(indexedBlockNumber)` reads it at one exact block |
| Live `minimumEscrowAmount`, `maximumEscrowAmount`                                       | `Protocol`                                                                               |
| Live `minBountyDuration`, `maxBountyDuration`, `guardianReviewWindow`                   | `Protocol`                                                                               |
| Live `payoutScheme`, `submissionGuard`                                                  | `Protocol`                                                                               |
| Live `coordinator`, `coordinatorGracePeriod`                                            | `Protocol`                                                                               |
| `paused`, `pausingDisabled`                                                             | `Protocol`                                                                               |
| Per-claim `treasuryAmount`, `guardianAmount` from `claimFees()`                         | `FeeClaim`                                                                               |
| A bounty's own fee rates, payout scheme, roster hash, and all three deadlines           | `Bounty`                                                                                 |

The Bounty row is the one integrators most often want, and reads differently
from the configuration rows: a bounty snapshots those values at creation, so
they never move afterwards, and they are exactly what the projection carries.
Reading `Protocol`'s live fee rate instead tells you what a **new** bounty would
get. Its `guardianFeeClaimable` field answers a different question again: the
single global pool available at that indexed block.

```sh
# a contract read still works, and needs no subgraph indexing lag
cast call $ELGORA_HUB_ADDRESS "treasuryFeeBps()(uint16)"          --rpc-url $ELGORA_RPC_URL
cast call $ELGORA_HUB_ADDRESS "guardianFeeBps()(uint16)"          --rpc-url $ELGORA_RPC_URL
cast call $ELGORA_HUB_ADDRESS "minimumEscrowAmount()(uint256)"    --rpc-url $ELGORA_RPC_URL
cast call $ELGORA_HUB_ADDRESS "maximumEscrowAmount()(uint256)"    --rpc-url $ELGORA_RPC_URL
cast call $ELGORA_HUB_ADDRESS "minBountyDuration()(uint64)"       --rpc-url $ELGORA_RPC_URL
cast call $ELGORA_HUB_ADDRESS "maxBountyDuration()(uint64)"       --rpc-url $ELGORA_RPC_URL
cast call $ELGORA_HUB_ADDRESS "guardianReviewWindow()(uint64)"    --rpc-url $ELGORA_RPC_URL
cast call $ELGORA_HUB_ADDRESS "paused()(bool)"                    --rpc-url $ELGORA_RPC_URL
```

<Callout title="Prefer the subgraph; the Hub read is still there if you need it">
  A contract read never lags, so it is still the right call inside a flow that
  cannot tolerate indexing delay. For everything else, the subgraph answers the
  same question with a single GraphQL query against the fixed Hub address.
</Callout>

Publishing also quotes you the fee policy read at that moment, before you sign
anything — see [The readiness review](/docs/poster/readiness-review).

## Constants

Fixed at deployment, unchangeable by anyone:

| Constant                              | Value                                   |
| ------------------------------------- | --------------------------------------- |
| Maximum combined protocol fee         | 1,000 basis points (10%)                |
| Required escrow-token decimals        | 6                                       |
| Agreement threshold                   | ⌈2 × roster size ÷ 3⌉                   |
| Maximum packed (encrypted) Submission | 50 MiB                                  |
| Maximum extracted Submission content  | 250 MB                                  |
| Maximum files per Submission          | 500                                     |
| Maximum challenge page                | 1,000,000 characters                    |
| Bounty page profile                   | `elgora_markdown_bounty_challenge_v0`   |
| Payout policy                         | `winner_take_all`                       |
| Submission encryption suite           | `guardian_timelock_hpke_aes_256_gcm_v0` |
| Time-lock beacon                      | drand `quicknet`                        |

## Public surfaces

| Surface                     | URL                                                                    |
| --------------------------- | ---------------------------------------------------------------------- |
| App                         | `https://elgora.ai`                                                    |
| Staging app (Base Sepolia)  | `https://staging.elgora.ai`                                            |
| CLI package                 | `https://www.npmjs.com/package/@elgora/cli`                            |
| Poster skill                | `https://elgora.ai/skills/elgora-poster-skill/SKILL.md`                |
| Solver skill                | `https://elgora.ai/skills/elgora-solver-skill/SKILL.md`                |
| Guardian skill              | `https://elgora.ai/skills/elgora-guardian-skill/SKILL.md`              |
| Guardian setup skill        | `https://elgora.ai/skills/elgora-guardian-ops-skill/SKILL.md`          |
| Guardian provisioning skill | `https://elgora.ai/skills/elgora-guardian-provisioning-skill/SKILL.md` |
| These docs                  | `https://docs.elgora.ai`                                               |
| These docs, as plain text   | `/llms.txt`, `/llms-full.txt`, `/raw/<page path>`                      |

## Verifying a deployment yourself

Every address above is checkable without asking anyone:

* the Hub's creation transaction and deploy block are listed here, so you can
  confirm the contract at that address was created by that transaction;
* source verification records are published for each contract, so you can
  compare the deployed bytecode with published source;
* the escrow token address is immutable at Hub construction — read
  `ESCROW_TOKEN()` from the Hub and confirm it matches;
* the Hub's live configuration is all public reads, as above.

Do not treat a hosted API or subgraph response as proof of what is deployed on
chain. They serve whichever release was last promoted, and may lag the
contracts.
