Implementing Ethereum smart contract in .NET

Here I’ve prepared a document to support anyone who might need guidance in the future. I had to collect this information from various sources. Here, i have tried to create a general step-by-step guide to connect with Ethereum, a popular blockchain platform, using .NET( Netherum)

Before it i think, when working with Ethereum and Nethereum, there are some basic definitions and concepts that we should understand:

Ethereum Basics

• Ethereum: A decentralized platform that enables developers to build and deploy smart contracts. It uses a proof-of-stake (PoS) consensus mechanism and has its own cryptocurrency, Ether (ETH).
• Smart Contract: A self-executing contract with the terms of the agreement directly written into code. Smart contracts are stored and executed on the Ethereum blockchain.
• Blockchain: A decentralized, distributed ledger that records transactions across many computers.

Ethereum Terms

• Ether (ETH): The native cryptocurrency of the Ethereum network. Used to pay for transactions and computational services on the blockchain.
• Gas: A unit that measures the amount of computational work required for a transaction. Gas is paid in Ether, and the "gas price" determines how much Ether you are willing to pay per unit of gas.
• Gas Limit: The maximum amount of gas a transaction is allowed to consume.
• Transaction: A record of an operation on the Ethereum network, like sending Ether or calling a smart contract function.
• Block: A collection of transactions that have been confirmed and added to the blockchain.

Key Components in Nethereum

• Web3: The core class for interacting with Ethereum. It provides access to Ethereum accounts, smart contracts, and other blockchain-related operations.
• ABI (Application Binary Interface): Defines the structure of a smart contract, including its functions and events. The ABI is used by Nethereum to interact with contracts.
• Account: Represents an Ethereum account, which is identified by its Ethereum address. In Nethereum, it is often created using a private key.
• TransactionInput: Describes the parameters for a transaction, like the to address, gas limit, and data payload.
• Contract: A representation of an Ethereum smart contract in Nethereum. It allows you to call functions, send transactions, and listen to events.

Common Operations in Nethereum

• Send Ether: Transferring Ether from one account to another.
• SendTransaction: Sending a transaction to the Ethereum network, which could involve sending Ether or interacting with a smart contract.
• GetBalance: Retrieving the Ether balance of an account.
• Call: Invoking a read-only function on a smart contract without creating a transaction.
• Deploy Contract: Deploying a new smart contract to the Ethereum blockchain.
• Event: A mechanism in smart contracts to log information. Nethereum can listen for events and process them.

Security and Best Practices

• Private Key: A unique cryptographic key that gives you control over an Ethereum account. Keep it secure and never share it publicly.
• Mnemonic: A series of words that represent a private key in a human-readable format. Used for wallet backups and recovery.
• Infura/Alchemy: Popular services that provide Ethereum node endpoints. Often used to connect to the Ethereum network without running your own node.

Now we can have a look for the environment settings and interact with Ethereum with .Net.

?

Step 1: Set Up Your Environment

Install Nethereum : Nethereum is a .NET library for interacting with Ethereum. Install it using NuGet Package Manager in Visual Studio or via command line:

dotnet add package Nethereum        

Step 2 : Setting Up Account and Web3

Create an Ethereum account using a private key and connect to an Ethereum node with Web3. The UseLegacyAsDefault flag indicates that transactions will use the legacy (non-EIP-1559) gas structure.

Importing the necessary namespace to use Nethereum and Web3 functionalities

//using Ethereum.Web3;Initializing an Ethereum account with a private key
var account = new Account(_walletPrivateKey);
//Creating an instance of Web3 to interact with the Ethereum network
var web3 = new Web3(account, _swissDltAddress);
//Configuring the transaction manager to use the legacy gas model
//This might be necessary for compatibility with certain smart contracts //or environments.
web3.TransactionManager.UseLegacyAsDefault = true;        

?_walletPrivateKey: Your Ethereum account's private key.

?_swissDltAddress: The Ethereum node endpoint (e.g., Infura, Alchemy).

Step 3: Connect to the Smart Contract

Using the Web3 instance, create a contract object by providing the contract ABI and address.

//CreateBatchWalletContractABI: Here we have used this //CreateBatchWalletContractABI For creating a Batch contract but here you //will use your own abi from the smart contract.

//_walletContractAddress: The address of the deployed smart contract.

var contract = web3.Eth.GetContract(CreateBatchWalletContractABI, _walletContractAddress);        

Step 4 : Get Contract Function and Estimate Gas

Retrieve a specific function from the contract and estimate the gas required for a transaction.

createBatch: The function name to interact with.our dummy function name for batch wallet creates ABI.

account.Address: The sender's Ethereum address

var function = contract.GetFunction("createBatch"); 
var gas = await function.EstimateGasAsync(account.Address, null, null, BatchWalletCreateAbiFunctionInput);        

Step 5 : Send a Transaction

With the estimated gas, send a transaction to the smart contract function.transactionHash: The resulting transaction hash for tracking.

The SendTransactionAsync method sends a transaction to the contract's createBatch function. BatchWalletCreateAbiFunctionInput is the function input of the ABI.

var transactionHash = await function.SendTransactionAsync(account.Address, gas, null,BatchWalletCreateAbiFunctionInput);        

Then we will search the transactionHash in our provider. If we get the success flag true in our provider.we will be confirmed that the transaction has successfully completed otherwise failed.?

Here I am giving an example. In the below swiss.dlt image we can see a transaction with the successful status.

We have got this transaction after searching it in swissdlt (our provider, use your provider here) with the transactionHash.It is kind of transaction snapshot for the smart contract.

?????????????????????????????????????????????????????????Img : swiss.dlt

?

?

Step 6 : Retrieve the Transaction Receipt

After sending the transaction, the code snippet retrieves the transaction receipt, checking every 5 seconds until it's available.

receipt: The transaction receipt containing transaction details.

var receipt = await web3.Eth.Transactions.GetTransactionReceipt.SendRequestAsync(transactionHash);

 

while (receipt == null)

{

    await Task.Delay(5000); // Wait 5 seconds

    receipt = await web3.Eth.Transactions.GetTransactionReceipt.SendRequestAsync(transactionHash);

}

 

return receipt;        

Here in the receipt you will get all the information of this transaction.This step-by-step guide provides an overview of interacting with an Ethereum smart contract using Nethereum in a .NET environment. It covers setting up Web3, estimating gas, sending transactions, and retrieving transaction receipts.

It is the basic way for implementing a smart contract abi with .Net. Just changing the function name and function input you will be able to interact with any deployed smart contract.

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? Thank you ??