Introdução ao desenvolvimento de Smart Contracts em RSK

22 de Maio de 2018 Autor: / Andres Bachfischer  

Motivação

Nos últimos anos, tem havido um crescimento no desenvolvimento de Smart Contracts, predominantemente no blockchain Ethereum. Ethereum, sendo um tipo diferente de blockchain do Bitcoin, pode executar linhas concisas de código dentro de sua cadeia, um trabalho que o Bitcoin (projetado especificamente para enviar facilmente transações) não pode fazer. Aqui é onde RSK intervém construindo uma sidechain (uma blockchain que valida dados de outras blockchains)  ligada ao Bitcoin por meio de um sistema Peg 2-Way, gerenciado pela Federation Partners, que torna a execução do código possível. Em vez de projetar uma nova linguagem de programação para o desenvolvimento de Smart Contracts, eles usaram Solidity, a mesma linguagem que a Ethereum usa. Isso tem dois benefícios: não apenas os programadores não terão que aprender uma nova habilidade, mas também os contratos na rede Ethereum podem ser implantados em RSK sem muito esforço, aproveitando a vasta capitalização de mercado do Bitcoin.

Neste artigo vou explicar como criar um node RSK, como configurá-lo corretamente e, finalmente, como implantar contratos e interagir com eles.

Instalação

Ambiente do Sistema

O software do node é baseado no EthereumJ. A equipe de desenvolvedores RSK oferece maneiras distintas de diferentes sistemas operacionais para configurar um node. Para este artigo, vamos aprender como configurar RSKj 4.2 no Linux, mais especificamente no Ubuntu LTS 16.04. Quando comecei este passo a passo, o último Ubuntu LTS era 16.04 e há alguns dias, o 18.04 foi lançado. Por causa disso e de outros problemas de estabilidade no novo sistema operacional lançado, vou usar a versão 16.04.

OK, vamos começar. Suponho que você irá instalar o node a partir de uma nova instalação do sistema operacional, então alguns programas provavelmente já estão instalados em seu PC e você pode pular etapas. Mas para aqueles que não os têm, isso seria uma ajuda.

Programas Essenciais

Nossas primeiras ferramentas são git e curl. Com eles podemos obter bibliotecas e código de vários desenvolvedores e usá-los em nosso trabalho. Para instalá-los temos que apenas escrever

$ sudo apt-get install git
$ sudo apt-get install curl

Precisamos de uma instância do Java para fazê-lo funcionar porque ele é executado em sua VM. Na hora de escrever este guia a versão mais recente do Java era a 10ª mas, em nosso caso, usaremos a 8ª versão do branch Oracle em vez do OpenJRE pois qualquer opção deve funcionar bem. Para fazer isso, primeiro adicionamos o repositório ao nosso sistema e depois o instalamos.

$ sudo add-apt-repository ppa:webupd8team/java
$ sudo apt-get update
$ sudo apt-get install oracle-java8-installer

Se tivermos outra versão do Java instalada temos que nos certificar de que o padrão é o que desejamos:

$ sudo apt-get install oracle-java8-set-default

Então, verificamos qual delas está em uso como

$ java -version

Depois disso, precisamos definir o caminho para Java adicionando uma linha no arquivo / etc / environment como raiz. A linha é

JAVA_HOME="/usr/lib/jvm/java-8-oracle"

Vamos resumir:

Java? Feito.

Git e curl? Duplamente feito

Então o que vem depois? O node, o próprio RSKj.

Node.js e RSK node

Vamos instalar a 8ª versão como

$ curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -
$ sudo apt-get install -y nodejs
$ sudo apt-get install -y build-essential

E então o projeto RSK já empacotou o rskj e o colocou em um PPA como

$ sudo add-apt-repository ppa:rsksmart/rskj
$ sudo apt-get update
$ sudo apt-get install rskj

Quando terminar, o instalador perguntará em qual rede gostaríamos de trabalhar. Não tenha medo de escolher um pois você pode alterá-lo mais tarde com alguns ajustes que veremos. Vamos selecionar Testnet por enquanto.

O node agora está instalado. Para usá-lo, você deve tratá-lo como um serviço como

