Best match

Most recent

DIS Introduced to Distinguish Human Interactions from Artificial Intelligence Zetrix, the Layer 1 blockchain platform by MY E.G. Services Berhad ("MYEG"), today announced the successful live deploymen

https://www.bing.com/th?id=OVFT.BKO504jrRAW71ZZTPd6a8S&pid=News

ZETRIX DEPLOYS W3C-COMPLIANT DIGITAL IDENTITY SERVICE ('DIS') AS XINGHUO INTERNATIONAL SUPERNODE GOES LIVE

https://www.bing.com/th?id=ODF.XZNn9HOnlY54H2MiwHL0lQ&pid=news

RYT9

EXCITING

THORChain, a thriving decentralized exchange and liquid decentralized finance protocol by measure of total value locked, intends to launch a feature called “Lending” later thi

THORChain Launching New Exciting Lending Feature

https://www.bing.com/th?id=ODF.xJeI9n0sq43e8acqzUtULA&pid=news

Inside Bitcoins

Middle East

Reef

Dubai, United Arab Emirates--(Newsfile Corp. - May 15, 2023) - Reef is thrilled to announce the launch of a $10 Million Accelerator Program for Web3 projects building on the Reef Chain ...

Reef Labs is Launching a $10M Accelerator Program to Empower Web3 Projects in the Middle East

Yahoo Finance

Metaverse-focused blockchain MultiversX ... browser as well as an Android experience that grants access to MultiversX-based sites. MultiversX aims to make Web3 interoperable and easily accessible ...

Crypto Browser Opera Integrates Layer 1 Blockchain MultiversX

CoinDesk

Stack

Infrastructure

Horizon, Saskatchewan

Horizon Blockchain Games ... Horizon says it “accelerates and simplifies web3 development and content creation, improves user experience, and makes web3 easy, fun, and accessible for everyone.”

Web3 Infrastructure: Polygon Labs, Horizon to Advance Sequence’s Wallet, Developer Stack on Polygon Supernets

Crowdfund Insider

Cross

Ecosystem

Wormhole

The Cross-Chain Ecosystem Fund is being managed and operated by Borderless Capital, a venture capital firm in the Web3 space. Backed by top blockchain protocols, infrastructure providers ...

Cross-Chain Ecosystem Fund raises $50M for Wormhole protocol

VentureBeat

It’s like the brash blockchain ... abstract geometric art using A.I. models under the name ArtGhost. DeMeter came to Stealcam fortuitously, having struggled to gain traction on established Web3 ...

‘Gamification Is the Vibe’: How This Web3 Platform Is Turning the NFT Trading Experience Into a Playful Game of Art Theft

Artnet

On Demand

Marketplace

Together, we’ll empower our joint customers with access to valuable data and analytics that will be crucial for the next wave of Web3 development ... of blockchain data. Cross-chain visibility ...

Blockchain Firm Flipside Launches On-Demand Data Offering for Enterprise on Snowflake Marketplace

The tl;dr here is that while Web3 sign-in is convenient and allows people to execute blockchain ... chain, of course, ensuring the benefits of decentralization are preserved." With Account ...

Navigating Risk In Web3 Is Hard – But Worth It

International Business Times

Enterprise

Access to Cross-Chain Data ... crucial for the next wave of Web3 development.” Enterprise Challenge and Solution The principal challenge enterprises have with blockchain is that while the ...

Flipside Launches Blockchain Industry’s First On-Demand Data Offering for the Enterprise on Snowflake Marketplace

Etherspot is an Account Abstraction SDK, delivering a frictionless Web3 user experience.

Etherspot

From Zero to Web3 Hero: Building a Multichain Dapp from Scratch

Etherspot Multichain SDK: Enabling Agile Web3 Development

Blockchain smart contract interactions and dApps (decentralised application) are becoming more advanced and interesting every week in the Web3 space. Exciting smart contract-based projects are emerging regularly but with the fast-paced environment there comes a challenge. That being, keeping up with the newest innovation and then coding for it efficiently. This is where Software Development Kits greatly assist builders to focus on their creative ideas for the products and dApps. They often allow projects to deploy their ideas in a matter of days instead of months of tedious preparation and infrastructure generation. Here’s an example, let’s say a project is interested in building a staking dApp. 6 months ago, that could have had some traction but now, if it is not able to service users coming from a multitude of EVM compatible chains, it may never garner much adoption. What is now required is hundreds of lines of code to integrate each desired blockchain. This is hugely time consuming and removes the developers focus from the app at hand. In this instance, such a project would benefit massively from building their app on top of an already established, reliable and effective SDK framework like . This removes the need for them to reinvent the wheel. Etherspot Rather they can integrate the quality, pre-written code that Etherspot SDK multichain framework provides for builders and offer their users a simplified, yet technically capable experience when using their products. What is Etherspot Exactly? Etherspot SDK is a blockchain development framework for EVM-compatible chains that creates direct state channel bridges to provide a seamless user experience across chains and wallets. With just one deposit, you can onboard your users to the entire multi-chain world of EVM compatible chains. This helps platforms save cost, time and increase user adoption. Etherspot is an open-source managed, free of charge, reliable multichain SDK which has been audited by for your peace of mind. Consensys Diligence Pain points in Web3 that Etherspot can help you avoid: Networking switching for every multichain connection Gas token requirements on the destination chain Splitting of dApps’ liquidity over multiple chains Custodial extensions for smart contract bridging solutions Complex user experience of Web3 products and more! Etherspot constantly strives to add functionality that assists in its mission to increase adoption in the Web3 space by abstracting the complexity away from your average user when interacting with decentralized apps (dApps) and services. Only once the crypto space is simplified enough for a non-tech-savvy user, will mass adoption take place. How Etherspot Simplifies Web3 Life Let’s take a look at more of the pain-points that Etherspot helps developers address through a particular use-case. This is just one of the many examples. Let’s say a DeFi yield farming project resides on one particular chain, for example, Polygon. In order for this project to access users from other chains, they would have to deploy on other chains thereby splitting their liquidity and resources to maintain the protocol on multiple chains. If they do not deploy on other chains, users coming from Ethereum mainnet or any other chain, for that matter, have an expensive and complex journey to take part in their protocol. The majority of users face major hurdles when attempting to stake into such projects cross-chain. Hurdles that often stop them from entering such positions. To take this example further, let’s imagine you have ETH on Mainnet and you want to reap the sweet rewards offered from the liquidity pair MaticX-MATIC on Polygon. This journey involves: Find the pool you wish to provide liquidity on. Find a secure bridge to get ETH onto Polygon as WETH (Ethereum gas fee involved) Switch RPC network in a wallet to Polygon Make sure you have MATIC for gas fees on Polygon. (Buy from a CEX or purchase with a credit card using a FIAT on-ramp) Fees involved Send to the wallet you wish to stake from (Polygon gas fee involved) Go to a DEX that supports Polygon chain and authorise WETH spending. Swap 50% of my remaining WETH for > MaticX Swap the rest for > MATIC Now go back to the LP protocol and stake into the LP pool. This is not helping with adoption… By projects employing the Etherspot SDK multichain framework their users are able to avoid these complex actions entirely, and get involved through following a vastly simplified 2 steps. Often users who come to a project with their assets on a separate chain have to go through at least 9 steps; interact with 3 separate platforms to bridge, swap and stake; acquire native tokens for gas fees on the destination chain; as well as the particular liquidity provision tokens (MaticX & MATIC in our example) and change RPC networks. All this in order to stake tokens on the platform. Etherspot is here to simplify your users' experience and to offer an out-the-box solution that allows developers to keep focussed on their products rather than building infrastructure. Etherspot Solutions: - by implementing Etherspot’s SDK, projects are able to attract users and funds from multiple EVM compatible blockchains without having to build the infrastructure or provide liquidity on each individual chain. Multichain infrastructure - this function means that users do not have to worry about acquiring native tokens to cover gas fees, for example, on Polygon if they are coming from another chain. Etherspot takes care of it. Meta-transactions -  dApps can use this to take care of all the required actions for the user in the background without them having to worry about the technicalities. For a user coming from another chain, this reduces the actions from 9 on-chain interactions down to 3, maximum 4, transaction signatures depending on wallet authorizations previously granted. Transaction batching - Etherspot automatically switches the blockchain network as the actions are implemented meaning that user, in-wallet, network switching becomes a thing of the past Network Switching - Quite often, due to blockchain network technicalities and congestion, transactions are known to fail. Relayers guarantee transactions are confirmed successfully by calls being resubmitted if the initial one fails. Etherspot will even take a hit and increase the gas price to ensure transactions confirm. Relayer Functionality - Etherspot makes utilising cross-chain messaging simple for dApp builders. Just add a few lines of code. Now users from other chains can interact and move cross-chain seamlessly from within your dApp. Cross-chain Messaging - Etherspot brings cross-chain capabilities to Superfluid’s integrated API. Now builders can access cross-chain programmable, composable and modular payment streaming, that can handle subscriptions, salaries, rewards and any composable stream of value, with continuous settlement and per-second netting for extreme capital efficiency. (only one gas fee on setup) Payment Streaming Read the technical details . here Additionally, developers can get a feel of exactly how the Etherspot SDK operates by going to the which is hosted on our testnet. From there, all the features can be interacted with and tried out. playground If you'd like to integrate Etherspot's SDK in your dApp or propose our team integrate your project, feel free to fill out and we will get back to you! this form All-in-all, Etherspot is fully managed & supported by engineers, designers, legal, financial, marketers and executives that believe in the refinement of the Ethereum vision and supporting teams to build the new world. Etherspot’s channels: | | | | Website Twitter Discord Github Medium

