Forem: Matt

Blockchain Game Finance and DeFi with NFT

Matt — Sun, 27 Feb 2022 14:43:30 +0000

The blockchain community and especially DeFi space have gained tremendous momentum since last year. At the same time, online NFT marketplaces are experiencing enormous traffic as many NFT fans are finding creative ways to convert physical and tangible assets into Non-fungible ones, as seen in the huge success of the Metaverse project. As such, the market cap of promising NFT projects are on the rise.

Market Cap

As a whole, the current two major trends in the IT industry consist of gaming and crypto where their online revenue and market cap are increasing on a daily basis.

Online Game Market

The revenue from virtual games and online entertainment will grow from $180B in 2020 to $400B in 2025 (majority of growth goes to in-game spending)

Crypto and NFT Market

In Q3 2021 alone the total crypto fundraising was $8.2B, out of which $1.2B went to Web3 and NFT. Also, fundraising in NFT games overshadows others in Q3 2021 by $1B.

NFT- New Promise of Game Finance

While current trends show a magnificent success of NFTs, many analysts believe that NFT has not yet fully tapped its potential. Indeed, we are at a very early stage of seeing how NFT is going to impact DeFi and more specifically game finance. Motivated by untapped market opportunity, RealBig is to harness the real power of NFT in game finance where NFT assets are used as an instrument for financial investment similar to traditional stock or bonds. In its business model, not only NFT owners can sell their assets to the secondary market, but also they can collect dividends on a monthly basis. As a matter of fact, with finite supply of NFT in its system and increasing value of NFT as result of platform activities will return an exponential increase in the value of NFT in such a way that an NFT asset can be treated as an independent financial instrument.

How RealBig NFT Works

RealBig is a platform that offers a variety of lottery prize games. In addition to prize games, it offers NFT game finance via a virtual league. Its virtual league consists of 5 clubs (each has 4 teams of different player sizes). In total, there will be 70 players where each player is represented as an NFT asset. The system runs competitions among teams within a club and across different clubs and anytime a player wins, its owner receives 20% of prize value as its dividend. Read our White Paper to learn more. Watch below video to learn more:
https://youtu.be/je0fXjIZniY

What is Programming and Who Is a Programmer

Matt — Wed, 16 Dec 2020 18:31:04 +0000

Without a doubt, terms like developers, programmers, Full-Stack engineers, etc are becoming buzzwords among the public, yet the element of programming is common among all of them. So this article in a nutshell helps you understand what is the foundation behind computer science or software engineering. It is worth mentioning that coding and programming terms are often used interchangeably.

Put it simply, a programmer is a person who writes computer software. The term computer programmer can refer to a specialist in one area of computer programming language or to a generalist who writes code for many kinds of software. Also, often the software and application terms are used interchangeably among IT professionals. One who practices or professes a formal approach to programming may also be known as a programmer analyst. A programmer's primary computer language (Assembly, COBOL, C, C++, C#, Java, Lisp, Python, etc.) is often prefixed to these titles, and those who work in a web environment often prefix their titles with web. A full spectrum of occupations, including: software developers, web developers, mobile applications developers, embedded firmware developers, cloud engineers, software engineers, computer scientists, or software analysts, while they do involve programming, also requires a range of other skills. For instance, all programmers need to have good analytical and problem solving skills as well as soft skills like communication. Also, programmers in general need to be creative as they often need to come up with unique solutions to new problems. Lastly, the changes in the IT landscape require programmers to learn new techniques, tools and terminologies frequently. Indeed, many companies have routine plans to upskill their technical teams.

Computer Programming is a process that leads from an original formulation of a computing problem to executable computer programs. Programming involves activities such as analysis, developing understanding, generating algorithms, verification of requirements of algorithms including their correctness and resources consumption, and implementation (known as coding) of algorithms in a target programming language. Source code is written in one or more programming languages. The purpose of programming is to find a sequence of instructions that will automate performing a specific task or solving a given problem. The process of programming thus often requires expertise in many different subjects, including knowledge of the application domain, specialized algorithms, and formal logic. It is worth mentioning that all programming languages have one thing in common- the programming logic. For instance, the conditional statement logic is the same in Java, C++ and PHP; however, they use different languages known as syntax to represent the logic. At a very high level, there are 6 major career tracks for IT professionals: web developer, mobile App developer, software engineer, cloud engineer, system administration, and blockchain. Here is a free course for learning more about said 6 career tracks.

Other related tasks of programmers are testing, debugging, and maintaining the source code, implementation of the build system, and management of derived artifacts such as machine code of computer programs. These might be considered part of the programming process, but often the term software or application development is used for this larger process with the term programming, implementation, or coding reserved for the actual writing of source code. Software engineering combines engineering techniques with software development practices. One of most popular and well-established methodologies for software engineering is Software Development Life Cycle (SDLC). It follows the below 6 essential steps sequentially for building high quality software applications.

Requirement analysis
Planning
Software design such as architectural design
Software development
Testing
Deployment

Computer Program is a collection of instructions that performs a specific task when executed by a computer. A computer requires programs to function and typically executes the program's instructions in a central processing unit. Unlike humans, computers just blindly follow the instructions and can not judge whether instructions are true or false. As such, if a computer receives erroneous instructions as its input, it will output errors or misleading results. Therefore, designing a well-thought-out program requires lots of foresight.

A computer program is usually written by a computer programmer in a programming language. From the program in its human-readable form of source code, a compiler can derive machine code—a form consisting of instructions that the computer can directly execute. Alternatively, a computer program may be executed with the aid of an interpreter. A part of a computer program that performs a well-defined task is known as an algorithm. A collection of computer programs, libraries, and related data are referred to as software. Computer programs may be categorized along functional lines, such as application software and system software.

