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

# Index Elysium bridge activity without code

> Deploy a subgraph that indexes every token deposit to and withdrawal from Elysium through the canonical bridge, with one Goldsky CLI command, then query it over GraphQL. No mapping code to write.

A no-code subgraph turns a contract's events into a GraphQL API. You give the Goldsky CLI the contract addresses, a network and the events you want, and it generates the subgraph, builds it and deploys it.

This guide indexes Elysium's canonical bridge: the gateways that move tokens such as USDC and WHYPE between HyperEVM and Elysium. The result is an API of every token deposit into Elysium and every withdrawal to HyperEVM, with the token, the sender, the recipient and the amount. The same steps work for any Elysium contract: change the addresses, the ABI and the events.

## What you'll need

* The Goldsky CLI, logged in.

> [accordion] Install Goldsky's CLI and log in
>
> 1. Install the Goldsky CLI:
>
>    **For macOS/Linux:**
>
>    ```shell theme={"dark"} theme={"dark"}
>    curl https://goldsky.com | sh
>    ```
>
>    **For Windows:**
>
>    ```shell theme={"dark"} theme={"dark"}
>    npm install -g @goldskycom/cli
>    ```
>
>    > [!NOTE]
>    >
>    > Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
> 2. Log into your Project by running:
>    ```shell theme={"dark"} theme={"dark"}
>    goldsky login
>    ```
>    This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
>    \[!NOTE] On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token <API_KEY>`. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
> 3. Now that you are logged in, run `goldsky` to get started:
>    ```shell theme={"dark"} theme={"dark"}
>    goldsky
>    ```

## The contracts

Elysium is an Arbitrum Orbit chain that settles to HyperEVM. Tokens issued on HyperEVM reach Elysium through two gateway contracts, which both emit the standard Arbitrum token bridge events:

| Contract | Address on Elysium | Carries |
| - | - | - |
| Standard gateway | `0x5dc84e4cb0f9082246e92a5585c5395592b1af1f` | ERC-20 tokens, such as USDC |
| WHYPE gateway | `0xb916e67307ad52955d37b6c123cf1a79c10855b6` | WHYPE |

| Event | Emitted when |
| - | - |
| `DepositFinalized` | A deposit from HyperEVM is credited on Elysium |
| `WithdrawalInitiated` | A withdrawal to HyperEVM starts on Elysium |

Both events name the token by its address on HyperEVM, not on Elysium. HYPE, Elysium's gas token, uses a different path and doesn't appear in these events. [Track Elysium bridge flows](https://docs.goldsky.com/chain-guides/elysium/bridge-flows.md) covers HYPE as well.

## 1. Save the ABI

The CLI reads a contract's ABI from a local file named after the contract, in lowercase. Both gateways use the same two events, so save this as `abis/standardgateway.json`:

```json abis/standardgateway.json theme={"dark"}
[
  {
    "anonymous": false,
    "inputs": [
      { "indexed": true, "name": "l1Token", "type": "address" },
      { "indexed": true, "name": "_from", "type": "address" },
      { "indexed": true, "name": "_to", "type": "address" },
      { "indexed": false, "name": "_amount", "type": "uint256" }
    ],
    "name": "DepositFinalized",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      { "indexed": false, "name": "l1Token", "type": "address" },
      { "indexed": true, "name": "_from", "type": "address" },
      { "indexed": true, "name": "_to", "type": "address" },
      { "indexed": true, "name": "_l2ToL1Id", "type": "uint256" },
      { "indexed": false, "name": "_exitNum", "type": "uint256" },
      { "indexed": false, "name": "_amount", "type": "uint256" }
    ],
    "name": "WithdrawalInitiated",
    "type": "event"
  }
]
```

Then copy it for the second gateway:

```bash theme={"dark"}
cp abis/standardgateway.json abis/whypegateway.json
```

## 2. Deploy the subgraph

Run this from the folder that contains `abis/`:

```bash theme={"dark"}
goldsky subgraph init elysium-bridge/1.0.0 --abi ./abis --contract 0x5dc84e4cb0f9082246e92a5585c5395592b1af1f,0xb916e67307ad52955d37b6c123cf1a79c10855b6 --contract-name StandardGateway,WhypeGateway --contract-events DepositFinalized,WithdrawalInitiated --network elysium-mainnet --start-block 2,2 --no-call-handlers --deploy
```

| Flag | Value | Why |
| - | - | - |
| `--contract` | Both gateway addresses | One subgraph indexes both gateways |
| `--contract-name` | `StandardGateway,WhypeGateway` | One name per contract, in the same order. The names pick the ABI files. |
| `--contract-events` | `DepositFinalized,WithdrawalInitiated` | The events to index |
| `--network` | `elysium-mainnet` | Elysium's network name for subgraphs. Elysium Testnet is `elysium-testnet`. |
| `--start-block` | `2,2` | Both gateways were deployed at block 2, so the subgraph indexes the bridge's full history. |
| `--deploy` | | Builds and deploys in the same command |

Leave out the flags to answer the same questions one at a time in the interactive wizard. The [no-code subgraph reference](https://docs.goldsky.com/subgraphs/guides/create-a-no-code-subgraph.md#wizard-cli-arguments) lists every flag.

When the deploy finishes, the CLI prints two links: the subgraph's dashboard, where you can follow indexing, and its GraphQL endpoint. The subgraph is named after the network, here `elysium-bridge-elysium-mainnet/1.0.0`.

## 3. Query bridge activity

Open the GraphQL endpoint in a browser to use its query editor, or send queries from your app. The subgraph returns data while it indexes.

Events from both gateways land in the same two collections, `depositFinalizeds` and `withdrawalInitiateds`. `contractId_` tells you which gateway emitted the event. The CLI drops the leading `_` from the event's parameter names, so `_from` becomes `from`, and it adds the fields that end in `_`.

The latest deposits into Elysium:

```graphql theme={"dark"}
{
  depositFinalizeds(first: 5, orderBy: block_number, orderDirection: desc) {
    timestamp_
    transactionHash_
    contractId_
    l1Token
    from
    to
    amount
  }
}
```

USDC deposits only, by its HyperEVM address:

```graphql theme={"dark"}
{
  depositFinalizeds(where: { l1Token: "0xb88339cb7199b77e23db6e890353e22632ba630f" }, orderBy: block_number, orderDirection: desc) {
    timestamp_
    to
    amount
  }
}
```

Every withdrawal one wallet started:

```graphql theme={"dark"}
{
  withdrawalInitiateds(where: { from: "0x0d104705d3d4bc5fcccde95ebc035cfad2888971" }, orderBy: block_number, orderDirection: desc) {
    timestamp_
    l1Token
    to
    amount
  }
}
```

`amount` is in the token's smallest unit: divide by 10^6 for USDC and 10^18 for WHYPE. Addresses in `where` filters are lowercase.

## Notes

* A withdrawal row means the withdrawal started on Elysium. The tokens reach HyperEVM later, when the withdrawal is executed there.

## Getting help

Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.


## Related topics

- [Elysium](https://docs.goldsky.com/chains/elysium.md)
- [Stream Elysium wallet activity](https://docs.goldsky.com/chain-guides/elysium/wallet-activity.md)
- [Read Elysium over Edge RPC](https://docs.goldsky.com/chain-guides/elysium/edge-rpc.md)
- [Track Elysium bridge flows](https://docs.goldsky.com/chain-guides/elysium/bridge-flows.md)
- [Activity](https://docs.goldsky.com/feeds/api/prediction-markets/activity.md)