Biblioteca JavaScript Web3.js¶

Introdução¶

Web3.js é um conjunto de bibliotecas que permite que desenvolvedores interajam com nós Ethereum usando os protocolos HTTP, IPC ou WebSocket em JavaScript. As redes EVM powered by Tanssi têm uma API semelhante à do Ethereum, totalmente compatível com chamadas JSON RPC no estilo Ethereum. Portanto, os desenvolvedores podem aproveitar essa compatibilidade e usar a biblioteca Web3.js para interagir com um nó EVM da Tanssi como se estivessem no Ethereum. Para saber mais sobre Web3.js, consulte o site de documentação.

Neste guia, você aprenderá a configurar a biblioteca Web3.js para sua rede EVM da Tanssi. Em seguida, para mostrar a biblioteca em ação, você usará Web3.js para enviar uma transação e implantar um contrato em uma rede EVM de demonstração da Tanssi executando no Dancelight. Este guia pode ser adaptado para sua própria rede EVM da Tanssi simplesmente trocando 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¶

Para os exemplos deste guia, você precisará de:

Uma conta com fundos na rede EVM da Tanssi que estiver usando nos testes

Instalando Web3Js¶

Para este guia, instale a biblioteca Web3.js e o compilador Solidity. Para instalar ambos os pacotes NPM, execute:

npmyarn

npm install web3 solc@0.8.0

yarn add web3 solc@0.8.0

Configurando o Provedor Web3¶

Ao longo deste guia, você criará vários scripts com funções diferentes, como enviar uma transação, implantar um contrato e interagir com um contrato implantado. Na maioria desses scripts, você precisará criar um provedor Web3.js para interagir com a rede.

Para configurar um provedor Web3, siga estes passos:

Importe a biblioteca Web3.
Crie o provedor Web3 e defina a URL RPC. Você pode configurar Web3.js para funcionar com a rede EVM de demonstração da Tanssi executando na Dancelight ou com sua própria rede EVM da Tanssi apenas alterando o endpoint.

// 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 snippet, pois ele será necessário nos scripts usados nas seções a seguir.

Enviar uma Transação¶

Nesta seção, você criará alguns scripts. O primeiro verificará os saldos de suas contas antes de tentar enviar uma transação. O segundo script enviará a transação.

Você também pode usar o script de saldo para verificar os saldos após a transação ser enviada.

Script para verificar saldos¶

Basta um arquivo para verificar os saldos dos dois endereços antes e depois da transação. Para começar, crie o arquivo balances.js executando:

touch balances.js

Em seguida, crie o script deste arquivo seguindo estes passos:

Configure o provedor Web3
Defina as variáveis addressFrom e addressTo
Crie a função assíncrona balances, que envolve o método web3.eth.getBalance
Use a função web3.eth.getBalance para buscar os saldos dos endereços addressFrom e addressTo. Você também pode usar web3.utils.fromWei para transformar o saldo em um número mais legível em TANGO
Por fim, execute a função 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();

Ver 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();

Para executar o script e buscar os saldos das contas, rode:

node balances.js

Se funcionar, os saldos dos endereços de origem e destino serão exibidos no terminal em ETH.

Script para Enviar Transação¶

Você só precisa de um arquivo para executar uma transação entre contas. Neste exemplo, você transferirá 1 token TANGO de um endereço de origem (do qual você possui a chave privada) para outro endereço. Para começar, crie o arquivo transaction.js executando:

touch transaction.js

Em seguida, crie o script deste arquivo seguindo estes passos:

Configure o provedor Web3
Defina addressFrom, incluindo a privateKey, e a variável addressTo. A chave privada é necessária para criar uma instância de carteira. Nota: isto é apenas para fins de exemplo. Nunca armazene suas chaves privadas em um arquivo JavaScript
Crie a função assíncrona send, que encapsula o objeto de transação e as funções de assinar e enviar a transação
Crie e assine a transação usando a função web3.eth.accounts.signTransaction. Informe o gas, o addressTo e o value da transação, além da privateKey do remetente
Envie a transação assinada usando o método web3.eth.sendSignedTransaction e passe a transação bruta. Em seguida, use await para aguardar o processamento e o retorno do recibo da transação
Por fim, execute a função send

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