Summary

In this article, we briefly reviewed the terms like programming and programmer and highlighted the context in which these terms are used. This article gives you a roadmap for becoming a software or application developer. Specifically, the first step in becoming a programmer is to choose a right IT career path. Then, start learning one or two coding languages and practice them. Read Comprehensive Review of Coding and Computer Programming article to learn more on the history and evolution of programming.

Resources

Here is a list of free courses for starting your programming career.

IT Career Roadmap Explained
Web Design with Bootstrap
User Experience Best Practices
Intro to Search Engine Optimization
Web Design with WordPress
Introduction to Drupal CMS
Intro to Joomla CMS
Intro to Cybersecurity
Introduction to Cloud Technology
Recorded Live Webinars and Classes

5 Benefits of Implementing AI in Business Processes

Matt — Mon, 05 Oct 2020 13:23:57 +0000

In the past few years, more and more companies have started to implement artificial intelligence in their business process, and in the coming year, this number will only go up. There was a time when the idea of artificial intelligence seemed absurd and impossible, but today it is at a stage that it is hard for business owners to ignore what it can bring to the table. If you are still skeptical about it and are wondering Why Artificial Intelligence Should be Deployed for business functions, then this article is for you. Below I have mentioned a few benefits of implementing AI in business processes that will help you understand its importance.

Cost Savings

One of the major benefits of implementing AI in business processes is that it reduces the expenses by automating certain processes. With the help of AI, businesses can now automate a lot of processes for which they needed additional resources in the past. You do not have to hire extra employees or freelancers anymore to complete certain tasks. Also, when the simplest of the process is automated, your employees will focus on the more important things that will make them more efficient. This not only frees up time for them but also clears the clutter around them, allowing them to focus more. This can enhance employees’ productivity dramatically as they will have a clear mind most of the time.

Helps with Decision Making

Another major benefit of AI for businesses is that it allows us to make better decisions. AI gives us clear and in-depth insights that allow us to make decisions that are based on data. These days’ businesses are dealing with tons of data on a daily basis. This is especially true for large enterprises who are sending and receiving hard data every day and can easily convert that data into insights. If you want to stay competitive in the market, then you will have to use this extensive data to your advantage. It allows you to understand market trends and customer behaviors that can predict your businesses’ future quite accurately. So, you need to create an environment in your workplace where these processes can be normalized.

Data Mining

Most people do not talk about data mining, but it is probably the most exciting use of artificial intelligence. AI has become so advanced that you can now take all the data from a user and use it to discover vital things that can help you with business decisions. When you have so much data available at your disposal, you can dominate the market and predict your future competitors. Keep in mind; data mining is not something that will prove or disprove certain hypotheses for you. Instead, it will provide you with answers to such advanced questions that you might not even be thinking about. Also, this data can be used for machine learning as well, which certain businesses can use to conquer new heights and introduce revolutionary change in the industry.

Improved Security for Data

Another major benefit of using artificial intelligence for business is that it provides you better security for your data. If your business is relevant to the banking or the financial sector, this can become quite handy. Unlike other types of security methods, AI does not only provide you protection against hackers but it can identify fraudulent attempts as well and can predict attacks even before they happen. In this modern age, data is everything, and if your company’s data falls into the wrong hands, it can do a lot of damage. So if you don’t want something like that happening to your business, it is time you Accelerate Your Company's AI Implementation.

Improved Recruitment Process

If you are a recruitment company, this might not be good news for you, but if you are another business, this can save you from a lot of hassle. With the help of AI, businesses can now automate their recruitment process for new employees. It can read all the job applications smartly and automatically reject those that do not meet the company's criteria. This helps the HR personnel save time and ensures that only the best recruits are hired for the job.

Blockchain Ethereum Development Guide from A to Z

Matt — Mon, 22 Jul 2019 18:38:04 +0000

Ethereum is a general-purpose blockchain that is geared toward describing business logic, through advanced scripts, also known as smart contracts. Ethereum was designed with a broader vision, as a decentralized or world computer that attempts to marry the power of the blockchain, as a trust machine, with a Turing-complete contract engine. Although Ethereum borrows many ideas that were initially introduced by bitcoin, there are many divergences between the two.
Solidity is an object-oriented, high-level language for implementing smart contracts. Smart contracts are programs which govern the behavior of accounts within the Ethereum state. Solidity was influenced by C++, Python and JavaScript and is designed to target the Ethereum Virtual Machine (EVM). Solidity is statically typed, supports inheritance, libraries and complex user-defined types among other features. With Solidity you can create contracts for uses such as voting, crowdfunding, blind auctions, and multi-signature wallets.
The Ethereum virtual machine and smart contracts are key elements of Ethereum, and constitute its main attraction. In Ethereum, smart contracts represent a piece of code written in a high-level language (Solidity, LLL, Viper) and stored as bytecode in the blockchain, in order to run reliably in a stack-based virtual machine (Ethereum Virtual Machine), in each node, once invoked. The interactions with smart contract functions happen through transactions on the blockchain network, with their payloads being executed in the Ethereum virtual machine, and the shared blockchain state being updated accordingly.

For those who are not familiar with blockchain technology reading History and Evolution of Blockchain Technology from Bitcoin article is strongly recommended. Also, if you wish to learn and practice Hyperledger blockchain development, visit Comprehensive Hyperledger Training Tutorials page to get the outline of our Hyperledger tutorial articles.

We have written two groups of recipes to explore Ethereum and Solidity coding in details. First group covers the following nine tutorials:

In summary, you learn about how to set up and configure Ethereum and develop blockchain applications using Solidity coding language. We explore its essential components such as smart contracts and Web3.JS API via an Auction Decentralized Application (DApp) step-by-step.
In second group, we will discuss more advance topics in Ethereum blockchain development and solidity while building a Tontine DApp game step-by-step. In particular, we discuss Truffle and Drizzle. For example, we show you how a tool such as Truffle can be an assistant in building, testing, debugging, and deploying DApps. In short, we are going to cover four main topics:

Exploring the Truffle suite
Learning Solidity's advanced features
Contract testing and debugging
Building a user interface using Drizzle

The 2nd set consists of 8 recipes as follows:

As a reminder, understanding and finishing the first group of recipes are required prior to working on second one.

Here are a few more hands-on tutorials covering advance topics in Ethereum blockchain development: Building Enterprise Blockchain-as-a-Service Applications Using Ethereum and Quorum, Harness the Power of Distributed Storage IPFS and Swarm in Ethereum Blockchain Applications, and Blockchain Developer Guide- How to Build Ethereum Financial Applications With Java and Web3J API Through Blockchain Oracles

About Authors
This article is written by Matt Zand (Founder of High School Technology Services, Hash Flow, and Coding Bootcamps) in collaboration with Brian Wu who is an advisor at DC Web Makers.

Debugging with Truffle and Ethereum Remix in Tontine DApp Game

Matt — Fri, 12 Jul 2019 18:40:34 +0000

Ethereum is a general-purpose blockchain that is more suited to describing business logic, through advanced scripts, also known as smart contracts. Ethereum was designed with a broader vision, as a decentralized or world computer that attempts to marry the power of the blockchain, as a trust machine, with a Turing-complete contract engine. Although Ethereum borrows many ideas that were initially introduced by bitcoin, there are many divergences between the two.
The Ethereum virtual machine and smart contracts are key elements of Ethereum, and constitute its main attraction. In Ethereum, smart contracts represent a piece of code written in a high-level language (Solidity, LLL, Viper) and stored as bytecode in the blockchain, in order to run reliably in a stack-based virtual machine (Ethereum Virtual Machine), in each node, once invoked. The interactions with smart contract functions happen through transactions on the blockchain network, with their payloads being executed in the Ethereum virtual machine, and the shared blockchain state being updated accordingly.

For those who are not familiar with blockchain technology reading History and Evolution of Blockchain Technology from Bitcoin article is strongly recommended. Also, if you wish to learn and practice Hyperledger blockchain development, visit Comprehensive Hyperledger Training Tutorials page to get the outline of our Hyperledger tutorial articles.
We have written two sets of tutorials to explore Ethereum and Solidity programming in depth. First set covered the following nine recipes:

In short, you learned about how to set up and configure Ethereum and develop blockchain applications using Solidity programming language. We explored its key components, including smart contracts and Web3.JS API via an Auction Decentralized Application (DApp) step-by-step.
In second set, we discuss more advance topics in Ethereum blockchain development and solidity while building a Tontine DApp game step-by-step. Specifically, we cover Truffle and Drizzle. For instance, we show you how a tool such as Truffle can be an assistant in building, testing, debugging, and deploying DApps. In summary, we are going to cover four main topics:

Exploring the Truffle suite
Learning Solidity's advanced features
Contract testing and debugging
Building a user interface using Drizzle

The 2nd set consists of 8 recipes as follows:

Install Truffle and Setup Ganache for Compiling Ethereum Smart Contracts for Tontine DApp Game
Run Tontine Ethereum DApp Game Contract
Design Tontine Ethereum DApp Game Interfaces
Contract Interactions between Ethereum and Solidity via Tontine DApp Game
Work with Truffle Unit Testing in Tontine DApp Game
Debugging with Truffle and Ethereum Remix in Tontine DApp Game
Building Frontend Application for Tontine DApp Game with Drizzle
Running and Playing Tontine Ethereum DApp Game

IMPORTANT: Understanding and completing the first set of recipes are required prior to working on second set of recipes.
In our first round of recipes, we learned a lot about the Ethereum ecosystem, but we are yet to realize the full potential of its different components. More precisely, we explored how Ethereum works, what a decentralized application (DApp) is and how to build one, and also covered the key concepts of Solidity and web3.js. We then introduced some of the most common smart contract design patterns (withdrawal from a contract, restricting access, state machines), before ending with a discussion of a contract’s cost optimization.
To brush up your knowledge and skills, on second round of recipes, we are going to build a Tontine DApp game. We will exploit this example to explore new tools that are going to change the way you build DApps, and introduce new Solidity features.

In this walkthrough, we will discover how a tool such as Truffle can aid in building, testing, debugging, and deploying our DApp.

Developers familiar with debugging will find this a welcome relief. Truffle and Remix provide built-in debugging features to help us understand where the code fails. This section provides a general overview of debugging in Truffle and Remix. If you are familiar with debugging using other IDEs, such as Eclipse or NetBeans, you will find Truffle and Remix similarly useful, even though they're less powerful.

Debugging with Truffle

Truffle includes a built-in debugger to debug transactions made against your contracts. It supports elementary debugging operations, such as code-stepping (over, into, out, next, and instruction), breakpoints, and watching expressions.

To try the debugging features, let's intentionally introduce a bug into the Ctontine contract and redeploy it into Ganache. Afterward, we will run the tests and use Truffle’s debugger to detect the source of the error.
First, in the Ctontine contract code, change the first require() statement in the join()
method as follows:

require(!Tplayer.exist(msg.sender));