$ sudo service rsk start
$ sudo service rsk status
$ sudo service rsk stop

Estes são, respectivamente, iniciar o node, observar o que está acontecendo (registros e problemas no serviço) e interrompê-lo.

Estas são algumas recomendações inatas da experiência. NÃO TENTE:

• Desligar seu PC enquanto ele estiver em execução

• Usar drivers / hardware conflitantes que podem congelar o sistema operacional (Ehmm.. Nvidia)

• Alterar os arquivos de configuração durante a execução.

Quando o banco de dados não é fechado corretamente, ele acaba corrompido e a maneira fácil de sincronizar o node novamente é redefini-lo e reiniciar o processo de sincronização do zero. Tente ter um nobreak no caso de frequentes quedas de energia.

Os locais onde o node salva sua configuração, logs e bancos de dados são:

Configurations files: /etc/rsk/
Databases: /var/lib/rsk/databases/
Logs: /var/logs/rsk/

Ambiente de desenvolvimento

Existem algumas maneiras de interagir com o rskj. Você pode usar o Node.js, o console dos utilitários RSK, chamadas  raw RPC (A unidade RAW significa que o sistema de arquivos está corrompido OU RPC original, bruta) , Truffle e qualquer biblioteca web3 funcional. Por enquanto, usaremos o Truffle porque ele também nos permite compilar e implantar em poucas etapas.

Para instalá-lo globalmente usamos a ferramenta npm dos pacotes node.js que instalamos.

$ sudo npm install -g truffle

Em seguida, criamos uma pasta e pedimos para desempacotar o modelo básico de desenvolvedor. Aviso: precisamos que a pasta esteja completamente vazia. Caso contrário, o Truffle terminará com erros.

$ mkdir ~/Truffle && cd ~/Truffle
$ truffle init

Para conectar truffle ao nosso node precisamos configurar a rede na qual o node está funcionando. Em nosso caso, a porta padrão é 4444 sobre localhost, então o arquivo deve ser semelhante a:

module.exports = {
  networks: {
    rsk: {
      host: "localhost",
      port: 4444,
      network_id: "*" // Match any network id
    }
  }
};

Depois de fazer isso podemos nos conectar ao node com

$ truffle console --network rsk

Se tudo deu certo, você deve conseguir usar o console do Truffle, mostrando a linha de comando como

truffle(rsk)>

Agora devemos ser capazes de observar o estado de sincronização do nosso node, o último número de bloco que temos e o número de pares aos quais estamos conectados. Para fazer isso, você deve usar a biblioteca da biblioteca web3 da mesma forma que no Ethereum.

Apenas um pequeno aviso: o web3 mais recente dentro do Truffle é um pouco antigo, 0.20.6, então esteja avisado que alguns comandos têm sintaxe diferente nas versões mais recentes. Procure os comandos disponíveis usando o recurso de preenchimento automático (tecla TAB duas vezes) após web3.

Para as funções que mencionamos, os comandos em sua respectiva ordem são

truffle(rsk)> web3.eth.syncing
truffle(rsk)> web3.eth.blockNumber
truffle(rsk)> web3.net.peerCount

Seleção de Rede

Até agora o procedimento era independente de qual rede RSK estávamos usando (Mainnet, Testnet ou Regtest). Para configurá-los, falamos sobre o que precisamos alterar de seu arquivo de configuração que está localizado em / etc / rsk /. Lá encontramos três arquivos de configuração e um link simbólico para um deles. O link simbólico, node.conf, é aquele que o serviço RSK lê. Então, se quisermos mudar sua rede, paramos o node, vamos para a pasta, mudamos o link para o arquivo de configuração correto e recomeçamos o serviço assim

$ sudo service rsk stop
$ cd /etc/rsk
$ sudo rm -f node.conf
$ sudo ln -s ABCDEFG.conf node.conf
$ sudo service rsk start

Onde ABCDEFG pode ser “testnet”, “mainnet” ou “regtest”. O procedimento é o mesmo em todos os três casos.

