Transferência de tokens

Por volta de 5 min

Este tutorial mostrará como transferir SC_Tokens entre a main chain e uma sidechain.

Pré-requisitos

sidechain-evm-cli é usado neste tutorial e está no repositório SC_EVM aquiopen in new window.
Baixe a ferramenta de conversão bech32 e adicione ao caminho do seu shell: https://github.com/input-output-hk/bech32.
Se ainda não o fez, crie e financie suas contas da main chain e da sidechain.
O código-fonte do contrato de ponte, que pode ser usado para compilar o Solidity ou obter o ABI, está no repositório SC_EVM aquiopen in new window.

Transferindo tokens de uma sidechain para a main chain

Transferir SC_Token de uma sidechain para a main chain exigirá interação com o contrato inteligente de ponte para bloquear a quantidade desejada de SC_Token a serem reivindicados na main chain. Neste guia, você usará o RemixIDE para interagir com o contrato de ponte.

Passo 01 - Configurar a interface do contrato no RemixIDE

Acesse https://remix.ethereum.org/
Crie /contracts/bridge.abi com o seguinte conteúdo: bridge.abiopen in new window

Observação: Certifique-se de que seu provedor Web3 compatível com o Remix esteja configurado para a testnet da sidechain EVM. Ex: MetaMask.

No Remix, vá para Deploy and Run transactions > selecione Injected Provider (MetaMask) para o ambiente > Carregue o contrato a partir do endereço (0x696f686b2e6d616d626100000000000000000000)

Seu RemixIDE ficará semelhante a este com uma interface de contrato: Remix IDE

Passo 02 - Bloquear SC_Token

A função lock do contrato de ponte requer o endereço do destinatário da main chain, mas o endereço do destinatário deve ser convertido para o formato bech32.

Converta o endereço da main chain para o formato bech32:

./bech32 <<< addr_test1vpzhx6enc57e75n2ygcgdt7cz2c8akt5rk5qaxy7j6vc3ycgly0wh
6045736b33c53d9f526a223086afd812b07ed9741da80e989e96998893 #Returns the conversion

Para garantir que o endereço seja reconhecido como uma string HEX, basta adicionar 0x no início do endereço convertido, por exemplo: 0x6045736b33c53d9f526a223086afd812b07ed9741da80e989e96998893

Determine quantos SC_Tokens você deseja bloquear. A quantidade em SC_Token deve ser um múltiplo de 10^9. Por exemplo, 10^9 wei na sidechain será igual a 1 SC_Token na mainchain. Digite a quantidade de SC_Token, em wei, que você deseja bloquear: por exemplo, 1000000000 Wei == 1 SC_Token. Seu Remix deve se parecer com isso:
Selecione o botão lock para iniciar a transação e siga as instruções do MetaMask para confirmar e assinar a transação.

Observação: Se a transação parecer estar travada, com status 'pendente', ou se o MetaMask mostrar um saldo inválido, tente redefinir o MetaMaskopen in new window e envie a transação novamente.

Para obter o hash da transação ou verificar se a transação foi bem-sucedida, você pode verificar a atividade do MetaMask ou o console do Remix:
- Alternativamente, você pode invocar o método da API eth_getTransactionReceipt. Você pode solicitar isso até que o recibo seja retornado ou a transação expire:
```
curl -L -X POST -H 'Content-type:application/json' -d '{
"jsonrpc": "2.0",
"method": "eth_getTransactionReceipt",
"params": [INSIRA_TX_CRUA],
"id": 1
}' https://localhost:8546 | jq
```

Etapa 03 - Aguarde o processamento da transação e obtenha a prova de Merkle

Obtenha o status atual da sidechain invocando sidechain_getStatus:

curl -L -X POST -H 'Content-type:application/json' -d '{
   "jsonrpc": "2.0",
   "method": "sidechain_getStatus",
   "params": [],
   "id": 1
   }' https://localhost:8546 | jq -r

Isso mostra em qual época e fase a transação lock() aconteceu. Se aconteceu durante a época N na fase da época regular, você pode obter a prova de Merkle na época N já que a fase da época muda para handover. Se aconteceu durante a época N na fase da época closedTransactionBatch ou handover, você pode obter a prova de Merkle na época N+1 já que a fase da época muda para handover.

Obtenha o índice de transação para a época em que a transação de bloqueio será processada invocando o método da API sidechain_getOutgoingTransactions:

curl -L -X POST -H 'Content-type:application/json' -d '{
  "jsonrpc": "2.0",
  "method": "sidechain_getOutgoingTransactions",
  "params": [<N or N+1>],
  "id": 1
  }' https://localhost:8546 | jq

Exemplo do output:

{
  "jsonrpc": "2.0",
  "result": {
    "transactions": [
      {
        "value": "0x1",
        "recipient": "0x6041e633c6b54572165a1563291c147dadb803667c99fc8c55ff3762fb",
        "txIndex": 0
      }
    ]
  },
  "id": 1
}

Para obter a merkleProof correspondente ao destinatário e ao valor usado para bloquear os tokens, proceda da seguinte maneira.

Aguarde até que a fase da época mude para handover da época N ou N+1 e obtenha a prova de Merkle para sua ação de bloqueio invocando o método da API sidechain_getOutgoingTxMerkleProof:

curl -L -X POST -H 'Content-type:application/json' -d '{
  "jsonrpc": "2.0",
  "method": "sidechain_getOutgoingTxMerkleProof",
  "params": [<N or N+1>, <txIndex>],
  "id": 1
  }' https://localhost:8546 | jq

