Pular para o conteúdo
0%

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

Uttam Singh headshot

Escrito por Uttam Singh

Publicado em 10 de novembro de 202610 min de leitura

Lançando um token na Elysium e levando-o a um order book do HyperCore

A Elysium é a Layer 2 da Kinetiq para a Hyperliquid, e sua mainnet entrou no ar em 9 de novembro. É 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 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 explica como as duas partes se encaixam, e nosso guia de trading na Elysium 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 limita a própria capacidade de propósito. Seus blocos pequenos carregam 3M de gas a cada segundo, 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. 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.

Elysium
HyperEVM
Tempo de bloco
Blocos canônicos de 100 ms
Blocos pequenos de 1 s, blocos grandes de 1 min
Capacidade de gas
Meta de 300 Mgas/s
3M de gas por bloco pequeno
Token de gas
HYPE, via bridge 1:1 como gas nativo
HYPE
Stack
Arbitrum Orbit (Nitro e ArbOS)
L1 da Hyperliquid
Acesso ao HyperCore a partir de contratos
Lanes de leitura e escrita previstas para cerca de quatro semanas após a mainnet
Precompiles de leitura e CoreWriter

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 por cima. Solidity, Foundry, Hardhat e viem funcionam sem alterações. A Kinetiq também destinou 25% das taxas do sequenciador aos builders 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. Nossa página de RPC da Elysium e nosso quickstart da API da Elysium trazem os endpoints da mainnet. Dois detalhes do nosso FAQ da API da Elysium 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:

text
Copied
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
Salto
Quem configura
Custo único
O que os detentores podem fazer depois
Da Elysium para o HyperEVM (bridge de espelhamento)
Qualquer pessoa, em duas transações
Gas mais uma pequena taxa em HYPE para mensagens cross-chain
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)
Do HyperEVM para o HyperCore (carteira de depósito)
O endereço que vence o leilão do ticker
Leilão do ticker, piso de 500 HYPE
Depositar no HyperCore e sacar de volta para o HyperEVM

A bridge de espelhamento 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 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 e selecione Elysium.
  • HYPE na Elysium. O HYPE chega 1:1 do HyperEVM pela bridge da Kinetiq 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 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, 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:

solidity
Copied
// 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:

bash
Copied
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 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:

typescript
Copied
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.

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 da Kinetiq. Confira-os lá antes de enviar fundos:

bash
Copied
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:

bash
Copied
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:

bash
Copied
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. Qualquer pessoa pode fazer o resgate, e a bridge da Kinetiq 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:

bash
Copied
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 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. 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 e assinam com o mesmo keystore do Foundry usado nas transações EVM:

python
Copied
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, 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:

python
Copied
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:

bash
Copied
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:

python
Copied
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:

python
Copied
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:

python
Copied
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:

bash
Copied
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. 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 e o 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:

text
Copied
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, 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. Adicione o HyperEVM da Hyperliquid ao mesmo app para a etapa do espelho e solicite acesso antecipado ao HyperCore para fazer streaming do order book em que o seu token vai chegar.

Background gradient

Construa magia blockchain

A Alchemy combina os produtos e ferramentas de desenvolvimento Web3 mais poderosos com recursos, comunidade e suporte lendário.