Web3Client Blog

How to execute near smart contract in web3Client.app

poriyaalar Marketing — Wed, 19 Jul 2023 10:52:06 GMT

As the blockchain industry continues to grow and evolve, more developers and users are turning to innovative protocols like Near to build decentralized applications (dApps) and execute smart contracts. At Web3Client, we're excited to support the Near ecosystem and empower developers with tools and services to easily interact with the blockchain.

Near's recent NearBOS movement has sparked even more interest in the protocol's potential as an operating system for the open web. Smart contracts are a key component of this ecosystem, allowing developers to automate transactions and build new decentralized applications on top of the Near blockchain. In this article, we'll be taking a closer look at how to execute an already deployed smart contract on the Near blockchain using Web3Client. We'll walk you through the steps needed to interact with the smart contract, and show you how Web3Client can simplify the process and make it accessible to developers of all levels.

For easy understanding purposes, we will take the well-known nearBOS contract social.near (https://docs.near.org/social/intro)

Let's do one get method call and one set method call on social.near

Step 1:

Open https://workspace.web3client.app/evm

Step 2:

Click +New button and Select Create New ABI

Step 3:

Fill in the contract details

ABI Name: Near Social

Contract ID: social.nearSelect Network: Near MainnetAnd click Submit

Step 3:

Fill in the contract details

ABI Name: Near Social

Step 4:

Click on the ABI created in the right sidebar and select the NEW METHOD

Step 5:

For making the get call on social.near, fill in the following details:Select View enter the method name as get add param type json name keys and values ["web3client.near/profile/**"]

And click Send

Click the Save icon to save the method created.

**Step 6:**For making set call on social.near, fill in the following details:

Click the kebab menu in sidebar and click the +New method icon

Select Payable enter the method name as set add param type json name data and values {"data":{"web3client.near":{"profile":{"name":"Web3client Near"}}}}

Add deposit 10000000000000000000000 or above this is equivalent to 0.01Near

And click Send.

It will open the wallet selector if the account is not connected. Select your preferred wallet and click Connect.

Once connected, click send again(since the previous send would be invalidated due to no wallet selected)

Approve the transaction in the wallet pop-up.

We hope this article has helped you understand how to use Web3Client to execute smart contracts on the Near blockchain. At Web3Client, we're dedicated to improving the performance and productivity of developers working on the blockchain. If you have any feedback or suggestions for how we can improve our platform, please join our Discord channel or reach out to us on Twitter @web3client. Thank you for reading, and we look forward to supporting you on your journey building on the Near blockchain!

Create and execute smart contracts locally with Truffle, Ganache and Web3Client

poriyaalar Marketing — Wed, 19 Jul 2023 10:51:42 GMT

Creating and executing smart contracts can be a challenging task, especially if you're new to the world of blockchain development. However, with the right tools and knowledge, the process can be streamlined and made more efficient. In this article, we will explore how to use Truffle Suite and Web3Client to deploy and test Solidity smart contracts locally.

What is the Truffle Suite?

The Truffle Suite is a collection of tools that is designed to ease the testing of your Ethereum Solidity smart contracts. It includes Truffle, Ganache, and Drizzle. Truffle is a development environment, testing framework, and asset pipeline for blockchains using the Ethereum Virtual Machine (EVM). Ganache is a simulated Ethereum blockchain where you can deploy contracts, develop your applications, and run tests. Drizzle is a collection of front-end libraries that make writing dApp front-ends easier and more predictable.

Installing Truffle

To install Truffle, open Terminal and type the following command:

npm install truffle -g

Creating the Working Directory

Create a new directory where you will store your project. In Terminal, type:

mkdir truffleapp

cd truffleapp

Creating the Truffle Project

To create a new Truffle project, type:

truffle init

This will create a bare Truffle project with no smart contracts included.

Writing a Smart Contract

Before we can deploy a smart contract, we need to write one. Solidity is a contract-oriented programming language that is used to write smart contracts on the Ethereum blockchain.

Here is a sample smart contract called "Greeting"

// SPDX-License-Identifier: MIT

pragma solidity >=0.7.0 <0.9.0;

contract Greetings {

string public name;

string public gPrefix = "Hello ";

constructor(string memory initName) {

name = initName;

}

function setName(string memory newName) public {

name = newName;

}

function getGreeting() public view returns(string memory) {

return string(abi.encodePacked(gPrefix,name));

}

Writing Migration Script

Migrations are JavaScript files that help you deploy contracts to the Ethereum network. They are responsible for staging your deployment tasks and are written under the assumption that your deployment needs will change over time. The filename is prefixed with a number and suffixed by a description. The numbered prefix is required to record whether the migration ran successfully.

var Greetings =

artifacts.require("Greetings");

module.exports = function(deployer) {

deployer.deploy(Greetings, "Web3 World");

// Additional contracts can be deployed here

};

Setting up Ganache

Ganache is a simulated Ethereum blockchain that we will use to test our smart contract. To install it globally, run:

npm install ganache --global

Once installed, start Ganache from your command line:

ganache

Deploying Smart Contract

To deploy the smart contract on the local Ganache network, run the following command in your terminal:

truffle migrate

Executing Smart Contract in Web3Client

To execute the smart contract, we can use Web3client.app. Web3client.app is a web-based platform that allows you to interact with the Ethereum blockchain.

Here are the steps to execute the smart contract using Web3client.app:

Open https://workspace.web3client.app/ in your web browser.

Select "Create new ABI"

Enter the ABI name and Contract ID that you got when you deployed the smart contract.

Select "Add Network Manually" in the "Add Network" section and fill in the Chain Name, Chain ID, and Local RPC URL.

Click "Submit" to create a new ABI.

Click on the created ABI and click "New Method"

Enter the method name and click "Send" to execute.

Example:

Method Name : setName

In this greetings example contract, setName method is used to set current name in contract.

Method Name : getGreeting

In this greetings example contract, getGreeting method is used to getGreeting from contract, it returns string

In conclusion, Truffle Suite and Web3Client are powerful tools that make it easy for developers to deploy and test Solidity smart contracts on their local computers. With Truffle, you can easily create a project structure and write smart contracts, while Ganache simulates an Ethereum blockchain environment for testing and development. Using Web3Client, you can interact with your deployed smart contract and execute its methods in a user-friendly web-based platform. These tools greatly streamline the development and testing process for Ethereum DApps and smart contracts, and they are highly recommended for any developer working in the blockchain space.

Github Repo

Create and Execute Smart Contracts Locally with Hardhat and Web3Client.app

poriyaalar Marketing — Wed, 19 Jul 2023 10:51:19 GMT

Smart contracts have gained widespread popularity in recent years due to their ability to automate business processes, eliminate intermediaries, and reduce costs. They are self-executing contracts with the terms of the agreement between buyer and seller directly written into lines of code. This blog will guide you through writing, compiling, deploying, and executing a smart contract using Hardhat and Web3Client.app.

Write a Smart Contract

First, you need to write a smart contract in the Solidity language. Solidity is a contract-oriented programming language used for creating smart contracts on the Ethereum blockchain. Below is a sample smart contract called "Greetings" that can be used to greet users.

// SPDX-License-Identifier: MITpragma 
solidity >=0.7.0 <0.9.0;
contract Greetings {
string public name;
string public gPrefix = "Hello ";

constructor(string memory initName) {
    name = initName;
}

function setName(string memory newName) public {
    name = newName;
}

function getGreeting() public view returns(string memory) {
    return string(abi.encodePacked(gPrefix, name));
}
}

Compile the Smart Contract

After writing the smart contract, you need to compile it. To compile the smart contract, navigate to the root directory of your Hardhat project and run the following command:

npx hardhat compile

Create a Deployment Script

To deploy the smart contract, you need to write a deployment script. Here is an example of a deployment script that deploys the "Greetings" contract on the local Hardhat network.

// We require the Hardhat Runtime Environment explicitly here. This is optional
// but useful for running the script in a standalone fashion through `node