Se você instalou o node conforme expliquei já deve ter a maioria dos parâmetros configurados. Se abrirmos um desses arquivos, veremos de onde o node obtém pares, a porta ativa (5050 para Mainnet e 50505 para Testnet), nossa chave privada de node, alguns parâmetros para a configuração do par, o ID da rede (775 para Mainnet, 779 para o Testnet e 34567 para o Regtest), onde o banco de dados específico é salvo, se quisermos começar do zero e redefinir o banco de dados (isso é útil quando nosso banco de dados está corrompido. Nesse caso, troque o bool reset para “true” uma vez e, em seguida, inicie o node), a porta onde podemos conectar a partir de programas como o Truffle e, por último, a configuração da wallet.

Configurações da wallet e da conta

No arquivo, por padrão, temos

wallet {
    accounts = []
}

Com esta configuração não podemos implantar contratos nem enviar transações, nem criar contas e assim por diante. Para habilitá-los, precisamos adicionar a seguinte linha

wallet {
    accounts = []
    enabled = true
}

Então podemos fazer uma nova conta no Truffle, fazendo

2
truffle(rsk)> web3.personal.newAccount(‘somePassword’)
truffle(rsk)> web3.personal.unlockAccount(web3.eth.accounts[0],'somePassword')

Além disso, se já tivermos uma conta na rede RSK, podemos simplesmente adicioná-la ao arquivo de configuração como

wallet {
    accounts = [
        {
            "privateKey" = "PRIVATEKEY"
            "address" = "0xADDRESS"
        }
    ]
    enabled = true
}

Onde “PRIVATEKEY” e “0xADDRESS” são a chave privada e o endereço da sua conta com fundos na rede a ser usada.

Tendo isso alterado, podemos adicionar esse endereço no arquivo de configuração truffle.js para que nossas transações e implantações sejam originadas desse endereço por padrão e também, se você estiver usando o Testnet, defina o limite de gas para um número alto e o gasPrice para zero. Esses 2 parâmetros são adicionados porque se não definirmos o gas, nossa transação nunca poderia ser explorada pela rede, e para o segundo, o Testnet não nos cobra dinheiro real para trabalhar, então, mesmo com um preço de valor nulo, os mineiros podem adicionar nossas transações.

Agora nosso truffle.js para Testnet deve ser semelhante a

module.exports = {
	networks : {
		rsk: {
			gas : 2500000,
			gasPrice : 0,
			from : "0xADDRESS",
			host : "localhost",
			port : 4444,
			network_id : "*" // Match any network id
		}
	}
};

Configurado tudo isso, e depois de esperarmos algum tempo para sincronizar nosso node no TestNet ou MainNet, entre 1 e 3 dias, podemos começar a implantar contratos e fazer transações. Parabéns!

Utilitários Extras

Enquanto esperamos que isso aconteça, quero acrescentar que a RSK produziu algumas ferramentas para nosso node que estão listadas em seu Github. Entre eles está um console, um explorador de blocos local que funciona em um navegador da web e um módulo de teste. Para usá-los, clone seu repositório como

$ mkdir Utils && cd Utils
$ git clone https://github.com/rsksmart/utilities.git

Em seguida, entramos na pasta útil, por exemplo console, e proceda como

$ cd utilities/console/
$ npm install

Depois disso, podemos nos conectar ao nosso node como

$ node console.js -server localhost:4444

Em que podemos chamar funções como de costume

RSK > web3.eth.blockNumber

Eu não o recomendo pois ele tem uma versão mais antiga do web3 que o Truffle (que já é velha!).

Para o explorer, você deve fazer o mesmo procedimento e adicionar uma etapa extra: alterar a linha host: port em config.json para localhost: 4444 após executar a instalação do npm. Então, para carregar o explorer:

$ npm start

Que podemos abrir no navegador da web em http: // localhost: 3000.

O Caminho Java

Existem também outros métodos para iniciá-lo, como executar o pacote .jar com java e introduzir o arquivo de configuração como entrada como

$ java -Drsk.conf.file=ABCDEFG.conf -cp rskj-core-0.4.1-BAMBOO-all.jar co.rsk.Star

De onde, a chave pública e privada, e o ID do node, podem ser obtidos

$ java -cp rskj-core-0.4.1-BAMBOO-all.jar co.rsk.GenNodeKeyId

No entanto, com este método, você deve definir todos os parâmetros do arquivo de modelo, o que pode ser confuso para um iniciante.

