Biblioteca JavaScript Web3.js¶

Introdução¶

Web3.js é um conjunto de bibliotecas que permite interagir com nós Ethereum via HTTP, IPC ou WebSocket em JavaScript. As redes EVM da Tanssi expõem uma API compatível com Ethereum/JSON-RPC, então você pode usar Web3.js para falar com um nó EVM da Tanssi como se estivesse no Ethereum. Consulte a documentação para mais detalhes.

Neste guia você configura o Web3.js para sua rede EVM da Tanssi e usa a biblioteca para enviar uma transação e implantar um contrato em uma rede de demonstração executando no Dancelight. Para sua rede, basta trocar o endpoint.

Note

Os exemplos deste guia partem de um ambiente MacOS ou Ubuntu 20.04. Se estiver usando Windows, adapte os comandos conforme necessário.

Verifique também se você tem o Node.js e um gerenciador de pacotes (como npm ou yarn) instalados. Para saber como instalar o Node.js, consulte a documentação oficial.

Além disso, certifique-se de ter inicializado um arquivo package.json para módulos ES6. Você pode criar um package.json padrão com npm executando npm init --yes.

Verificando pré-requisitos¶

Você precisará:

De uma conta com fundos na rede EVM Tanssi usada nos testes

Instalando Web3.js¶

Instale Web3.js e o compilador Solidity:

npmyarn

npm install web3 solc@0.8.0

yarn add web3 solc@0.8.0

Configurando o provedor Web3¶

Os scripts a seguir usam um provedor Web3 para se conectar à rede.

Importe Web3.
Crie o provedor definindo a URL RPC (altere para sua rede quando necessário).

// 1. Importe o Web3
const Web3 = require('web3');

// 2. Crie o provider do Web3 e insira sua URL RPC
const web3 = new Web3(
  'https://services.tanssi-testnet.network/dancelight-2001/'
);

Guarde este trecho; ele será reutilizado.

Enviar uma transação¶

Dois scripts: um para consultar saldos e outro para enviar a transação.

Script de saldos¶

Crie o arquivo:

touch balances.js

Passos:

Inclua o provedor Web3.
Defina addressFrom e addressTo.
Crie balances().
Use web3.eth.getBalance + web3.utils.fromWei para exibir em TANGO.
Chame balances().

// 1. Adicione aqui a lógica do provider do Web3:
// {...}

// 2. Crie as variáveis de endereço
const addressFrom = 'INSERIR_ENDERECO_DE';
const addressTo = 'INSERIR_ENDERECO_PARA';

// 3. Crie a função de saldos
const balances = async () => {
  // 4. Busque as informações de saldo
  const balanceFrom = web3.utils.fromWei(
    await web3.eth.getBalance(addressFrom),
    'ether'
  );
  const balanceTo = web3.utils.fromWei(
    await web3.eth.getBalance(addressTo),
    'ether'
  );

  console.log(`O saldo de ${addressFrom} é: ${balanceFrom} TANGO`);
  console.log(`O saldo de ${addressTo} é: ${balanceTo} TANGO`);
};

// 5. Chamar a função de saldos
balances();

Visualizar o script completo

// Import Web3
const Web3 = require('web3');

// Add the Web3 provider logic here:
const providerRPC = {
  evmNetwork: 'https://services.tanssi-testnet.network/dancelight-2001', // Insert your RPC URL here
};
const web3 = new Web3(providerRPC.evmNetwork);

// Create address variables
const addressFrom = 'INSERT_ADDRESS_FROM';
const addressTo = 'INSERT_ADDRESS_TO';

// Create balances function
const balances = async () => {
  // Fetch balance info
  const balanceFrom = web3.utils.fromWei(
    await web3.eth.getBalance(addressFrom),
    'ether'
  );
  const balanceTo = web3.utils.fromWei(
    await web3.eth.getBalance(addressTo),
    'ether'
  );

  console.log(`The balance of ${addressFrom} is: ${balanceFrom} TANGO`);
  console.log(`The balance of ${addressTo} is: ${balanceTo} TANGO`);
};