Blockchain technology has revolutionized our approach to transactions and data management. However, the complexity of blockchain development has made it difficult for non-blockchain developers to create decentralized applications ( ). As a result, there is a growing need for tools that simplify the development process and make it more accessible for those unfamiliar with blockchain. dApps That's why today we’re excited to introduce a prominent solution for this problem — . TransactionKit What is it? is the world’s first React library for fast and straightforward Web3 development created by . It is designed to help developers not familiar with blockchain technology and services to quickly and easily integrate blockchain functionality into their web applications. TransactionKit Etherspot It is a one-stop-shop solution for multichain smart contract wallets. self-custody Who can use it? Any dApp devs or front-end developers without deep blockchain knowledge. It abstracts complex blockchain operations and instructions by hiding them behind the React components, whilst leveraging the use of counter-factual smart contract wallets and a multichain relayer infrastructure provided by Etherspot. With TransactionKit, developers can: simply create and execute transactions; interact with smart contracts; transfer tokens; approval token transfers; deliver a seamless Web3 UX; manage digital assets without an in-depth understanding of the underlying blockchain technology; design freedom - TransactionKit doesn’t impose a UI on the developer; create dApps that are multichain by design (14+ blockchains are supported). Further, we will discuss how TransactionKit works, its benefits, and how it can be used to simplify Web3 development. Whether you are a seasoned crypto coder or a rookie blockchain developer attempting to include blockchain technology into your application, Etherpsot’s library has something to offer. So let's dive in and explore the world of multichain dApp development with TransactionKit. Why Etherspot's TransactionKit? Web3 development is a complex and challenging area requiring developers to understand blockchain technology, cryptography, and decentralized systems. The high barrier to entry and complexity associated with Web3 development have made it difficult for developers to create applications that can attract a more extensive user base. Consequently, such a level of complexity does not help with mass adoption, which is necessary for the growth and development of the industry. TransactionKit’s aim is to help developers onboard the next billion users. Benefits you get TransactionKit is the best way out of this problem. It provides a low barrier to entry, enabling developers to start building Web3 applications quickly. The library is easy to understand with universally understandable naming, simplifying the development process and making it easy to use. TransactionKit also doesn’t require you to sign up for various Web3 services, just plug (in a wallet) and play. One of TransactionKit’s design philosophies is to embrace the Web2 world, enabling developers who are used to working with traditional front-end libraries to transition to Web3 development easily. The library is extremely easy to install and get going - . It is well-structured and documented with various CodeSandbox’s ready to go. Even the library's error messages are helpful and will attempt to point you in the right direction. Developers do not have to worry about the intricacies of the technology but can instead focus on building powerful applications. npm i @etherspot/transaction-kit Features of dApps made with TransactionKit TransactionKit offers a range of features that make it a powerful tool for simplifying multichain dApp development. Some of its key features include the following: Injecting the full power of Etherspot into any React app Any React developer can incorporate Etherspot’s TransactionKit components into their code to gain access to a number of ready-made features. Some of these components include: <EtherspotUI /> This component enables seamless integration of the complete functionality of Etherspot into any React application. It takes a Web3 provider (i.e. your wallet), a chain ID (we support 14+ blockchains), and any child Ul components. Essentially, thanks to this component you can incorporate Etherspot's functionality, meaning you get access to a wide range of blockchain-related features. <EtherspotBatches /> The TransactionKit allows developers to batch multiple transactions into a single one. This reduces the number of activities required to perform a set of operations. Consequently, you provide faster and more efficient execution of transactions. All this can be achieved with the component. It can be skipped or given an ID, depending on your requirements. This component also returns transaction estimation data for all batches within it. <EtherspotBatches /> Using the component is a useful way to save on gas fees when sending multiple transactions. By grouping transactions into batches, you can optimize your gas usage and reduce costs. <EtherspotBatches /> <EtherspotTransaction /> is an essential component of the Etherspot library that enables the specification of Ethereum transactions. This tag requires the specification of a destination blockchain address and a value to be sent. Additionally, it can accept a data value for smart contract interaction and allows for the inclusion of any necessary UI components for customization. <EtherspotTransaction /> Using the component is a seamless way to initiate transactions on the Ethereum blockchain. Moreover, it enhances flexibility in customization by allowing the use of any UI components, making it more user-friendly. <EtherspotTransaction /> <EtherspotTokenTransferTransaction /> The component helps you facilitate the transfer of an asset (such as PLR. USDC or SHIB) to another account. You just need to specify the token address, the destination address, and the number of tokens you want to transfer to the destination address, and then we'll do the rest. <EtherspotTokenTransferTransaction /> <EtherspotApprovalTransaction /> The component authorizes the spending of an asset you own by another Smart Contract. This Smart Contract can serve any purpose but is usually associated with decentralized financial applications (also known as DeFi) such as Uniswap or Gamma. <EtherspotApprovalTransaction /> In other words, it's like giving your friend permission to spend some of your money within a certain limit. In this scenario, the friend is the Smart Contract mentioned above. Compatibility with various chains TransactionKit is compatible with a range of chains, including Ethereum, Polygon, Gnosis Chain, Binance Smart Chain, Fantom, Aurora, Avalanche, Optimism, Arbitrum, Moonbeam, Celo, Fuse, Arbitrum Nova. Base and Polygon zkEVM are coming soon. This ensures that developers have the flexibility to build decentralized applications on the blockchain of their choice. Ability to pay transaction fees with stablecoins In order to carry out a transaction on a blockchain, it is necessary to pay fees using the network's native token. However, this can pose a challenge for individuals who are unfamiliar with blockchain technology, as they must first acquire these tokens. That’s where Etherspot’s solution comes in handy. Users now can pay transaction fees with stablecoins, not just the native token of the blockchain they are using (ETH, BNB, etc.). This also allows them to avoid the high transaction fees associated with some blockchains (e.g., Ethereum) and can result in significant cost savings. Check out . TransactionKit CodeSandbox here Five Pillars of Web3 for TransactionKit The development of decentralized applications (dApps) on blockchain networks can be complex and time-consuming, with developers needing to manage accounts, transactions, and security measures. Etherspot aims to simplify the process with its TransactionKit library. TransactionKit is powered by Etherspot’s SDK. Built around five core product pillars, Etherspot’s SDK offers a range of features to suit the needs of different projects. Further, we will explore these points in detail and how they contribute to making Etherspot's tools valuable products for Web3 developers. Simplicity Etherspot’s SDK provides developers with TransactionKit - a clean and concise library for working with accounts and transactions, allowing them to focus on their application's logic rather than the Ethereum network's intricacies. At the same time, Etherspot’s team created a BUIDLer React component for plug & play integration. Flexibility Etherspot’s SDK provides developers with a range of tools and features for working with Ethereum accounts, including support for any Web3 provider and the ability to manage multiple accounts from a single interface. This flexibility makes it easy for developers to tailor their applications to their specific needs, whether they are building a simple decentralized application (dApp) or a complex smart contract. Security The SDK implements industry-standard security measures, including encryption to ensure that developers and their users are protected from potential threats. Scalability Etherspot SDK is designed to work seamlessly with different blockchains and Ethereum's layer 2 solutions, such as Optimism and Arbitrum (currently supports 14+ chains), allowing developers to build applications that can handle high volumes of transactions with minimal gas costs. This feature is essential for building dApps that can serve large user bases without sacrificing performance or security. Interoperability The SDK is designed to work with programming languages such as JavaScript and TypeScript, making it easy for developers to integrate Etherspot’s functionality into their existing codebases. In addition, the SDK supports popular Ethereum tools such as MetaMask and Infura, making it easy for Web3 coders to work with familiar tools and workflows. Give it a try Building a multichain dApp without blockchain experience may seem daunting, but now it is not impossible. With the right tools and knowledge, anyone can build a dApp that is secure, transparent, and decentralized. Following the steps outlined in , you can develop your own multichain dApp and join the growing community of decentralized applications. this documentation With its powerful features and easy-to-use structure, TransactionKit is the perfect tool for anyone looking to get started in the exciting world of blockchain development.

From Zero to Web3 Hero: creación de una Dapp multicadena desde cero

De zéro à Web3 Hero : créer une Dapp multichaîne à partir de zéro

ज़ीरो से वेब3 हीरो तक: स्क्रैच से एक मल्टीचैन डैप का निर्माण

ゼロから Web3 ヒーローまで: マルチチェーン Dapp をゼロから構築する

Do Zero ao Herói Web3: Construindo um Dapp Multichain do Zero

Từ Zero đến Web3 Hero: Xây dựng Dapp đa chuỗi từ đầu

从零到 Web3 英雄：从头开始构建多链 Dapp

167 Stories To Learn About Developer Tools