// 2. Crie as variáveis de conta
const accountFrom = {
  privateKey: 'INSIRA_SUA_CHAVE_PRIVADA',
  address: 'INSIRA_O_ENDERECO_PUBLICO_DA_CHAVE',
};
const addressTo = 'INSERIR_ENDERECO_PARA'; // Alterar para o endereço desejado

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

  // 4. Assine a transação 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 transação 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 send
send();

Ver 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();

Para executar o script, rode o seguinte comando no terminal:

node transaction.js

Se a transação for bem-sucedida, o hash será exibido no terminal.

Você também pode usar o script balances.js para verificar se os saldos das contas de origem e destino mudaram. O fluxo completo ficaria assim:

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 para Compilar o Contrato¶

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 para Implantar o Contrato¶

Com o script para compilar o contrato Incrementer.sol pronto, você pode usar os resultados para enviar uma transação assinada que o implanta. Para isso, crie um arquivo para o script de implantação chamado deploy.js:

touch deploy.js

Em seguida, crie o script deste arquivo seguindo estes passos:

Importe o arquivo do contrato a partir de compile.js
Configure o provedor Web3
Defina as variáveis addressFrom, incluindo a privateKey, e addressTo. A chave privada é necessária para criar uma instância de carteira. Nota: isto é apenas para fins de exemplo. Nunca armazene suas chaves privadas em um arquivo JavaScript
Salve o bytecode e o abi do contrato compilado
Crie a função assíncrona deploy que será usada para implantar o contrato
Crie a instância do contrato usando a função web3.eth.Contract
Crie o builder e passe o bytecode e o valor inicial do incrementer. Neste exemplo, defina o valor inicial como 5
Crie e assine a transação usando a função web3.eth.accounts.signTransaction. Informe o data e o gas da transação, além da privateKey do remetente
Envie a transação assinada usando o método web3.eth.sendSignedTransaction e passe a transação bruta. Em seguida, use await para aguardar o processamento e o retorno do recibo
Por fim, execute a função 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',
};

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

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

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

  // 7. Crie a transação do builder
  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 transação e aguarde o recibo
  const createReceipt = await web3.eth.sendSignedTransaction(
    createTransaction.rawTransaction
  );
  console.log(`Contrato implantado no endereço: ${createReceipt.contractAddress}`);
};

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

Ver 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();

Para executar o script, digite o seguinte comando no terminal:

node deploy.js

Se der certo, o endereço do contrato será exibido no terminal.

Ler Dados do Contrato (métodos de chamada)¶

Métodos de chamada são interações que não modificam o armazenamento do contrato (não alteram variáveis), portanto nenhuma transação precisa ser enviada. Eles simplesmente leem variáveis de armazenamento do contrato implantado.

Para começar, crie um arquivo chamado get.js:

touch get.js

Depois, siga estes passos para criar o script:

Importe o abi do arquivo compile.js
Configure o provedor Web3
Crie a variável contractAddress usando o endereço do contrato implantado
Crie uma instância do contrato usando a função web3.eth.Contract e passando o abi e o contractAddress
Crie a função assíncrona get
Use a instância do contrato para chamar um dos métodos do contrato e passe os inputs necessários. Neste exemplo, você chamará o método number, que não requer entradas. Use await, que retornará o valor solicitado quando a promessa for resolvida
Por fim, chame a função get

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

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