// Call balances function
balances();

Execute:

node balances.js

Script de envio de transação¶

Crie o arquivo:

touch transaction.js

Passos:

Inclua o provedor Web3.
Defina addressFrom (com privateKey) e addressTo. Não armazene chaves reais em arquivos JS.
Crie send() para assinar e enviar.
Assine com web3.eth.accounts.signTransaction (gas, to, value).
Envie com web3.eth.sendSignedTransaction e aguarde recibo.
Chame send().

// 1. Adicione aqui a lógica do provider do Web3:
// {...}

// 2. Crie as variáveis da conta
const accountFrom = {
  privateKey: 'INSERIR_SUA_CHAVE_PRIVADA',
  address: 'INSERIR_ENDERECO_PUBLICO_DA_CHAVE',
};
const addressTo = 'INSERIR_ENDERECO_PARA'; // Altere para o endereço desejado

// 3. Crie a função de envio
const send = async () => {
  console.log(
    `Tentando enviar a transação de ${accountFrom.address} para ${addressTo}`
  );

  // 4. Assine a tx com a chave privada
  const createTransaction = await web3.eth.accounts.signTransaction(
    {
      gas: 21000,
      to: addressTo,
      value: web3.utils.toWei('1', 'ether'),
    },
    accountFrom.privateKey
  );

  // 5. Envie a tx e aguarde o recibo
  const createReceipt = await web3.eth.sendSignedTransaction(
    createTransaction.rawTransaction
  );
  console.log(
    `Transação bem-sucedida com hash: ${createReceipt.transactionHash}`
  );
};

// 6. Chame a função de envio
send();

Visualizar o script completo

// Import Web3
const Web3 = require('web3');

// Add the Web3 provider logic here:
const providerRPC = {
  evmNetwork: 'https://services.tanssi-testnet.network/dancelight-2001', // Insert your RPC URL here
};
const web3 = new Web3(providerRPC.evmNetwork);

// Create account variables
const accountFrom = {
  privateKey: 'INSERT_YOUR_PRIVATE_KEY',
  address: 'INSERT_PUBLIC_ADDRESS_OF_PK',
};
const addressTo = 'INSERT_ADDRESS_TO';

// Create send function
const send = async () => {
  console.log(
    `Attempting to send transaction from ${accountFrom.address} to ${addressTo}`
  );

  // Sign tx with PK
  const createTransaction = await web3.eth.accounts.signTransaction(
    {
      gas: 21000,
      to: addressTo,
      value: web3.utils.toWei('1', 'ether'),
    },
    accountFrom.privateKey
  );

  // Send tx and wait for receipt
  const createReceipt = await web3.eth.sendSignedTransaction(
    createTransaction.rawTransaction
  );
  console.log(
    `Transaction successful with hash: ${createReceipt.transactionHash}`
  );
};

// Call send function
send();

Execute:

node transaction.js

Implantar um contrato¶

O contrato que você irá compilar e implantar nas próximas seções é um simples incrementador, chamado Incrementer.sol. Comece criando o arquivo do contrato:

touch Incrementer.sol

Depois, adicione o código Solidity ao arquivo:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

contract Incrementer {
    uint256 public number;

    constructor(uint256 _initialNumber) {
        number = _initialNumber;
    }

    function increment(uint256 _value) public {
        number = number + _value;
    }

    function reset() public {
        number = 0;
    }
}

A função constructor, executada quando o contrato é implantado, define o valor inicial da variável number armazenada on-chain (padrão é 0). A função increment soma o _value informado ao número atual, mas exige uma transação, pois modifica o dado armazenado. Por fim, a função reset zera o valor armazenado.

Note

Este contrato é apenas um exemplo simples para fins ilustrativos.

Script de compilação¶

