> For the complete documentation index, see [llms.txt](https://docs.gravity.xyz/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.gravity.xyz/the-g-token/bridge-g-to-ethereum.md).

# Bridge G from Gravity L1 to Ethereum

Move native G from Gravity Mainnet (L1) to ERC-20 G on Ethereum through the Chainlink CCIP-based G bridge: architecture, contracts, fees and timing.

The **Gravity L1 → Ethereum G bridge** turns native G on Gravity Mainnet (L1, chain ID `127001`) into ERC-20 G on Ethereum at a 1:1 ratio. It uses [Chainlink CCIP](https://docs.chain.link/ccip) to carry the bridge message. You sign one transaction on Gravity L1 and pay the CCIP fee in native G; the ERC-20 G is minted to your Ethereum address automatically, with no transaction needed on Ethereum.

The opposite direction, Ethereum → Gravity L1, uses the canonical bridge built on the [Native Oracle](/research-and-development/native-oracle.md). See [How to Get G](/the-g-token/how-to-get-g.md).

{% hint style="info" %}
**Web interface:** a bridge UI for this direction will be published soon. Until then, call the bridge contract directly (see [For developers](#for-developers)).
{% endhint %}

## How it works

```
Gravity L1                                   Chainlink CCIP                 Ethereum
user ──bridge(recipient, amount)──► GravityGSender
          value = amount + fee        │  amount ──► 0x…dEaD (unspendable)
                                      │  fee ─────► CCIP Router ──► OnRamp
                                      │                               │ verify + execute
                                      ▼                               ▼
                               GDeposited event              OffRamp ──► Router ──► EthereumGMinter
                                                                                        │ mint(recipient, amount)
                                                                                        ▼
                                                                                  G ERC-20 (0x9C7B…0649)
```

1. **Deposit on Gravity L1.** You call `bridge(recipient, amount)` on `GravityGSender` and send `amount + fee` in native G. In the same transaction the contract assigns a deposit ID, hands a data-only message to the CCIP Router (paying exactly the CCIP fee), sends `amount` to `0x000000000000000000000000000000000000dEaD`, and refunds any overpayment. If any step fails, the whole transaction reverts and you keep your G.
2. **CCIP delivery.** Chainlink CCIP waits for Gravity L1 finality, verifies the message and executes it on Ethereum. Gravity L1 has fast BFT finality, so this usually takes seconds.
3. **Mint on Ethereum.** `EthereumGMinter` accepts the message only from the CCIP Router, only with Gravity's CCIP chain selector, and only from the `GravityGSender` address. It checks that the deposit ID was not credited before, then calls `mint(recipient, amount)` on the G ERC-20 token.

The message carries `(version, depositId, recipient, amount)`. Each deposit ID can be credited only once, so a message can never mint twice.

## Contracts

| Chain      | Contract          | Address                                                                                                                                 |
| ---------- | ----------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| Gravity L1 | `GravityGSender`  | [`0x40011DF49B772a70b171712f36AA59E1FCdCE62F`](https://mainnet-explorer.gravity.xyz/address/0x40011DF49B772a70b171712f36AA59E1FCdCE62F) |
| Ethereum   | `EthereumGMinter` | [`0xE0a7F6938a1748a715302480668BaB90de7d90a6`](https://etherscan.io/address/0xE0a7F6938a1748a715302480668BaB90de7d90a6)                 |
| Ethereum   | G ERC-20          | [`0x9C7BEBa8F6eF6643aBd725e45a4E8387eF260649`](https://etherscan.io/token/0x9C7BEBa8F6eF6643aBd725e45a4E8387eF260649)                   |

Both bridge contracts are verified on their explorers.

**Chainlink CCIP lane parameters**

| Network              | EVM chain ID |   CCIP chain selector | CCIP Router                                  |
| -------------------- | -----------: | --------------------: | -------------------------------------------- |
| Gravity Mainnet (L1) |     `127001` | `2988178761202034333` | `0x492641F648a4986844848E0beFE66D14817bCE34` |
| Ethereum             |          `1` | `5009297550715157269` | `0x80226fc0Ee2b096224EeAc085Bb9a8cba1146f7D` |

A CCIP chain selector is not an EVM chain ID. See the Chainlink CCIP directory for [Gravity Mainnet](https://docs.chain.link/ccip/directory/mainnet/chain/gravity-mainnet).

## Fees and timing

* **CCIP fee:** paid in native G on Gravity L1, in addition to the amount you bridge. The fee does not depend on the amount; it mostly covers execution on Ethereum, so it moves with Ethereum gas prices. Read the current fee with `quoteBridge(recipient, amount)` right before you send. Any value above `amount + fee` is refunded in the same transaction.
* **Gas on Gravity L1:** a direct call to `bridge` uses roughly 370,000 gas.
* **Time to arrive:** usually seconds to a few minutes. The first mainnet transfer was minted on Ethereum 11 seconds after the Gravity transaction.
* **Tracking:** the `GDeposited` event contains the CCIP message ID. Look it up on the [CCIP Explorer](https://ccip.chain.link) at `https://ccip.chain.link/msg/<messageId>`. On Ethereum, `EthereumGMinter` emits `GCredited(depositId, recipient, amount, messageId)` when the G is minted.

## Before you bridge

{% hint style="warning" %}
**The transfer is irreversible.** Once the Gravity transaction succeeds, the bridged G is sent to `0x…dEaD` and cannot be returned on Gravity L1. There is no refund path.
{% endhint %}

* **Use a recipient you control on Ethereum.** The recipient is an Ethereum address. A smart-contract wallet (for example a Safe) at some address on Gravity L1 is not necessarily deployed, or controlled by you, at the same address on Ethereum.
* **Delivery failures are retried, not lost.** If execution on Ethereum fails (for example while the bridge is paused or a configured limit is reached), CCIP records the message as failed and it can be executed again once the cause is resolved. The deposit is credited exactly once.
* **Deposits can be rejected up front.** `bridge` reverts, with nothing sent, when the bridge is paused, when the amount is zero, or when the deposit would exceed the configured total limit.

## Security model

* **Message authenticity** relies on Chainlink CCIP. The minter accepts only messages delivered by the Ethereum CCIP Router, from Gravity's chain selector, sent by the `GravityGSender` contract. A message cannot be forged by sending to CCIP from another contract.
* **No custody of user funds.** `GravityGSender` holds no G after a deposit; the minter has no withdrawal function and can only mint against authenticated deposits.
* **Administration.** Each contract is owned by a 3-of-6 Safe multisig (`0xeF936B0CaaAdfb439dd24F14411949694aB3C507` on Gravity L1, `0xbD6e434dB90FD8AD4E28d85C133AD34cA6fbfB6D` on Ethereum). The owners can pause the bridge, adjust its total deposit and mint limits and the destination gas limit. They cannot move user funds or mint without a deposit. The sender's destination minter is fixed after the first deposit, and ownership cannot be renounced.
* **Limits.** The bridge has adjustable cumulative limits on each side, and the G ERC-20 applies its own rate limit to the minter. These values change over time and are readable on-chain (`totalDepositLimit`, `totalMintLimit`, and `mintingCurrentLimitOf(minter)` on the token).

## Supply accounting

Bridged G is not burned by the protocol on Gravity L1: it is sent to `0x…dEaD`, an address no one can spend from, and an equal amount of ERC-20 G is newly minted on Ethereum. Native G held at `0x…dEaD` should be treated as out of circulation. On-chain totals for reconciliation: `totalDeposited` on `GravityGSender` and `totalMinted` on `EthereumGMinter`.

## For developers

```solidity
interface IGravityGSender {
    /// @return fee CCIP fee in wei of native G for this deposit
    function quoteBridge(address recipient, uint256 amount) external view returns (uint256 fee);
    /// @notice send msg.value >= amount + fee; the excess is refunded
    function bridge(address recipient, uint256 amount) external payable returns (bytes32 messageId);
}
```

Example with Foundry `cast`, bridging 10 G:

```bash
SENDER=0x40011DF49B772a70b171712f36AA59E1FCdCE62F
RECIPIENT=<your Ethereum address>
AMOUNT=$(cast to-wei 10)
FEE=$(cast call $SENDER 'quoteBridge(address,uint256)(uint256)' $RECIPIENT $AMOUNT \
  --rpc-url https://mainnet-rpc.gravity.xyz | awk '{print $1}')
cast send $SENDER 'bridge(address,uint256)' $RECIPIENT $AMOUNT \
  --value $(echo "$AMOUNT + $FEE * 11 / 10" | bc) \
  --rpc-url https://mainnet-rpc.gravity.xyz --account <your-keystore>
```

The 10% fee buffer covers fee movement between the quote and inclusion; the unused part is refunded. For more examples and the full event list, see the [Gravity Skill](/developer-resources/gravity-skill.md).


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.gravity.xyz/the-g-token/bridge-g-to-ethereum.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
