---
title: "Como lançar um token na Elysium e negociá-lo na Hyperliquid"
description: "Lance um token na Elysium, a L2 da Hyperliquid, e negocie-o em um order book spot do HyperCore. Faça o deploy com Foundry e Alchemy, espelhe-o no HyperEVM e depois liste-o."
datePublished: "2026-11-10"
dateModified: "2026-11-10"
---

# Como lançar um token na Elysium e negociá-lo na Hyperliquid

<ImageBlock
  src="https://media.alchemy.com/overviews/how-to-launch-a-token-on-elysium-hyperliquid-hero-20261110.png"
  alt="Lançando um token na Elysium e levando-o a um order book do HyperCore"
  width={1920}
  height={900}
  priority
/>

A Elysium é a Layer 2 da Kinetiq para a Hyperliquid, e sua [mainnet entrou no ar em 9 de novembro](https://www.alchemy.com/blog/elysium-mainnet-is-live-on-alchemy). É uma chain EVM com blocos de 100 ms, que usa HYPE como gas e liquida no HyperEVM. Um token da Elysium pode ser negociado nos próprios order books da Hyperliquid. Este guia percorre o caminho completo. Você faz o deploy de um ERC-20 na Elysium com Foundry e nosso RPC da Elysium, espelha o token no HyperEVM e depois executa a listagem no HyperCore, que o coloca em um order book spot contra USDC.

O deploy e o espelhamento são baratos e permissionless, embora o primeiro mint do espelho precise aguardar um período de contestação de cerca de 5,5 dias. A listagem no HyperCore é uma cerimônia única do emissor na Hyperliquid e começa com um leilão de ticker cujo preço nunca cai abaixo de 500 HYPE. Depois dessa cerimônia, tudo fica aberto a qualquer detentor, que pode mover o token entre a Elysium, o HyperEVM e o HyperCore pelas bridges.

## O que você precisa saber sobre a Elysium antes do lançamento?

A Elysium é uma [chain Arbitrum Orbit construída pela Kinetiq](https://elysium.kinetiq.xyz/docs/what-is-elysium) que liquida no HyperEVM e roda co-localizada com o HyperCore. O HyperCore é a camada de exchange da Hyperliquid, onde ficam seus order books de spot e de perpétuos. O HyperEVM é o ambiente EVM que roda ao lado dele, na mesma L1 da Hyperliquid. Nosso post sobre [como estamos apostando tudo na Hyperliquid](https://www.alchemy.com/blog/alchemy-going-all-in-on-hyperliquid) explica como as duas partes se encaixam, e nosso [guia de trading na Elysium](https://www.alchemy.com/overviews/how-to-trade-on-elysium-hyperliquid-l2) cobre a própria chain em mais detalhes, desde por que a Hyperliquid precisa de uma L2 até os apps que estão sendo lançados nela.

O [HyperEVM](https://www.alchemy.com/hyperevm) limita a própria capacidade de propósito. Seus [blocos pequenos carregam 3M de gas a cada segundo](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/hyperevm/dual-block-architecture), com 30M de gas apenas nos blocos grandes de um minuto. A Kinetiq construiu a Elysium para cargas de trabalho que precisam de mais, como market makers que [atualizam cotações várias vezes por segundo](https://elysium.kinetiq.xyz/docs/what-is-elysium). Ela mira 300 Mgas/s (milhões de gas por segundo) de execução, cerca de duas ordens de grandeza a mais que o HyperEVM, e mantém o HYPE como o único token de que você precisa para transacionar.

<EmbeddedTable
  table={{
    columns: [
      { key: "feature", width: 180, title: "", dataType: "object" },
      { key: "elysium", width: 260, title: "Elysium", dataType: "object" },
      { key: "hyperevm", width: 260, title: "HyperEVM", dataType: "object" },
    ],
    data: [
      {
        feature: { title: "Tempo de bloco", tooltip: "", icon: "" },
        elysium: { title: "Blocos canônicos de 100 ms", tooltip: "", icon: "" },
        hyperevm: {
          title: "Blocos pequenos de 1 s, blocos grandes de 1 min",
          tooltip: "",
          icon: "",
        },
        id: 0,
      },
      {
        feature: { title: "Capacidade de gas", tooltip: "", icon: "" },
        elysium: { title: "Meta de 300 Mgas/s", tooltip: "", icon: "" },
        hyperevm: {
          title: "3M de gas por bloco pequeno",
          tooltip: "",
          icon: "",
        },
        id: 1,
      },
      {
        feature: { title: "Token de gas", tooltip: "", icon: "" },
        elysium: {
          title: "HYPE, via bridge 1:1 como gas nativo",
          tooltip: "",
          icon: "",
        },
        hyperevm: { title: "HYPE", tooltip: "", icon: "" },
        id: 2,
      },
      {
        feature: { title: "Stack", tooltip: "", icon: "" },
        elysium: {
          title: "Arbitrum Orbit (Nitro e ArbOS)",
          tooltip: "",
          icon: "",
        },
        hyperevm: { title: "L1 da Hyperliquid", tooltip: "", icon: "" },
        id: 3,
      },
      {
        feature: {
          title: "Acesso ao HyperCore a partir de contratos",
          tooltip: "",
          icon: "",
        },
        elysium: {
          title:
            "Lanes de leitura e escrita previstas para cerca de quatro semanas após a mainnet",
          tooltip: "",
          icon: "",
        },
        hyperevm: {
          title: "Precompiles de leitura e CoreWriter",
          tooltip: "",
          icon: "",
        },
        id: 4,
      },
    ],
  }}
/>

Os blocos da Elysium são blocos canônicos de verdade, então `latest` e os recibos de transação têm o significado de sempre, [sem camada de pré-confirmação](https://elysium.kinetiq.xyz/docs/blocks-fees-and-ordering) por cima. Solidity, Foundry, Hardhat e viem funcionam sem alterações. A Kinetiq também [destinou 25% das taxas do sequenciador aos builders](https://x.com/Kinetiq_xyz/status/2091888509472932145) cujos apps geram atividade na chain.

Somos o principal provedor de RPC da Elysium, e a documentação da Kinetiq nos lista como o [provedor de infraestrutura recomendado para a Elysium](https://elysium.kinetiq.xyz/docs/connecting-to-elysium). Nossa [página de RPC da Elysium](https://www.alchemy.com/rpc/elysium) e nosso [quickstart da API da Elysium](https://www.alchemy.com/docs/reference/elysium-api-quickstart) trazem os endpoints da mainnet. Dois detalhes do nosso [FAQ da API da Elysium](https://www.alchemy.com/docs/reference/elysium-api-faq) poupam tempo de depuração:

- **O export `elysiumTestnet` em `viem/chains` é outra chain.** Ele pertence a um projeto sem relação com este, então defina você mesmo a Elysium da Kinetiq com `defineChain`.
- **Uma transferência simples de HYPE custa um pouco mais de 21.000 de gas.** As chains Arbitrum adicionam uma pequena quantia pelos dados da chain pai, então um limite de gas fixado em `21000` no código falha com `intrinsic gas too low`.

## Como um token vai da Elysium a um order book do HyperCore?

Um token faz dois saltos de bridge, e cada salto tem sua própria configuração:

<CodeSnippet
  language="text"
  code={`Elysium     your ERC-20
              |  mirror bridge: lock on Elysium, mint a 1:1 mirror on HyperEVM
              v
HyperEVM    the mirror, a plain ERC-20
              |  deposit wallet: escrow on HyperEVM that HyperCore credits and debits
              v
HyperCore   a spot token with an order book against USDC`}
/>

<EmbeddedTable
  table={{
    columns: [
      { key: "hop", width: 200, title: "Salto", dataType: "object" },
      { key: "who", width: 200, title: "Quem configura", dataType: "object" },
      { key: "cost", width: 200, title: "Custo único", dataType: "object" },
      {
        key: "after",
        width: 280,
        title: "O que os detentores podem fazer depois",
        dataType: "object",
      },
    ],
    data: [
      {
        hop: {
          title: "Da Elysium para o HyperEVM (bridge de espelhamento)",
          tooltip: "",
          icon: "",
        },
        who: {
          title: "Qualquer pessoa, em duas transações",
          tooltip: "",
          icon: "",
        },
        cost: {
          title: "Gas mais uma pequena taxa em HYPE para mensagens cross-chain",
          tooltip: "",
          icon: "",
        },
        after: {
          title:
            "Bloquear na Elysium para fazer o mint do espelho (cerca de 5,5 dias), queimar o espelho para liberar na Elysium (cerca de um minuto)",
          tooltip: "",
          icon: "",
        },
        id: 0,
      },
      {
        hop: {
          title: "Do HyperEVM para o HyperCore (carteira de depósito)",
          tooltip: "",
          icon: "",
        },
        who: {
          title: "O endereço que vence o leilão do ticker",
          tooltip: "",
          icon: "",
        },
        cost: {
          title: "Leilão do ticker, piso de 500 HYPE",
          tooltip: "",
          icon: "",
        },
        after: {
          title: "Depositar no HyperCore e sacar de volta para o HyperEVM",
          tooltip: "",
          icon: "",
        },
        id: 1,
      },
    ],
  }}
/>

A [bridge de espelhamento](https://elysium.kinetiq.xyz/docs/bridging-elysium-tokens-to-hyperevm) não exige nenhum código no seu token. Ela bloqueia o original na Elysium em uma carteira de custódia e faz o mint de um espelho 1:1 no HyperEVM, então o supply do espelho é sempre igual ao que está bloqueado.

O HyperCore vincula cada token spot a um único contrato EVM, e quem faz o deploy precisa provar que controla esse contrato. Um contrato implantado diretamente a partir de uma carteira prova isso com o nonce do deploy. O seu espelho é implantado pela factory da bridge, então essa verificação não funciona para ele. Uma [carteira de depósito](https://elysium.kinetiq.xyz/docs/hypercore-bridging-via-deposit-wallets) resolve isso, seguindo o padrão que a Circle usa para vincular o USDC. Ela mantém o espelho em custódia, grava o seu endereço de assinatura no slot de storage que o HyperCore lê para contratos implantados por factories e se torna o contrato ao qual o HyperCore se vincula.

Três escolhas nesse caminho não podem ser desfeitas, então defina-as antes de gastar qualquer coisa. São elas os decimais do token no HyperCore (fixados quando você vence o ticker), o seu supply de genesis e o vínculo entre o token do HyperCore e a carteira de depósito.

## Como fazer o deploy do token na Elysium?

Você precisa de três coisas antes de tocar na chain:

- **Um endpoint da Elysium.** Crie um app no [dashboard da Alchemy](https://dashboard.alchemy.com/) e selecione Elysium.
- **HYPE na Elysium.** O HYPE chega 1:1 do HyperEVM pela [bridge da Kinetiq](https://elysium.kinetiq.xyz/bridge) como gas nativo, sem nenhum token wrapped no meio.
- **Foundry.** Todos os comandos abaixo usam `forge` e `cast`, e a mesma chave de deployer assina na Elysium, no HyperEVM e no HyperCore.

A bridge de espelhamento aceita qualquer ERC-20 padrão com três propriedades. Ele precisa expor `name()`, `symbol()` e `decimals()`, porque é por esses metadados que a bridge pareia o token com o seu espelho. Os metadados nunca devem mudar. As transferências também precisam mover exatamente o valor solicitado, o que exclui tokens fee-on-transfer e de rebase. Um ERC-20 simples da OpenZeppelin atende às três. Nosso [guia sobre tokens ERC-20 em Solidity](https://www.alchemy.com/overviews/erc20-solidity) cobre o que cada função faz.

Planeje desde já o supply de acordo com os limites do HyperCore. O HyperCore armazena saldos como inteiros de 64 bits e permite [no máximo 8 decimais de wei](https://hyperliquid.gitbook.io/hyperliquid-docs/hyperliquid-improvement-proposals-hips/frontend-checks), o que limita um token com 8 decimais a cerca de 184 bilhões de unidades inteiras. Um supply fixo de um bilhão cabe com folga:

<CodeSnippet
  language="solidity"
  code={`// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract ExampleToken is ERC20 {
    constructor() ERC20("Example Token", "EXMPL") {
        _mint(msg.sender, 1_000_000_000 * 10 ** decimals());
    }
}`}
/>

O ERC-20 da OpenZeppelin define o nome e o símbolo uma única vez no construtor e, sem função de mint, o supply fica fixo no deploy. Salve o contrato como `src/ExampleToken.sol` e faça o deploy:

<CodeSnippet
  language="bash"
  code={`forge init example-token && cd example-token
forge install OpenZeppelin/openzeppelin-contracts
# Save the contract above as src/ExampleToken.sol, then import your deployer key once.
cast wallet import deployer --interactive
export ELYSIUM_RPC="https://elysium-mainnet.g.alchemy.com/v2/$ALCHEMY_API_KEY"
forge create src/ExampleToken.sol:ExampleToken \\
  --rpc-url "$ELYSIUM_RPC" \\
  --account deployer \\
  --broadcast`}
/>

`cast wallet import` guarda a chave em um keystore criptografado, e `--account` a desbloqueia no momento da assinatura, então a chave bruta nunca aparece no histórico do shell. Nosso [guia de token na Robinhood Chain](https://www.alchemy.com/overviews/launch-a-memecoin-on-robinhood-chain) usa o mesmo fluxo em outra chain Arbitrum Orbit.

Para ver a cadência de blocos por conta própria, assine novos blocos pelo endpoint WebSocket. Nessa cadência, o polling via HTTP pula blocos entre uma consulta e outra, então use aqui a URL WebSocket:

<CodeSnippet
  language="typescript"
  code={`import { createPublicClient, defineChain, webSocket } from "viem";
const wssUrl = process.env.ELYSIUM_WSS;
if (!wssUrl) throw new Error("Set ELYSIUM_WSS to your Alchemy Elysium WebSocket URL");
// viem/chains exports an unrelated chain called elysiumTestnet, so define Elysium yourself.
const elysium = defineChain({
  id: 99901, // Elysium mainnet
  name: "Elysium",
  nativeCurrency: { name: "HYPE", symbol: "HYPE", decimals: 18 },
  rpcUrls: { default: { http: [], webSocket: [wssUrl] } },
});
const client = createPublicClient({ chain: elysium, transport: webSocket(wssUrl) });
let previous;
client.watchBlocks({
  onBlock: (block) => {
    const now = Date.now();
    if (previous) console.log(\`block \${block.number} arrived \${now - previous} ms after the last one\`);
    previous = now;
  },
  onError: (error) => console.error(error.message),
});`}
/>

Defina `ELYSIUM_WSS` como a URL `wss://elysium-mainnet.g.alchemy.com/v2/` com a sua chave. Você pode consultar o seu token e as transações dele no [explorador da Elysium](https://elysium.kinetiq.xyz/explorer).

## Como espelhar o token no HyperEVM?

A bridge de espelhamento tem duas partes. Uma carteira de custódia na Elysium guarda os tokens bloqueados, e somente a bridge faz o mint e a queima de um ERC-20 espelho no HyperEVM. A configuração é permissionless e exige uma transação em cada chain, em qualquer ordem. Os endereços abaixo são os da mainnet da Elysium, retirados da [página de endereços de contratos](https://elysium.kinetiq.xyz/docs/contract-addresses) da Kinetiq. Confira-os lá antes de enviar fundos:

<CodeSnippet
  language="bash"
  code={`export HYPEREVM_RPC="https://hyperliquid-mainnet.g.alchemy.com/v2/$ALCHEMY_API_KEY"
export TOKEN=<your token's address on Elysium>
export BRIDGE_FACTORY=0x209B0476ec33841c661f41C0C260A3b8aF94164A   # ElysiumBridgeFactory, on Elysium
export MIRROR_FACTORY=0x473D61817Da6ce1a97aDC010FF1e96048504643B   # ElysiumMirrorFactory, on HyperEVM
export ELYSIUM_ROUTER=0x61EbbC3A29f1970aF2Ce862bA9c5364832E14d17   # gateway router, on Elysium
export DEPLOYER=$(cast wallet address --account deployer)
# Elysium: deploy the escrow wallet that will hold locked tokens.
cast send "$BRIDGE_FACTORY" "createL2Wallet(address)" "$TOKEN" \\
  --rpc-url "$ELYSIUM_RPC" --account deployer
# The one mirror address the factory derived from your token's name, symbol, and decimals.
export MIRROR=$(cast call "$BRIDGE_FACTORY" "expectedL1Mirror(address)(address)" "$TOKEN" --rpc-url "$ELYSIUM_RPC")`}
/>

A transação no HyperEVM faz o deploy do espelho nesse endereço e registra o par na bridge nas duas chains. Ela paga em HYPE por duas mensagens de entrega para a Elysium, e o valor que você envia precisa ser exatamente igual à soma dos dois orçamentos de mensagem. A Kinetiq recomenda oferecer o dobro do preço de gas atual da Elysium, com mínimo de 0,5 gwei, para que as duas mensagens sejam executadas assim que chegarem. Qualquer excedente é reembolsado para o seu endereço na Elysium:

<CodeSnippet
  language="bash"
  code={`GAS_PRICE_BID=$(( $(cast gas-price --rpc-url "$ELYSIUM_RPC") * 2 ))   # 2x the current Elysium gas price
(( GAS_PRICE_BID < 500000000 )) && GAS_PRICE_BID=500000000            # at least 0.5 gwei
MAX_GAS=300000
MAX_SUBMISSION=400000000000000                                       # 0.0004 HYPE per message
VALUE_EACH=$(( MAX_SUBMISSION + MAX_GAS * GAS_PRICE_BID ))
cast send "$MIRROR_FACTORY" \\
  "createAndRegisterL1Mirror(address,string,string,uint8,(uint256,uint256,uint256,uint256,uint256,uint256,uint256,address))" \\
  "$TOKEN" "Example Token" "EXMPL" 18 \\
  "($MAX_SUBMISSION,$MAX_SUBMISSION,$MAX_GAS,$MAX_GAS,$GAS_PRICE_BID,$VALUE_EACH,$VALUE_EACH,$DEPLOYER)" \\
  --value $(( 2 * VALUE_EACH )) \\
  --rpc-url "$HYPEREVM_RPC" --account deployer`}
/>

Passe exatamente o nome, o símbolo e os decimais atuais do token. A factory aceita quaisquer metadados, mas só o espelho que corresponde ao seu token pode receber supply, e um espelho divergente fica vazio para sempre. As duas mensagens normalmente chegam à Elysium em até um minuto. Se uma delas não for executada, rode de novo o mesmo registro com os mesmos argumentos para reenviar as duas.

A partir daqui, a bridge fica aberta a todos os detentores. Para mover tokens, aprove a carteira de custódia na Elysium e envie-os pelo router. O router recebe o endereço do espelho como argumento de token nas duas direções:

<CodeSnippet
  language="bash"
  code={`export WALLET=$(cast call "$BRIDGE_FACTORY" "l2WalletFor(address)(address)" "$TOKEN" --rpc-url "$ELYSIUM_RPC")
AMOUNT=$(cast to-wei 1000000)   # 1,000,000 tokens, converted to 18-decimal base units
cast send "$TOKEN" "approve(address,uint256)" "$WALLET" "$AMOUNT" \\
  --rpc-url "$ELYSIUM_RPC" --account deployer
cast send "$ELYSIUM_ROUTER" "outboundTransfer(address,address,uint256,uint256,uint256,bytes)" \\
  "$MIRROR" "$DEPLOYER" "$AMOUNT" 0 0 0x \\
  --rpc-url "$ELYSIUM_RPC" --account deployer`}
/>

O bloqueio acontece na hora. O espelho pode ser resgatado no HyperEVM depois que termina o período de contestação da Elysium, que é a janela de espera das mensagens que saem de um optimistic rollup e dura [cerca de 5,5 dias na mainnet](https://elysium.kinetiq.xyz/docs/bridging-elysium-tokens-to-hyperevm). Qualquer pessoa pode fazer o resgate, e a [bridge da Kinetiq](https://elysium.kinetiq.xyz/bridge) mostra a transferência como resgatável quando ela estiver pronta. Planeje o primeiro mint do espelho em torno dessa espera. Depois que o resgate for confirmado, leia o supply do espelho com a [Alchemy CLI](https://www.alchemy.com/agents):

<CodeSnippet
  language="bash"
  code={`alchemy evm contract read "$MIRROR" "totalSupply()(uint256)" -n hyperliquid-mainnet`}
/>

A volta é mais rápida. Queimar o espelho no HyperEVM libera o original na Elysium, normalmente em até um minuto.

Integradores que listam o espelho devem verificá-lo pela factory em vez de confiar apenas no endereço. A verificação da Kinetiq combina duas leituras. `elysiumTokenOf(mirror)` na factory de espelhos precisa retornar o token original, e o supply do espelho precisa ser maior que zero, o que um espelho divergente nunca alcança.

## Como listar o token em um order book spot do HyperCore?

A listagem é uma cerimônia do emissor no HyperCore com cinco partes. Você compra um ticker, cria a carteira de depósito, executa o genesis, vincula o token à carteira e registra o par spot. O [guia de deploy spot da Kinetiq](https://elysium.kinetiq.xyz/docs/hypercore-spot-deployment) documenta a cerimônia completa. Só o endereço que vence o ticker pode assinar as ações no HyperCore, e não há allowlist nem revisão entre a compra do ticker e um order book no ar. Na prática, a cerimônia leva dias, porque o leilão segue o próprio cronograma.

### Quanto custa o leilão do ticker?

Os tickers são vendidos em um [leilão holandês de 31 horas](https://hyperliquid.gitbook.io/hyperliquid-docs/hyperliquid-improvement-proposals-hips/hip-1-native-token-standard). O preço cai de forma linear até um piso de 500 HYPE, e cada novo leilão abre com o dobro do preço da venda anterior, ou no piso, se o último leilão não teve venda. A documentação da Hyperliquid pede que quem faz o deploy ensaie antes o deploy exato na testnet, porque o pagamento do leilão não é reembolsado se um deploy travar.

As ações no HyperCore abaixo usam o [SDK Python da Hyperliquid](https://github.com/hyperliquid-dex/hyperliquid-python-sdk) e assinam com o mesmo keystore do Foundry usado nas transações EVM:

<CodeSnippet
  language="python"
  code={`import getpass
import json
import pathlib
import eth_account
from hyperliquid.exchange import Exchange
from hyperliquid.info import Info
from hyperliquid.utils import constants
from hyperliquid.utils.signing import get_timestamp_ms, sign_l1_action
keystore = json.loads(pathlib.Path("~/.foundry/keystores/deployer").expanduser().read_text())
deployer = eth_account.Account.from_key(
    eth_account.Account.decrypt(keystore, getpass.getpass("Keystore password: "))
)
exchange = Exchange(deployer, base_url=constants.MAINNET_API_URL)
info = Info(constants.MAINNET_API_URL, skip_ws=True)
def ok(response):
    if response.get("status") != "ok":
        raise RuntimeError(response)
    return response
auction = info.post("/info", {"type": "spotDeployState", "user": deployer.address})["gasAuction"]
print("Current ticker price in HYPE:", auction["currentGas"])`}
/>

Nossa [HyperCore Data API](https://www.alchemy.com/docs/data/hypercore/rest-api/token-deployment/spot-deployment-state), agora em acesso antecipado, fornece o mesmo estado do leilão.

Quando o preço estiver aceitável, compre o ticker. Essa chamada fixa de vez a especificação de decimais no HyperCore. O exemplo usa 8 decimais de wei e 2 decimais de tamanho, o que atende à regra do HyperCore de que os decimais de wei sejam pelo menos os decimais de tamanho mais 5. O teto do lance está em unidades do HyperCore, nas quais o HYPE tem 8 decimais:

<CodeSnippet
  language="python"
  code={`MAX_GAS = 600 * 10**8   # refuse to pay more than 600 HYPE
result = ok(exchange.spot_deploy_register_token("EXMPL", 2, 8, MAX_GAS, "Example Token"))
TOKEN_INDEX = result["response"]["data"]
print("Ticker index:", TOKEN_INDEX)`}
/>

### Como a carteira de depósito, o genesis e o vínculo se encaixam?

Crie a carteira de depósito no HyperEVM enquanto o ticker ainda não está vinculado. O último argumento é o endereço que vai assinar o vínculo, que a carteira grava no slot de storage verificado pelo HyperCore:

<CodeSnippet
  language="bash"
  code={`export DEPOSIT_WALLET_FACTORY=0x9aD2639eB48FD7dd0f6F310F04aF5A9f7937cf6c   # HyperCoreDepositFactory, on HyperEVM
export TOKEN_INDEX=<ticker index from the purchase>
cast send "$DEPOSIT_WALLET_FACTORY" "createWallet(address,uint64,address)" "$MIRROR" "$TOKEN_INDEX" "$DEPLOYER" \\
  --rpc-url "$HYPEREVM_RPC" --account deployer
cast call "$DEPOSIT_WALLET_FACTORY" "walletFor(address,uint64,address)(address)" "$MIRROR" "$TOKEN_INDEX" "$DEPLOYER" \\
  --rpc-url "$HYPEREVM_RPC"`}
/>

O genesis cria todo o supply do token no HyperCore. Para um token via bridge, tudo vai para o endereço de sistema do token, um endereço reservado do HyperCore formado por `0x20` seguido do índice do ticker. O supply só sai do endereço de sistema quando alguém deposita tokens espelho em custódia, então o supply circulante no HyperCore sempre corresponde ao que a carteira de depósito guarda. O genesis só pode ser executado uma vez. Um token via bridge também desativa a Hyperliquidity, a estratégia do HIP-2 que abastece um book novo com ordens operadas pelo protocolo:

<CodeSnippet
  language="python"
  code={`MAX_SUPPLY_WEI = str(1_000_000_000 * 10**8)              # one billion tokens at 8 HyperCore decimals
SYSTEM_ADDRESS = "0x20" + format(TOKEN_INDEX, "038x")    # 0x20, then the index in the remaining 19 bytes
ok(exchange.spot_deploy_user_genesis(TOKEN_INDEX, [(SYSTEM_ADDRESS, MAX_SUPPLY_WEI)], []))
ok(exchange.spot_deploy_genesis(TOKEN_INDEX, MAX_SUPPLY_WEI, True))   # True = no Hyperliquidity`}
/>

O vínculo consiste em duas ações no HyperCore, uma solicitação que indica a carteira de depósito e uma finalização assinada pelo endereço gravado nela. O offset de decimais é a diferença entre os 18 decimais do ERC-20 e os 8 do token no HyperCore. O SDK não tem helper para essas ações, então assine-as e envie-as diretamente. O vínculo é permanente:

<CodeSnippet
  language="python"
  code={`DEPOSIT_WALLET = "<deposit wallet address from walletFor>"
def submit(action):
    nonce = get_timestamp_ms()
    signature = sign_l1_action(deployer, action, None, nonce, None, True)   # True = mainnet
    return ok(exchange.post("/exchange", {
        "action": action, "nonce": nonce, "signature": signature, "vaultAddress": None,
    }))
submit({"type": "spotDeploy", "requestEvmContract": {
    "token": TOKEN_INDEX, "address": DEPOSIT_WALLET.lower(), "evmExtraWeiDecimals": 10,
}})
submit({"type": "finalizeEvmContract", "token": TOKEN_INDEX, "input": "customStorageSlot"})`}
/>

A partir daqui, os depósitos já funcionam, mesmo antes de o token ter um order book.

### Como abrir o order book?

Registrar o par spot contra USDC (índice de token `0`) e depois registrar a Hyperliquidity cria o mercado. A segunda chamada é obrigatória mesmo com a Hyperliquidity desativada e, nesse caso, não posiciona nenhuma ordem e apenas define o preço de abertura:

<CodeSnippet
  language="python"
  code={`pair = ok(exchange.spot_deploy_register_spot(TOKEN_INDEX, 0))   # 0 = USDC
SPOT_INDEX = pair["response"]["data"]
START_PX = 0.01   # opening price in USDC; set it to a real price, not a placeholder
ok(exchange.spot_deploy_register_hyperliquidity(SPOT_INDEX, START_PX, 1, 0, None))   # 0 orders`}
/>

Agora os detentores podem mover tokens para o HyperCore. Eles aprovam a carteira de depósito para o espelho e chamam `deposit` com o spot do HyperCore como destino. Com 18 decimais na EVM e 8 no HyperCore, os valores precisam ser múltiplos de 10^10 unidades base, e valores em tokens inteiros sempre são:

<CodeSnippet
  language="bash"
  code={`export DEPOSIT_WALLET=<deposit wallet address>
AMOUNT=$(cast to-wei 1000)   # 1,000 tokens
cast send "$MIRROR" "approve(address,uint256)" "$DEPOSIT_WALLET" "$AMOUNT" \\
  --rpc-url "$HYPEREVM_RPC" --account deployer
cast send "$DEPOSIT_WALLET" "deposit(uint256,uint32)" "$AMOUNT" 4294967295 \\
  --rpc-url "$HYPEREVM_RPC" --account deployer   # 4294967295 routes to HyperCore spot`}
/>

O HyperCore credita o saldo no próximo bloco. Para voltar, basta uma ação `sendAsset` para o endereço de sistema, que paga o espelho a partir da custódia no HyperEVM. Com a Hyperliquidity desativada, o book novo começa vazio. Sua equipe ou um market maker precisa fazer cotações nele, usando o ID de ativo spot `10000 + SPOT_INDEX` nas ordens.

## Um agente de programação pode fazer isso por você?

A maior parte do lado EVM pode ser automatizada com scripts. Um agente pode fazer o deploy do token, configurar o espelho e levar o supply pela bridge com Foundry, e depois confirmar cada etapa com a [Alchemy CLI](https://www.alchemy.com/docs/alchemy-cli). Todo comando da CLI aceita `--json --no-interactive`, para que o agente consiga interpretar a saída. Se o seu agente trabalha com skills ou MCP em vez de um shell, as [Agent Skills](https://www.alchemy.com/docs/alchemy-agent-skills) e o [Alchemy MCP server](https://www.alchemy.com/docs/alchemy-mcp-server) cobrem as mesmas leituras. Use `-n hyperliquid-mainnet` para leituras no HyperEVM e aponte o Foundry para o seu endpoint da Elysium em tudo o que acontece na Elysium.

Deixe a assinatura da cerimônia no HyperCore com uma pessoa. Ela gasta pelo menos 500 HYPE no leilão e fixa os decimais, o supply e o vínculo de forma permanente, então um agente deve preparar essas ações e uma pessoa deve assiná-las. Um prompt para o lado EVM:

<CodeSnippet
  language="text"
  code={`Run \`alchemy --json --no-interactive agent-prompt\` to load the CLI's command contract, then help me launch a token on Elysium mainnet and mirror it to HyperEVM.

Start by asking me for the token name, symbol, and total supply. Do not invent them. Confirm them back before writing any code.

Then:

- Sign everything with my Foundry keystore account \`deployer\`. If it doesn't exist, stop and tell me to run \`cast wallet import\`.
- Get my deployer address with \`cast wallet address --account deployer\`, then check its HYPE balance on Elysium with \`cast balance <deployer-address> --rpc-url <my Alchemy Elysium endpoint>\` before each transaction, and stop if it can't cover gas.
- Write a fixed-supply ERC-20 with no owner and no mint function, and deploy it with \`forge create --rpc-url <my Alchemy Elysium endpoint>\`.
- Run the mirror-bridge setup from Kinetiq's docs, taking every contract address from https://elysium.kinetiq.xyz/docs/contract-addresses. Show me each \`cast send\` command, with the value in HYPE, before running it.
- Verify the mirror with \`alchemy evm contract read <mirror> "totalSupply()(uint256)" -n hyperliquid-mainnet\`.

Ask before every transaction that spends HYPE. Do not buy a HyperCore ticker or run any HyperCore deploy action. Stop after the mirror and hand me the addresses.`}
/>

## Comece a construir na Elysium

Crie um app no [dashboard da Alchemy](https://dashboard.alchemy.com/), selecione Elysium e você terá endpoints de RPC e WebSocket da mainnet em poucos minutos. Sem contratos, sem lista de espera, sem compromisso mínimo. Equipes que constroem na Elysium também podem solicitar créditos pelo [programa de créditos da Alchemy para a Elysium](https://www.alchemy.com/credits-program/elysium). Adicione o [HyperEVM da Hyperliquid](https://www.alchemy.com/rpc/hyperliquid) ao mesmo app para a etapa do espelho e [solicite acesso antecipado ao HyperCore](https://www.alchemy.com/hypercore-early-access) para fazer streaming do order book em que o seu token vai chegar.