Nesta seção, você criará um script que usa o compilador Solidity para gerar o bytecode e a interface (ABI) do contrato Incrementer.sol. Para começar, crie o arquivo compile.js executando:

touch compile.js

Em seguida, escreva o script e conclua estas etapas:

Importe os pacotes fs e solc
Use fs.readFileSync para ler e salvar o conteúdo de Incrementer.sol em source
Monte o objeto input para o compilador Solidity especificando language, sources e settings
Compile o contrato usando solc.compile com o objeto input
Extraia o contrato compilado e exporte-o para ser usado no script de implantação

// 1. Import packages
import fs from 'fs';
import solc from 'solc';

// 2. Get path and load contract
const source = fs.readFileSync('Incrementer.sol', 'utf8');

// 3. Create input object
const input = {
  language: 'Solidity',
  sources: {
    'Incrementer.sol': {
      content: source,
    },
  },
  settings: {
    outputSelection: {
      '*': {
        '*': ['*'],
      },
    },
  },
};
// 4. Compile the contract
const tempFile = JSON.parse(solc.compile(JSON.stringify(input)));
const contractFile = tempFile.contracts['Incrementer.sol']['Incrementer'];

// 5. Export contract data
export default contractFile;

Script de deploy¶

Compile Incrementer.sol e crie deploy.js:

touch deploy.js

Passos:

Importe o contrato de compile.js.
Inclua o provedor Web3.
Defina addressFrom/privateKey. Não salve chaves reais em JS.
Guarde bytecode e abi.
Crie deploy().
Instancie o contrato: new web3.eth.Contract(abi).
Construa o deploy com deploy({ data: bytecode, arguments: [5] }).
Assine com web3.eth.accounts.signTransaction (data, gas).
Envie com web3.eth.sendSignedTransaction e aguarde recibo.
Chame deploy().

// 1. Importe o arquivo do contrato
const contractFile = require('./compile');

// 2. Adicione aqui a lógica do provider do Web3:
// {...}

// 3. Crie as variáveis de endereço
const accountFrom = {
  privateKey: 'INSERIR_CHAVE_PRIVADA',
  address: 'INSERIR_ENDERECO_PUBLICO_DA_CHAVE_PRIVADA',
};

// 4. Obtenha o bytecode e o ABI
const bytecode = contractFile.evm.bytecode.object;
const abi = contractFile.abi;

// 5. Crie a função de deploy
const deploy = async () => {
  console.log(`Tentando implantar da conta ${accountFrom.address}`);

  // 6. Crie a instância do contrato
  const incrementer = new web3.eth.Contract(abi);

  // 7. Crie a tx do construtor
  const incrementerTx = incrementer.deploy({
    data: bytecode,
    arguments: [5],
  });

  // 8. Assine a transação e envie
  const createTransaction = await web3.eth.accounts.signTransaction(
    {
      data: incrementerTx.encodeABI(),
      gas: await incrementerTx.estimateGas(),
    },
    accountFrom.privateKey
  );

  // 9. Envie a tx e aguarde o recibo
  const createReceipt = await web3.eth.sendSignedTransaction(
    createTransaction.rawTransaction
  );
  console.log(`Contrato implantado no endereço: ${createReceipt.contractAddress}`);
};

// 10. Chamar a função de deploy
deploy();

Visualizar o script completo

// Import web3 and the contract file
const Web3 = require('web3');
const contractFile = require('./compile');

// Add the Web3 provider logic here
const providerRPC = {
  evmNetwork: 'https://services.tanssi-testnet.network/dancelight-2001', // Insert your RPC URL here
};
const web3 = new Web3(providerRPC.evmNetwork);

// Create address variables
const accountFrom = {
  privateKey: 'INSERT_PRIVATE_KEY',
  address: 'INSERT_PUBLIC_ADDRESS_OF_PK',
};

// Get the bytecode and API
const bytecode = contractFile.evm.bytecode.object;
const abi = contractFile.abi;