While some Web 2.0 businesses are already transforming their infrastructure by adding Web 3.0 elements, most ‘traditional’ internet-based companies and developers are still unaware of the whole Web 3.0 trend and how it can upgrade nearly any business. In this article, we thoroughly explain the differences between the web generations and why Web 3.0 is often called the internet of the future. We’ll answer the questions of what exactly is hampering the wide Web 3.0 adoption and how to get into the Web3 world easily and quickly. Web Generations Explained Web 1.0 vs. Web 2.0 Web 1.0 is the internet of the ’90s. Lots of articles and pages are linked together into one web. The only thing you could do was just to read these articles. That was the ultimate experience you could have. Web 2.0 is a step ahead, and we assume you know a lot about Web 2.0. It’s the internet you mostly use today. You interact with thousands of web pages, and social networks; you consume and create content yourself. If you are a web developer, you mostly create the structure of Web 2.0. Web 2.0 is a ‘read-write’ web, while the previous Web 1.0 is ‘read-only.’ That makes sense, right? In addition to that, advertising is a vast sector of Web 2.0 revenues. Partially, it shapes the logic of the current internet as a whole. Every page wants to grab your attention. Web 2.0 is a centralized, mostly non-anonymous structure. It was designed to safeguard users from ‘harmful’ content, but as we can often see, it's very hard to draw the line. Web 3.0 And Why It’s So Cool Web 3.0 is a network of smart contracts, decentralized apps, and organizations. Think of it more as a technological movement that revolutionizes the way our internet works. You can access Web 3.0 through special browser extensions, such as Brave, Osiris, etc. Some Web 3.0 apps can also be accessed from the traditional internet. Decentralization is the main strength of Web 3.0. No institution or government is regulating Web 3.0. Another huge advantage of Web 3.0 is anonymity. Most of the time, Web3 services won't collect any data about you. Without an extensive  ‘portfolio’ of every person, targeted advertising will fade away on the internet of the future. With the growth of Web 3.0, many Web 2.0 businesses are transforming some parts of their infrastructures to keep up with the newer standards. What is hampering Web3 adoption? However, when it comes to Web 3.0, not everything is as smooth as you may expect. Not user-friendly The ecosystem of Web 3.0 is still not very user-friendly, which might scare off many newcomers, both users and developers. For example, if you run your application on Ethereum mainnet, you may know that the gas prices are unpredictable and mostly very high. Every time you make a transaction, you basically overpay. That’s why many Web3 app developers build ways to switch to efficient Layer2 solutions. However, from the UI/UX point of view, the whole process is usually very convoluted. Setting up a wallet, connecting it to another chain, transaction signing,, bridging and many other complicated things can take a lot of effort and time for a non-tech savvy user to learn. Time-costly Since the Web3 space is fairly new, building an application requires lots of developer time. Think about how long it took to build a website in the 2000’s. A few months? And how long does it take now, in 2022? Thanks to the hundreds of website constructors that provide multiple layers of abstraction, it's a matter of hours. Now you don’t even need to code to build your website. Say it to a web developer from the past, and they wouldn’t believe you! Lack of tools & education As a developer, you’ve probably already encountered the absence of reliable tools in the Web3 space. Since the industry moves at unprecedented speeds, you should have a consistent toolkit that allows you to prototype ideas quickly and with frequent changes in mind. No one wants to build a whole new app with every minor network upgrade. Not only is it hard to find the right toolkit, but also learning about Web3 is not an easy task. Since the industry is pretty new, there are not a lot of educational platforms on the radar that offer extensive Web3 education. The educational wave in Web3 is only just on the rise. Just recently, its new course to learn the fundamentals of Web3 development. Also, offers a few courses on Web3. Web3 University started Coursera Solution? Since the above-described problems have been known for some time, there is a couple of companies that are trying to facilitate Web3 development through truly innovative solutions. In this article, we’ll take a look at three of them. Biconomy — is a platform for Web3 developers that takes care of multi-chain transactions infrastructure. It is being described as a ‘Next-Gen Multichain Relayer Protocol’ with the goal of making Web3 development easier. Currently, there are 2.1m unique users on the platform and 20.1M transactions. Biconomy Among other investors, Biconomy is backed by Binance and Coinbase, so there shouldn’t be questions about its reliability. The platform provides various Plug-n-play APIs to seamlessly integrate your dApp and ‘not break things’. There are several key features that Biconomy provides: Onboarding even without being crypto proficient — just using Javascript SDK, npm or CDN Free gasless transactions Simple & fast user onboarding to Layer 2 Pay gas in your favorite ERC20 token Instant cross-chain transactions between chains Always pay the correct gas fees and never overspend again No need to manually change RPC to connect and switch to L2s and EVM-compatible chains Apart from that, Biconomy describes itself as a blockchain and platform agnostic, supporting the always-growing number of chains. Etherspot The team behind the Pillar Wallet has created , an all-in-one, EVM-compatible platform that accelerates ideas and their execution. Etherspot Etherspot solves nearly all the problems that were described in the previous chapter. In fact, this is the only SDK you need to interact with the Ethereum multiverse quickly with minimal effort and cost. It literally makes Ethereum application development painless by easily deploying their SDK, you no longer have to re-invent the wheel when building. Here is a short overview of the fundamental features of Etherspot: Extremely fast app prototyping — hours instead of months Intelligent Smart Contract Management — automatically or manually Smart Contracts are owned by your application accounts and ensure that assets remain on-chain and secured Multichain Access — use one or all the chains simultaneously with the same address for greater flexibility and speed Off-chain Payment Hubs & Bridges for unlimited amounts Off-chain P2P transactions directly and at no cost Cross-chain messaging (for cross-chain swap and streaming) Meta-transactions (pay gas in any token) Save time and money with Transaction batching Guaranteed tx confirmations ensured by relayers Full NFT support Prototype & develop quickly with the ready-to-go, disposable playground, which allows technical teams to test-drive their ideas and products Use their Discord faucet for test tokens Extensive documentation by the Etherspot engineers and great community support Currently, Etherspot gives developers the freedom to use the following chains: Ethereum Mainnet Polygon Gnosis Chain Binance Smart Chain Fuse Phantom Moonbeam Aurora Avalanche Arbitrum Optimism Celo With Etherspot, you, as a developer or business owner, can focus on the most important thing — building your product and jack in insane functionality with their SDK. Sequence is claimed to be ‘the smartest Web3 wallet’. It is a non-custodial and user-friendly wallet with multi-chain support. Sequence What Sequence can do: Connect to Ethereum + EVM Chains Swap, trade, and bridge in the wallet Buy crypto with credit or debit Built-in smart security keeps your crypto safe Full NFT support Meta-transactions: users can pay for gas in any token Save time and money with batched transactions Multi-key security Conclusion As you can see, there are quite a few obstacles that the internet of the future must overcome before becoming widely used and appreciated. Since Web 3.0 is still in its early stages of development, it has lower accessibility than the regular Internet. Your business can still gain a massive competitive advantage by simply being the first.

Is Web3 (still) the Internet of the Future?

HackPedia: 16 Solidity Hacks/Vulnerabilities, their Fixes and Real World Examples

The introduction of the ERC-721 token made blockchain gaming a reality. However, games based on the blockchain have all suffered from long delay times and high costs associated with using the blockchain for all game processes…until now. Introducing EtherSparks, a new gaming experience based around the blockchain. EtherSparks is not bound by the same limitations of the games that came before it. Now you can play mini-games and battle other players in real time without having to pay gas, while still maintaining ownership of game items through blockchain security. It’s the best of both worlds. How Does it Work? As crypto enthusiasts and early adopters of the first blockchain games,, we quickly noticed something missing about them. While the ability to have ownership of non-fungible tokens on the blockchain is revolutionary, the limitations of decentralized networks makes a truly engaging gaming experience challenging. So what is it that makes a blockchain game successful? What do people like and dislike the most when they breed cats or fight robots on the Ethereum network? From those questions, we identified the following observations: Sounds obvious, but it’s critical. Any crypto-based gaming experience has to allow players to truly own their assets. Once secured on the blockchain, not even developers can alter a player’s collection without permission. Not just that, the blockchain lets everyone track the origins of every item to ensure no cheating is happening. Blockchain games are about owning things on the blockchain. Having loot generation occur on the blockchain ensures that everyone who plays is subject to the same randomization parameters. When items that are generated potentially have real value, that level of trust is important for players. Having provably fair random loot generation is important. When every action made requires players to pay for gas, the costs quickly pile up. Not only that, but having to constantly pay for gas limits the number of decisions in the gameplay mechanics. The high cost of gas is ultimately a drain on the economy of any crypto game. It’s essentially a fee for playing which cannot be reinvested to the game or its players. Most current games struggle to maintain a balanced economy as a result of having to pay these fees. Players don’t like having to constantly pay for gas. Existing blockchain games require players to wait for network confirmations for every action. Depending on the amount of gas they use, this can potentially take hours. Real-time gaming is therefore impossible and even turn based game mechanics have to be limited in scope. Players are looking for a faster-paced gaming experience. When we considered these observations, we came to a realization: players play blockchain games because token ownership is fair and secure. However, the blockchain is a poor environment for creating engaging gameplay. Thus EtherSparks was born! To solve these problems, we decided to create a game where gameplay elements will be processed on dedicated servers while loot generation and item ownership can still be secured on the blockchain. Players only have to pay gas and wait for confirmations when performing an action that modifies their collection. Playing games and other activities that don’t require the security of the blockchain can be done separately. This allows for the results and rewards to be integrated in a semi-decentralized manner. Sparks: What are They? Sparks are your pets and avatars in the world of EtherSparks. You can care for them, equip them, train them, and even fuse them together. They represent you when you play mini-games and fight for you in battles. Compete against other players to collect and raise the rarest and strongest Sparks. Battles! Many of the first games to come out on the Ethereum network were simply collectables. There wasn’t much you could do with the items you obtained except breed more or sell them. Later games which were developed advanced the concept to include battling with your collectibles. However, the nature of incorporating all the game logic onto the blockchain severely limited the number of game mechanics that were possible. Combat systems in current blockchain games are often simplistic with limited strategic offerings, not to mention the high gas costs that are often needed to even engage in battle. All this changes with EtherSparks. Since game logic is not processed on the blockchain, all the disadvantages these other game suffer from are not an issue. You don’t have to send all your moves at once like other blockchain games require, and you don’t have to pay gas to the network for every move you make. Engage in a fast-paced confrontation where the strength of your Sparks, the soundness of your strategy, and a little bit of luck all contribute to victory. Yet, at the end of the day, the victor’s spoils can still be secured on the blockchain Mini-Games! EtherSparks is not a game where you have to pay large amounts of ETH just to get started. Players can begin to earn Sparks and items by playing mini-games. This is one of the key differences between EtherSparks and other blockchain games. Play a variety of mini-games for free and earn rewards which you can use on loot crates to start or grow your collection. There’s no need for any ETH investment upfront, not even for gas, to start playing and earning! Core Nodes: Become a Part of EtherSpark’s Growth In addition to a completely revolutionary gaming experience, we are also offering something special for our players. Core nodes are a way for early investors as well as winners of special events and champions in tournaments to share in the success of EtherSparks. Core nodes represent a percentage of revenues generated from marketplace transactions. As EtherSparks becomes more popular and the number of transactions on the marketplace increases, the value of core nodes increases as well. As a reward for your support, participating in the pre-sale can earn you a permanent source of income that grows as the game does. How Can I Support EtherSparks? The best way to support EtherSparks is to participate in the pre-sale! During the presale, players can obtain special loot boxes which contain rare items and Sparks. These pre-sale loot boxes are unique and have a much higher probability of containing rare items than any loot boxes created thereafter. Not only that, but several core nodes will be scattered across the pre-sale loot boxes randomly. This is the only opportunity to open a core node from a loot box. If pre-sales aren’t your thing, then there is still a way you can support us. During the announcement phase, you can sign up for a referral link with your email and ethereum wallet ID. For each pre-sale purchase that is generated though your referral link, you be entitled to rewards which are sent to your wallet once the game launches! Want to stay in the loop? Sign up for Updates and check us out at http://ethersparks.io/ Take a look at the to see the full concept of EtherSparks and feel free to provide us with thoughts and feedback. This game is in the early stages of development and we are excited to move this project forward with your support. Whitepaper

Introducing EtherSparks: The Next Generation in Blockchain Gaming

