DAG Connection

Blockchain Interaction with Web3.js

To interact with the Ethereum blockchain developers can utilize the Web3.js library. Web3.js offers a range of modules and functionalities that enable creating, sending and managing transactions on the Ethereum blockchain. It also allows interaction, with contracts, event subscription and accessing blockchain data.

The first step is setting up Web3.js. Assuming you have Node.js and npm installed on your machine (if not please install them beforehand) you can easily install the Web3.js library using npm.

Once you have successfully installed web3.js you can include it in your JavaScript file by using the "statement.

const Web3 = require('web3');

To interact with a blockchain we also need to establish a connection with an Ethereum node. If we're working on a project we can utilize Ganache, which is a local in memory blockchain. However for a project it's preferable to connect with a live Ethereum node like Infura. Let me provide you with an example; Blockchain Interaction using the Web3.js Library.

When it comes to interacting with blockchains it's important to have an understanding of how they function and be familiar with tools designed for this purpose. In this context we'll be utilizing the Web3.js library as it offers extensive capabilities for interacting with the Ethereum blockchain. Although our intention is to develop our blockchain in the future for illustrative purposes we will use Ethereum due to its maturity and strong developer community. The principles discussed here are applicable, to our blockchain as well.

Initializing Web3

The first step in interacting with a blockchain using Web3.js is to initialize a Web3 instance. This requires a connection to an Ethereum node, which can be a local node or a node provided by a service like Infura.

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

// Connect to an Ethereum node
const web3 = new Web3('https://mainnet.infura.io/v3/YOUR-INFURA-PROJECT-ID');

This code will create a new instance of Web3 connected to the Ethereum mainnet via the Infura node specified by YOUR-INFURA-PROJECT-ID.

Interacting with a Smart Contract

Interacting with a smart contract involves reading from and writing to the contract. To do this, you need to have the contract's address and ABI (Application Binary Interface), which defines how to interact with the contract.

Here is an example of how to load a contract using its address and ABI:

// Define the contract address and ABI
const contractAddress = '0xYourContractAddress';
const contractABI = [/* contract ABI goes here */];

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

This code creates a new contract instance that can be used to call the contract's functions.

To call a read-only function, use the call method:

// Call a read-only function
contract.methods.myMethod().call()
  .then(result => console.log(result))
  .catch(error => console.error(error));

To call a function that modifies the contract's state, use the send method:

// Define the sender's address
const senderAddress = '0xYourAccountAddress';

// Call a state-changing function
contract.methods.myMethod().send({ from: senderAddress })
  .on('transactionHash', hash => console.log(`Transaction hash: ${hash}`))
  .on('receipt', receipt => console.log(`Receipt: ${JSON.stringify(receipt, null, 2)}`))
  .on('confirmation', (confirmationNumber, receipt) => console.log(`Confirmation number: ${confirmationNumber}\nReceipt: ${JSON.stringify(receipt, null, 2)}`))
  .on('error', error => console.error(error));

This code sends a transaction to call a function on the contract. It listens for various events during the transaction's lifecycle and logs the results to the console.

Note that before an account can send a transaction, it needs to be unlocked:

// Unlock the account
web3.eth.personal.unlockAccount(senderAddress, 'YourPassword', 600)
  .then(() => console.log('Account unlocked!'))
  .catch(console.error);

This code unlocks the account for 600 seconds.

Working with Verified Data

In this project our main objective is to extract verified information from our semi database transform it into a format like a JSON string and then transmit it to our initialization contract. Once the information is stored on the blockchain our initialization contract will. Timestamp it before transferring it to the appropriate contract on the blockchain. Given that blockchain data cannot be altered it is of importance that we establish a robust and comprehensive verification process, for our data before writing anything onto the blockchain. Making any errors can lead to consequences so we must meticulously review our work multiple times.

Required Signatures

Once the data is on the initialization contract, the wallet of the user who sent the request earlier can see the data and has to verify it with his private key, after the entrypoint provided the on-chain confirmation.