// Create deploy function
const deploy = async () => {
  console.log(`Attempting to deploy from account ${accountFrom.address}`);

  // Create contract instance
  const incrementer = new web3.eth.Contract(abi);

  // Create constructor tx with initial value of 5
  const incrementerTx = incrementer.deploy({
    data: bytecode,
    arguments: [5],
  });

  // Sign transacation and send
  const createTransaction = await web3.eth.accounts.signTransaction(
    {
      data: incrementerTx.encodeABI(),
      gas: await incrementerTx.estimateGas(),
    },
    accountFrom.privateKey
  );

  // Send tx and wait for receipt
  const createReceipt = await web3.eth.sendSignedTransaction(
    createTransaction.rawTransaction
  );
  console.log(`Contract deployed at address: ${createReceipt.contractAddress}`);
};

// Call deploy function
deploy();

Execute:

node deploy.js

Ler dados do contrato (calls)¶

Calls não mudam estado; não precisam de transação. Crie get.js:

touch get.js

Passos:

Importe abi de compile.js.
Inclua o provedor Web3.
Defina contractAddress.
Instancie: new web3.eth.Contract(abi, contractAddress).
Crie get().
Chame incrementer.methods.number().call() e exiba.
Chame get().

// 1. Importe o ABI do contrato
const { abi } = require('./compile');

// 2. Adicione aqui a lógica do provider do Web3:
// {...}

// 3. Endereço do contrato
const contractAddress = 'INSERIR_ENDERECO_DO_CONTRATO';

// 4. Crie a instância do contrato
const incrementer = new web3.eth.Contract(abi, contractAddress);

// 5. Crie a função get
const get = async () => {
  console.log(`Fazendo uma chamada para o contrato no endereço: ${contractAddress}`);

  // 6. Chamar o contrato
  const data = await incrementer.methods.number().call();

  console.log(`O número atual armazenado é: ${data}`);
};

// 7. Chamar a função get
get();

Visualizar o script completo

// Import web3 and the contract file
const Web3 = require('web3');
const { abi } = require('./compile');

// Add the Web3 provider logic here:
const providerRPC = {
  evmNetwork: 'https://services.tanssi-testnet.network/dancelight-2001', // Insert your RPC URL here
};
const web3 = new Web3(providerRPC.evmNetwork);

// Create address variables
const contractAddress = 'INSERT_CONTRACT_ADDRESS';

// Create contract instance
const incrementer = new web3.eth.Contract(abi, contractAddress);

// Create get function
const get = async () => {
  console.log(`Making a call to contract at address: ${contractAddress}`);

  // Call contract
  const data = await incrementer.methods.number().call();

  console.log(`The current number stored is: ${data}`);
};

// Call get function
get();

Execute:

node get.js

Interagir com o contrato (sends)¶

Sends mudam estado, exigem transação. Crie increment.js e reset.js:

touch increment.js reset.js

increment.js:

Importe abi.
Inclua o provedor.
Defina privateKey, contractAddress, _value (não salve chaves reais em JS).
Instancie o contrato.
Construa incrementTx = incrementer.methods.increment(_value).
Crie increment().
Assine com signTransaction (to, data, gas) e envie com sendSignedTransaction.
Aguarde recibo; exiba o hash.
Chame increment().

Visualizar o script completo

// Import Web3 and the contract abi
const Web3 = require('web3');
const { abi } = require('./compile');

// Add the Web3 provider logic here:
const providerRPC = {
  evmNetwork: 'https://services.tanssi-testnet.network/dancelight-2001', // Insert your RPC URL here
};
const web3 = new Web3(providerRPC.evmNetwork);

// Create variables
const accountFrom = {
  privateKey: 'INSERT_YOUR_PRIVATE_KEY',
};
const contractAddress = 'INSERT_CONTRACT_ADDRESS';
const _value = 3;

// Create contract instance
const incrementer = new web3.eth.Contract(abi, contractAddress);