All proceeds from the game will go toward building a real life mech-laser-horse. New to Etherbots? Check out our and launch article getting started guide. Wow. It’s been an insane 24 hours since launch. Etherbots has more than doubled the number and volume of CryptoKitty transactions. For a few hours Etherbots transactions represented . We’ve had robot parts ($18,000 USD), of individual duels, hit the front page of /r/ethereum, and a few lucky individuals have even forged our launch-exclusive body, never again available after 72 hours from launch. 5% of the entire Ethereum network selling for 21 ETH thousands A rare shadow Ancient Protector sold for 21 ETH 5 minutes before this piece was published. I’m writing this with my incredibly sleep-deprived, but incredibly excited team. This game has surpassed our wildest expectations — especially considering it’s the most ambitious game on the blockchain to date — and we’re stoked that people are loving it as much as we do. So… WHERE TO FROM HERE? We have a really exciting roadmap for the next month. International translations of the website in Chinese, Japanese, Korean and Russian. Launch on OPSkins/Wax.io, with of monthly unique visitors. millions Continual updates: weekly tournaments with massive prizes, and some secret content ;) Robot Unicorn ATTACK! As always, join our lively to chat to us directly. We’re awake for 20 hours of the day, and are content with the fact we’ll live much shorter because of it. ❤ discord See you in the arena. Our sleek battle interface, where you can browse past battles, watch it play out, and redeem valuable prizes after.

ETHERBOTS Launches, overtaking CryptoKitties in Transaction Volume (Again)

JOIN US! 8.00 PM PST, March 3rd. The grand launch is here! Since selling over $1M USD robots in our pre-sale in days, we have expanded and been working sleeplessly to make this game amazing. It is certainly the most ambitious blockchain game to date, and we’re proud to say thanks to the hard work of our developers (and our beloved beta testers on the Etherbots ), it has surpassed even our biggest expectations. ETHERBOTS Discord As huge fans of CryptoKitties, made us incredibly excited — and also gave us a sense of responsibility to make this game bloody incredible. We reckon we’ve done it. But don’t trust us, check it out for yourself. (We apologise to the Ethereum network in advance, because this is going to be huge.) overtaking their transaction volume during our presale But before we go on… … A CHALLENGER APPROACHES Does it come in black? The Ancient Protector will only be available for the first 72 hours after game launch. And if you’re the lucky first to win it — you’ll be labelled as its discoverer forever. Ever. People like rare things. CryptoKitties’ ‘Bug Cat’ was sold for last December. But ultimately, CryptoKitties only did it half right. It’s a beautiful proof-of-concept and a great collectible, but it lacks meaningful gameplay and competition. What use is ownership if you can’t do anything with it? 246 ETH So we thought to ourselves: what happens when you combine immutable digital scarcity and collectability with Win enough battles, and you might be lucky enough to find the Ancient Protector (or heaven forbid, a shadow or gold version) in a crate, and find out. actual strategic utility? So, what else will you find at launch? The most advanced and beautiful Ethereum Game to date. Period. Each robot part (melee, body, turret, defence) is an individual ERC-721 token fully owned by you. Build, battle and trade to your heart’s content. A fully featured, strategy-based battling system. It incorporates user’s perk trees, part rarity, elemental combinations and level, as well as their moves. (We’re so serious about strategy, we made a ). battle white paper A marketplace where you can hunt for the elusive “gold lambo” (…does it even exist?!) sweet Reward crates after battle, with the value increasing proportionate to how well you went, and how difficult your opponent was compared to you. every Forge parts of different rarity — from common, to rare shadow, to the elusive . legendary gold A beautiful profile page with unlockable achievements and perk-tree. Live notifications for in-game actions (when someone attacks you, etc…) OPSkins/Wax.io — COMING SOON Partners with OPSkins/Wax.io ETHERBOTS is the second ever ERC-721 based game to be featured on OPSkins, powered by . We’re working on integrating with their API and will be available on their site towards the end of March. WAX We want to bridge the market between mainstream gamers and crypto gamers, and bring the idea of to the masses. true digital ownership It’s time to stop letting game companies get away with non-transparent reward percentages, market manipulation, temporary “licensing” of ownership of in-game items, and abrupt changes which hurt the players. It’s time to bring power to the players. And do it in style ;) ETHERBOTS launches 8.00 PM PST March 3rd. Join us! See you in the arena.

ETHERBOTS GRAND OPENING - 72 Hr Limited Launch-Exclusive Part

Soon to be featured on our coding house wall. That sentence feels awesome — and a little crazy — to write. The public reaction to has been unreal since our launch. Players have bought over 1100 robot crates. The is thriving with users already hooked on perk trees, legendary Etherbots they received, and suggestions for tournament battle modes and wagering. We’ve even had users spend hours making game guides and beautiful infographics for fun. (The only downside is we’ve heard is how addictive the crates are to open). We’re iterating the contract as fast as we can to make the game insanely amazing and gorgeous. Etherbots discord We have some incredible fans. ❤ 24 Hour Transaction Volume on [Mon 11:58am] DappRadar I remember seeing CryptoKitties’ success a few months ago, when a Gen 0 “Bug Cat” sold for (then ~$60K USD). It seemed an absurd premium to pay for a set of layered images generated from a random string. But I didn’t realise two things. First: scarcity is a powerful force. And if that scarcity is immutably guaranteed by thousands of computers across the world, it becomes powerful indeed. 131 ETH very Secondly: up until now, users never owned their data, whether it was characters in computer games or information online. The idea of ownership of digital assets — being able to trade, send and use them at your whim and with no external control — The innocuous game about collecting cute kittens heralded an important social message: decentralised and trustless ownership is here, and it’s here to stay. It’s cheaper, immune to fraud or database errors, and gives you full autonomy — always. The popularisation of these tokens through games like CryptoKitties and Etherbots is not a fun gaming niche, either; it marks the beginning of tokenisation everywhere. complete is a fundamentally revolutionary one. We have the utmost respect for them (and use the ERC721 token they standardised), but ultimately CryptoKitties did it half right. It’s a beautiful proof-of-concept and a great collectible, but it lacks meaningful gameplay and competition. What use is ownership if you can’t do anything with it? The legendary gold horse mech, the hero of our artwork. Crossbow for silent assassinations. Bug lantern cause you’ll be LIT UP. Battling takes into account the level of your robot parts, their rarity and their element, but it also takes into account strategic moves you input which can drastically affect your chances against a tough opponent. Investing in a tree vertically can empower one move in comparison to others; allowing you to dominate — or even trick your opponent into thinking that you’ll use it! Etherbots has both in spades. Sneak peek at the Etherbots perk tree. Each perk can be unlocked with experience you earn in battle, which persists with your account. We want the user experience of our game to be a magical one. We want them to know the robot they own is special and unique to them ( ). And we want the decisions they make in the game to be important — rather than a cosmetic for a battle functionality which is ultimately a random outcome. which isn’t hard with over 2 million possible robots Check out some of our users finest crate openings below, or get your own at . But that’s enough talk. etherbots.io Bonus robots our players opened: To the moon. Choo choooo!

Etherbots overtakes CryptoKitties in Transaction Volume

Overview: What is Etherbots? is a decentralized application hosted on the Ethereum network. It’s a Robot Wars inspired game where you collect parts and weapons, forge dynamic robots, and use them to battle others on the platform. Level up and discover rare parts by winning duels in the arena. Win — and you might receive a rare gold flamethrower to roast your enemies. Lose, and you’ll be rewarded with a common frying pan (which is about as useful as it would be dropping in the middle of Pochinki). Etherbots There are over two-million unique possible robots to create, with the scarcity of each immutably guaranteed by the smart contract. We loved CryptoKitties, but thought it was missing something. Crypto collectibles are fun — and groundbreaking — but we thought just breeding was more of a proof-of-concept than true game functionality. We wanted battling with interactive elements, social leaderboards, and an ability to build and customise your creations (and boast about them). Ethereum provides a unique and incredibly powerful platform to combine the guaranteed scarcity of collectibles with the functionality and competitiveness of a fully fleshed-out game. Combine that with a bit of creative inspiration from the old tv show Robot Wars (Sir Killalot OP), and you’ve got Etherbots! Customizability — Over Two Million Unique Robots Each robot is fully customisable and interchangeable. If you hate your turtle robot body — (you ) — sell it on the market it and snap up a sexy Mech T-Rex. monster You can combine any of the parts in your inventory to make a robot which can be used for battle (and gain bonuses if they’re of the same element or rarity — read below!) Battle Functionality & Rewards — Randomness on the Blockchain (AKA Boring Tech Stuff) A well-studied and often poorly understood topic is how to generate a good source of randomness when the hardware which runs the code are decentralised and deterministic — they all need to end up with the same result. We wanted to implement a solution for probabilistic battling which was random, game-theoretically safe, fit in with the narrative of the site, and was gas-efficient (*cough* oracles *cough*). Users submit a private string of text of their choice, which acts as the “instructions” for their robot. This is a string of 0’s and 1’s 32 characters in length — allowing for over 4 billion permutations, kept secret from the other player via a commit/reveal scheme. (Players can randomly generate this if they want, but we suggest ingesting your favourite substance and chanting maniacally until you find one which feels ). Both battling player’s secret strings are used to generate a seed which neither party can know without knowing the other player’s instructions — forming the basis for the random/probabilistic part of their battle. This probability will matter less the greater the disparity between their combat effectiveness, obviously! This seed can also be used to securely generate reward probabilities for the winner within the same transaction. just right Levelling & Perk Trees Our team is very much in love with the Fallout series (particularly New Vegas — sorry Bethesda). The perk tree system presented in this series, and others such as Skyrim, allows a high degree of personalisation and customisability, while rewarding the experience of levelling. While selling your crates or won parts is a core functionality of the game, we also wanted to reward users who regularly battle and use the platform in order to motivate true engagement. Thus there are two forms of levels in Etherbots: 1. Account Level Your account level allows you to accumulate experience independent of the robots you use to battle overtime. It persists with your Ethereum account and allows you to unlock rewards according to a perk tree. Maybe you want to invest in your fire perk tree, benefiting the combat capabilities of fire parts you use in battle; this could influence the way you decide to keep and sell parts after battles, too. 2. Part Level When you battle, your parts gain a little bit of experience (and more if you win). This directly affects the combat capability of those parts. Levels are intrinsic to parts, and stay with them even when they’re sold. Rarity & Types — Set Bonuses If you collect enough parts of one elemental type or rarity, and combine them into a robot, you’ll gain enhanced combat powers for that bot. Get a robot of the same type rarity (say, a legendary golden, fire element Etherbot) — and gain the highest set bonus possible. and Robot Crates We wanted to distribute a small amount of initial parts to users in a way that was incredibly fun, fair and rewarding, and had an element of luck due to part rarity. Crates provide players with a sense of for unlocking rare robots. pride and accomplishment Why the pre-sale? Why not just launch the full game? It’s hard to get a game like this started; you need to distribute robots in a fair way, and provide some sort of intrinsic reward for those who take the risk of getting in early. The entire game benefits from network effects and communal engagement, and rewarding early adopters — thereby turning them into advocates and fans who were with you from the beginning — is one of the best ways to create a thriving community around this game. Besides, loot crates are fun (as long as you don’t ruin the functionality by relying on huge amounts of microtransactions like Battlefront). Opening a satisfying loot crate literally feels like Christmas. Think about the animation of opening one up on Overwatch or League of Legends. Sure it’s harder to do this in the browser than in a unity engine rendered video game, but we want you to feel incredible when you open up and find what parts you received in your crate. Also — our loot crates provide you at the *very worst* with a full set of 4 parts, everything you need to create your own robot and battle. And these crates are hard-capped at 3900 to be sold, ever — even after the presale. However, all good things must come to an end. We’ve time-locked the presale contract to end 15 Feburary, which is when the main game will launch. Etherbots Crate Presale is Live Now! The source code is verified on Etherscan. We recommend interacting with the contract using MetaMask and . https://etherbots.io A crate opened by a very lucky user. Two gold parts has a spawn chance of 0.25 (5% each). Shadow parts have a 10% chance. Developing Etherbots was a labour-intensive task. It’s a work of love of many people, and we are constantly looking to integrate as much community feedback as possible. Don’t hesitate to contact us at support@etherbots.io, and we almost always have someone manning the live chat on . etherbots.io Join us on for live updates. Discord