Node Dedicado

Além disso, se alguém usa um computador apenas para executar o node, pode ser melhor usá-lo como um servidor e conectar-se a ele via ssh. Antes, você precisa instalar nesse computador o servidor SSH com

$ sudo apt-get install openssh-server openssh-client

Para conectar-se a partir de outro computador com

$ ssh user@host

Obtendo Fundos

Para obter fundos em sua conta, depende de qual rede você está trabalhando. Para a Mainnet, você deve trocar seu BTC por um 2-Way Peg  para obter SBTC no lado RSK e poder pagar pelo gás e taxas do minerador / RSK Labs. Para fazer isso, primeiro você precisa colocar sua conta BTC na lista de permissões acessando este formulário.

Então, assim que estiver na lista de permissões, você precisa ligar para o endereço do Contrato da Federação (0x0000000000000000000000000000000001000006) e pedir o endereço do depósito. Isso pode ser feito apenas como

truffle(rsk)> web3.sha3("getFederationAddress()").slice(0,10); // = 0x6923fa85
truffle(rsk)> web3.eth.call({data: "6923fa85", to: "0x0000000000000000000000000000000001000006"});

O resultado é um número hexadecimal longo que tem 3 partes. Os primeiros 32 bytes representam o campo de comprimento, os segundos 32 bytes representam o comprimento da string e o resto é o endereço codificado na representação ASCII seguido por zeros. Portanto, se convertermos esta última parte da mensagem, obteremos nosso endereço BTC (ou tBTC) da Federação para depositar nossos fundos.

truffle(rsk)> web3.toAscii(‘LAST_PART’)

Depois de enviar a transação, você deve esperar por +100 confirmações naquele bloco mais um período de 5 minutos para ver seus fundos na rede RSK. Sua conta do outro lado é derivada de sua conta BTC original por meio de sua chave privada. Para obter o controle de sua nova conta, você pode entrar no site dos utils e obter a chave privada de sua conta derivada.

Neste caso, como eu tinha apenas o Testnet sincronizado, fiz isso apenas nessa rede em particular. Além disso, minhas contas BTC e tBTC ainda não foram incluídas na lista de permissões, então não posso dizer como o sistema funciona (espero que em breve!). Só uma última coisa: o endereço da Mainnet é diferente daquele da Testnet. Você deve fazer o mesmo procedimento para a rede selecionada. Esteja avisado!

Embora você não precise de fundos em sua conta Testnet (o gas é grátis!: 😊, é recomendado obter alguns apenas para testar se você tiver um problema com sua conta, node ou qualquer outra coisa enquanto libera um contrato. Às vezes, o sistema está inativo e você não pode implantar contratos; nesse caso, se você não sabe o que está acontecendo e está arrancando os cabelos, você pode testar se a rede está ok apenas enviando uma transação para outra conta sua e ver o que acontece no bloco. Se você não quiser fazer o 2-Way Peg ou esperar para entrar na lista de permissões, você pode simplesmente pedir fundos de teste do faucet.

Conectando Metamask ao nosso node RSK

Se você quiser usar Metamask para enviar transações, você deve configurar duas coisas: a primeira está em node.conf, em que temos que alterar o parâmetro de cors = “* .rsk.co” para cors = “* “e reinicie nosso node. O segundo é definir a rede RPC local em Metamask como http: // localhost: 4444, ou como você configurou no arquivo node.conf.

Depois disso, você deve importar a chave privada da sua conta para o Metamask e então deverá aparecer o saldo da sua conta. A unidade diz ETH, mas é realmente SBTC. Não se preocupe.

Conclusões

Nesta primeira parte do passo a passo, mostrei uma introdução para a criação do ambiente de desenvolvimento de Smart Contracts RSK. Vimos como

• construir um node RSK em redes diferentes,

• selecionar uma rede para sincronizar,

• configurar o Truffle para interagir com nosso node,

• adicionar uma conta para fazer transações na rede,

• interagir com o sistema 2-Way Peg e transferir nossos fundos.

No próximo capítulo, estaremos criando e implantando contratos na rede e interagindo com eles na Mainnet. Você pode checar isso aqui.