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

# Deployed Addresses

> Calibri's on-chain contract addresses — what is deployed, where to read the live values, and how to verify every one of them yourself on the block explorer.

Every contract Calibri trades against is public. You do not have to take custody
claims on trust: read the code, check the balances, and confirm your own Safe
holds what you think it holds.

This page lists what is deployed and shows you how to verify each address for
yourself.

<Note>
  The **API is the authoritative source** for every address on every network. The values below are for reference and verification — if this page and the API ever disagree, the API is right and this page is stale.
</Note>

## Polygon (mainnet)

Calibri settles on **Polygon**, chain id **137**, collateralised in **native
USDC**.

| Contract | Address | Verify |
| - | - | - |
| **CTF Exchange** (Calibri) | `0xB6Ac44d5A6388b8C7511F2fb20C0c03fD0CeDC83` | [View on Polygonscan](https://polygonscan.com/address/0xB6Ac44d5A6388b8C7511F2fb20C0c03fD0CeDC83) |
| **USDC** (collateral) | `0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359` | [View on Polygonscan](https://polygonscan.com/address/0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359) |
| **ConditionalTokens** (Gnosis CTF) | read from `GET /account/wallet` → `conditional_tokens_address` | `https://polygonscan.com/address/{address}` |
| **CalibriResolver** (oracle) | *to be published* — ask support | `https://polygonscan.com/address/{address}` |
| **AutoRedeemer** | read from `GET /account/wallet/auto-redeem` → `auto_redeemer_address` | `https://polygonscan.com/address/{address}` |
| **Your Safe** | read from `GET /account/wallet` → `proxy_address` | `https://polygonscan.com/address/{address}` |

The CTF Exchange was deployed on **2 August 2026** and carries Calibri's own
EIP-712 domain name — it is not a shared or third-party exchange. That domain
name is hashed into every order signature, which is why the app serves it rather
than hard-coding it, and why signatures made against a different exchange cannot
be replayed here.

<Note>
  **ConditionalTokens is not ours.** It is Gnosis' audited Conditional Token Framework, already deployed on Polygon and used by other prediction markets. Calibri deploys against the canonical instance rather than a fork — your collateral sits in a contract that predates us and is not under our control.
</Note>

## Wallet infrastructure

These four are what a **Safe** is made of. You never need them to trade, or to move funds
from a Safe that exists — they matter for exactly one case: a Safe address that was funded
before it was deployed. Deployment happens on your first deposit, so an address can hold
USDC with no contract at it yet, and both factories below are **permissionless**, meaning
anyone can deploy it. That is what keeps
[withdrawing without Calibri](/non-custodial/withdraw-without-calibri) true even for a
wallet we never got around to creating.

| Contract | Address | What it does |
| - | - | - |
| **Safe factory** | *to be published* | Deploys your Safe at its derived address |
| **Safe singleton** | *to be published* | The implementation every Safe proxy delegatecalls |
| **Safe fallback handler** | *to be published* | Handles signature checks and other non-core calls |
| **WebAuthn signer factory** | *to be published* | Deploys the secp256r1 signer contract a passkey owns |

<Note>
  The mainnet values are published here once the production contracts are deployed. Until then, ask support — they are fixed per network, identical for every member, and not secret: the Safe factory is readable from the exchange's own `safeFactory` view, and the singleton and handler from any deployed Safe's storage.
</Note>

## Cross-network deposits

These contracts let USDC sent to your Safe address on another network reach your Safe on
Polygon — see [Deposits from other networks](/non-custodial/deposits-from-other-networks).
Each is deployed at **the same address on Polygon, Ethereum, Base, Arbitrum and
Optimism**, which is what makes your Safe's address the same on all of them. When they are
live, **CalibriSafeFactoryV2** is the Safe factory listed above.

| Contract | Address | What it does |
| - | - | - |
| **CalibriSafeFactoryV2** | *Not yet deployed* | Creates member Safes with the bridge module enabled; permissionless |
| **SafeModuleSetup** | *Not yet deployed* | Switches the module on during a Safe's setup |
| **CctpBridgeModule** | *Not yet deployed* | Moves a Safe's USDC through Circle's CCTP to the same Safe on Polygon |
| **BridgeFeeConfig** | *Not yet deployed* | Holds the relayer allowed to charge the bridge fee, the treasury it is paid to, and the consent signer that countersigns an accepted fee above the cap |

<Note>
  **These contracts are not deployed to mainnet yet.** Addresses are published here once they are. Until then, deposits from other networks are not available — send USDC on Polygon only.
</Note>

When they are live, you can check a module against its limits yourself. `CctpBridgeModule`
exposes `MAX_FEE_ABS`, `MAX_FEE_BPS`, `MIN_AMOUNT`, `DEST_DOMAIN` (`7`, Polygon) and
`TOKEN_MESSENGER` (Circle's TokenMessengerV2) as public views, and `localUsdc()` returns the
USDC it moves on that network. `CalibriSafeFactoryV2.module()` names the module every Safe
is created with, and `computeProxyAddress(owner)` returns your Safe's address — the same
answer on every network.

## Reading the live values

Signed in, these two endpoints return the exact addresses your account is
trading against:

```
GET /api/v2/atlas/account/wallet
GET /api/v2/atlas/account/wallet/markets/:id
```

The member-level call returns `chain_id`, `blockchain_key`, `usdc_address`,
`conditional_tokens_address`, `exchange_address`, `domain_name`, your own
`proxy_address` (your Safe), and `owner_address` (what owns it). The per-market
call adds `condition_id`, `yes_token_id`, and `no_token_id` — the two ERC-1155
outcome tokens for that market.

<Warning>
  Read these addresses from the API rather than copying them into your own client. A wrong address silently sends signatures somewhere they cannot settle.
</Warning>

## Verifying it yourself

<Steps>
  <Step title="Check your Safe holds your money">
    Take `proxy_address` from `GET /account/wallet` and open it on Polygonscan. Its USDC
    balance is your money, in a contract only you can authorise. Nothing about
    that depends on Calibri being honest.
  </Step>

  <Step title="Check the exchange you are signing for">
    Confirm `exchange_address` from the API matches the CTF Exchange above, and
    that the contract has code at that address.
  </Step>

  <Step title="Check the collateral">
    Confirm `usdc_address` is native USDC on Polygon — the address in the table
    above — and not a look-alike token.
  </Step>

  <Step title="Check a specific market">
    For any market, verify its `condition_id` and the `yes_token_id` /
    `no_token_id` against ConditionalTokens. Those token ids are derived from the
    resolver, the question and the collateral, so they name exactly one outcome
    of one market and never change.
  </Step>

  <Step title="Watch a settlement land">
    After a market resolves, the redemption that pays you is a transaction on
    ConditionalTokens against your Safe. It is on the explorer like anything
    else.
  </Step>
</Steps>

## Related

<CardGroup cols={2}>
  <Card title="Smart Contracts" href="/smart-contracts/overview">
    What each contract does and why self-custody is verifiable rather than promised.
  </Card>

  <Card title="The Safe" href="/non-custodial/the-safe">
    Your own Safe — the `proxy_address` in the config.
  </Card>

  <Card title="Signed orders" href="/non-custodial/signed-orders">
    The EIP-712 domain and order struct you sign.
  </Card>

  <Card title="Market resolution" href="/non-custodial/resolution">
    What the resolver can and cannot do, and the permissionless fallbacks.
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.