💰Desenvolvendo uma Wallet Lunes

Rede Lunes: Criação de Carteiras, Simulação de Taxas e Transações

A Lunes é uma solochain desenvolvida com o framework Substrate, operando de forma independente, mas utilizando ferramentas e padrões comuns ao ecossistema Substrate. Esta documentação oferece um guia detalhado para desenvolvedores que desejam criar carteiras, simular taxas e realizar transações na rede Lunes, utilizando os endpoints fornecidos para a rede de teste e produção.

Sumário

Configuração Inicial e Conexão com a Rede Lunes
Criação ou Importação de Carteira
Simulação de Taxas na Rede Lunes
Realização de Transações na Rede Lunes
Gerenciamento de Erros
Conversão de Valores (Unis para Lunes)
Obtenção de Tokens na Rede de Teste
Diferenças entre Rede de Teste e Rede de Produção
Boas Práticas e Considerações Finais

1. Configuração Inicial e Conexão com a Rede Lunes

Para interagir com a rede Lunes, você precisa se conectar a um nó da rede via WebSocket. Abaixo estão os endpoints disponíveis:

Endpoints da Rede Lunes

Rede de Teste (Testnet):
- wss://ws-test.lunes.io
Rede de Produção (Mainnet):
- wss://ws.lunes.com
- wss://ws-lunes-main-01.lunes.io
- wss://ws-lunes-main-02.lunes.io
- wss://ws-archive.lunes.io

Para desenvolvimento e testes, utilize a rede de teste (wss://ws-test.lunes.io). Para operações reais, escolha um dos endpoints da mainnet, como wss://ws.lunes.com.

Exemplo de Conexão (JavaScript com @polkadot/api)

const { ApiPromise, WsProvider } = require("@polkadot/api");

// Configurar o provider com o endpoint da rede de teste
const provider = new WsProvider("wss://ws-test.lunes.io");

// Inicializar a API
(async () => {
  const api = await ApiPromise.create({ provider });
  console.log("Conectado à rede Lunes (Testnet) com sucesso!");
  // Aqui você pode começar a interagir com a rede
})();

Explicação:

WsProvider: Estabelece uma conexão WebSocket com o nó da Lunes.
ApiPromise.create: Inicializa a API de forma assíncrona para interação com a blockchain.
Para a mainnet, substitua o endpoint por um dos disponíveis, como wss://ws.lunes.com.

2. Criação ou Importação de Carteira

A Lunes utiliza o esquema de criptografia sr25519 para chaves públicas e privadas. Você pode criar uma nova carteira ou importar uma existente usando uma seed phrase (frase mnemônica).

a) Importar uma Carteira Existente

Se você já possui uma seed phrase da Lunes:

const { Keyring } = require("@polkadot/api");

// Configurar o Keyring com criptografia sr25519
const keyring = new Keyring({ type: "sr25519" });

// Sua seed phrase (substitua pelo valor real)
const seed = "palavra1 palavra2 palavra3 ... palavra12";

// Importar a conta
const account = keyring.addFromUri(seed);

console.log("Endereço da carteira Lunes:", account.address);

Explicação:

Keyring: Gerencia chaves com o tipo sr25519.
addFromUri: Converte a seed phrase em um par de chaves.
account.address: Mostra o endereço público da carteira no formato específico da Lunes.

b) Criar uma Nova Carteira

Para gerar uma nova carteira com uma seed phrase aleatória:

const { Keyring } = require("@polkadot/api");
const { mnemonicGenerate } = require("@polkadot/util-crypto");

// Configurar o Keyring
const keyring = new Keyring({ type: "sr25519" });

// Gerar uma nova seed phrase
const newSeed = mnemonicGenerate();

// Criar a conta
const newAccount = keyring.addFromUri(newSeed);

console.log("Nova Seed Phrase para Lunes:", newSeed);
console.log("Endereço da nova carteira Lunes:", newAccount.address);

Explicação:

mnemonicGenerate: Cria uma frase mnemônica de 12 palavras.
Segurança: Guarde a seed phrase em um local seguro, pois ela é essencial para recuperar a carteira.

3. Simulação de Taxas na Rede Lunes

Antes de enviar uma transação, é útil simular a taxa para verificar se você tem tokens Lunes suficientes.

