DEV Community: AbhayPatel98

Escrow in blockchain.

AbhayPatel98 — Sat, 24 Jun 2023 05:35:41 +0000

Blockchain-based escrow works by locking the funds or assets in a smart contract until specific conditions are fulfilled. These conditions can be based on time, delivery of goods or services, or any other predefined criteria agreed upon by the parties involved. Once the conditions are met, the smart contract automatically releases the funds or assets to the appropriate party.

The benefits of using blockchain for escrow include:

Transparency: Since the smart contract and its execution are recorded on the blockchain, all parties involved can verify the transaction details and ensure transparency.

Security: Blockchain employs strong cryptographic techniques, making it difficult for malicious actors to tamper with the escrowed funds or assets. This provides an additional layer of security compared to traditional escrow systems.

Efficiency: Blockchain-based escrow eliminates the need for intermediaries, such as banks or escrow agents, thereby reducing costs and accelerating transaction settlement times.

Global accessibility: Blockchain operates on a decentralized network, enabling escrow transactions to be conducted globally without relying on a centralized authority or jurisdiction.

However, it's important to note that while blockchain-based escrow offers advantages, it does not eliminate all risks associated with transactions. Parties should still exercise due diligence and carefully define the terms and conditions of the escrow agreement to ensure their interests are protected.

Libraries in Solidity.

AbhayPatel98 — Sun, 29 Jan 2023 10:30:14 +0000

When you need to share code between Solidity Contracts, it's time to utilize Libraries.

Libraries are a great place to store functions that are common to many Smart Contracts. These functions can range from re-usable math functions to contract patterns and permissions.

Using libraries can:

Reduce new code, limiting the opportunity for bugs.

Save development time by not re-inventing the wheel.

Secure your contracts with audited code and best practices.

*Save gas on deployments by making use of already deployed code.

*Saving gas depends on how you use the library. Libraries can be deployed on their own, like contracts, and they can also be compiled into the contract bytecode directly.

ERC-20 Tokens

AbhayPatel98 — Tue, 17 Jan 2023 16:13:04 +0000

An ERC-20 token is a representation of some sort of asset on the Ethereum network. These could be anything:

shares in a company
reward system points
voting rights
cryptocurrency
lottery tickets
on-chain Chuck E Cheese tokens
anything you can think of!
This is what has made Ethereum a popular choice for many different use cases across industries - anyone can tokenize any asset.

Importance of the ERC-20 Token Standard
A key point to understand here is that ERC-20 is a technical standard! 💡

The main use of the ERC-20 standard is to increase compatibility of the ecosystem. Exchanges like Uniswap are then able to build incredibly powerful applications because they create infrastructure that supports the ERC-20 interface; this then triggers developers who use the ERC-20 standard to develop, instant compatibility with Uniswap and many other dApps!

ERC-20 Token Smart Contract
At the base level, an ERC-20 token smart contract simply uses a mapping to keep track of fungible tokens: any one token is exactly equal to any other token; no tokens have special rights or behavior associated with them.

ERC-20 Token Interface
As we covered above, ERC-20 defines a common interface so that any application can use them in a standard way.

This simplifies and eases developers’ tasks, because they can proceed with their work, knowing that each and every new project won’t need to be redone every time a new token is released, as long as the token follows the rules.

The interface consists of a number of functions that must be present in every implementation of the standard, as well as some optional.

An ERC-20-compliant token contract must provide at least the following:

name, symbol, and decimals are all optional fields
totalSupply defines the current circulating supply of the tokens
balanceOf will return the balance for a particular user
transfer which is the bread and butter, transfer from one account to another
approve, transferFrom and allowance are methods for other contracts moving your funds

ERC-20 Data Structures
There are two important data structures used by the ERC-20 token standard that we should review:

balances: mapping of token balances, by owner. Each transfer is a deduction from one balance and an addition to another balance.
allowances: mapping of allowances/delegate spending. This is a nested mapping in which the primary key is the address of the token owner which maps to a spender address and amount delegated to spend.

Smart Contract Inheritance.

AbhayPatel98 — Mon, 09 Jan 2023 14:28:35 +0000