// Build increment tx
const incrementTx = incrementer.methods.increment(_value);

// Create increment function
const increment = async () => {
  console.log(
    `Calling the increment by ${_value} function in contract at address: ${contractAddress}`
  );

  // Sign Tx with PK
  const createTransaction = await web3.eth.accounts.signTransaction(
    {
      to: contractAddress,
      data: incrementTx.encodeABI(),
      gas: await incrementTx.estimateGas(),
    },
    accountFrom.privateKey
  );

  // Send Tx and Wait for Receipt
  const createReceipt = await web3.eth.sendSignedTransaction(
    createTransaction.rawTransaction
  );
  console.log(`Tx successful with hash: ${createReceipt.transactionHash}`);
};

// Call increment function
increment();

reset.js segue o mesmo padrão, mas chamando reset() sem argumentos:

Visualizar reset.js

// Import Web3 and the contract abi
const Web3 = require('web3');
const { abi } = require('./compile');

// Add the Web3 provider logic here:
const providerRPC = {
  evmNetwork: 'https://services.tanssi-testnet.network/dancelight-2001', // Insert your RPC URL here
};
const web3 = new Web3(providerRPC.evmNetwork);

// Create variables
const accountFrom = {
  privateKey: 'INSERT_YOUR_PRIVATE_KEY',
};
const contractAddress = 'INSERT_CONTRACT_ADDRESS';

// Create Contract Instance
const incrementer = new web3.eth.Contract(abi, contractAddress);

// Build reset tx
const resetTx = incrementer.methods.reset();

// Create reset function
const reset = async () => {
  console.log(
    `Calling the reset function in contract at address: ${contractAddress}`
  );

  // Sign tx with PK
  const createTransaction = await web3.eth.accounts.signTransaction(
    {
      to: contractAddress,
      data: resetTx.encodeABI(),
      gas: await resetTx.estimateGas(),
    },
    accountFrom.privateKey
  );

  // Send tx and wait for receipt
  const createReceipt = await web3.eth.sendSignedTransaction(
    createTransaction.rawTransaction
  );
  console.log(`Tx successful with hash: ${createReceipt.transactionHash}`);
};

// Call reset function
reset();

Execute:

node increment.js
node reset.js

Use get.js junto para confirmar as mudanças.

As informações apresentadas aqui foram fornecidas por terceiros e estão disponíveis apenas para fins informativos gerais. A Tanssi não endossa nenhum projeto listado e descrito no Site de Documentação da Tanssi (https://docs.tanssi.network/). A Tanssi Foundation não garante a precisão, integridade ou utilidade dessas informações. Qualquer confiança depositada nelas é de sua exclusiva responsabilidade. A Tanssi Foundation se exime de toda responsabilidade decorrente de qualquer confiança que você ou qualquer outra pessoa possa ter em qualquer parte deste conteúdo. Todas as declarações e/ou opiniões expressas nesses materiais são de responsabilidade exclusiva da pessoa ou entidade que as fornece e não representam necessariamente a opinião da Tanssi Foundation. As informações aqui não devem ser interpretadas como aconselhamento profissional ou financeiro de qualquer tipo. Sempre busque orientação de um profissional devidamente qualificado em relação a qualquer assunto ou circunstância em particular. As informações aqui podem conter links ou integração com outros sites operados ou conteúdo fornecido por terceiros, e tais sites podem apontar para este site. A Tanssi Foundation não tem controle sobre esses sites ou seu conteúdo e não terá responsabilidade decorrente ou relacionada a eles. A existência de qualquer link não constitui endosso desses sites, de seu conteúdo ou de seus operadores. Esses links são fornecidos apenas para sua conveniência, e você isenta e exonera a Tanssi Foundation de qualquer responsabilidade decorrente do uso dessas informações ou das informações fornecidas por qualquer site ou serviço de terceiros.

Última atualização: 9 de dezembro de 2025
| Criada: 9 de dezembro de 2025