const { ApiPromise, WsProvider } = require("@polkadot/api");

(async () => {
  // Conectar à rede de teste
  const provider = new WsProvider("wss://ws-test.lunes.io");
  const api = await ApiPromise.create({ provider });

  // Configurar a conta (exemplo com seed fictícia)
  const { Keyring } = require("@polkadot/api");
  const keyring = new Keyring({ type: "sr25519" });
  const account = keyring.addFromUri("palavra1 palavra2 palavra3 ... palavra12");

  // Simular uma transação
  const destination = "endereco_destino_lunes_aqui";
  const amount = "1000000"; // 1 milhão de Unis
  const info = await api.tx.balances
    .transfer(destination, amount)
    .paymentInfo(account);

  console.log("Taxa estimada em Unis:", info.partialFee.toHuman());
})();

Explicação:

api.tx.balances.transfer: Prepara uma transação de transferência.
paymentInfo: Calcula a taxa estimada sem enviar a transação.
partialFee.toHuman: Converte a taxa para um formato legível.

4. Realização de Transações na Rede Lunes

Aqui está como enviar tokens Lunes para outro endereço:

const { ApiPromise, WsProvider } = require("@polkadot/api");

(async () => {
  // Conectar à rede de teste
  const provider = new WsProvider("wss://ws-test.lunes.io");
  const api = await ApiPromise.create({ provider });

  // Configurar a conta
  const { Keyring } = require("@polkadot/api");
  const keyring = new Keyring({ type: "sr25519" });
  const account = keyring.addFromUri("palavra1 palavra2 palavra3 ... palavra12");

  // Realizar a transação
  const to = "endereco_destino_lunes_aqui";
  const value = "1000000"; // 1 milhão de Unis
  const txHash = await new Promise((resolve, reject) => {
    api.tx.balances
      .transfer(to, value)
      .signAndSend(account, (result) => {
        if (result.status.isInBlock) {
          console.log("Transação incluída no bloco:", result.status.asInBlock.toString());
        } else if (result.status.isFinalized) {
          console.log("Transação finalizada com hash:", result.txHash.toString());
          resolve(result.txHash.toString());
        }
        if (result.isError) {
          reject(new Error("Erro na transação"));
        }
      });
  });

  console.log("Hash da transação na Lunes:", txHash);

  // Desconectar
  await api.disconnect();
})();

Explicação:

signAndSend: Assina e envia a transação.
result.status: Monitora o progresso da transação (inclusão no bloco e finalização).
txHash: Retorna o hash para rastreamento.

5. Gerenciamento de Erros

É fundamental lidar com erros de forma adequada para garantir que seu aplicativo seja robusto. Abaixo estão alguns exemplos de como tratar erros comuns ao interagir com a rede Lunes.

Exemplo de Tratamento de Erros em Transações

try {
  const txHash = await api.tx.balances
    .transfer(to, value)
    .signAndSend(account, { nonce: -1 });
  console.log('Transação enviada com hash:', txHash.toHex());
} catch (error) {
  if (error.message.includes("1010")) {
    console.error("Erro: Saldo insuficiente para a transação.");
  } else if (error.message.includes("1002")) {
    console.error("Erro: Falha na conexão com o nó.");
  } else {
    console.error("Erro desconhecido:", error.message);
  }
}

Explicação:

Erro 1010: Geralmente indica saldo insuficiente para cobrir a transação e a taxa.
Erro 1002: Pode indicar falha na conexão com o nó da rede.
Use try...catch para capturar e tratar erros de forma apropriada.

6. Conversão de Valores (Unis para Lunes)

Na rede Lunes, os valores são expressos em Unis, a menor unidade da moeda. Para facilitar o uso, é útil converter entre Unis e Lunes (a unidade principal).

Funções de Conversão

Supondo que 1 Lunes = 1.000.000.000 Unis:

const lunesToUnis = (lunes) => BigInt(lunes * 1000000000);
const unisToLunes = (unis) => Number(unis) / 1000000000;

const amountInLunes = 1.5;
const amountInUnis = lunesToUnis(amountInLunes);
console.log(`1.5 Lunes em Unis: ${amountInUnis}`);

const feeInUnis = info.partialFee.toBigInt();
const feeInLunes = unisToLunes(feeInUnis);
console.log(`Taxa em Lunes: ${feeInLunes}`);