Inheritance Overview
As with many object-oriented languages, Solidity includes inheritance as a feature.

Inheritance means that you can create an object with some values/methods and use it as a base for other objects.
In Solidity, the objects we're referring to are contracts and interfaces. We can write a contract with state variables and functions. Then we can create contracts that inherit those variables and functions. These derived contracts can then choose to add behavior as necessary.

Smart contracts can inherit other contract by using the is keyword. More specifically, a contract that inherits is the child and the inheritor is the parent. Using the is keyword in Solidity establishes a smart contract parent-to-child chain. So whenever you think of inheritance, just think of the father-son relations.

Inheritance allows programmers to create classes that are built upon existing classes, to specify a new implementation while maintaining the same behaviors.

Contracts can inherit other contracts by using the is keyword.

Just as illustrated in the diagram above, the syntax to establish inheritance between smart contracts in Solidity is to simply us the is keyword in the child contract - which creates an explicit pointer to the parent contract:

contract A {

}

contract B is A {

}

In this case Contract A is the parent contract, often times referred to as the base contract whereas Contract B is the child contract, often referred to as the derived contract. Let's break down the different types of smart contract inheritance in Solidity.

Arrays & Structs.

AbhayPatel98 — Tue, 03 Jan 2023 14:39:56 +0000

Solidity Reference Types

At this point, you are well on your way to becoming a Solidity master. We've looked at the primitive data types in Solidity, such as:

uint/int
boolean
address
enum
bytes

Primitive data types can also be referred to as "value types". A value type stores its data directly in the variable.

Solidity, like most other object-oriented programming languages, has another type of data for reference-based data types, such as:

arrays
strings
structs