Etherbots.io Launch — Decentralized Robot Wars on the blockchain

Solidity events Solidity events are the closest thing to a “print” or “console.log” statement in Ethereum. We will explain how they work and when to use them. We will also go into a lot of technical details often omitted in other resources. Here is a minimal example to emit a solidity event. contract ExampleContract {

  // We will explain the significance of the indexed parameter later.
  event ExampleEvent(address indexed sender, uint256 someValue);

  function exampleFunction(uint256 someValue) public {
    emit ExampleEvent(sender, someValue);
  }
} Perhaps the most well-known events are those emitted by tokens when they are transferred. The sender, receiver, and amount are recorded in an event. ERC20 emit Transfer(from, to, amount); Isn’t this redundant? We can already look through the past transactions to see the transfers, and then we could look into the transaction calldata to see the same information. This is correct, one could delete events and have no effect on the business logic of the smart contract. However, this would not be an efficient way to look at history. Table of contents Solidity events Retrieving transactions faster Listening to events Solidity-indexed events vs non-indexed events Solidity events best practices Events cannot be used in functions How many arguments can an event take? Variable names in events are option but recommended Events can be inherited through parent contracts and interfaces Event selector Anonymous events Advanced topics about events Gas cost to emit solidity event Conclusion Retrieving transactions faster The Ethereum client does not have an API for listing transactions by “type,” for example “all transfer transactions of an ERC20.“ Here are your options if you want to query transactions: getTransaction getTransactionFromBlock API can only tell you what transactions occurred on a particular block, it cannot target a smart contract address multiple blocks. getTransactionFromBlock can only inspect transactions you know the transaction hash for. getTransaction Events on the other hand can be retrieved much more easily. Here are the Ethereum client options: events events.allEvents getPastEvents Each of these requires specifying the smart contract address that the querier wishes to examine and returns a subset (or all) of the events a smart contract emitted according to the query parameters specified. Here is the key insight for why you would use Events to track transactions rather than transactions themselves: Ethereum does not provide a mechanism to get all transactions for a smart contract, but it does provide a mechanism for getting all events from a smart contract. Why is this? Making events quickly retrievable requires additional storage overhead. If Ethereum did this for every transaction, this would make the chain considerably larger. With events, solidity programmers can be selective about what kind of information is worth paying the additional storage overhead for, to enable quick off-chain retrieval. Listening to events Here is an example of using the API described above. In this code, the client subscribes to events from a smart contract. These examples are all in Javascript. Example 1: Listening to ERC20 Transfer events. This code triggers a callback every time an ERC20 token emits a transfer Event. const { ethers } = require("ethers");

// const provider = your provider

const abi = [
  "event Transfer(address indexed from, address indexed to, uint256 value)"
];

const tokenAddress = "0x...";
const contract = new ethers.Contract(tokenAddress, abi, provider);

contract.on("Transfer", (from, to, value, event) => {
  console.log(`Transfer event detected: from=${from}, to=${to}, value=${value}`);
}); Example 2: Filtering an ERC20 approval for a specific address If we want to look at events retroactively, we can use the following code. In this example, we look to the past for Approval transactions in an ERC20 token. const ethers = require('ethers');

const tokenAddress = '0x...';

const filterAddress = '0x...';

const tokenAbi = [
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "name": "from",
        "type": "address"
      },
      {
        "indexed": true,
        "name": "to",
        "type": "address"
      },
      {
        "indexed": false,
        "name": "value",
        "type": "uint256"
      }
    ],
    "name": "Transfer",
    "type": "event"
  }
];

const tokenContract = new ethers.Contract(tokenAddress, tokenAbi, provider);

// this line filters for Approvals for a particular address.
const filter = tokenContract.filters.Approval(filterAddress, null, null);

tokenContract.queryFilter(filter).then((events) => {
  console.log(events);
}); If you wanted to look for a trade between two particular known addresses (if such a transaction exists), the ethers.js. code would be as follows: tokenContract.filters.Transfer(address1, address2, null); Here is a similar example in instead of ethers.js. Note that the and query parameters are added (to signify we only care about events between these blocks), and we will demonstrate the ability to listen to multiple addresses being the sender. The addresses are combined with the "OR" condition. web3.js fromBlock toBlock const Web3 = require('web3');

const web3 = new Web3('https://rpc-endpoint');
const contractAddress = '0x...'; // The address of the ERC20 contract
const contractAbi = [
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "name": "from",
        "type": "address"
      },
      {
        "indexed": true,
        "name": "to",
        "type": "address"
      },
      {
        "indexed": false,
        "name": "value",
        "type": "uint256"
      }
    ],
    "name": "Transfer",
    "type": "event"
  }
];
const contract = new web3.eth.Contract(contractAbi, contractAddress);

const senderAddressesToWatch = ['0x...', '0x...', '0x...']; // The addresses to watch for transfers from

const filter = {
  fromBlock: 0,
  toBlock: 'latest',
  topics: [
    web3.utils.sha3('Transfer(address,address,uint256)'),
    null,
    senderAddressesToWatch,
  ]
};

contract.getPastEvents('Transfer', {
  filter: filter,
  fromBlock: 0,
  toBlock: 'latest',
}, (error, events) => {
  if (!error) {
    console.log(events);
  }
}); Solidity-indexed events vs non-indexed events The example above works because the Approve (and Transfer) event in ERC20 sets the sender to be indexed. Here is the ERC20 Approval event declaration in Solidity. event Approval(address indexed owner, address indexed spender, uint256 value); If the “owner” argument was not indexed, the javascript code earlier would silently fail. The implication here is that you cannot filter for ERC20 events that have a specific (token amount) for the transfer, because that is not indexed. You must pull in all the events and filter them javascript side; it cannot be done in the Ethereum client. value An indexed argument for an event declaration is called a . topic Solidity events best practices The generally accepted best practice for events is to log them whenever a potentially consequential state change happens. Some examples include: Changing the owner of the contract Moving ether Conducting a trade Not every state change requires an event. The question the Solidity developers should ask themselves is “would someone have an interest in retrieving or discovering this transaction quickly?” Index the right event parameters This will requires some subjective judgement. Remember, an unindexed parameter cannot be searched for directly, but still might be useful data when accompanied by an indexed parameter. A good way to get an intuition for this is to look at how established codebases design their events Gnosis Safe Uniswap ERC20 Specification ERC721 Specification As a general rule of thumb, cryptocurrency amounts should not be indexed, and an address should be, but this rule should not be applied blindly. Indexes only allow you to quickly get exact values, not a range of values. Avoid redundant events An example of this would be adding an event when tokens are minted because underlying libraries already emit this event. Events cannot be used in view functions Events are state changing; they alter the state of the blockchain by storing the log. Therefore, they cannot be used in view (or pure) functions. Events are not as useful for debugging the way console.log and print are in other languages; because events themselves are state-changing, they are not emitted if a transaction reverts. How many arguments can an event take? For unindexed arguments, there is no intrinsic limit to the number of arguments, though of course there are contract size and gas limits that apply. The following nonsensical example is valid solidity: contract ExampleContract {
  event Numbers(uint256, uint256, uint256, uint256, uint256, uint256, uint256, uint256);
} Similarly, there is no intrinsic limit to the length of strings or arrays stored in a log. However, there cannot be more than three indexed arguments (topics) in an event. An anonymous event can have 4 indexed arguments (we will cover this distinction later). An argument with zero events is also valid. Variable names in events are optional but recommended The following events behave identically event NewOwner(address newOwner);
event NewOwner(address); In general, including the variable name would be ideal because the semantics behind the following example are very ambiguous (this is not how you should declare events!) event Trade(address,address,address,uint256,uint256); We can guess that the addresses correspond to the sender, and the token addresses, while the uint256es correspond to the amounts, but this is hard to decipher. It is conventional to capitalize the name of an event, but the compiler does not require it. This would be a much better declaration: event Trade(address trader, address token1, address token2, uint256 token1Amount, uint256 token2Amount); Events can be inherited through parent contracts and interfaces When an event is declared in a parent contract, it can be emitted by the child contract. Events are internal and cannot be modified to be private or public. Here is an example: contract ParentContract {
  event NewNumber(uint256 number);

  function doSomething(uint256 number) public {
    emit NewNumber(number);
  }
}

contract ChildContract is ParentContract {
  function doSomethingElse(uint256 number) public {
    emit NewNumber(number); // valid
  }
} Similarly, events can be declared in an interface and used in the child, as in the following example. interface IExampleInterface {
	event Deposit(address indexed sender, uint256 amount);
}