Example:

curl -L -X POST https://localhost:8546 -H 'Content-type:application/json' -d '{"jsonrpc": "2.0", "method": "sidechain_getOutgoingTxMerkleProof", "params": [1295, 1], "id": 1}' | jq

{
  "jsonrpc": "2.0",
  "result": {
    "proof": {
      "bytes": "0xd8799fd8799f0101581d6045736b33c53d9f526a223086afd812b07ed9741da80e989e96998893d8799f5820772485d60f6744cf252f26560413aae8d28c82a88b1c77eede792f28965f4e79ffff9fd8799f005820ed69142610619b748ec5cd657e418c1c891c3a176900376d12db0b3c406a0a38ffffff",
      "info": {
        "transaction": {
          "value": "0x1",
          "recipient": "0x6045736b33c53d9f526a223086afd812b07ed9741da80e989e96998893",
          "txIndex": 1
        },
        "merkleRootHash": "0xaacd27079b9c8b8bd17693beccb8997b4b7b1ef97596018d43047a40dab6b021"
      }
    },
    "sidechainEpoch": 1295
  },
  "id": 1
}

A partir do retorno, você precisa obter o proof/bytes e remover o 0x que está prefixado. Chame essa string de merkleProof.

No exemplo acima d8799fd8799... é a prova de Merkle.

Aguarde até que a época mude e a entrega do comitê tenha ocorrido.

Nota: Uma época de sidechain é de 1 hora; 30 minutos na fase regular, 15 minutos na fase closedTxBatch e 15 minutos na fase handover.

A entrega do comitê acontece automaticamente nos testnets por um serviço (relay) que tenta encontrar assinaturas de época a cada minuto, e tem sucesso após o início de uma nova época e a obtenção das assinaturas. Na mainnet, a entrega do comitê será feita por qualquer pessoa que queira, onde haverá um incentivo para isso. Uma boa maneira de verificar isso é esperar até que você observe sua transação na lista de assinaturas para enviar:

curl -L -X POST -H 'Content-type:application/json' -d '{
    "jsonrpc": "2.0",
    "method": "sidechain_getSignaturesToUpload",
    "params": [<limite>],
    "id": 1
    }' https://localhost:8546 | jq

Onde limite = min(limit, número de épocas que ainda não foram transmitidas). O valor padrão é 100, mas você pode definir para qualquer outro número. Normalmente, quando a entrega acontece a cada época, deveria mostrar apenas 0 ou 1 épocas (a última). Assim que você identificar que não há roothashes pendentes na lista sob a época que seu bloqueio foi processado (N ou N+1), você pode reivindicar seus tokens. Nesse momento, a época será N+1 or N+2, dependendo da fase em que você executou a operação de bloqueio.

Etapa 04 - Reivindicar SC_Token

Reivindique os tokens enviando uma transação na main chain com o merkleProof que você obteve usando o sidechain-cli. Você precisará assinar a transação com sua chave de assinatura da main chain (ex: payment.skey):

./sidechain-cli claim-sc-token \
--sc-evm-url https://localhost:8546 \
--signing-key-file /Caminho/Para/payment.skey \
--combined-proof <merkleProof sem 0x>

Saída de exemplo:

{
  "endpoint": "ClaimAct",
  "transactionId": "1334b3dab421911af68b9393e5cc4756c46c9ab1ac567a57450597e174351a48"
}

Aviso: Por favor, note que este comando pode levar alguns minutos para ser concluído.

🎉 Parabéns! Neste ponto, você reivindicou com sucesso seus SC_Token na main chain.

Transferindo tokens da main chain para uma sidechain

Etapa 01 - Queimar SC_Token

Para transferir SC_Token da main chain para uma sidechain, use o sidechain-cli para queimar SC_Token da main-chain.

sbt "scEvmCli/run burn-sc-token \
--signing-key-file payment.skey \
--sc-evm-url https://localhost:8546 \
--recipient ae3dffee97f92db0201d11cb8877c89738353bce \
--amount 10"

Aviso: Por favor, note que este comando pode levar alguns minutos para ser concluído.

Entendendo este comando:

--signing-key-file payment.skey: Ao gerar uma conta na main-chain, um arquivo .skey é criado para assinar transações. O comando fornece o caminho para este arquivo.
--sc-evm-url https://localhost:8546: Fornecendo o URL da API JSON-RPC, ou endpoint, para o nó da rede sidechain.
--recipient ae3dffee97f92db0201d11cb8877c89738353bce: Define o endereço de destino na sidechain onde os tokens SC_Token aparecerão.
--amount 10: Define a quantidade de SC_Token (na main chain) a ser queimada para SC_Token (na sidechain) à taxa de conversão de quantidadex10^9.

A transação será estável na main chain em aproximadamente 12 minutos ou 36 blocos. A sidechain então a adicionará a um bloco produzido e os tokens deverão aparecer no saldo da conta da sidechain:

Verifique o saldo de tokens SC_Token usando a API JSON-RPC:

curl -L -X POST https://localhost:8546 -H 'Content-type:application/json' -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBalance",
    "params": ["0xae3dffee97f92db0201d11cb8877c89738353bce", "latest"],
    "id": 1}'

Dica: O saldo pode ser verificado em uma carteira Web3 compatível configurada para a rede de teste EVM sidechain.

🎉 Parabéns! Neste ponto, você queimou com sucesso seus SC_Token da main chain para um SC_Token nativo da sidechain.