As you can see, we reversed the required condition by adding an exclamation mark, "!", indicating that the player shouldn’t be registered in the Cplayer contract. This goes against our previous test's logic as we add the testing player before calling each unit test, including a test for the join() method.
Now, if you run the truffle test test/test.js --network my_ganache tests, you will see the following error:

The output shows that we have a serious problem with the Ctontine tests and the VM exception while processing transaction error message isn’t much help in detecting the cause behind it. Let’s chase the bug.

Spotting the error

To debug the previous error, copy the transaction ID from ganache-cli:

Then feed it as an argument to the truffle debug <tx id> --network my_ganache

debug command.

In this case, we run:

truffle debug 0x90e02cc211733cade22bd5ff3b1ea1600781b48a1c792d867cda83190f773319 -- network my_ganache

Once executed, you’ll enter Truffle's debugging mode, as shown the following screenshot:

Keep pressing the Enter button to step through the code and trace the execution steps. Finally, the debugger will stop with an error message:

As a result, Truffle's debugger indicates that the exception (error) is raised due to a failed require() statement, as the evaluated expression (!Tplayer.exist(msg.sender)) will definitively always be false. This is because, if you remember, in the join() test we added the player first, therefore the exist() function will be always true, and hence our faulty require() will fail. The important point is that Truffle indicates to us where the code fails with an interesting message, instead of the previous error message generated by the VM.

Breakpoints and watching values

More importantly, Truffle’s debugger console enables you to toggle a breakpoint by pressing b and then pressing c to debug until reaching the breakpoint. Additionally, you can choose a variable (state or local) to watch using +:variable_name or by pressing v at any debugging step.

For example, if we debug the transaction initiated by the first (successful) Cplayer test (the addPlayer() test), we can visualize the values of each variable using the v option, as follows:

Make sure to experiment with all the debugger features introduced earlier. A good start point would be to read Truffle’s documentation.

Now, roll back the changes, and save the contract to try debugging with Remix.

Debugging with Remix

If you’re not a fan of CLI tools, Remix is a good debugging alternative for you. In fact, Remix provides a graphical interface with many more options.

Start and connect Remix to Ganache as we did in the previous recipes. Once connected, you will be able to debug the previous transaction we debugged using Truffle. First of all, we need to activate the debugging mode. There are several ways to achieve that, the easiest way being to browse to the debugger tab in the right-hand panel, and then provide either a transaction hash (transaction index) or a block number in the debugging input:

In Remix's right-hand pane, on the debugging form with several controls, press the play button to start debugging. You’ll get a debugging menu with the views depicted here:

The views are listed as follows:

Instructions: Lists the executed opcodes
Solidity Locals: Shows the content of local variables in the current scope
Solidity State: Displays state variables of the current executing contract
Step detail: Displays the current step's execution details (remaining gas and VM trace step)

      <li><strong>Stack</strong>:  Displays the local variables values stored in the stack</li>
      <li><strong>Storage</strong>:  Displays the contract storage entries(key, value) as shown here:</li>
    </ul>
  </ul>
</ul>

Memory: Provides a view into the memory space that is used by the contract
Call Data: Usually contains a 4-byte method signature followed by serialized arguments

The slider bar at the top (transaction section) helps you advance or roll back the execution of the transaction (debugging) easily to visualize the evolution of the available debugging information.

Below the slider, Remix provides a set of buttons at the top of the toolbar for controlling the execution of the transaction you are debugging:

Step through a transaction's payload execution using the debugging buttons: Single over back , step back , step into , and step over
You can stop debugging and resume operations at any time using the respective debugging buttons: and

Debugging the previous faulty transaction using the transaction’s ID with Remix debugger boils down to dealing with crude information, including the list of executed opcodes. In this first case, the debugger shows us that the execution ends with a REVERT instruction:

If you follow the JUMP instructions and the values being loaded into the stack, you’ll be able to trace the source of the exception. However, I highly suspect you can't (or don't want to) deal with this hard task, which is why we are proposing an easier alternative in the remainder of this section.

Attaching the debugger to the code

Using Remix’s debugger with only the transaction ID can be a little troublesome for beginners trying to spot where the code breaks, without having the debugger attached to the code. To make the attachment, we need to load the contract code and connect Remix to the new instance you’ve migrated in Ganache.

First, import the contract file from Truffle’s folder, as follows:

Deploy the contract into Ganache using truffle migrate –reset –network my_ganache, then retrieve the contract's address:

Under the Run tab, connect Remix to the deployed Ctontine contract using the At Address button (not Deploy). We then do the same for Cplayer. You’ll end up with two contracts loaded into Remix.

Then, we add three fictional players using addPlayer(). To add different players, change the account indicated in the transaction parameters in the top of the right-hand panel each time and execute the addPlayer() function (by pressing the addPlayer() button):

Now that we have three registered players, we can start interacting with the Ctontine

contract.

Watching values

Remix provides us with a watch window to observe and inspect contract variables. To use this feature, in the right panel, second tab from the left, fill in the Value input with 1 and ether:

Then make the first player join the Tontine game by pressing the join button. When it completes successfully, change the account and call the join method with zero ether, and you’ll get the following error in the messages output:

Have you noticed the send higher pension message in the output console? If you remember, this message was defined in the require function to show us the reason behind the exception: require(msg.value >= 1 ether && Tpension[msg.sender] == 0, "send higher pension");.

Press the Debug button in the console or go to the Debugger configuration tab to go through the steps!

The Solidity State section will show us that, unlike the first player, the second player wasn’t added successfully, as depicted in the following diagram:

In addition, when the debugging panel loads up, you will see a blue highlight that marks the part of the code being executed as the debugging progresses, which provides precious assistance.

Notice the existence of a warning button under the debugging buttons. Once pressed, it will rethrow the exception and jump directly to the last opcode before the exception happened:

Setting breakpoints

As you know, breakpoints are the most basic and essential feature of reliable debugging. They represent a handy tool to help you examine in detail the execution of a specific section of code. As in other popular IDEs, in Remix breakpoints can be added and removed by clicking on the left margin of a line of code:

For example, let’s define two debugging breakpoints. Set the first at the line where the player is added to the active players array, and the second at the line where the current timestamp is recorded.
Now, make the second player join the game properly with one ether, then debug the transaction. Once the debugger starts, you can jump directly to your fixed breakpoints using the Jump to previous breakpoint, Jump to next breakpoint, or Jump out debugger buttons:

At the breakpoint, Remix's debugger suspends your running code so you can take a look at the values of contract's states and explore the memory or storage at the current execution level.

For the sake of brevity, breakpoints will be the last debugging feature we cover. You can refer to Remix's documentation (https://remix.readthedocs.io/en/latest/tutorial_debug.html) for more information about the debugger's advanced features.

This has been a long discussion on writing, testing, and debugging our contracts. With that in place, we can safely shift to the frontend and start building the UI components in our next recipe.

This recipe is written in collaboration with Brian Wu who is a senior blockchain instructor at Coding Bootcamps school in Washington DC.

Deployment Environments for Managing Ethereum Smart Contracts

Matt — Fri, 12 Jul 2019 18:23:51 +0000

For those who are not familiar with blockchain technology reading History and Evolution of Blockchain Technology from Bitcoin article is strongly recommended. Also, if you wish to learn and practice Hyperledger blockchain development, visit Comprehensive Hyperledger Training Tutorials page to get the outline of our Hyperledger tutorial articles.
We have written two sets of tutorials to explore Ethereum and Solidity programming in depth. First set covers the following nine recipes:

In short, you learn about how to set up and configure Ethereum and develop blockchain applications using Solidity programming language. We explore its key components, including smart contracts and Web3.JS API via an Auction Decentralized Application (DApp) step-by-step.
In second set, we will discuss more advance topics in Ethereum blockchain development and solidity while building a Tontine DApp game step-by-step. Specifically, we cover Truffle and Drizzle. For instance, we show you how a tool such as Truffle can be an assistant in building, testing, debugging, and deploying DApps. In summary, we are going to cover four main topics:

Exploring the Truffle suite
Learning Solidity's advanced features
Contract testing and debugging
Building a user interface using Drizzle

The 2nd set consists of 8 recipes as follows:

IMPORTANT: Understanding and completing the first set of recipes are required prior to working on second set of recipes.

In Ethereum, we have multiple ways to deploy a smart contract without spending real ether. In this recipe, we will present how to set up and deploy your contract in the following testing environments:

Ganache
Remix Testnet
Private network

Option 1 – Ganache

If you're looking for a testing blockchain with a graphical interface, Ganache (previously TestRpc) is for you. It's an in-memory blockchain (think of it as a blockchain simulator) that runs locally.