contract ExampleContract is IExampleInterface {
	function deposit() external payable {
		emit Deposit(msg.sender, msg.value); // also valid
	}
} Event selector The EVM (Ethereum Virtual Machine) identifies events with the keccak256 of their signature. For solidity versions 0.8.15 or higher, you can also retrieve the selector using the .selector member. pragma solidity ^0.8.15;
contract ExampleContract {

    event SomeEvent(uint256 blocknum, uint256 indexed timestamp);

    function selector() external pure returns (bool) {

        // true
        return SomeEvent.selector == keccak256("SomeEvent(uint256,uint256)");
    }
} The event selector is actually a topic itself (we will discuss this further in a later section). Marking variables as indexed or not does not change the selector. Anonymous events Events can be marked as anonymous, in which case they will not have a selector. This means that client-side code cannot specifically isolate them as a subset like our earlier examples. The only way for client-side code to see an anonymous event is to get all events for the smart contract. pragma solidity ^0.8.15;
contract ExampleContract {

    event SomeEvent(uint256 blocknum, uint256 timestamp) anonymous;

    function selector() public pure returns (bool) {

        // ERROR: does not compile, anonymous events don't have selectors
        return SomeEvent.selector == keccak256("SomeEvent(uint256,uint256)");
    }
} Because the event signature is used as one of the indexes, an anonymous function can have four indexed topics, since the function signature is “freed up” as one of the topics. An anonymous event can have up to four indexed topics. A non-anonymous event can have up to three. contract ExampleContract {

    // valid
    event SomeEvent(uint256 indexed, uint256 indexed, address indexed, address indexed) anonymous;
} Anonymous events are rarely used in practice. Advanced topics about events This section describes events at the assembly level of the EVM. This section can be skipped for programmers new to . blockchain development Implementation detail: Bloom filters To retrieve every transaction that has happened with a smart contract, the Ethereum client would have to scan every block, which would be an extremely heavy I/O operation; but Ethereum uses an important optimization. Events are stored in a data structure for each block. A Bloom Filter is a probabilistic set that efficiently answers if a member is in the set or not. Instead of scanning the entire block, the client can ask the bloom filter if an event was emitted in the block. This allows the client to scan the blockchain much faster to find events. Bloom Filter Bloom Filters are probabilistic: they sometimes incorrectly return that an item is a member of the set even if it isn’t. The more members that are stored in a Bloom Filter, the higher the chance of error, and the larger the bloom filter must be (storage wise) to compensate for this. Because of this, Ethereum doesn’t store all the transactions in a Bloom Filter. There are far fewer events than there are transactions. This keeps the storage size on the blockchain manageable. When the client gets a positive membership response from a bloom filter, it must scan the block to verify the event took place. However, this will only happens for a tiny subset of blocks, so on average the Ethereum client saves a lot of computation by checking the bloom filter for event presence first. Yul Events In the Yul intermediate representation, the distinction between indexed arguments (topics) and unindexed arguments becomes clear. The following yul functions are available for emitting events (and their EVM opcode bears the same name). The table is copied from the with some simplification. yul documentation op code Usage log0(p, s) log without topics and data mem[p…(p+s)) log1(p, s, t1) log with topic t1 and data mem[p…(p+s)) log2(p, s, t1, t2) log with topics t1, t2 and data mem[p…(p+s)) log3(p, s, t1, t2, t3) log with topics t1, t2, t3 and data mem[p…(p+s)) log4(p, s, t1, t2, t3, t4) log with topics t1, t2, t3, t4 and data mem[p…(p+s)) A log can have up to 4 topics, but a non-anonymous solidity event can have up to 3 indexed arguments. That is because the first topic is used to store the event signature. There is no opcode or Yul function for emitting more than four topics. The unindexed parameters are simply abi encoded in the memory region [p…(p+s)) and emitted as one long byte sequence. Recall earlier that there was no limit in principle for how many unindexed arguments an event in Solidity can have. The underlying reason is that there is no explicit limit on how long the memory region pointed to in the first two parameters of the log op code takes. There is of course, limits provided by the contract size and memory expansion gas costs. Gas cost to emit solidity event Events are substantially cheaper than writing to storage variables. Events are not intended to be accessible by smart contracts, so the relative lack of overhead justifies a lower gas cost. The formula for how much gas an event costs is as follows ( ): source 375 + 375 * num_topics + 8 * data_size + mem_expansion cost Each event costs at least 375 gas. An additional 375 is paid for each indexed parameter. A non-anonymous event has the event selector as an indexed parameter, so that cost is included most of the time. Then we pay 8 times the number of 32 byte words written to the chain. Because this region is stored in memory before being emitted, the memory expansion cost must be accounted for also. In general, the intuition that the more you log the more you pay in gas, is accurate. Conclusion Events are for clients to quickly retrieve transactions that may be of interest. Although they don’t alter smart contract functionality, they allow the programmer to specify which transactions should be quickly retrievable. This makes it easier for dapps to quickly summarize important information. Events are relatively cheap gas-wise compared to storage, but the most important factor in their cost is the number of indexed parameters, assuming the coder does not use an inordinate amount of memory. Learn More Like what you see here? See our advanced to learn more. Solidity Bootcamp The lead image for this article was generated by HackerNoon's AI Image Generator via the prompt "Events in Solidity"

Solidity Events: A Comprehensive Overview

Eventos de solidez: una descripción completa

Événements Solidity : un aperçu complet

सॉलिडिटी इवेंट्स: एक व्यापक अवलोकन

Solidity イベント: 包括的な概要

Solidity Events: Uma Visão Abrangente

Sự kiện Solidity: Tổng quan toàn diện

Solidity 事件：全面概述

In a previous , we discussed the importance of verifying Solidity smart contracts before deploying them onto the blockchain. However, there is a way to automate that process and make it more efficient. blog post With the help of Hardhat, a popular development environment for Ethereum, developers can now verify their smart contract code programmatically as part of the deployment process. This means the verification process can be integrated into the development pipeline, ensuring the code is verified automatically each time the contract is deployed. This blog post will explore how to use Hardhat to verify smart contract codes and streamline the verification process programmatically. Hardhat Runtime Environment HRE stands for Hardhat Runtime Environment. It provides a robust set of tools and APIs that can be used to verify the correctness of a smart contract code programmatically. Verification is an essential step in the development process of smart contracts, as it ensures that the code behaves as intended and is secure. Verifying Smart Contracts Programmatically To programmatically verify a smart contract with HRE, we should use a plugin called in combination with the HRE subtask . hardhat-etherscan verify:verify To verify the smart contract automatically, we need to pass: the network name that we can get from the Hardhat Network addon; smart contract address, constructor arguments. We should wait for the deployment transaction to be finished to avoid problems when verifying a smart contract that hasn't been deployed yet. Let's now put it all together in a Hardhat script. import hre, { network, ethers } from "hardhat";

async function main() {
  const SaveNumber = await ethers.getContractFactory("SaveNumbero");

  const number = 6;

  const saveNumber = await SaveNumber.deploy(number);

  await saveNumber.deployed();

  console.log(`SecretNumber deployed to ${saveNumber.address}`);

  try {
    console.log("\nEtherscan verification in progress...");
    await saveNumber.deployTransaction.wait(6);
    await hre.run("verify:verify", {
      network: network.name,
      address: saveNumber.address,
      constructorArguments: [number],
    });
    console.log("Etherscan verification done. ✅");
  } catch (error) {
    console.error(error);
  }
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
}); TL;DR Automated smart contract verification with HRE provides a much more streamlined and efficient way to verify smart contract code than manually verifying it from the terminal. It saves time and reduces the chances of errors compared to manual verification from the terminal. Links How Hardhat Simplifies Smart Contract Verification on Ethereum Hardhat Runtime Environment (HRE) documentation hardhat-verify

How to Programmatically Verify Solidity Smart Contract Code With Hardhat

Building an Ethical Text-to-Image AI-Art Site That Pays Royalties to Original Creators

Decentralized finance (DeFi) has been revolutionizing the financial industry, with Ethereum at the core of this transformation. In this guide, we'll walk you through the process of creating a simple DeFi protocol on Ethereum using Hardhat, a powerful development environment for Ethereum. By the end of this tutorial, you'll have a basic understanding of the tools and techniques required to build your own DeFi protocol. : This article is for educational purposes only. Do not use this information to build a real-world DeFi protocol without proper research, security audits, and legal advice. Disclaimer Prerequisites: To follow this tutorial, you'll need: A basic understanding of blockchain technology and Ethereum Familiarity with the Solidity programming language Node.js installed on your computer An Ethereum wallet, such as MetaMask Set up the development environment: We'll use Hardhat, a popular development environment for Ethereum. To install Hardhat, open your terminal and run: npm install --global hardhat Create a new Hardhat project: Navigate to your desired project folder and run: npx hardhat Select "Create an empty hardhat.config.js" to create a new Hardhat project. Install necessary packages: To interact with Ethereum, you'll need the following packages: npm install --save-dev @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle ethereum-waffle chai Update hardhat.config.js: Add the following code to your file to configure the Hardhat project: hardhat.config.js require("@nomiclabs/hardhat-ethers");

module.exports = {
  solidity: "0.8.4",
}; Write the smart contract: In the "contracts" folder, create a new file called . This file will contain the Solidity code for our DeFi protocol. Here's an example contract: SimpleDeFi.sol // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

contract SimpleDeFi {
  using SafeERC20 for IERC20;
  IERC20 public token;
  address public owner;

  constructor(address _token) {
    token = IERC20(_token);
    owner = msg.sender;
  }

  function deposit(uint256 amount) external {
    require(amount > 0, "Amount must be greater than zero");
    token.safeTransferFrom(msg.sender, address(this), amount);
  }

  function withdraw(uint256 amount) external {
    require(token.balanceOf(address(this)) >= amount, "Insufficient balance");
    require(msg.sender == owner, "Only owner can withdraw");
    token.safeTransfer(owner, amount);
  }
} This simple DeFi protocol allows the owner to deposit and withdraw ERC20 tokens. Write and run tests: In the "test" folder, create a new file called . Write tests to ensure the smart contract behaves as expected: SimpleDeFi.test.js const { expect } = require("chai");

