Como criar sua própria carteira de criptomoedas com JS (Solana) – Parte 2

Recentemente eu escrevi a primeira parte de um tutorial sobre como criar seu próprio software de carteira de criptomoedas para a rede Solana utilizando Node.js. Se você ainda não implementou a primeira etapa, deve fazê-lo antes desse, seguindo estas instruções.

Agora se já implementou a primeira funcionalidade e estrutura geral e está ansioso como eu para terminar o projeto, só seguir abaixo!

#1 – Recuperando sua Wallet

Recuperar uma wallet, tenha ela sido criada em nosso software ou qualquer outro que siga o padrão da Solana é tão simples quanto criar uma nova. Começaremos pelo WalletService.js novamente, onde criaremos e exportaremos uma nova função.


//WalletService.js
function recoverWallet(secretKey) {
    const binarySecretKey = base58_to_binary(secretKey);
    myWallet = Keypair.fromSecretKey(binarySecretKey);
    myWallet.publicKeyDecoded = myWallet.publicKey.toBase58();
    myWallet.secretKeyDecoded = secretKey;
    return myWallet;
}

module.exports = {
    createWallet,
    recoverWallet
}

//WalletService.js

function recoverWallet(secretKey) {

const binarySecretKey = base58_to_binary(secretKey);

myWallet = Keypair.fromSecretKey(binarySecretKey);

myWallet.publicKeyDecoded = myWallet.publicKey.toBase58();

myWallet.secretKeyDecoded = secretKey;

return myWallet;

}

module.exports = {

createWallet,

recoverWallet

}

Aqui eu recebo uma string (jeito mais comum de guardar a secret key) e converto para o formato binário original da secret key usando a função base58_to_binary da lib base58-j2 que importamos na parte 1 deste tutorial. O resultado eu salvo na variável de módulo que guarda a carteira e retorno ela para que as informações sejam de acesso de quem chamou (com as opções decodificadas junto).

Agora voltamos ao index.js para criar a função recoverWallet() que será chamada na opção 2 do menu.


//index.js
function recoverWallet() {
    console.clear();
    rl.question(`What is your secret key? `, (secretKey) => {
        const myWallet = WalletService.recoverWallet(secretKey);
        myAddress = myWallet.publicKeyDecoded;

        console.log(`Your recovered wallet:`);
        console.log(myAddress);

        preMenu();
    })
}

//index.js

function recoverWallet() {

console.clear();

rl.question(`What is your secret key? `, (secretKey) => {

const myWallet = WalletService.recoverWallet(secretKey);

myAddress = myWallet.publicKeyDecoded;

console.log(`Your recovered wallet:`);

console.log(myAddress);

preMenu();

})

}

Console limpo, perguntamos pela secret key e passamos essa informação para o WalletService fazer a recuperação. Guardamos o endereço da carteira na variável global para uso posterior e apresentamos para o usuário antes de limpar tudo e voltar ao menu.

Para testar você pode pegar a secret key de uma carteira gerada pelo nosso software, ou então, se possuir uma carteira criada em outro software compatível com Solana, como a Brave Wallet, experimente usar a sua secret key e verá que a recuperação funciona.

Agora com a carteira criada ou recuperada, o próximo passo é aprendermos a consultar seu saldo.

#2 – Saldo da sua Carteira

Aqui vamos consultar o saldo da carteira “autenticada” (tendo sido ela criada ou recuperada) na moeda nativa da rede que estamos conectados. Para isso, voltamos ao WalletService.js para implementar a respectiva função. Não esqueça de exportar ela.


async function getBalance() {
    const balance = await connection.getBalance(new PublicKey(myWallet.publicKey));
    return {
        lamports: balance,
        sol: balance / LAMPORTS_PER_SOL
    }
}