// 3. Crie as variáveis de endereço
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 ao contrato no endereço: ${contractAddress}`);

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

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

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

Ver 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();

Para executar o script, digite o seguinte comando no terminal:

node get.js

Se der certo, o valor será exibido no terminal.

Interagir com o Contrato (métodos de envio)¶

Métodos de envio são interações que modificam o armazenamento do contrato (alteram variáveis), portanto uma transação precisa ser assinada e enviada. Nesta seção, você criará dois scripts: um para incrementar e outro para resetar o incrementer. Para começar, crie um arquivo para cada script e nomeie-os increment.js e reset.js:

touch increment.js reset.js

Abra o arquivo increment.js e siga estes passos para criar o script:

Importe o abi do arquivo compile.js
Configure o provedor Web3
Defina a privateKey da conta de origem, o contractAddress do contrato implantado e o _value pelo qual incrementar. A chave privada é necessária para criar uma instância de carteira. Nota: isto é apenas para fins de exemplo. Nunca armazene suas chaves privadas em um arquivo JavaScript
Crie uma instância do contrato usando a função web3.eth.Contract e passando o abi e o contractAddress
Use a instância do contrato para construir a transação de incremento usando a função methods.increment e passando _value como entrada
Crie a função assíncrona increment
Use a instância do contrato e a transação de incremento criada para assinar a transação com a chave privada do remetente. Use a função web3.eth.accounts.signTransaction e especifique o endereço to, o data e o gas da transação
Envie a transação assinada usando o método web3.eth.sendSignedTransaction e passe a transação bruta. Em seguida, use await para aguardar o processamento e o retorno do recibo
Por fim, chame a função increment

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

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

// 3. Crie as variáveis
const accountFrom = {
  privateKey: 'INSIRA_SUA_CHAVE_PRIVADA',
};
const contractAddress = 'INSERIR_ENDERECO_DO_CONTRATO';
const _value = 3;

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

// 5. Monte a transação de incremento
const incrementTx = incrementer.methods.increment(_value);

// 6. Crie a função increment
const increment = async () => {
  console.log(
    `Chamando a função increment de ${_value} no contrato no endereço: ${contractAddress}`
  );

  // 7. Assine a transação com a chave privada
  const createTransaction = await web3.eth.accounts.signTransaction(
    {
      to: contractAddress,
      data: incrementTx.encodeABI(),
      gas: await incrementTx.estimateGas(),
    },
    accountFrom.privateKey
  );

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

// 9. Chame a função increment
increment();

Ver 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();

Para executar o script, digite o seguinte comando no terminal:

node increment.js

Se der certo, o hash da transação será exibido no terminal. Você pode usar o script get.js junto com o increment.js para garantir que o valor esteja mudando como esperado.

Em seguida, abra o arquivo reset.js e siga estes passos para criar o script:

Importe o abi do arquivo compile.js
Configure o provedor Web3
Defina a privateKey da conta de origem e o contractAddress do contrato implantado. A chave privada é necessária para criar uma instância de carteira. Nota: isto é apenas para fins de exemplo. Nunca armazene suas chaves privadas em um arquivo JavaScript
Crie uma instância do contrato usando a função web3.eth.Contract e passando o abi e o contractAddress
Use a instância do contrato para montar a transação de reset usando a função methods.reset
Crie a função assíncrona reset
Use a instância do contrato e a transação de reset criada para assinar a transação com a chave privada do remetente. Use a função web3.eth.accounts.signTransaction e especifique o endereço to, o data e o gas da transação
Envie a transação assinada usando o método web3.eth.sendSignedTransaction e passe a transação bruta. Em seguida, use await para aguardar o processamento e o retorno do recibo
Por fim, chame a função reset

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

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

// 3. Crie as variáveis
const accountFrom = {
  privateKey: 'INSIRA_SUA_CHAVE_PRIVADA',
};
const contractAddress = 'INSERIR_ENDERECO_DO_CONTRATO';

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

// 5. Monte a transação de reset
const resetTx = incrementer.methods.reset();

// 6. Crie a função reset
const reset = async () => {
  console.log(
    `Chamando a função reset no contrato no endereço: ${contractAddress}`
  );

  // 7. Assine a transação com a chave privada
  const createTransaction = await web3.eth.accounts.signTransaction(
    {
      to: contractAddress,
      data: resetTx.encodeABI(),
      gas: await resetTx.estimateGas(),
    },
    accountFrom.privateKey
  );

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

// 9. Chame a função reset
reset();

Ver 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';

// 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();

Para executar o script, digite o seguinte comando no terminal:

node reset.js

Se der certo, o hash da transação será exibido no terminal. Você pode usar o script get.js junto com o reset.js para garantir que o valor esteja mudando como esperado.

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: 7 de janeiro de 2026
| Criada: 7 de janeiro de 2026