describe("SimpleDeFi", function () {
  let SimpleDeFi, simpleDeFi, Token, token, owner, addr1;

  beforeEach(async () => {
    Token = await ethers.getContractFactory("ERC20Mock");
    token = await Token.deploy();
    await token.deployed();

    SimpleDeFi = await ethers.getContractFactory("SimpleDeFi");
    simpleDeFi = await SimpleDeFi.deploy(token.address);
    await simpleDeFi.deployed();

    [owner, addr1] = await ethers.getSigners();
  });

  describe("Deployment", () => {
    it("Should set the correct owner", async () => {
      expect(await simpleDeFi.owner()).to.equal(owner.address);
    });

    it("Should set the correct token", async () => {
      expect(await simpleDeFi.token()).to.equal(token.address);
    });
  });

  describe("Deposit and Withdraw", () => {
    it("Should deposit tokens to the contract", async () => {
      const amount = ethers.utils.parseEther("100");
      await token.transfer(owner.address, amount);
      await token.connect(owner).approve(simpleDeFi.address, amount);

      await simpleDeFi.connect(owner).deposit(amount);
      expect(await token.balanceOf(simpleDeFi.address)).to.equal(amount);
    });

    it("Should allow the owner to withdraw tokens", async () => {
      const depositAmount = ethers.utils.parseEther("100");
      const withdrawAmount = ethers.utils.parseEther("50");

      await token.transfer(owner.address, depositAmount);
      await token.connect(owner).approve(simpleDeFi.address, depositAmount);

      await simpleDeFi.connect(owner).deposit(depositAmount);
      await simpleDeFi.connect(owner).withdraw(withdrawAmount);

      expect(await token.balanceOf(simpleDeFi.address)).to.equal(depositAmount.sub(withdrawAmount));
      expect(await token.balanceOf(owner.address)).to.equal(withdrawAmount);
    });

    it("Should not allow non-owners to withdraw tokens", async () => {
      const depositAmount = ethers.utils.parseEther("100");

      await token.transfer(owner.address, depositAmount);
      await token.connect(owner).approve(simpleDeFi.address, depositAmount);

      await simpleDeFi.connect(owner).deposit(depositAmount);

      await expect(simpleDeFi.connect(addr1).withdraw(depositAmount)).to.be.revertedWith("Only owner can withdraw");
    });
  });
}); Run the tests: In the terminal, execute the following command to run the tests: npx hardhat test This will execute the tests and show the results. Deploy the smart contract: Create a deployment script in the "scripts" folder. Name it and add the following code: deploy.js async function main() {
  const Token = await ethers.getContractFactory("ERC20Mock");
  const token = await Token.deploy();
  await token.deployed();
  console.log("Token deployed to:", token.address);

  const SimpleDeFi = await ethers.getContractFactory("SimpleDeFi");
  const simpleDeFi = await SimpleDeFi.deploy(token.address);
  await simpleDeFi.deployed();
  console.log("SimpleDeFi deployed to:", simpleDeFi.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  }); To deploy the smart contract, run the following command: npx hardhat run scripts/deploy.js Interact with the DeFi protocol: You can use Hardhat's console to interact with the deployed DeFi protocol. First, create a script in the "scripts" folder with the following code: console.js const hre = require("hardhat");

async function main() {
  const [owner, addr1] = await hre.ethers.getSigners();
  const tokenAddress = "YOUR_TOKEN_ADDRESS";
  const simpleDeFiAddress = "YOUR_SIMPLEDEFI_ADDRESS";

  const Token = await hre.ethers.getContractFactory("ERC20Mock");
  const token = Token.attach(tokenAddress);

  const SimpleDeFi = await hre.ethers.getContractFactory("SimpleDeFi");
  const simpleDeFi = SimpleDeFi.attach(simpleDeFiAddress);

  // Example: Deposit tokens
  const depositAmount = hre.ethers.utils.parseEther("100");
  await token.connect(owner).approve(simpleDeFi.address, depositAmount);
  await simpleDeFi.connect(owner).deposit(depositAmount);

  // Example: Check the contract's token balance
  const balance = await token.balanceOf(simpleDeFi.address);
  console.log("Contract balance:", hre.ethers.utils.formatEther(balance));
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  }); Don't forget to replace and with the actual addresses from your deployment. YOUR_TOKEN_ADDRESS YOUR_SIMPLEDEFI_ADDRESS Run the script using the following command: console.js npx hardhat run scripts/console.js You can modify the script to interact with your DeFi protocol in different ways, such as depositing, withdrawing, and checking balances. console.js Conclusion: In this tutorial, we've shown you how to create a simple DeFi protocol on Ethereum using Hardhat. We covered the basics of setting up a Hardhat project, writing a smart contract, testing, deploying, and interacting with the deployed contract. This is just the beginning; you can now extend and modify this basic DeFi protocol to create more complex and feature-rich financial applications on the Ethereum blockchain.

Creating a Simple DeFi Protocol on Ethereum with Hardhat: A Step-by-Step Guide

How to Create an NFT (Digital Collectible) for Thanking Fans

The is one of the most promising blockchain networks that enable interoperability between different blockchain platforms, and it's becoming increasingly important for developers to understand how to build and deploy smart contracts on this network. Cosmos network are self-executing contracts with the terms of the agreement written directly into code. They are a vital component of decentralized applications and are crucial for creating trustless and transparent systems. As the demand for decentralized applications rises, understanding and using smart contracts is a prerequisite skill for developers building and developing applications in Web3. Smart contracts Does the cosmos support smart contracts? Yes. In this tutorial, we will learn about the Cosmos ecosystem and how to build and deploy a smart contract on the cosmos network. Understanding the Cosmos Network The engine powers the independent, parallel blockchains that make up the decentralized Cosmos Network. The Cosmos Network aims to build a decentralized network of interconnected blockchains that can expand and cooperate, facilitating the exchange of data and value between various blockchain platforms. Tendermint Core consensus Tendermint is a Byzantine Fault Tolerant (BFT) consensus engine that enables fast and secure transaction processing. It allows a group of to agree on the state of the network through a voting procedure. Tendermint enables quicker transaction processing than conventional proof-of-work consensus methods, such as those employed by Bitcoin and Ethereum (Now Proof of Stake). validators The Cosmos Network's use of the Inter-Blockchain Communication (IBC) protocol is crucial. Interoperability across several blockchain systems is made possible by IBC, which enables the transfer of value and data between various blockchains in the Cosmos Network. Additionally, the Cosmos Network features a hub-and-spoke architecture that enables the development of standalone blockchains (spokes) that can communicate with the Cosmos Hub (the hub). Data and currency can be exchanged between the various blockchains in the network thanks to the Cosmos Hub, which acts as the network's hub. Scalability, security, and interoperability are just a few of the Cosmos Network's benefits over other blockchain platforms. It is an intriguing and promising blockchain network overall. It is a desirable alternative for developers looking to create decentralized applications due to its capacity to handle colossal throughput and connect several blockchains. Why Cosmos? The Inter-Blockchain Communication (IBC) protocol and the Tendermint Core consensus engine form the Cosmos network's foundation, enabling the exchange of value and data between various blockchains within the Cosmos Network. This was covered in more detail in the previous section when we discussed the Cosmos ecosystem. The Cosmos Network's main traits include the following: A Byzantine Fault Tolerant consensus engine, Tendermint provides quick and secure transaction processing. Tendermint Core Consensus Engine: IBC enables communication across several blockchains inside the Cosmos Network, allowing for the exchange of value and data. Inter-Blockchain Communication (IBC) protocol: The Cosmos Network provides support for custom token creation. These tokens can be used in decentralized apps to represent digital assets or as payment. Using independent blockchains with Tendermint Core enables quicker transaction processing times and the capacity to process many transactions per second. Scalability: The Cosmos Network's interoperability feature enables developers to create decentralized applications that communicate with many blockchain systems, including Bitcoin, Ethereum, and others. Interoperability: The Cosmos Network's hub-and-spoke architecture enables the development of separate blockchains that can communicate with the Cosmos Hub. The network's central node, the Cosmos Hub, facilitates the exchange of money and information among its several blockchains. Hub-and-spoke architecture: In the following section, let's dive deeply into the practical aspect of building and deploying smart contracts on the cosmos network. Prerequisite Let's make sure Node/NPM is set up on our computer. is a guide if we don't already have it installed. Here Project Setup and Installation Let's navigate to the terminal. We'll need to into any directory of our choice and then run the following commands: cd mkdir cosmos-project
cd cosmos-project 
npm init -y 
npm install --save-dev hardhat Let's create a sample project by using the following command: npx hardhat The above command will check if we have hardhat installed globally; if not, it will download it from the npm registry and run the command using the downloaded version. Accept the following options. Let's run the command below to verify that everything is operating as it should. npx hardhat test A passing test result will appear in our console. Now, may be removed from the directory and the scripts directory. After that, delete in the directory. Lock.js test deploy.js Lock.sol contracts The folders themselves should not be deleted! Create a Smart Contract Greeter This section will create a file in the contract directory with the following code snippet. Greeter.sol // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

// Define a smart contract called "Greeter"
contract Greeter {
    // Define a public variable called "greeting" of type string
    string public greeting;

    // Define a constructor that takes in a string and assigns it to the "greeting" variable
    constructor(string memory _greeting) {
        greeting = _greeting;
    }

    // Define a function called "setGreeting" that allows the "greeting" variable to be changed
    function setGreeting(string memory _greeting) public {
        greeting = _greeting;
    }

    // Define a function called "greet" that returns the current "greeting" variable
    function greet() public view returns (string memory) {
        return greeting;
    }
} In the code snippet above, it's important to note that the line serves as a unique identifier to signify that the code is unlicensed and available for anybody. SPDX-License-Identifier: UNLICENSED Testing the Smart Contract Create a new file called inside the directory and update it with the following code snippet. Greeter-test.js test const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Greeter", function () {
  it("Should deploy the Greeter contract", async function () {
    // Get the contract factory for the "Greeter" contract
    const Greeter = await ethers.getContractFactory("Greeter");
    // Deploy the contract to the blockchain
    const greeter = await Greeter.deploy("Hello, world!");

    // Wait until the contract is deployed
    await greeter.deployed();

    // Check that the contract's greet() method returns the expected greeting
    expect(await greeter.greet()).to.equal("Hello, world!");
  });

  it("Should return the new greeting once it's changed", async function () {
    // Get the contract factory for the "Greeter" contract
    const Greeter = await ethers.getContractFactory("Greeter");
    // Deploy the contract to the blockchain
    const greeter = await Greeter.deploy("Hello, world!");

    // Wait until the contract is deployed
    await greeter.deployed();

    // Check that the contract's greet() method returns the expected greeting
    expect(await greeter.greet()).to.equal("Hello, world!");

    // call the setGreeting method
    const setGreetingTx = await greeter.setGreeting("Hola, mundo!");

    // wait until the transaction is mined
    await setGreetingTx.wait();

    // Check that the contract's greet() method returns the new greeting
    expect(await greeter.greet()).to.equal("Hola, mundo!");
  });
}); Next, run the following command in the terminal to compile test cases. npx hardhat test We should have something similar to what is shown below. Compile and Deploy the Greeter Smart Contract to the Cosmos Network To compile the smart contract, we will need to create a new file inside the folder and update it with the following code snippet. deploy.js scripts const main = async () => {
  // Get the contract factory for the "Greeter" contract
  const greeterContractFactory = await hre.ethers.getContractFactory("Greeter");

  // Deploy the contract to the blockchain
  const greeterContract = await greeterContractFactory.deploy(
    "Hello, Hardhat!"
  );

  // Wait until the contract is deployed
  await greeterContract.deployed();

  // Log the address of the deployed contract
  console.log("Greeter Contract deployed to: ", greeterContract.address);
};

