Category:
Blockchain Development & Web3 Solutions
Share Your Requirements
Vishal Yadav (Manager-Technical Project Manager)
Experience: 6+ yrsVishal is a highly skilled backend developer with extensive 3+ years experience in developing various blockchain platforms. He has a comprehensive understanding of the technologies and has hands-on expertise in Node.js, Ethereum, Layer 1 and Layer 2 solutions, smart contract development, and databases like MySQL and MongoDB. He has a proven track record of working on a range of blockchain-related projects, including token development, staking, governance, indexes, bridges, NFT, marketplace, ICO/IDO, and more. He is adept at managing trading bots, and developing centralized exchanges, and has a creative mind with excellent analytical skills.
Vishal Yadav
(Technical Project Manager)
Vishal is a highly skilled backend developer with extensive 3+ years experience in developing various blockchain platforms. He has a comprehensive understanding of the technologies and has hands-on expertise in Node.js, Ethereum, Layer 1 and Layer 2 solutions, smart contract development, and databases like MySQL and MongoDB. He has a proven track record of working on a range of blockchain-related projects, including token development, staking, governance, indexes, bridges, NFT, marketplace, ICO/IDO, and more. He is adept at managing trading bots, and developing centralized exchanges, and has a creative mind with excellent analytical skills.
Languages
English
Bilingual
Hindi
Fluent
Skills
Uniswap
IPFS
Ethereum
ERC-721
Ganache
Truffle
FunC Language
Gnosis Safe
Etherscan
Postgres
The Graph
MetaMask
Chainlink
Golang
Marlowe
Node Js
Cosmos IBC
Ethers.js
OpenZeppelin
Arbitrum
Bitcoin (BTC)
Coinbase API
Smart Contract
DyanmoDB
Remix IDE
Hardhat
Solidity
Rust
ERC-1155
ZKsync
Optimism
Anchor
Haskell
Technical Project Management
Solana
BASE
Work
Experience /
Trainings / Internship
Aug 2019-Present
Technical Project Manager
Unit No. 117- 120, Welldone Tech Park, Sector 48, Sohna Road, Gurugram, Haryana- 122018, IN.
Oodles Technologies
Unit No. 117- 120, Welldone Tech Park, Sector 48, Sohna Road, Gurugram, Haryana- 122018, IN.
Aug 2019-Present
Education
2015-2019
World college of Technology and Management
B.Tech-Computer science
Top Blog Posts
How to Create Your Own Private Blockchain using Cosmos
Cosmos is an open-source blockchain app development project that aims to connect other blockchains to each other to establish an easily usable, fast scalable, interoperable, and low-fee hub for basically any use of a blockchain. Cosmos internet of blockchains would allow different blockchains to communicate with each other in a decentralized way a way where one person or one single organization is not able to completely control so how is Cosmos planning on actually making this dream a reality this is where the cosmos Hub and zone model come in hubs are often very important for systems to really take off with a high number of users and Cosmos is no different in Cosmos they took a look at the cryptocurrency landscape and saw a lot of spokes but no Hub in other words they saw a large number of blockchains with interesting use cases but the methods of communicating between these chains still left a lot to be desired in fact one of the largest vulnerabilities out there are blockchain bridges which is a tool used to move money from one chain to another Cosmos created what they call a hub and zones model they have a central Hub that facilitates the transfer of tokens across various chains the founder of the Tinder mint protocol which later became Cosmos. Cosmos provides an SDK that can be used to create your own custom blockchain solution. Please check the steps below to set up the local system.Check out | Understanding the Importance of Cross Chain dAppsPrerequisiteNode.jsStep 1 : Take clone of the project and change the directory to the main root folder folder of the projectgit clone https://github.com/cosmos/cosmos-sdk Step 2: Initialize application ./build/simd init demo \ --home ./private/.simapp \ --chain-id learning-chain-1 Step 3: Prepare sample account, a test account with alice name is created ./build/simd keys add alice \ --home ./private/.simapp \ --keyring-backend testStep 4: Become validator // Give initial balance to account
./build/simd add-genesis-account alice 100000000stake \ --home ./private/.simapp \ --keyring-backend test
// Now include bootstrap transaction in genesis
./build/simd add-genesis-account alice 100000000stake \ --home ./private/.simapp \ --keyring-backend test
// Now we need to collect all genesis transaction
./build/simd add-genesis-account alice 100000000stake \ --home ./private/.simapp \ --keyring-backend testStep 5: Create blocks ./build/simd start \ --home ./private/.simapp Read Also | Build a Blockchain or dApp on Cosmos NetworkConclusionNow, a simple Cosmos node is running. In the next blog, we will focus on how to interact with this blockchain node. Connect with our blockchain developers today.
Vishal Yadav
31 May 2024
How to Create and Deploy an ERC404 token contract
ERC404 is a new concept in the realm of crypto token development that combines the functionality of NFT and ERC20 tokens. This is an experimental token and is not included under EIP, due to its experimental status project owner can do customization as per their need. This token will act as both ERC20 and NFT, it has two types of transfer function. In the first transfer function, only the receiver address and amount are passed which will be used to transfer fraction tokens (ERC-20 tokens), and in other transfer functions, a receiver address, ID, and the amount will be passed. To access the NFT, we can use the standard NFT function like setting the base URI, and getting the URI from the token ID. The major difference in this standard is that you get both the functionalities under same hood.See the example below to get an understanding of how ER404 works and how you can create your custom ERC404 token, for more about token standards, check out Unexplored ERC Token Standards On Ethereum.The Core Library for the ERC404 Libraryabstract contract ERC404 is Ownable2Step {
// Events
event ERC20Transfer(
address indexed from,
address indexed to,
uint256 amount
);
event Approval(
address indexed owner,
address indexed spender,
uint256 amount
);
event Transfer(
address indexed from,
address indexed to,
uint256 indexed id
);
event ERC721Approval(
address indexed owner,
address indexed spender,
uint256 indexed id
);
event ApprovalForAll(
address indexed owner,
address indexed operator,
bool approved
);
// Errors
error NotFound();
error AlreadyExists();
error InvalidRecipient();
error InvalidSender();
error UnsafeRecipient();
error Unauthorized();
error InvalidOwner();
// Metadata
/// @dev Token name
string public name;
/// @dev Token symbol
string public symbol;
/// @dev Decimals for fractional representation
uint8 public immutable decimals;
/// @dev Total supply in fractionalized representation
uint256 public immutable totalSupply;
/// @dev Current mint counter, monotonically increasing to ensure accurate ownership
uint256 public minted;
// Mappings
/// @dev Balance of user in fractional representation
mapping(address => uint256) public balanceOf;
/// @dev Allowance of user in fractional representation
mapping(address => mapping(address => uint256)) public allowance;
/// @dev Approval in native representaion
mapping(uint256 => address) public getApproved;
/// @dev Approval for all in native representation
mapping(address => mapping(address => bool)) public isApprovedForAll;
/// @dev Owner of id in native representation
mapping(uint256 => address) internal _ownerOf;
/// @dev Array of owned ids in native representation
mapping(address => uint256[]) internal _owned;
/// @dev Tracks indices for the _owned mapping
mapping(uint256 => uint256) internal _ownedIndex;
/// @dev Addresses whitelisted from minting / burning for gas savings (pairs, routers, etc)
mapping(address => bool) public whitelist;
// Constructor
constructor(
string memory _name,
string memory _symbol,
uint8 _decimals,
uint256 _totalNativeSupply,
address _owner
) Ownable(_owner) {
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _totalNativeSupply * (10 ** decimals);
}
/// @notice Initialization function to set pairs / etc
/// saving gas by avoiding mint / burn on unnecessary targets
function setWhitelist(address target, bool state) public onlyOwner {
whitelist[target] = state;
}
/// @notice Function to find owner of a given native token
function ownerOf(uint256 id) public view virtual returns (address owner) {
owner = _ownerOf[id];
if (owner == address(0)) {
revert NotFound();
}
}
/// @notice tokenURI must be implemented by child contract
function tokenURI(uint256 id) public view virtual returns (string memory);
/// @notice Function for token approvals
/// @dev This function assumes id / native if amount less than or equal to current max id
function approve(
address spender,
uint256 amountOrId
) public virtual returns (bool) {
if (amountOrId <= minted && amountOrId > 0) {
address owner = _ownerOf[amountOrId];
if (msg.sender != owner && !isApprovedForAll[owner][msg.sender]) {
revert Unauthorized();
}
getApproved[amountOrId] = spender;
emit Approval(owner, spender, amountOrId);
} else {
allowance[msg.sender][spender] = amountOrId;
emit Approval(msg.sender, spender, amountOrId);
}
return true;
}
/// @notice Function native approvals
function setApprovalForAll(address operator, bool approved) public virtual {
isApprovedForAll[msg.sender][operator] = approved;
emit ApprovalForAll(msg.sender, operator, approved);
}
/// @notice Function for mixed transfers
/// @dev This function assumes id / native if amount less than or equal to current max id
function transferFrom(
address from,
address to,
uint256 amountOrId
) public virtual {
if (amountOrId <= minted) {
if (from != _ownerOf[amountOrId]) {
revert InvalidSender();
}
if (to == address(0)) {
revert InvalidRecipient();
}
if (
msg.sender != from &&
!isApprovedForAll[from][msg.sender] &&
msg.sender != getApproved[amountOrId]
) {
revert Unauthorized();
}
balanceOf[from] -= _getUnit();
unchecked {
balanceOf[to] += _getUnit();
}
_ownerOf[amountOrId] = to;
delete getApproved[amountOrId];
// update _owned for sender
uint256 updatedId = _owned[from][_owned[from].length - 1];
_owned[from][_ownedIndex[amountOrId]] = updatedId;
// pop
_owned[from].pop();
// update index for the moved id
_ownedIndex[updatedId] = _ownedIndex[amountOrId];
// push token to to owned
_owned[to].push(amountOrId);
// update index for to owned
_ownedIndex[amountOrId] = _owned[to].length - 1;
emit Transfer(from, to, amountOrId);
emit ERC20Transfer(from, to, _getUnit());
} else {
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max)
allowance[from][msg.sender] = allowed - amountOrId;
_transfer(from, to, amountOrId);
}
}
/// @notice Function for fractional transfers
function transfer(
address to,
uint256 amount
) public virtual returns (bool) {
return _transfer(msg.sender, to, amount);
}
/// @notice Function for native transfers with contract support
function safeTransferFrom(
address from,
address to,
uint256 id
) public virtual {
transferFrom(from, to, id);
if (
to.code.length != 0 &&
ERC721Receiver(to).onERC721Received(msg.sender, from, id, "") !=
ERC721Receiver.onERC721Received.selector
) {
revert UnsafeRecipient();
}
}
/// @notice Function for native transfers with contract support and callback data
function safeTransferFrom(
address from,
address to,
uint256 id,
bytes calldata data
) public virtual {
transferFrom(from, to, id);
if (
to.code.length != 0 &&
ERC721Receiver(to).onERC721Received(msg.sender, from, id, data) !=
ERC721Receiver.onERC721Received.selector
) {
revert UnsafeRecipient();
}
}
/// @notice Internal function for fractional transfers
function _transfer(
address from,
address to,
uint256 amount
) internal virtual returns (bool) {
uint256 unit = _getUnit();
uint256 balanceBeforeSender = balanceOf[from];
uint256 balanceBeforeReceiver = balanceOf[to];
balanceOf[from] -= amount;
unchecked {
balanceOf[to] += amount;
}
// Skip burn for certain addresses to save gas
if (!whitelist[from]) {
uint256 tokens_to_burn = (balanceBeforeSender / unit) -
(balanceOf[from] / unit);
for (uint256 i = 0; i < tokens_to_burn; i++) {
_burn(from);
}
}
// Skip minting for certain addresses to save gas
if (!whitelist[to]) {
uint256 tokens_to_mint = (balanceOf[to] / unit) -
(balanceBeforeReceiver / unit);
for (uint256 i = 0; i < tokens_to_mint; i++) {
_mint(to);
}
}
emit ERC20Transfer(from, to, amount);
return true;
}
// Internal utility logic
function _getUnit() internal view returns (uint256) {
return 10 ** decimals;
}
function _mint(address to) internal virtual {
if (to == address(0)) {
revert InvalidRecipient();
}
unchecked {
minted++;
}
uint256 id = minted;
if (_ownerOf[id] != address(0)) {
revert AlreadyExists();
}
_ownerOf[id] = to;
_owned[to].push(id);
_ownedIndex[id] = _owned[to].length - 1;
emit Transfer(address(0), to, id);
}
function _burn(address from) internal virtual {
if (from == address(0)) {
revert InvalidSender();
}
uint256 id = _owned[from][_owned[from].length - 1];
_owned[from].pop();
delete _ownedIndex[id];
delete _ownerOf[id];
delete getApproved[id];
emit Transfer(from, address(0), id);
}
function _setNameSymbol(
string memory _name,
string memory _symbol
) internal {
name = _name;
symbol = _symbol;
}
}Note: You can use Openzeppelin for import libraries like ownable2step, pausable, ERC721, etc.The next step will be to inherit this library into the main contract to use the functionality.contract SampleToken is ERC404, Pausable, ReentrancyGuard {
string public baseTokenURI;
using Strings for uint256;
constructor(
address _owner,
uint256 _initialSupply,
uint8 _decimal
) ERC404("Sample", "SAMPLE", _decimal, _initialSupply, _owner) {
balanceOf[_owner] = _initialSupply * 10 ** _decimal;
}
function _mint(
address to
) internal override whenNotPaused{
return super._mint(to);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override virtual whenNotPaused returns (bool){
return super._transfer(from, to, amount);
}
function setTokenURI(string memory _tokenURI) public onlyOwner {
baseTokenURI = _tokenURI;
}
function setNameSymbol(
string memory _name,
string memory _symbol
) public onlyOwner {
_setNameSymbol(_name, _symbol);
}
function tokenURI(uint256 id) public view override returns (string memory) {
return bytes(baseTokenURI).length > 0 ? string.concat(baseTokenURI, id.toString(), ".json") : "";
}
}Now the contracts are ready, we can either use remix or hardhat for deployment over the network. After the deployment, the owner will get the initial supply of tokens. In the above example, mint is only overridden internally but not used after that, you can write your custom logic for minting NFT, and after that use that same mint function to mint NFT. For setting the base URI use the function "setTokenURI".Conclusion:This blog gives you a brief idea about ERC404 and how we can create a token with this Ethereum token standard, you can write your custom on top of this code base to add functionality like tax, whitelisting, blacklist, reflection mechanism, etc. Connect with our smart contract developers to get started with your project/token development.
Category:
Blockchain Development & Web3 Solutions
Vishal Yadav
31 Mar 2024
A Brief Introduction to the Intricacies of Dynamic NFTs
A dynamic NFT, or dNFT, is like a special kind of digital collectible that can change itself based on certain conditions. Regular NFTs are already popular online, with famous people creating their own collections using NFT development services. But now, dNFTs are the new thing. They can adapt and update themselves depending on what's happening around them. This makes them more flexible and opens up new possibilities. In this article, we'll explain what NFTs are, how dNFTs take them to the next level, and some ways people are using them.Also Read: AI and Blockchain Augmentation: The Future of Intelligent AutomationHow Dynamic NFTs are DifferentRegular NFTs are the usual ones you see, like digital art or game items. They're also used for making digital versions of real things like property deeds or patents. But there's a drawback – once these NFTs are made, their details can't be updated.For things like tokenizing real-world stuff or making games where progress matters, you need updates. That's where dynamic NFTs come in. They're like a mix of the regular ones and something that can change. So, a dynamic NFT is an NFT that can update itself based on certain conditions, thanks to some smart contract magic. This means it keeps its original identity but can also freshen up its details when needed.Developers interested in dNFTs should also explore tools like Chainlink Nodes that can bring real-world data to smart contracts.Since NFTs can be super unique and made in lots of different ways, they're kind of like customizable digital tokens. But here's the thing – most dynamic NFTs need to tweak their details so that regular folks can actually notice the changes.If you're working on smart contracts for dynamic NFTs, don't miss this checklist for better blockchain testing.Also, Explore | Unlocking Value: Exploring the World of NFT LendingUse casesDynamic NFTs can do more than just change their details. Let's say you find a secret spot in an augmented reality app – a dynamic NFT could be created as a reward. These NFTs can also have "hidden traits" that show up based on how people interact with them, not just in their details.In projects where art is created on the fly (like generative NFT art), each token has different traits, some rarer than others. These traits are saved in the NFT's metadata, which also includes a link to the image or video of the NFT.Interested in decentralized exchanges and evolving token standards? Here's a step-by-step guide to develop a DEX on BSC.Also, Explore | NFT-Based Loyalty Programs: Revamping Customer EngagementHere's another way metadata changes come in handy: when we turn real things into digital tokens. Think of it like this – if we make an NFT for a house, we'd want it to show stuff like when it was last fixed, how old it is, its value, and other details that might change. So, to make NFTs for these kinds of things work, they need to be able to update with new information.Bonus Read: Explore ERC-4626 Token Contracts for Yield-Bearing Vaults and understand how they fit into dynamic financial NFTs.Looking to build beyond NFTs? Discover Polygon (MATIC) and its scalable opportunitiesPlus, DeFi builders will want to know how to overcome slippage in decentralized finance – a key issue for evolving NFT-Fi use cases.
Category:
Blockchain Development & Web3 Solutions
Vishal Yadav
30 Nov 2023
A Quick Guide to Beacon Chain Ethereum 2.0
Ethereum 2.0, also known as Beacon Chain, represents a significant upgrade in the Ethereum blockchain development space. One of its key changes is the transition from proof of work to proof of stake consensus model, introducing validators instead of miners. Becoming an ETH2 validator requires a stake of 32 ETH, although staking pools offer alternatives for those with less ETH.Limitations of EthereumHigh Transaction FeesEthereum's proof of work consensus relies on miners and high-end hardware, leading to significant gas fees during peak hours, sometimes reaching hundreds of dollars per transaction.ScalabilityThe Ethereum network's capacity of around 15 transactions per second poses a scalability challenge, hindering user onboarding and project launches. Ethereum 2.0 aims to support thousands of transactions per second to address this limitation.SecurityEnsuring network security is paramount in a decentralized ecosystem. Ethereum 2.0 enhances security measures to mitigate various attacks, including the infamous 51% attack. By transitioning from proof of work to proof of stake, ETH2 aims to reduce energy consumption while maintaining network integrity.You may also like | Biggest Upgrade of Ethereum, Dencun (Deneb-Cancun) ExplainedWorkingProof of WorkIn Ethereum's proof of work model, miners validate transactions by expending substantial energy resources. This approach, while effective, consumes significant energy and is susceptible to 51% of attacks.Proof of StakeEthereum 2.0's proof of stake model eliminates miners, relying instead on validators who stake their ETH to secure the network. Validators are incentivized to validate transactions and are subject to a slashing mechanism, losing their stake if they attempt to attack the network.Also, Read | Exploring Token Standards Beyond EthereumSecurityProof of stake introduces a slashing mechanism to deter attacks, requiring attackers to control a significant portion of validators, which necessitates owning a large amount of liquidity.ConclusionEthereum 2.0 represents a crucial evolution for the Ethereum network, addressing key limitations while enhancing security and scalability. As a leading Blockchain Development Company based in Gurugram, we offer expertise in developing Ethereum projects. Contact our expert blockchain developers to discuss your requirements and leverage the potential of Ethereum 2.0.
Category:
Blockchain Development & Web3 Solutions
Vishal Yadav
23 Jun 2022
Avalanche: An Innovative Blockchain Offering Diverse Use Cases
Avalanche platform built by Avalabs is a decentralized proof of stake blockchain, it allows users to create their multifunctional blockchain and dApps using the smart contract.
Avalanche blockchain is designed to solve older blockchain platform limitations like slow transaction speed, centralization, and scalability. It uses a unique consensus protocol promising high throughput capabilities, low latency, and resistance to attacks.
Avalanche uses solidity language for smart contracts that allow Ethereum's projects to easily migrate to the avalanche platform.
Features
Avalanche is EVM compatible that allows Ethereum or similar EVM-based blockchain to be easily run on the avalanche blockchain. According to the creators, the blockchain can handle the order of 4,500 transactions per second. In comparison with other blockchains 7 transactions/second for bitcoin and 14 transactions/second for Ethereum, it can also achieve finality in 3 seconds. This makes the platform more suitable for massive calling dAppas.
Avalanche Consensus
Avalanche uses a proof of stake consensus mechanism. In the POW system blockchain depends on miners to mine new blocks or validate the transaction, in POS (proof of stake) instead of setting up expensive mining equipment users need to stake AVAX tokens to qualify as Validators.
Avalanche's Workings
Avalanche is built with three interoperable blockchains: Contract Chain (C-Chain), Exchange Chain (X-Chain), and Platform Chain(P-Chain).
X Chain: It is used for the creation of new assets like fungible and non-fungible tokens. AVAX token will be used to collateralize the assets.
C Chain: It is an EVM implementation that is used for smart contract development and deployment. The platform also provides a bunch of tools for developers to easily migrate applications to Avalanche.
P-Chain: It is used for creating subnets and coordinating validators. It is also responsible for hosting network Defi features like staking protocols.
"Snowman" consensus is used by both P-Chain and C-Chain that provides security for smart contracts. X-Chain uses DAG optimized consensus a scalable and secure protocol for achieving finality in seconds.
Connect with our blockchain development experts if you have a project in mind that you would like to discuss.
Vishal Yadav
21 May 2022
Using Merkle Proof for Whitelisting Your Token Mechanism
Introduction:
Cryptocurrency is one of the trending topics in recent times. People are moving toward blockchain technology and new project are continuously launching daily along with the utility token like ERC20, ERC721, and ERC1155 this gave the chances for users/investors to participate in projects at early stages but with these bad elements like hackers or whales get the chances to manipulate new tokens so whitelisting become one of the important features at the time of launch. If we store every user address at the smart contract level then it will take too many gas fees, especially for blockchain like Ethereum.
Merkle proof solves these problems by only needing to save one root key in the smart contract. It works by hashing the corresponding hash moving way up in the tree till the root hash is achieved. You can see more details for Merkle proof from the links in the reference section.
Merkle proof concept is not limited to whitelist only you can use this any way you want based on the requirement. Please see the below section to understand its works.
Step 1: Installing libraries and importing your files.
// Install Merkle proof js library. Run this command in the root folder of the project directory.
npm imerkletreejs
npm i keccak256
// Import in your javascript files using these codes.
const { MerkleTree } = require('merkletreejs')
const keccak256 = require('keccak256')
Step 2: Adding users' addresses and generating root keys.
// List of address that need to be whitelisted
const addresses = ['0x000000000000000000000000000000000000dEaD', '0x0000000000000000000000000000000000000000', '0x1234567890123456789012345678901234567890']
// Create an instance with Merkle proof.
const leaf nodes = addresses.map(addr =>keccak256(addr));
const tree = new MerkleTree(leafnodes, keccak256)
// This will generate the key that needs to be stored in smart contract
const root = tree.getRoot().toString('hex');
console.log("Root ",root);
Step 3: Generate leaf and proof
// Generating proof with leaf that will be passed to smart contract during the transaction.
// During transaction smart will also generate leaf with root and msg.sender address and verify the same
const proof = tree.getHexProof(leafnodes[0]);
Step 4: Integrate with smart contract.
// Import from Merkle proof library from openzeppelin.
import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
// Using inside contract function. merleRoot should be stored inside the contract either at deployment or later by the owner.
// Proof needs to be generated via frontend/backend and passed in the function parameter. The leaf will be generated by a smart contract to compare.
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(proof, merkleRoot, leaf), "INVALID PROOF");
Conclusion
Using this Merkle proof concept you can easily whitelist users without saving every user's details in the smart contract. This helps a lot in blockchain like Ethereum which charges too manyfees for transactions.
Reference:
https://medium.com/crypto-0-nite/merkle-proofs-explained-6dd429623dc5
https://ethereum.org/en/developers/tutorials/merkle-proofs-for-offline-data-integrity/
https://docs.openzeppelin.com/contracts/3.x/api/cryptography
Vishal Yadav
25 Feb 2022
Automatically create NFT images using HashLips art
Introduction:
Hashlips art engine is used to automatically generate the instance of multiple arts based on the different layers.
In order to generate the image, we need to upload the image layer/traits that the code will pick to generate art. In order to do that we need to create a folder named "layer" in the root directory of the project. Now suppose if we want tocreate art for the face we can create multiple folders like head, eye, nose, and ears inside the layer. Inside this folder, we can put a different images for eyes like blue, brown, black eyes.
Now code will use this randomly pick an image from each layer in order to create art. Also customizeorder by
Step 1: Project setup and installing dependency
//Clone project
git clone https://github.com/HashLips/hashlips_art_engine.git
// Install dependency
npm install
Step 2: Uploading images layers
Uploadall image layerlayers, folders as mentioned above.
Step 3: Configure setting
Now we need to configure the setting to generate art. Go to folder src/config.js and in layer configurations, we need to mention how much art you want to generate in "growEditionSizeTo" after that in "layersOrder" you need to mention which layer to use during the build process. You can also use different types of layers please see the example below.
const layerConfigurations = [
{
// Creates up to 10 artworks
growEditionSizeTo: 10,
layersOrder: [
{ name: "Eye" },
{ name: "Hair" },
{ name: "Mouth" },
{ name: "Nose" },
{ name: "Ear" },
{ name: "Headwear" },
],
},
{
// Creates an additional 40 artworks
growEditionSizeTo: 50,
layersOrder: [
{ name: "Eye" },
{ name: "Hair" },
{ name: "Mouth" },
{ name: "Nose" },
{ name: "Ear" },
{ name: "Headwear" },
{ name: "Mask" },
],
},
];
Step 4: Build images
npm run build // You can check all the generated images in the build folder.
Conclusion: Using this tool you can easily generate thousands of artworks in a few simple steps.
Vishal Yadav
27 Dec 2021
Security Analysis of your Smart Contracts using Mythx
The smart contract has been a key part to work with block-chain technologies like Ethereum, Binance, Matic, KCC, etc. In recent times we have seen that many old or new projects are moving towards blockchain to implement the business logic over block-chain. Both Ethereum and Bitcoin are two of the most famous blockchain but ethereum provided extra functionality of smart contracts using that users can implement their custom application logic over the blockchain. So for such implementation, Ethereum is most trusted by users followed by Binance, Matic, and others that also follow the same structure. Users can also create their custom tokens like ERC20, ERC721 over these networks.
Need to do the security analysis
Security is the main reason users move from a centralized approach to a decentralized one. You need to make sure smart contract has no issue but these smart contracts are written by humans and there are high chances that issues will be there. We have seen in the past where hackers exploit these bugs to steal funds like the DAO attack in June 2016 which cause a loss of $60 million and not even hacker sometime issues was there user face the bugs and platform loss millions of dollars like in case of parity wallet.
Solution
To solve these issues platform choose to do the auditing of smart contract but auditing is also done by humans that also has chances of error. So recommend method is along with audits you need to use any security analysis tool like Mythix. You can use mythix actually at the time of development. You can use these development tools like truffle where you can run scans at the time of compilation with just one single command.
Usage
First, you need to register over Mythx for an API key. Mythx provides both free versions and paid versions based on the tool you want to use.
Prerequisites
Python
Mythx API key
Step 1 Install Mythx CLI.
pip install mythx-cli
Step 2 Configure the Mythx by exporting.
//Private key obtained from Mythx dashboard
export MYTHX_API_KEY=PRV_KEY
Step 3 Scan contract.
Details: Mythx provide different type of scans like quick, deep, etc. In the free version,n only a quick scan is available but it also covers most of the things. The quick scan takes up to 30 seconds for a scan. Deep scans use various algorithms to do the complete analysis of contracts. It takes up to 50 minutes with a deep scan.
mythx analyze --async --mode quick path_for_contract
Conclusion
This blog gives you a brief overview of smart contract security issues and how to avoid them. Mythx can be further integrated with other tools like Remix, Vscode, Truffle. Please go to the link below to get more details about this.
Link: https://docs.mythx.io/
Vishal Yadav
27 Jul 2021
An Introduction to Casper Network and How to Set Up its Environment
Casper Network is a Proof of stake blockchain built over CBC Casper specification. Using a proof of stake architecture enables sharding a database scaling method. Businesses can use Casper for creating permissioned or private applications. The key feature that Casper provides is predictable gas fees, Upgradeable contracts, and WebAssembly.
The native coin of the Casper Network is CSPR. As PoS blockchain uses the validators to participate in consensus mechanisms for making it secure and uphold the network. So this CSPR coin is used to pay the validators as a reward, also users have to pay gas fees in CSPR for on-chain actions.
Currently, Casper Network is not live yet and their coin is available on the coin list for the initial sale.
In this blog, we are going to show to set up the environment for the Casper Network contract development. Currently, Casper uses Rust to write smart contracts like we use solidity with Ethereum/Binance.
Prerequisites:-
Rust
Cmake
Google Protobuf Compiler
Step 1: Install dependencies
cargo install cargo-casper
Step 2: Setup your Project. By using this command it will create a new project and its structure with a sample contract and its corresponding test cases.
cargo casper my-project
Step 3: Now you have the project set up at your end. You need to compile the contract and run the corresponding in order to test all things are working fine.
// Install required tools
cd contract
rustup install $(cat rust-toolchain)
rustup target add --toolchain $(cat rust-toolchain) wasm32-unknown-unknown
// Compile and create a build
cargo build --release
// Run test cases
cd ../tests
cargo test
Step 4: Once this sample code is working. You can use the code of this repository for standard ERC20 over Casper Network. Simply replace the main.rs and test folder from Repository.
Link: https://github.com/casper-ecosystem/erc20
Step 5: Install the Casper Client. This is a CLI tool that can be used to interact with blockchain and contracts.
curl -JLO https://bintray.com/casperlabs/debian/download_file?file_path=casper-client_0.9.3-0_amd64.deb
sudo apt install -y ./casper-client_0.9.3-0_amd64.deb
// For interacting with contracts
casper-client put-deploy --session-hash <HEX STRING> --session-entry-point <FUNCTION_NAME>
Conclusion: By following this blog you will get an idea about Casper and how we can create your contract over the network.
Vishal Yadav
27 Mar 2021
Migrating a Project from Ethereum to Binance Smart Chain
Ethereum has recently reached its all-time around $2036 and the increase in gas fees makes the DeFi protocols barely usable. DeFi protocol is one of the major reasons for the success of crypto in the year 2020 but is continuing to boom in 2021 but rising gas fees has been a concern for investors/traders and looking for alternatives with lower gas fees.Binance Smart ChainBinance Smart Chain (BSC) offers a compelling alternative by delivering similar functionality to Ethereum but with much lower gas fees. Unlike Ethereum's Proof of Work (PoW), BSC uses a hybrid mechanism of Delegated Proof of Stake (DPoS) and Proof of Authority (PoA), which makes it faster and more scalable. Ethereum plans to transition to Proof of Stake with ETH 2.0, but the full rollout could take years, leaving BSC as the more cost-effective option today.Ethereum disadvantage is acting as a growth factor for the Binance smart chain. Now several Defi projects are moving from ethereum to the Binance smart chain due to lower fees and high scalability. As a result, the price of the BNB token increased by more than 500 percent last month.Migrating a Project from Ethereum to Binance Smart ChainTo migrate your ethereum project from Ethereum to project you first have to convert your ethereum based asset in BNB.Suppose you have ERC20 running over the ethereum network and there are thousands of users. Now to convert/get that token over the binance chain you have to use a bridge where two versions of the token are held one is for the ethereum network and another one is for the Binance network. Now if one the user holds 20 tokens over ethereum then he can send those to the bridge and these tokens will be locked and the equivalent number of Binance versions will be provided to the user. The process will be the same if the user wants to convert from the Binance version to the Ethereum version.Currently, on a binance bridge, it supports a limited number of tokens but we can create a custom with the same logic.Once your main assets are moved now you can deploy the remaining contract over binance. Smart contract structure and deployment process, unit testing all the things are same over Binance smart chain as it is on Ethereum.For testing, you can use the remix browser with Metamask to deploy some test contracts. If you are using Metamask as a provider, you need to add a custom RPC that is provided over Binance official documentation.Below are some details that will help you in the processBinance testnet faucet(You can use your ethereum wallet in metamask just need to update the RPC):Faucet: https://testnet.binance.org/faucet-smartTestnet RPC: https://data-seed-prebsc-1-s1.binance.org:8545/ChainID Testnet: 97Like on Ethereum, we have Uniswap, on the Binance, we have Pancake Swap. It is similar to Uniswap but with some modifications.
Category:
Blockchain Development & Web3 Solutions
Vishal Yadav
26 Feb 2021