Download and install it from the official Ganache repository (https://github.com/trufflesuite/ganache/releases) for the appropriate version for your OS.

When you run Ganache, you will get a graphical screen showing some details about the server, the blocks created, transactions, and a list of created accounts, each loaded with 100 ether:

To interact with Ganache, you can use Remix, but this time, you have to specify a new web3 provider with Ganache's IP and RPC port; for example, http://localhost:7545 (if you have connection troubles, try to use Remix over HTTP, not HTTPS):

Once Remix is connected to Ganache, deploy your smart contract as you did earlier and start bidding through Remix. In Ganache's interface, you'll be able to visualize the transactions and the created blocks:

If you think Ganache is enough for you, you can stop here and jump directly to the Running the auction DApp section, in order to run the auction DApp using Ganache. However, if you're interested in learning about other possible deployment environments so you can choose the suitable one for you, continue reading.

Option 2 – Testnet

Similar to bitcoin, Ethereum's Testnet is a public network dedicated to testing developers' contracts online without using real ether. You can join this network without the need to run a full node, by using a plugin called MetaMask on your browser. Let's see how it's possible.

Connecting MetaMask to Testnet

MetaMask is a browser plugin that allows your normal browser to behave as a web3 browser, to interact with DApps, and to send transactions without running an Ethereum node. MetaMask achieves this by injecting the web3js API into every web page's JavaScript context.

The necessary instructions for installing and setting up MetaMask are well documented on their official website, at: https://metamask.io/. After the process of wallet creation, switch to the Ropsten test network in MetaMask's settings by clicking on the network selector located on the upper left corner. Once you're connected to Ropsten, you'll need to get some free worthless ether by choosing to buy some coins as shown in the following screenshot:

MetaMask can be connected to any RPC provider locally (Ganache, Geth) or online (testnet, Mainnet). For a detailed step-by-step guide to using MetaMask, I point you to the official documentation available at https://github.com/MetaMask/faq/blob/master/USERS.md.

All set; now, go back to your Remix browser (you may need to refresh it) and select (in Remix) injected web3 as the environment option, in order to deploy your contract directly online. MetaMask will initiate the deployment transaction and give you back the contract address:

MetaMask provides an Ethereum Etherscan link for each transaction, in order to visualize, among other details, the transaction status and gas cost:

The contract is easily deployed in the testnet.

Alternatively, you can connect Remix to the testnet by setting up a light node connected to the testnet network as explained in the next section. To test your auction web page using MetaMask, you have to add the following code snippet to the beginning of your auction.js file to detect MetaMask's injected web3 instance:
if (typeof web3 !== 'undefined') { App.web3Provider = web3.currentProvider; web3 = new Web3(web3.currentProvider);
} else {
// change to your RPC provider IP and Port App.web3Provider = new
web3.providers.HttpProvider('http://127.0.0.1:7545'); web3 = new Web3(App.web3Provider);
}

Instead using only web3.setProvider(new web3.providers.HttpProvider("http://127.0.0.1:8545")); as we did earlier in section talking to the blockchain.

The testnet network is very helpful as it gives you an accurate idea of the delay processing and cost of your transactions. However, the implied delay time and limited ether won't be helpful for developers who regularly change their DApp's code, hence the following third option or Ganache is more suitable as a starting environment. You can then you move to this testnet option before going into production on the Mainnet.

Option 3 – private network

Despite the ease of using the previous environment, which abstracts away all the details, it is still good to know how things work at a granular level. Besides, you might face the need to deploy private Ethereum blockchains for private entities to use in production, or during the software development process.

Let's set up our private Ethereum network (a kind of localhost), composed of two running nodes on the same machine which is covered in our next recipe.

This recipe is written in collaboration with Brian Wu who is a senior Hyperledger instructor at Coding Bootcamps school in Washington DC.

Definitive Guide for Learning Blockchain Hyperledger Development from Beginner to Advance Level

Matt — Thu, 11 Jul 2019 14:55:13 +0000

This article is only focused on building a blockchain application using one of Hyperledger projects. I briefly survey each project followed by its hands-on recipes. Also, if you wish to learn and practice Ethereum blockchain development, visit Comprehensive Ethereum Training Tutorials page to get the outline of our Ethereum tutorial articles.

Note: Good knowledge of blockchain concepts, JavaScript and Python as well as basic skills in Linux OS are required in order to complete tutorials listed on this article.

Here is a good article on why choosing Hyperledger Fabric over other blockchain development platforms.

Overview of Hyperledger Project and Family
Hyperledger project is made of many frameworks and tools.
Hyperledger Project Frameworks
The frameworks under Hyperledger project aim to provide platforms to build a variety of distributed ledgers and their components. They are as follows:

Hyperledger Fabric: Fabric is the most popular Hyperledger framework. Smart contracts (also known as chaincode) are written in Golang and JavaScript, and run in Docker containers. Fabric is known for its extensibility and allows enterprises to build distributed ledger networks on top of an established and successful architecture.
Hyperledger Sawtooth: Sawtooth is the second project to reach 1.0 release maturity. Sawtooth-core is written in Python, while Sawtooth Raft and Sawtooth Sabre are written in Rust. It also has JavaScript and Golang components. Sawtooth supports both permissioned and permissionless deployments. It supports the EVM through a collaboration with the Hyperledger Burrow.
Hyperledger Burrow: Burrow is the first permissioned ledger that supports EVM. It is written in Go and heavily focuses on being a deterministic Smart Contract engine.
Hyperledger Indy: Indy is built explicitly for decentralized identity management. The server portion, Indy node, is built in Python, while the Indy SDK is written in Rust. It offers tools and reusable components to manage digital identities on blockchains or other distributed ledgers.
Hyperledger Iroha: Iroha is designed to target the creation and management of complex digital assets and identities. It is written in C++ and is end user friendly. Iroha has a powerful role-based model for access control and supports complex analytics.

Below graph succinctly depicts Hyperledger frameworks and tools.

For learning more about Hyperledger project tools and Hyperledger family the following articles are strongly recommended. Intro to Hyperledger Family and Hyperledger Blockchain Ecosystem and Hyperledger Design Philosophy and Framework Architecture .

I- Hyperledger Fabric Project and Development
It is out of question that Hyperledger Fabric is currently the most popular platform for blockchain development. Hyperledger Fabric is an open source enterprise-grade platform that leverages a highly-modular and configurable architecture. Hyperledger Fabric is optimized for a broad range of industry use cases, including the finance, banking, healthcare, insurance, and public sectors, as well as supply chains and digital asset management. Read below article to learn about Hyperledger Fabric architecture and design:
https://weg2g.com/application/touchstonewords/article-the-survey-of-hyperledger-fabric-architecture-and-components-for-blockchain-developers.php

We have written two sets of tutorials to explore Hyperledger Fabric in depth. First set covers the following six recipes:
It starts with installing Hyperledger Fabric on an AWS EC2 virtual machine, setting up the first Hyperledger Fabric network and working with Hyperledger Fabric Command Line Interface or CLI. We learn the following:

Generating the crypto/certificate using cryptogen
Generating the configuration transaction using configtxgen
Bring up the nodes based on what is defined in the docker-compose file
Using the CLI to set up the first network
Using the CLI to install and instantiate the chaincode
Using the CLI to invoke and query the chaincode

We move on to show you how to Add New Network to a Channel, Use CouchDB as a State Database for Hyperledger Fabric, and Create a Smart Contract and then Deploy it into the Blockchain.
In short, in first 6 recipes, we learn about how to set up and configure Hyperledger Fabric. We explore its key components, including channels, Membership Service Providers (MSPs), the ordering service, and Fabric Certificate Authority (CA).
The second set, we will show you how to build a simple device asset management DApp. It consists of 6 recipes as follows:

In summary, in the second set of recipes, we are going to build a simple device asset management DApp. We will exploit this example by writing chaincode implemented by various programming languages and we'll also build, test, and deploy our DApp.

After finishing first two sets of tutorials, you can move on to more advance topics on Hyperledger Fabric development via the following recipes: Build Blockchain Applications with Hyperledger Fabric and Composer on IBM Cloud, Building A Blockchain for Letter of Credit Using Hyperledger Fabric and Composer and Ultimate Guide for Building A Blockchain Supply Chain Using Hyperledger Fabric and Composer.

II- Hyperledger Sawtooth Project and Development
Hyperledger Sawtooth is an enterprise blockchain platform for building distributed ledger applications and networks. The design philosophy targets keeping ledgers distributed and making smart contracts safe, particularly for enterprise use. Read below article to learn more:
https://weg2g.com/application/touchstonewords/article-essential-hyperledger-sawtooth-features-for-enterprise-blockchain-developers.php

Follow below 5 steps or tutorials for building blockchain application in Sawtooth:
1. Install Hyperledger Sawtooth
Follow Install and Work with Hyperledger Sawtooth recipe.

2. Configure Sawtooth Validators and REST API
Follow Configuring Hyperledger Sawtooth Validator and REST API on AWS recipe.

3. Design a Namespace and Address for Transaction Family and Implement Transaction Family
Follow Designing Namespace and Address for Hyperledger Sawtooth Transaction Family recipe

4. Build a Transaction Processor and Grant Permission on the Sawtooth Network
Follow Building Transaction Handler and Processor for Hyperledger Sawtooth with Python SDK recipe

5. Develop Client Applications with the Sawtooth REST API and SDK
Follow Transaction Processor and Python Egg For Hyperledger Sawtooth recipe.

III- Hyperledger Composer Project and Development
Hyperledger Composer is a set of collaboration tools for business owners and developers that make it easy to write chaincode for Hyperledger Fabric and decentralized applications (DApps). With Composer, you can quickly build POC and deploy chaincode to the blockchain in a short amount of time. Hyperledger Composer consists of the following toolsets:

A modeling language called CTO: A domain modeling language that defines a business model, concept, and function for a business network definition
Playground: Rapid configuration, deployment, and testing of a business network
Command-line interface (CLI) tools: The client command-line tool is used to integrate business network with Hyperledger Fabric

Follow below tutorials for building blockchain application using Hyperledger Composer:

After completing above 3 recipes, it’s recommended to learn the following topics: i- Implementing models, transaction logic, access control, and query definitions, ii- Deploying, testing, and exporting business network archives using the Composer command-line interface and iii- Interacting with Composer through the RESTful API as covered in the below links:
https://developer.ibm.com/recipes/tutorials/blockchain-hyperledger-composer-and-playground-development-components/
https://developer.ibm.com/recipes/tutorials/interacting-with-hyperledger-composer-through-restful-api/

IV- Hyperledger Explorer Project and Development
Hyperledger Explorer is a powerful utility that allows users to create user-friendly web-based applications. It is a blockchain dashboard and provides the ability to view, invoke, deploy, and query raw blockchain data and network information, including block details, chain codes, and transactions stored in the ledger.
Follow below recipes to install and configure Explorer:
https://myhsts.org/tutorial-learn-how-to-install-blockchain-hyperledger-explorer-and-configure-it-with-fabric.php
https://myhsts.org/tutorial-learn-how-to-build-blockchain-hyperledger-explorer-and-development-environment.php

Follow below tutorials for building your first blockchain application using Hyperledger Explorer and Fabric.
https://developer.ibm.com/recipes/tutorials/configure-hyperledger-explorer-with-fabric-to-build-blockchain-applications/
https://developer.ibm.com/recipes/tutorials/building-hyperledger-explorer-for-developing-blockchain-applications/

V- Hyperledger Indy Project and Development
Hyperledger Indy is a distributed ledger in The Linux Foundation family which is built for decentralized digital-identity management. Hyperledger Indy is in its incubation stage so in this recipe we will explore the Indy Command Line Interface or CLI to look at the concept and functions offered by Hyperledger Indy with the current distribution.
To develop blockchain applications using Hyperledger Indy, you need to run Hyperledger Indy and explore it’s the power of its Command line Interface or CLI by creating, opening, and listing the wallet, creating, importing, and using decentralized identifier or DID and creating, connecting, and listing Hyperledger Indy node pool. Follow below three tutorials to build your blockchain application using Hyperledger Indy.
https://myhsts.org/tutorial-learn-how-to-install-blockchain-hyperledger-indy-on-amazon-web-services.php
https://developer.ibm.com/recipes/tutorials/manage-hyperledger-indy-wallet-and-did-through-indy-cli-and-docker/
https://myhsts.org/tutorial-learn-how-to-work-with-hyperledger-indy-command-line-interface.php

VI- Hyperledger Iroha Project and Development
Hyperledger Iroha is a general-purpose permissioned blockchain system hosted by The Linux Foundation. It was contributed by Soramitsu, Hitachi, NTT DATA, and Colu.Hyperledger Iroha is written in C++ and incorporates the BFT consensus algorithm, named Yet Another Consensus (YAC). Hyperledger Iroha consists of simple deployment and fast development. It can be used in applications that manage digital assets, identity, interbank payment, and so on. Follow below link to install Iroha on Amazon Web Services or AWS:
https://myhsts.org/tutorial-learn-how-to-install-blockchain-hyperledger-iroha-on-amazon-web-services.php
For the next step, follow below two tutorials for building your blockchain application using Iroha:
https://myhsts.org/tutorial-learn-how-to-work-with-hyperledger-iroha-cli-to-create-cryptocurrency.php
https://developer.ibm.com/recipes/tutorials/configuring-hyperledger-iroha-peer-node-and-network/

VII- Hyperledger Burrow Project and Development
Hyperledger Burrow is one of the Hyperledger projects hosted by The Linux Foundation. Hyperledger Burrow was originally contributed by Monax and co-sponsored by Intel. Hyperledger Burrow provides a modular blockchain client with a permissioned smart contract interpreter partially developed to the specification of the Ethereum Virtual Machine (EVM). Follow the below recipe to install Burrow on AWS:
https://myhsts.org/tutorial-learn-how-to-install-blockchain-hyperledger-burrow-on-amazon-web-services.php
For next steps, follow below tutorials to build your blockchain application using Hyperledger Burrow:
https://developer.ibm.com/recipes/tutorials/deploying-and-calling-ethereum-smart-contracts-on-hyperledger-burrow/
https://myhsts.org/tutorial-learn-how-to-build-and-deploy-ethereum-smart-contracts-on-hyperledger-burrow.php

Summary
In this article, we reviewed blockchain Hyperleger project such as its frameworks and tools. We also cover its 5 development frameworks- Fabric, Iroha, Burrow, Indy and Sawtooth and two most popular tools- Composer and Explorer. To learn and master blockchain development, it requires patience and consistent training. Also, Hyperledger development libraries and resources are updated frequently, so it is good to check their website and use their latest documentations.

As of this writing, Hyperledger Foundation offers the following two Hyperledger certifications: The Certified Hyperledger Fabric Administrator (CHFA) and The Certified Hyperledger Sawtooth Administrator (CHSA), both of which are highly regarded in the industry. Hyperledger Foundation is in the process of creating Hyperledger Developer certification program, which may be released in early or middle of 2020.

About Authors
This article is written by Matt Zand (Founder of High School Technology Services, Hash Flow, and Coding Bootcamps) in collaboration with Brian Wu who is an advisor at DC Web Makers.

Essential Developer Guide for Building Blockchain Applications Using Hyperledger Sawtooth

Matt — Mon, 08 Jul 2019 14:02:30 +0000

Hyperledger Sawtooth is an enterprise blockchain platform for building distributed ledger applications and networks. The design philosophy targets keeping ledgers distributed and making smart contracts safe, particularly for enterprise use.

Sawtooth simplifies blockchain application development by separating the core system from the application domain. Application developers can specify the business rules appropriate for their application, using the language of their choice, without needing to know the underlying design of the core system.

Sawtooth is also highly modular. This modularity enables enterprises and consortia to make policy decisions that they are best equipped to make. Sawtooth’s core design allows applications to choose the transaction rules, permissioning, and consensus algorithms that support their unique business needs.

For those who are not familiar with Hyperledger project Intro to Hyperledger Family and Hyperledger Blockchain Ecosystem and Hyperledger Design Philosophy and Framework Architecture articles are strongly recommended.

The features offered by Hyperledger Sawtooth are the following:

A truly distributed DLT: The Hyperledger Sawtooth blockchain network is made up of validator nodes. The ledger is shared between all validator nodes and each node has the same information. They participate in a consensus to manage the network.
Proof of Elapsed Time (PoET) consensus and support for large-scale networks: Hyperledger Sawtooth includes a novel consensus algorithm, PoET. PoET is a Byzantine Fault-tolerance (BFT) consensus algorithm that supports large-scale networks with minimal computing and much more efficient resource consumption compared to proof of work algorithms. PoET was invented by Intel and utilizes the special CPU instruction set called Software Guard Extensions (SGX), to achieve the scaling benefits of the Nakamoto-style consensus algorithms. Each node waits for a random period of time and the first node to finish is the leader and commits the next block.
Fast transaction performance: Hyperledger Sawtooth keeps the latest version of assets in the global state and transactions in the block chain on each network node. This means that you can look up the state quickly to carry out CRUD actions, which provides fast transaction processing. Sawtooth requires transactions to be processed in batches and supports parallel scheduling of transactions. Parallel transaction execution not only accelerates the execution of transactions but also correctly handles the double spending problem known as Unspent Transaction Output (UTXO).
Support for a broad variety of languages: Sawtooth supports the implementation of transaction families (safe and smart contracts) in a wide variety of programming languages, including Python, Go, Rust, Java, and JavaScript.
The ability to configure private, public, and consortium blockchain networks:

Sawtooth can be configured with different permissions to build private, consortium, or public networks by specifying which nodes are allowed to join the validator network and participate in the consensus, and which clients are allowed to submit batches and transactions.

In this article, I give step-by-step guide for building blockchain applications using Hyperledger Sawtooth. Good knowledge of blockchain concepts, JavaScript and Python as well as basic skills in Linux OS is required in order to complete tutorials listed on this article.

In short, we follow below steps:

Install Hyperledger Sawtooth on a cloud service like AWS
Configure Sawtooth validators and REST API
Design a namespace and address for a transaction family
Implement a transaction family
Build a transaction processor
Grant permission on the Sawtooth network
Develop client applications with the Sawtooth REST API and SDK

To help blockchain developers to find their feet in Hyperledger Sawtooth development, I’ve written a series of hands-on tutorials to cover each topic in depth as follows.

Install Hyperledger Sawtooth
Follow Install and Work with Hyperledger Sawtooth recipe.

Configure Sawtooth Validators and REST API
Follow Configuring Hyperledger Sawtooth Validator and REST API on AWS recipe.

Design a Namespace and Address for Transaction Family and Implement Transaction Family
Follow Designing Namespace and Address for Hyperledger Sawtooth Transaction Family recipe

Build a Transaction Processor and Grant Permission on the Sawtooth Network
Follow Building Transaction Handler and Processor for Hyperledger Sawtooth with Python SDK recipe

Develop Client Applications with the Sawtooth REST API and SDK
Follow Transaction Processor and Python Egg For Hyperledger Sawtooth recipe.

About Authors
This article is written by Matt Zand (Founder of High School Technology Services) in collaboration with Brian Wu who is a senior blockchain instructor at Coding Bootcamps.