const runMain = async () => {
  try {
    // Call the main function
    await main();
    process.exit(0);
  } catch (error) {
    // Log any errors that occur
    console.log(error);
    process.exit(1);
  }
};

// Run the main function
runMain(); In the code snippet above, This script deploys a smart contract called to the blockchain using the hre.ethers library. Greeter The method deploys a new contract instance to the blockchain. greeterContractFactory.deploy() method is used to await the contract deployment. await greeterContract.deployed() The address of the deployed contract is then logged into the console, and then function is a wrapper function that runs the main function and catches any possible errors. runMain() Next, create on the project's root directory to store the private key, which we will use in the file during deployment. .env hardhat.config.js PRIVATE_KEY= Navigate to the file and then add the following code snippet. hardhat.config.js require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  // Specify version of solidity compiler
  solidity: "0.8.17",

  // Define networks to be used for testing and deployment
  networks: {
    // Hardhat network is a built-in development network in Hardhat
    hardhat: {
    },
    // Local network is a network running on localhost
    local : {
      url: "http://localhost:8545",
    },
    // evmos network is a network hosted by evmos
    evmos: {
      url: "https://eth.bd.evmos.dev:8545",
      // Use the private key specified in the .env file
      accounts:[process.env.PRIVATE_KEY],
    },
  },
}; This is a configuration file for the Hardhat development environment. We will deploy the smart contract in the next step, but we need to ensure we fund our wallet with a test EVMOS ( token. and fund the wallet using this evmos . A decentralized proof of stake blockchain in the Cosmos ecosystem) Set up evmos on MetaMask faucet site After requesting a faucet, we should have something similar to what is shown below. Now we can deploy the smart contract on the Cosmos network using the following command. npx hardhat run --network evmos scripts/deploy.js Verify Contract Deployment on EVM Explorer Let’s view this block in the EVM Explorer https://evm.evmos.dev To follow up, you can find the entire code for this project . here Conclusion This article provided a beginner-friendly guide to building and deploying smart contracts on the Cosmos network. Using the Hardhat development environment, we also demonstrated how to deploy a smart contract to the Cosmos network. See you in my next blog article. Take care!!! Also published . here

Mastering the Cosmos: A Beginner's Guide to Building and Deploying Smart Contracts

Introduction This tutorial will show you how to transfer Ethers using code rather than Metamask. The implementation makes use of the ethers library, which allows JavaScript to interact with Ethereum networks and contracts. Upon completion, you will have gained a deeper understanding of how to programmatically transmit Ethers and will have a working sample for future reference. Sending Ethers without Metamask Here is a full code performing a programmatic transaction of ethers between accounts. https://gist.github.com/Daltonic/bc4f985537de2bd700eef8289a3617a1?embedable=true To dive deeper into the world of Web3 development, check out this video on how to build a decentralized autonomous organization. https://www.youtube.com/watch?v=Gm442Ihv1GU&embedable=true Let's start by taking a closer look at the code and understanding how it works. Clone this repository into your preferred working directory using the command below. Make sure you have NodeJs and Git Bash installed on your local machine before proceeding with these steps. git clone https://github.com/Daltonic/tailwind_ethers_starter_kit <PROJECT NAME> Next, you need to install the packages using or on that project directory. npm install yarn install Next, create a file at the root of this project called and start by importing the library from hardhat: transactions.js **ethers** const { ethers } = require('hardhat') Next, it defines two helper functions, and , to convert between Ether and its smallest unit, Wei. This is important because the Ethereum network operates in Wei, so we need to make sure the amounts we send are in Wei. **toWei** **fromWei** const toWei = (num) => ethers.utils.parseEther(num.toString())
const fromWei = (num) => ethers.utils.formatEther(num) These two functions, and , convert between ether and wei. converts a value in ether to its equivalent in wei, and does the opposite. The and methods from the the module is used for this conversion. **toWei** **fromWei** **toWei** **fromWei** **parseEther** **formatEther** **ethers.utils** const sendEthers = async (recipientAddress, amountInWei) => {
  return new Promise(async (resolve, reject) => {
    const privateKey =
      '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
    const provider = new ethers.providers.JsonRpcProvider(
      'http://localhost:8545',
    );
    const wallet = new ethers.Wallet(privateKey, provider);
    const gasPrice = provider.getGasPrice();
    const nonce = provider.getTransactionCount(wallet.address, 'latest');
    const transaction = {
      to: recipientAddress,
      value: amountInWei,
      gasPrice,
      gasLimit: ethers.utils.hexlify(100000),
      nonce,
    };
    await wallet
      .sendTransaction(transaction)
      .then((transactionHash) => resolve(transactionHash))
      .catch((error) => reject(error));
  });
}; The function is defined to send ethers from one wallet to another. It takes two parameters: and which represent the address of the recipient and the amount to be sent, respectively. **sendEthers** **recipientAddress** **amountInWei** A and a are created. The transaction is signed with the private key, and the provider communicates with the Ethereum network. Using the private key and the provider, a instance is created. **privateKey** **provider** wallet The provider's and getTransactionCount methods are used to obtain the current and nonce of the wallet, respectively. The represents the cost of one unit of gas, and the nonce represents the number of transactions sent from the wallet. getGasPrice gasPrice gasPrice A object is created with the following parameters: (recipientAddress), (amountInWei), , (100000 in hex), and . The method of the instance is then used to send the transaction. **transaction** **to** **value** **gasPrice** **gasLimit** **nonce** **sendTransaction** **wallet** If the transaction is successful, the promise resolves with the transaction hash, otherwise it rejects with an error. const getBalance = async (walletAddress) => {
  return new Promise(async (resolve, reject) => {
    const provider = new ethers.providers.JsonRpcProvider(
      'http://localhost:8545',
    )
    await provider
      .getBalance(walletAddress)
      .then((balanceInWei) => resolve(balanceInWei))
      .catch((error) => reject(error))
  })
} The function returns a promise that resolves with the balance of a wallet in wei. The function creates a JsonRpcProvider object and calls the method on it. **getBalance** **getBalance** The method takes the address of the wallet as an argument. The method returns a Promise that resolves with the balance of the wallet in wei. If an error occurs, the Promise is rejected with the error. **getBalance** Check out the video below to learn how to code a blog smart contract in solidity. This will give you a head start on how to advance in Web3 development. https://www.youtube.com/watch?v=UbidE-tAibk&embedable=true async function main() {
  // the rest of the codes goes in here
} The function is defined to perform the transfer of ethers. **main** ;[sender, receiver] = await ethers.getSigners()
const amountInWei = toWei(4.7)

console.log('\n')
let balance = await getBalance(sender.address)
console.log('Sender balance before transfer: ', fromWei(balance))
balance = await getBalance(receiver.address)
console.log('Receiver balance before transfer: ', fromWei(balance))
console.log('\n') The method is called to obtain the sender and receiver addresses. The amount to be sent is converted to wei using the function. **ethers.getSigners** **toWei** The balance of the sender and receiver is logged before the transfer by calling the function twice and pass the addresses of the sender and receiver as arguments. **getBalance** await sendEthers(receiver.address, amountInWei).then((data) =>
  console.log('Transaction Details: ', data),
)
console.log('\n') The function is called to initiate the transfer of ethers. The function takes the recipient's address and the amount in wei as arguments. **sendEthers** The function returns a Promise that resolves with the transaction details. This Promise is logged into the console. **sendEthers** balance = await getBalance(sender.address)
console.log('Sender balance after transfer: ', fromWei(balance))
balance = await getBalance(receiver.address)
console.log('Receiver balance after transfer: ', fromWei(balance))
console.log('\n') The balance of the sender and receiver is logged again to show that the transfer was successful. The function is called twice to obtain the balance of the sender and receiver after the transfer. The result is logged onto the console. **getBalance** Conclusion In conclusion, this tutorial has shown how to send Ethers programmatically without the need for Metamask. The code provided demonstrates the use of the library in JavaScript to interact with the Ethereum network and perform a programmatic transaction of ethers between accounts. **ethers** The code includes helper functions to convert between Ether and its smallest unit, Wei, as well as functions to send ethers and get the balance of a wallet. The code also demonstrates the use of private keys, providers, wallets, gas prices, nonces, and transactions in Ethereum. The article has provided a good foundation for understanding how to send Ethers programmatically and serves as a useful reference for those starting out in this area. Obtain a copy of my book, " ", to attain the skills and knowledge needed to be a sought-after smart contract developer. Capturing Smart Contract Development Remember to to see various web3 development videos. Take care until our next tutorial. sign up for my channel About the Author Gospel Darlington is a full-stack blockchain developer with years of experience in the software development industry. 6+ By combining Software Development, writing, and teaching, he demonstrates how to build decentralized applications on EVM-compatible blockchain networks. For more information about him, kindly visit and follow his page on , , , or his . Twitter Github LinkedIn website If you're passionate about Web3 development, make sure to for a variety of educational videos. If you'd like to connect with me, . subscribe to my channel take a look at my services

Etherspot News on
HackerNoon and Around the Web

etherspot.io

11-50 employees

Since n.d.

Etherspot's Official Statements to HackerNoon

From Zero to Web3 Hero: Building a Multichain Dapp from Scratch

Etherspot Multichain SDK: Enabling Agile Web3 Development

Etherspot Story Mentions

Articles Around the Web

Read More Tech Stories Related to #Etherspot

Etherspot News on HackerNoon and Around the Web

etherspot.io

11-50 employees

Since n.d.

Etherspot's Official Statements to HackerNoon

From Zero to Web3 Hero: Building a Multichain Dapp from Scratch

Etherspot Multichain SDK: Enabling Agile Web3 Development

Etherspot Story Mentions

Articles Around the Web

Read More Tech Stories Related to #Etherspot

Etherspot News on
HackerNoon and Around the Web