Explicação:

lunesToUnis: Converte Lunes para Unis.
unisToLunes: Converte Unis para Lunes.
Use essas funções para evitar erros ao lidar com valores monetários.

7. Obtenção de Tokens na Rede de Teste

Para testar suas aplicações na rede de teste da Lunes, você precisará de tokens de teste. Esses tokens não têm valor real e são usados apenas para desenvolvimento.

Como Obter Tokens de Teste

Acesse o faucet oficial da Lunes em [link do faucet] e siga as instruções para solicitar tokens para seu endereço de teste.

Nota: Substitua [link do faucet] pelo URL real do faucet da Lunes, se disponível.

8. Diferenças entre Rede de Teste e Rede de Produção

É importante entender as diferenças entre a rede de teste e a rede de produção para garantir que você esteja utilizando a rede correta para cada finalidade.

Rede de Teste (wss://ws-test.lunes.io):
- Destinada a desenvolvimento e testes.
- Tokens sem valor real.
- Ambiente menos estável, sujeito a reinicializações ou atualizações frequentes.
Rede de Produção (wss://ws.lunes.com, etc.):
- Para operações reais com tokens de valor.
- Ambiente estável e seguro.
- Transações têm impacto financeiro real.

Recomendação: Sempre teste suas aplicações na rede de teste antes de migrar para a rede de produção.

9. Boas Práticas e Considerações Finais

Segurança: Nunca exponha a seed phrase no código ou logs. Use variáveis de ambiente ou métodos seguros de armazenamento.
Testes: Utilize a rede de teste para desenvolvimento e testes antes de migrar para a mainnet.
Redundância: Na mainnet, alterne entre os endpoints disponíveis em caso de falhas ou alta latência.
Desconexão: Sempre chame api.disconnect() ao finalizar para liberar recursos.
Endpoints Alternativos:
- Use wss://ws-archive.lunes.io para consultas de dados históricos.
- Use wss://ws.lunes.com para transações em tempo real.

Exemplo Completo de Código

Abaixo está um exemplo completo que demonstra a criação de uma carteira, simulação de taxas e realização de uma transação na rede de teste da Lunes.

const { ApiPromise, WsProvider } = require('@polkadot/api');
const { Keyring } = require('@polkadot/api');
const { mnemonicGenerate } = require('@polkadot/util-crypto');

async function main() {
  // Conectar à rede de teste
  const provider = new WsProvider('wss://ws-test.lunes.io');
  const api = await ApiPromise.create({ provider });

  // Criar uma nova carteira
  const keyring = new Keyring({ type: 'sr25519' });
  const newSeed = mnemonicGenerate();
  const account = keyring.addFromUri(newSeed);
  console.log('Nova Seed Phrase:', newSeed);
  console.log('Endereço da carteira:', account.address);

  // Simular uma transação
  const destination = 'endereco_destino_lunes_aqui';
  const amount = BigInt(1500000000); // 1.5 Lunes em Unis
  const info = await api.tx.balances
    .transfer(destination, amount)
    .paymentInfo(account);
  console.log('Taxa estimada:', info.partialFee.toHuman());

  // Realizar a transação (apenas se tiver saldo suficiente)
  try {
    const txHash = await api.tx.balances
      .transfer(destination, amount)
      .signAndSend(account, { nonce: -1 });
    console.log('Transação enviada com hash:', txHash.toHex());
  } catch (error) {
    console.error('Erro na transação:', error.message);
  } finally {
    await api.disconnect();
  }
}

main().catch(console.error);

Explicação:

Este script cria uma nova carteira, simula uma transação e, se houver saldo, realiza a transação na rede de teste.
Certifique-se de substituir 'endereco_destino_lunes_aqui' por um endereço válido.

Conclusão

Esta documentação atualizada fornece um guia completo e detalhado para interagir com a rede Lunes, desde a configuração inicial até a realização de transações, com foco em boas práticas, gerenciamento de erros e conversão de valores. Todas as referências a "Planck" foram corrigidas para "Unis", refletindo a nomenclatura correta da menor unidade da Lunes. Com essas informações, os desenvolvedores poderão trabalhar de forma eficiente e segura na rede Lunes, tanto na testnet quanto na mainnet.

Last updated 6 months ago

Was this helpful?