mappings (also reference types, but we've already covered them quite heavily!)
A reference type does not store values directly in a variable. Instead, reference types hold a pointer to the address of the data's location.

The two main reference types we will cover today are: arrays and structs.

Arrays
In computer science, an array is a data structure consisting of a collection of elements (values or variables), each identified by at least one array index or key. In Solidity, an array can be both of fixed or dynamic size.

What Are Dynamic & Fixed Arrays?
The size of dynamic arrays are not predefined when they are declared. As elements are systematically added, the size of the dynamic array changes, and during runtime, the actual size of the array will be determined.

In contrast, fixed arrays have a predefined size, and the quantity of elements present in the array should not exceed the size of the array.

Storage Arrays
Storage arrays are typically declared as state variables and can be either fixed or dynamic in size. Here's a Solidity code snipper declaring both a fixed and dynamic-sized array in a simple MyContract

Both fixed and dynamic sized arrays have access to the .length array member:

.length: returns how many values an array holds per index
Dynamic storage arrays have the typical array methods available, such as:

.push(): used to add an element to the array at the last position

.pop(): used to remove an element of the array at the last position

Introduction to Escrows.

AbhayPatel98 — Tue, 03 Jan 2023 07:08:16 +0000

An escrow is an agreement often used when transferring funds in exchange for a good or service. Funds can be held in escrow and a third party can be chosen to "arbitrate" or approve the transfer when the service or good is provided.

We'll have three parties involved in the Escrow:

Depositor - The payer of the Escrow, makes the initial deposit that will eventually go to the beneficiary.

** Beneficiary** - The receiver of the funds. They will provide some service or good to the depositor before the funds are transferred by the arbiter.

Arbiter - The approver of the transaction. They alone can move the funds when the goods/services have been provided.

Events in Solidity.

AbhayPatel98 — Mon, 02 Jan 2023 06:43:10 +0000

Events in Solidity.
**Events are the way Solidity **and the EVM provides developers with logging functionality used to write information to a data structure on the blockchain that lives outside of smart contracts’ storage variables.

Events are an abstraction on top of the EVM’s low-level logging functionality, opcodes LOG0 to LOG4. The specific opcode used will depend on the number of topics the event declares using the indexed keyword. A topic is just a variable that we want to be included in the event and tells Solidity we want to be able to filter on the variable as well.

The low-level logs are stored in the transaction receipt of the transaction under the transaction receipts trie. Logs are written by the smart contract when the contract emits events, but these logs cannot be ready by the smart contract. The inaccessibility of the logs allows developers to store data on-chain that is more searchable and gas efficient than saving data to the smart contract’s storage variables.

Events are defined in smart contracts using the event keyword. Here is the transfer event from the ERC20 smart contract. It is emitted whenever tokens are transferred from 1 account to another.

Here we can see the different components of an event:

the event's name Transfer

the event's topics from (sender's address), to (the receiver's address), value (the amount transferred).

if a variable in the event is not marked as indexed it will be included when the event is emitted, but code listening on the event will not be ablel to filter on non-indexed varables (aka topics).

Whenever a Transfer event is emitted, the from, to and value data will be contained in the event.

Emiting Events

Once an event has been defined we can emit the event from the smart contract. Continuing on from the ERC20 smart contract let's see where the Transfer event is emitted.

Listening to Events

If you remember the definition of an Event from above, smart contracts can write events, but not read events. So how do we listen/read to data that smart contracts cannot read?

We listen to and read events from code connected to a provider. From what we've learned so far in this course we could do this in JS code using an ethers provider to connect to a contract and listen to transfer events and do something with the event data.

Mappings in Solidity

AbhayPatel98 — Fri, 30 Dec 2022 13:18:05 +0000

Mappings in Solidity
Have you ever heard of a hash table? If you've taken one or two computer science courses, chances are you have! If not, don't worry, you're in the right place. Let's jump in… 🛩
A hash table is a data structure that implements an associative array (also referred to as a "dictionary"). In an associative array, data is stored as a collection of key-value pairs. The position of the data within the array is determined by applying a hashing algorithm to the key.
As seen above, a key represents some data to be stored in the hash table data structure. That key is fed into a hash function which produces a hash value. That hash value dictates the index where the data, pertaining to the key, will be stored in the hash table. 🧩
Any time you "look up" (hence why hash tables are referred to as "dictionary" data structures!) a value by key, you will get whatever value is stored in the hash table back. Hash functions are deterministic, so you will always get the same value back as long as you provide the same key.
Hash Table Data Structures Are Efficient 🏎
Hash tables enable very efficient searching, in fact, they enable the "holy grail" O(1) search time. Hash tables do not require a brute force search or a for loop to look up a value thanks to the deterministic nature of hash functions! 🐐 You can just say, gimme whatever value is held at this key and the hash table data structure will comply. ⚡️

Mappings
In Solidity, hash tables are called mappings. They function pretty much the exact same as hash tables. 🤷
Mappings act as hash tables which consist of key types and corresponding value type pairs.
They are defined like any other variable type in Solidity:
**
mapping(_KeyType => _ValueType) public mappingName;**
mapping(_KeyType => _ValueType) public mappingName;
**
Useful for address Association
Solidity mappings are particularly useful for address association.
Thanks to mappings, you can associate an Ethereum address to a specific value. Here are a few examples we could use address association for:
Keeping track of how many sodas a user has purchased from a vending machine smart contract:
mapping(address => uint) public sodasPurchased;.

How to Unit Test a Smart Contract.

AbhayPatel98 — Fri, 30 Dec 2022 12:11:47 +0000

Guide Requirements
Hardhat: Hardhat is an Ethereum development platform that provides all the tools needed to build, debug and deploy smart contracts.

Useful JS + Solidity Testing Resources
We will use these resources throughout this guide but bookmark these for any other testing you do!
**
ChaiJS**
Chai BDD Styled
Chai Assert
Mocha Hooks
Solidity Chai Matchers

Step 1: Hardhat Project Structure Setup

In a directory of your choice, run npm init -y
Run npm install --save-dev hardhat
Run npx hardhat and you will get the following UI on your terminal:

*Select Create a JavaScript project
*Select YES to all of these options!

Your project should now contain the following:

Files: node_modules, package.json, hardhat.config.js, package-lock.json, README.md
Folders: scripts, contracts, test

*Run npx hardhat test in your terminal
*

Ethereum Messages

AbhayPatel98 — Wed, 28 Dec 2022 07:50:16 +0000

When we have an Externally Owned Account and we want to communicate with the Ethereum Network we broadcast a transaction. Inside this transaction we can choose to send data which is bytecode intended to interact with the EVM.

If we don't send data then there's no intention to interact with the EVM. This is the case for simple ether transfers from one address to another.

The data, often refered to as the calldata, is used to pass a message into the EVM. It will target a specific contract account (could be either a contract or library in Solidity terms) which may also make calls to another contract account. Every time a contract account calls into another contract account it forms a message. This message includes its sender address, the targeted function signature, and the amount of wei sent.

In Solidity we have access to these message through global variables:
**
msg.data (bytes) - the complete calldata
msg.sender (address) - the address sending the message
msg.sig (bytes4) - the targeted function signature
msg.value (uint) - the amount of wei sent
**

Wondering why the msg.sig is 4 bytes? This value is actually the first four bytes of the keccak256 hash of the function signature. It provides a way to uniquely identify (and target) the functions on a smart contract without worrying about how long the function signature is. Otherwise you could potentially store a reallyLongNameForAFunction and the calldata would need to store all of this information to invoke that function!

EOAs - Externally owned Account.

AbhayPatel98 — Tue, 27 Dec 2022 17:13:02 +0000

What are the two types of accounts in Solidity?**
**
Externally Owned Accounts** - All transactions originate from an EOA, they are controlled by a private key which signs off on the transaction.

Smart Contract - This is code deployed to the blockchain. It is programmed to respond to different inputs sent by EOAs or other contracts.

contract SpecialNumber {
address author1;
address author2;
}

What's something we can do with EOAs? We can pay them! Let's do that. Any time this contract receives ether, let's send half to author1 and half to author2.

A payable function is one that can receive ether. The receive function is a special function that will be invoked when a smart contract receives ether. We'll touch on this further later on.

contract SpecialNumber {
address author1;
address author2;

receive() external payable {
    // msg.value is passed to this contract
    uint totalValue = msg.value;

    // make a call to author1 sending half of the ether
    (bool success1, ) = author1.call{ value: totalValue / 2 }("");
    require(success1);

    // make a call to author2 sending half of the ether
    (bool success2, ) = author2.call{ value: totalValue / 2 }("");
    require(success2);
}

}
**
The .call method
The curly brace {} syntax
The empty string argument passed in ("")
The return value (bool success1, )**

Call
First let's talk about call. The call method is something you'll find on every address type when you want to send input data or ether to an address. When you do this, you'll be making something called a message call. You'll often hear this terminology used to describe a call to a smart contract. We differentiate this from a transaction, which is object signed by the EOA sent to the blockchain.

Curly Braces
The curly braces which comes after call {} provides an opportunity to override the value and gas parameters on the message call. The gas parameter will be relevant when we start calling smart contract addresses. When you leave it unspecified it will forward along all the gas remaining that the transaction sender designated (through the gasLimit parameter on the front-end, remember?).

The Empty String Argument
You can see where passing in an empty string here. If you were trying to target a function on a smart contract this is where your calldata would go. The calldata will specify the function you're trying to call as well as the arguments you are sending. In this case, we're just trying to send ether to an EOA, so we pass an "" to indicate there is no calldata.
**

Return Value**
The (bool success1, ) part probably looks a bit confusing! Remember how in the previous lesson we wrote a contract that can return multiple values? The call method returns multiple values. Solidity will warn you if you don't use the first value returned, which indicates if the message call was successful or not. In most cases, we will want the transaction to fail if a message call fails. The code require(success1) will do just that. We'll take about require further very shortly!

THANKS!!!!>.......

Create your own private blockchain using Ethereum.

AbhayPatel98 — Tue, 27 Dec 2022 11:30:00 +0000

The Ethereum private blockchain is a blockchain like Ethereum, but the network used is not the Ethereum Main. When you use a private network all blockchain is totally apart from the Ethereum blockchain, it's possible to change the configurations like mining difficulty, access, and other aspects.

😁 Follow the next steps to build your Private Blockchain.
1-Install Geth
2-Define Genesis Block
3-Start the first blockchain node
4-Start the second blockchain node
5-Create the peer-to-peer connection
6-Mining Blocks and Creating Transactions.

Boot Node - The advantage of a boot node is it connects all the nodes, it would not mine blocks.