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

# List supported chains and tokens

> Returns supported chains and tokens with their deposit and destination availability.



## OpenAPI

````yaml https://raw.githubusercontent.com/rhinestonewtf/openapi/refs/heads/main/deposit-service.json get /chains
openapi: 3.1.0
info:
  title: Deposit Service API
  version: 1.0.0
  description: >-
    Rhinestone Deposits API: accept deposits from any chain, asset or payment
    method, and settle them as one token on one chain.
servers:
  - url: https://v1.orchestrator.rhinestone.dev/deposit-processor
security: []
paths:
  /chains:
    get:
      tags:
        - Utilities
      summary: List supported chains and tokens
      description: >-
        Returns supported chains and tokens with their deposit and destination
        availability.
      responses:
        '200':
          description: Supported chains with their tokens
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ChainsResponse'
components:
  schemas:
    ChainsResponse:
      type: object
      additionalProperties:
        type: object
        properties:
          name:
            type: string
          testnet:
            type: boolean
          deposit:
            type: boolean
          destination:
            type: boolean
          refund:
            type: boolean
            description: >-
              Whether a failed deposit on this chain can be refunded via POST
              /deposits/{id}/refund. Chain-level only: a chain that advertises
              true still declines individual deposits for reasons belonging to
              the deposit or the account rather than the chain — a HyperCore
              deposit already credited to HyperEVM, a Solana Token-2022 mint or
              one with unsupported decimals, or a user-owned account with no
              session on the source chain. Not the same as POST
              /deposits/recover, the signature-authorized self-service path,
              which is EVM-only on both source and target chain.
            example: true
          vmType:
            type: string
            enum:
              - evm
              - svm
              - tvm
              - stellar
            description: >-
              Address format the chain uses: 'evm' is 20-byte hex, 'svm' base58,
              'tvm' base58check, 'stellar' base32 strkey. Validate an address
              against this rather than inferring from the chain id. HyperCore is
              'evm' — it is EVM-addressed without being an EVM execution chain.
              On 'stellar' the format alone is not enough to tell a recipient
              from a token: an account is a 'G' strkey and an asset its 'C'
              Soroban contract, distinguished by the version byte the two
              encode.
            example: evm
          nativeToken:
            type: object
            properties:
              symbol:
                type: string
              address:
                type: string
              decimals:
                type: number
            required:
              - symbol
              - address
              - decimals
            description: >-
              The chain's gas asset, for rendering a native-value transfer that
              carries no token address.
          explorer:
            type:
              - object
              - 'null'
            properties:
              url:
                type: string
              addressPath:
                type: string
              txPath:
                type: string
            required:
              - url
              - addressPath
              - txPath
            description: >-
              Block explorer, or null for a chain that has none (render plain
              text instead of a link). `url` has no trailing slash and the paths
              carry their own, so a link is `${url}${addressPath}${value}`. The
              paths vary — Tronscan routes under a fragment and calls a
              transaction `transaction`, not `tx`.
            example:
              url: https://etherscan.io
              addressPath: /address/
              txPath: /tx/
          supportedTokens:
            anyOf:
              - type: string
                enum:
                  - all
              - type: array
                items:
                  type: object
                  properties:
                    symbol:
                      type: string
                    address:
                      type: string
                    decimals:
                      type: number
                  required:
                    - symbol
                    - address
                    - decimals
            description: >-
              What can be DELIVERED to this chain — the identity a
              `target.token` must use. Meaningful only when `destination` is
              true. `"all"` means any token on the chain.
          depositTokens:
            anyOf:
              - type: string
                enum:
                  - all
              - type: array
                items:
                  type: object
                  properties:
                    symbol:
                      type: string
                    address:
                      type: string
                    decimals:
                      type: number
                  required:
                    - symbol
                    - address
                    - decimals
            description: >-
              What can be DEPOSITED from this chain — the identity a deposit
              whitelist is matched on, and the units its `minAmount`/`maxAmount`
              are in. Meaningful only when `deposit` is true; `"all"` means any
              token on the chain. Equal to `supportedTokens` everywhere except
              HyperCore, where a deposit is identified by its Core spot token id
              at `weiDecimals` and a delivery by the token's HyperEVM ERC20 at 6
              — configure a whitelist from THIS field, never from
              `supportedTokens`.
          publicRpcUrl:
            type: string
            description: >-
              The chain's PUBLIC, unauthenticated JSON-RPC endpoint. Build a
              viem `Chain` with `defineChain` from it — a browser client can
              derive every other argument from this entry but not this one,
              which is what makes a chain it was never compiled against usable.
              Deliberately not the rpc-proxy URL: this is served to a browser
              holding no credential. Absent for a chain that publishes none —
              treat that chain as display-only rather than as an error.
            example: https://mainnet.base.org
          iconUrl:
            type: string
            description: >-
              The chain's mark, for rendering a chain the client was never
              compiled against and therefore holds no bundled asset for. Absent
              for a chain that publishes no icon — render a text or colour
              fallback, never an error. Served from Rhinestone's public CDN, so
              a host with an explicit `img-src` CSP must include
              `https://s3.rhinestone.dev` in it: without that the image fails
              SILENTLY, with no console error naming the policy.
            example: https://s3.rhinestone.dev/chains/base.svg
        required:
          - name
          - testnet
          - deposit
          - destination
          - refund
          - vmType
          - nativeToken
          - explorer
          - supportedTokens
          - depositTokens

````

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