Interacting with external contracts

Smart contracts can interact with other contracts on the Ethereum blockchain, allowing them to call functions, read variables, and send Ether or tokens. One way to facilitate this interaction is by using Web3j, a lightweight Java library for working with Ethereum. Web3j can auto-generate smart contract wrapper code, enabling seamless deployment and interaction with smart contracts from the JVM.

To interact with external contracts using Web3j, you’ll first need to compile your smart contract and generate the wrapper code. You can then create and deploy your smart contract or use an existing contract, making it easy to transact with and call smart contract methods directly.

Events and logs

Events are crucial for tracking and monitoring smart contract activity on the blockchain. They provide a way to emit logs that can be stored and later retrieved by off-chain systems. Events make it easier to track specific contract events or changes in state variables, which is especially helpful for dApps (decentralized applications) that require real-time updates.

Logs are the records emitted by events and are stored on the blockchain. They are an essential part of the Ethereum ecosystem, as they enable efficient communication between smart contracts and off-chain systems. Logs are also indexed, making it easy for applications to filter and search for specific events or data points.

Example: Deploying a smart contract using Remix and MetaMask

Step 1: Open Remix IDE
First, open the Remix IDE (https://remix.ethereum.org/) in your web browser.

Step 2: Create a new file
Click on the “+” button in the top left corner of the IDE to create a new Blank Workspace. Then click on the Page “New File” to create a new File

Name the file “Auction.sol”.

Step 3: Define the contract
Copy and paste the following code into the new “Auction.sol” file:

TypeScript
// SPDX-License-Identifier: MIT
// Specify the Solidity version
pragma solidity ^0.8.0;

// Define the Auction contract
contract Auction {
    // Declare state variables
    address payable public owner; // The owner of the contract (can cancel the auction)
    uint public startBlock; // The block number at which the auction starts
    uint public endBlock; // The block number at which the auction ends
    string public ipfsHash; // IPFS hash for the item being auctioned
    bool public canceled; // Whether the auction has been canceled
    bool public ended; // Whether the auction has ended
    uint public highestBid; // The highest bid so far
    address payable public highestBidder; // The address of the highest bidder

    // Declare events
    event AuctionCanceled(); // Event emitted when the auction is canceled
    event HighestBidIncreased(address bidder, uint amount); // Event emitted when a new highest bid is set
    event AuctionEnded(address winner, uint amount); // Event emitted when the auction ends

      // Declare mapping
    mapping(address => uint256) public balances;

    // Constructor function
    constructor() {
        owner = payable(msg.sender); // Set the owner to the address that deploys the contract
        startBlock = block.number; // Set the start block to the current block number
        endBlock = startBlock + 40320; // Set the end block to 1 week (40320 blocks) after the start block
        ipfsHash = ""; // Initialize the IPFS hash to an empty string
    }

    // Function to place a bid
    function placeBid() public payable {
        require(block.number >= startBlock && block.number <= endBlock, "Auction is not active."); // Check that the auction is active
        require(msg.value > highestBid, "There is already a higher bid."); // Check that the new bid is higher than the current highest bid
        require(!canceled, "Auction is canceled."); // Check that the auction has not been canceled

        // If there was a previous highest bidder, add their bid amount to their balance
        if (highestBidder != address(0)) {
        balances[highestBidder] += highestBid;
    }

        // Set the new highest bid and bidder
        highestBid = msg.value;
        highestBidder = payable(msg.sender);

        // Emit an event to signal a new highest bid has been set
        emit HighestBidIncreased(msg.sender, msg.value);
    }

    // Function to cancel the auction
    function cancelAuction() public {
        require(msg.sender == owner, "Only the owner can cancel the auction."); // Check that the sender is the owner
        require(!ended, "Auction has already ended."); // Check that the auction has not already ended

        // Set the canceled flag and emit an event to signal the auction has been canceled
        canceled = true;
        emit AuctionCanceled();
    }

    // Function to end the auction
    function endAuction() public {
        require(block.number > endBlock, "Auction is not over yet."); // Check that the auction is over
        require(!canceled, "Auction is canceled."); // Check that the auction has not been canceled
        require(!ended, "Auction has already ended."); // Check that the auction has not already ended

        // Set the ended flag and emit an event to signal the auction has ended
        ended = true;
        emit AuctionEnded(highestBidder, highestBid);

        // Transfer the highest bid amount to the owner
        owner.transfer(highestBid);

        // Ifthere was a previous highest bidder, add their bid amount to their balance
        if (highestBidder != address(0)) {
        balances[highestBidder] += highestBid;
        }
    }

    // Function to set the IPFS hash for the item being auctioned
    function setIpfsHash(string memory hash) public {
        require(msg.sender == owner, "Only the owner can set the IPFS hash."); // Check that the sender is the owner
        ipfsHash = hash; // Set the IPFS hash to the provided value
    }
}

This code defines the Auction contract, which allows users to place bids on an item and ends the auction after a specified period. The contract also has a function to cancel the auction and a function to set an IPFS hash for the item being auctioned.

Step 4: Compile the contract

Click on the “Solidity Compiler” tab in the left-hand menu. Under “Compile Auction.sol”, click the “Compile” button. The contract should be compiled successfully, and you should see a green checkmark next to “Auction.sol” in the file explorer.

Step 5: Deploy the contract

Click on the “Deploy & Run Transactions” tab in the left-hand menu. Under “Environment”, select “Injected Web3” as the environment. Under “Contract”, select “Auction” as the contract to deploy. Click the “Deploy” button.

Step 6: Interact with the contract
Once the contract is deployed, you can interact with it using the various functions defined in the contract. For example, you can call the placeBid() function to place a bid on the item

By using Remix and MetaMask, you can easily deploy and interact with smart contracts on the Ethereum network, enabling the development and testing of decentralized applications in a user-friendly environment.

Highlights
Smart contracts can interact with other contracts on the Ethereum blockchain, enabling function calls, variable reading, and the transfer of Ether or tokens.
Web3j is a lightweight Java library that facilitates interaction with Ethereum. It can auto-generate smart contract wrapper code for seamless deployment and interaction with contracts from the JVM.
Events are essential for tracking and monitoring contract activity on blockchain. They emit logs that can be stored and retrieved by off-chain systems, enabling real-time updates for dApps.
Logs, which are the records emitted by events, play a crucial role in efficient communication between smart contracts and off-chain systems. They are indexed, allowing for easy filtering and searching of specific events or data points.
The provided example demonstrates the process of deploying a smart contract using Remix IDE and MetaMask. It includes steps such as creating a new file, defining the contract, compiling it, deploying it, and interacting with its functions.