async function getBalance() {

const balance = await connection.getBalance(new PublicKey(myWallet.publicKey));

return {

lamports: balance,

sol: balance / LAMPORTS_PER_SOL

}

A consulta de saldo de uma carteira na blockchain é bem direta e basta termos em mãos o endereço da carteira a ser consultada, sendo que pegaremos o endereço do usuário “logado”. O resultado é o saldo em “lamports”, a menor fração da criptomoeda da Solana (SOL). Este valor nessa escala é importante pois todas as funções nativas da blockchain esperam lamports e nunca SOLs. No entanto, para o usuário não é nada prático lidar com estes números gigantescos (1 SOL = 1B lamports), então além de retornar o balance em lamports, eu vou retornar também ele formatado para a escala de SOL, ambos dentro de um objeto.

Agora no index.js, vamos criar a getBalance() que será disparada quando a opção 3 do menu for escolhida.


//index.js
async function getBalance() {
    console.clear();

    if (!myAddress) {
        console.log(`You don't have a wallet yet.`);
        return preMenu();
    }

    const { lamports, sol } = await WalletService.getBalance();
    console.log(`SOL ${sol}`);

    preMenu();
}

//index.js

async function getBalance() {

console.clear();

if (!myAddress) {

console.log(`You don't have a wallet yet.`);

return preMenu();

}

const { lamports, sol } = await WalletService.getBalance();

console.log(`SOL ${sol}`);

preMenu();

}

Nesta função se não tivermos ainda um endereço ela vai gerar um erro e voltar ao menu. Caso tenhamos um endereço já configurado (seja pela criação ou recuperação de uma carteira previamente), nós obtemos o saldo chamando a respectiva função do WalletService e imprimimos essa informação no terminal, na escala de SOL (maior escala da moeda).

Para que você possa testar essa funcionalidade você deve ou recuperar uma carteira sua que já tenha saldo ou então adicionar saldo em uma carteira recém criada usando algum faucet da sua rede. Na rede devnet (que estou usando) eu costumo pegar fundos nesse faucet aqui. Ele exige autenticação via GitHub e às vezes dá erro, mas é só aguardar alguns minutos (ou horas) e tentar de novo que funciona (eu costumo pegar 0.5 SOL dessa forma).

Agora que já temos como ver o saldo também, que tal aprendermos como enviar ele para outra carteira?

#3 – Transferindo fundos da sua carteira

Essa é de longe a funcionalidade mais complexa de ser desenvolvida, mas a essa altura você já deve estar entendendo bem o modus operandi do nosso software de carteira, então não terá grandes problemas. Primeiro passo: WalletService.js, vamos criar a função transfer nele, que vai esperar o “to” (destinatário dos fundos) e o “amountInSol” (quantidade de fundos a serem transferidos, na escala de SOL).


async function transfer(to, amountInSol) {
    const transaction = new Transaction();

    const sendSolInstruction = SystemProgram.transfer({
        fromPubkey: new PublicKey(myWallet.publicKey),
        toPubkey: new PublicKey(to),
        lamports: LAMPORTS_PER_SOL * amountInSol,
    });

    transaction.add(sendSolInstruction);

    const txHash = await sendAndConfirmTransaction(connection, transaction, [myWallet]);
    return txHash;
}

module.exports = {
    createWallet,
    recoverWallet,
    getBalance,
    transfer
}

async function transfer(to, amountInSol) {

const transaction = new Transaction();

const sendSolInstruction = SystemProgram.transfer({

fromPubkey: new PublicKey(myWallet.publicKey),

toPubkey: new PublicKey(to),

lamports: LAMPORTS_PER_SOL * amountInSol,

});

transaction.add(sendSolInstruction);

const txHash = await sendAndConfirmTransaction(connection, transaction, [myWallet]);

return txHash;

}

module.exports = {

createWallet,

recoverWallet,

getBalance,

transfer

}

Aqui começamos criando um objeto de transação, na qual colocaremos todas as instruções que queremos que sejam executadas de maneira atômica. No nosso caso é apenas uma instrução, de transferência, que construímos a partir do programa System. Os programas são os equivalentes aos smart contracts na rede Solana, sendo que o System é o programa padrão, que faz coisas fundamentais como transferências de fundos.

A função transfer do SystemProgram exige a passagem de três parâmetros: a public key de quem está enviando, a public key de quem vai receber os fundos e a quantidade de lamports que vamos enviar. Com essa instrução preparada, adicionamos ela na transação com a função add.

Com a transação pronta, é hora de enviar ela para a blockchain usando a função sendAndConfirmTransaction que espera um objeto de conexão, um objeto de transação e um array de assinantes desta transação, geralmente com apenas um objeto de carteira. Cabe ao primeiro assinante da transação o pagamento das taxas da mesma.

E agora, como usar esta função no index.js? É mais fácil do que foi para programar no WalletService pois aqui temos apenas uma função transfer que será disparada quando a opção 4 for escolhida no menu.


function sendTx() {
    console.clear();

    if (!myAddress) {
        console.log(`You don't have a wallet yet.`);
        return preMenu();
    }

    console.log(`Your wallet is ${myAddress}`);
    rl.question(`To Wallet: `, (toWallet) => {

        rl.question(`Amount (in SOL): `, async (amountInSol) => {
            if (!amountInSol) {
                console.log(`Invalid amount.`);
                return preMenu();
            }

            const txHash = await WalletService.transfer(toWallet, amountInSol);
            console.log("Transaction successful: ");
            console.log(txHash);

            return preMenu();
        })
    })

    preMenu();
}

function sendTx() {

console.clear();

if (!myAddress) {

console.log(`You don't have a wallet yet.`);

return preMenu();

}

console.log(`Your wallet is ${myAddress}`);

rl.question(`To Wallet: `, (toWallet) => {

rl.question(`Amount (in SOL): `, async (amountInSol) => {

if (!amountInSol) {

console.log(`Invalid amount.`);

return preMenu();

}

const txHash = await WalletService.transfer(toWallet, amountInSol);

console.log("Transaction successful: ");

console.log(txHash);

return preMenu();

})

preMenu();

}

Começamos com a limpeza e verificações básicas, para em seguida pedir a carteira do destinatário dos fundos. Com o destinatário em mãos, pedimos a quantia a ser transferida, na escala SOL (maior) e testamos se o usuário digitou algo antes de avançar. Caso a quantia esteja válida, construímos a transação com a função do bloco anterior. Caso dê tudo certo, receberemos um hash da transação (txHash), que você pode usar para consultar no explorador de blocos da Solana (exemplo de transação aqui).

Faça esse teste: crie duas carteiras (ou recupere-as caso já possua) e transfira fundos de uma para a outra, anotando o hash da transação, para verificar pelo block explorer. E com isso finalizamos o desenvolvimento de nosso primeiro software de carteira. Espero que este desenvolvimento tenha lhe ajudado a entender melhor como as carteiras funcionam e quiçá sirva como base para você desenvolver um software real de carteira.

Se quer aprender a criar carteira para rede Bitcoin, use este tutorial. Agora se quiser criar carteira para rede Ethereum (e compatíveis), use este.

Até a próxima!