Hedera Workshop - ETHGlobal San Francisco 2024

I have been formally part of the Hideera ecosystem for three years, and I have been testing the SDKs and following the progress from the outside for almost four and a half years. As far as my professional interests are concerned, blockchain and its convergence with other technologies are very interesting to me technologies are very interesting to me ; Specifically the intersection with AI, where I see a lot of potential, and I've developed some fun plugins and utilities there. So we only have 20 minutes and I want this to be practical. Therefore, I want to go through these slides fairly quickly. My goal today is to let you know what Hideera is, why you should build on it, and how you can get started.

Let's start with: what is Hideera? Hideera is an open-source Layer 1 network compatible with EVM. I'll leave it at that. That's a set of concepts that's quite familiar to this audience. And when thinking about what makes Hideera different, I like to divide it into two categories.

One is technology. The other is governance. When it comes to technology, Hideera has a next-generation consensus algorithm that makes it truly scalable. It makes it fast and very safe scalable. It makes it fast and very safe .

I mentioned in the previous slide that Hideera is compatible with EVM and uses the Hyperledger Besu EVM client as the execution layer for smart contracts. A key differentiator is that it not only has efficient, fast, economical and scalable smart contracts. It also offers things beyond EVM and smart contracts. We have other services that I'll tell you about for tokenizing, creating timestamps and logs, and you can access them through SDKs in languages ​​like Java, JavaScript, Go, Swift, C++ and Rust. So, whether you come from the world of Web 2 or Web 3, Hideera offers you an easy entry point.

Thanks to this technology and this next-generation consensus algorithm, there are other benefits such as consensus without leading nodes and also fair ordering. So there's no MEV for me in Hideera. Some say that the MEV is a function, but it's a function until it happens to you. Here you have a fair ordering, which is important for several use cases. When we think about governance, we have a global council of organizations that make decisions organizations that make decisions , run operations, and create use cases on the network, including names like Google, IBM, Ubisoft, LG, and many more.

But it's not just for businesses. There are also many Web3 projects and a small community of Web3 ecosystems being built on Hedera. The other differentiating factor is sustainability. It is the most environmentally friendly network on the market in terms of energy consumption. This is a study conducted by University College London that shows the energy consumption per transaction of Hedera.

What can be seen here is that with the same energy required for one Visa transaction, approximately 1,000 Hedera transactions can be carried out . So it's a massive improvement in the order of magnitude that this represents. When thinking about why to build on Hedera, I already mentioned aspects of technology and governance, but there is also a very active community of projects, startups and founders, and we see many active developers joining global events, hackathons and meetings, actively participating in the network. We have over 100 applications deployed on the main network, and to date, we have processed over 70 billion transactions on the main network. That is, by far, the highest number of transactions I know of for any public network.

In addition, we have seen very healthy growth in total accounts and also year-to-date, with millions of accounts created this year alone. Another reason is that we have excellent hackathons and incentives to help you familiarize yourself with the network and start building, so that you can eventually deploy on the main network and serve your customers. Here at ETH San Francisco we have $10,000 in rewards, with prizes for EVM beginners, for people just starting out with our native services, and for more advanced developers who can build something compelling and earn $4,000. I'd be happy to tell you more about it at our booth. We also have a big hackathon coming up in a month.

Registration opens on November 11. You can register now. That event has a total prize fund of $300,000 for the winning projects. You can find more information at hedera.com/hackathon.

Let's start building in Hedera. What we're going to do is quickly review the services . Regarding the services I mentioned earlier, we have smart contracts that you can see on the right. We have a tokenization service that allows you to create tokens even without Solidity, using only Java, JavaScript, Go, and other languages. Fungible and non-fungible tokens can be created , which is very attractive to those coming from the Web2 world.

And we also have a consensus service for creating decentralized records and logs . So you can think of this as a decentralized messaging bus that allows you to have topics and also messages within those topics. And this is the part of the technology stack that is governed by the Council of Hedera. And it is on that basis that developers like you create compelling use cases and applications that serve end users. So with all that context in mind, let's go in and open this repository to choose your own adventure on how to create a token on Hedera.

I'll leave this URL here for just one more second, or if you want to copy the short URL, feel free to do so. Very good. So now all you need to follow this workshop is a browser and a GitHub account. Hopefully, most of us already have a GitHub account. What we'll do here is, if you go to the repository linked in the slides, you can open it in GitPod, which will automate any necessary configuration.

Now that we're here, what you'll see is that this will open three different terminals this will open three different terminals . The first two only run background processes, and this is the main one we will use to follow our tutorial. What we will do is create or implement an ERC token on Hedera and then implement a native token on Hedera, just to show you those two routes to tokenize on this network. We will begin by generating a seed phrase. This will be a BIP-39 seed phrase.

And we'll only do that with the default values. So we can just press enter here. Next, I'm going to... here. Next, I'm going to...

let me zoom in a little more. Starting from that seed phrase, we are going to generate accounts, Hedera accounts. And the default value will be three. We'll continue with that. And we're also going to instantiate a JSON RPC URL endpoint so we can send transactions to our network.

If you're using JSON RPC, it means you're probably working with smart contracts. And the other native services, such as the token service or the consensus service, can be accessed directly through the SDKs. In this case, we will continue with this RPC JSON URL value. And then we want to enter a private key or generate one. In this case, we will also generate one randomly using the default value.

Just press enter there. And now what we have to do is fund this account. So we're going to fund this account by going to the Hedera faucet. So, if we go to faucet.portal.

hedera or portal.hedera.com/faucet. Let's give it a second here. Now we can enter our EVM address and just like that we can receive 100 Hbar to start our development and testing.

So you see, from that EVM address we were able to create and fund an account. And now that that account has funds, we can continue here. And what you'll see is that he's also creating some additional accounts. So those values ​​you see there in the terminal will now be written to our .env file.

If we say yes, then we'll have those variables on the disk, right? And now we can start working with all these things. And what you see here is that our JSON RPC is already instantiated. It is active. Um, and we can probably start deploying our ERC token or ERC contract on Hedera.

So, what we'll do is use the files in this folder. That is, HSCS token, which stands for Hedera Smart Contract Service. So, we'll just make a classic CD. And there you see that we have some files. Um, we can also show them here.

But what they do have is a script that we'll use to walk through the deployment and interactions step by step. So we'll do ./script. And that will guide us through all the steps we need to follow. Here we can see the lines of code that we will execute up to a certain point once we press enter.

And the first thing we're going to do is verify the Solidity code that we're going to deploy. The Solidity contract we are deploying in this case is a very basic implementation of an ERC20 token. In other words, only the bare minimum you need to be able to deploy it. So let's proceed to execute it. Next, we need to load the EVM bytecode and also the ABI of our contract.

So there's the code that indicates we're doing it. In this case, we have not performed the compilation, so it will give an error, which you will see here. That's to be expected. And obviously what we need to do now is compile that smart contract into bytecode and also generate the ABI to have the summary of the different functions we have in that Solidity file. So let's do it with npm run.

And there you can see the different options we have. So the one we want is this one to compile smart contracts, because it will basically run a solcjs build that gives us the ABI and the binary for the my token contract. So let's run mpm run compile. smart contract. Ready.

Now you can see that we have a lot of artifacts here, binaries and interfaces. And now we can go back to our script and try running it one more time. Yes, we are verifying. Let's proceed. Let's load.

And you see that we were able to obtain the constructor, the ABI string, and here's the important part: the different functions we will have; In this case, the function we will use later will be this transfer function in our smart contract. Very good. Now let's verify that our JSON RPC is active. Let's verify it with two connection points here. That is, get block number and get balance.

So we simply called it and, sure enough, it was active. Now we can send our EVM transaction to deploy our contract's bytecode. So we'll do that right here. We are using a deploy contract. In fact, I forgot to mention that in this file we are using VM for implementation and interactions with the contract.

So we used this deploy contract. Here we are passing the ABI, the bytecode, and some arguments for the constructor, which are just the token symbol and the token name that are passed right here. So let's move forward with that implementation. And this transaction is usually one of the heaviest in Hedera. It will probably take a little over 3 seconds.

That 's normally the timeframe we 're working with right now . And once this is completed, you will see the different links for the successful implementation of the contract. We can go to HashScan, which is a transaction or network explorer transaction or network explorer . We can see the details of the implementation transaction. There we see that it is a type of Ethereum contract creation transaction and some other details.

And if we come back here, we can also see the URL of the contract that was just implemented. So, instead of a transaction, we are seeing a network entity. Here is the contract and its details. And now we see all the bytecode and also all the assembly bytecode, plus some additional sets of information like events, but it's not readable. It is not human-readable.

The next step we want to take is to verify that smart contract to gain greater visibility into the source code, the API, and the events that are part of that smart contract. I already ran it here, but what you'll see is that Hashscan, the network explorer, has a Sourcify instance that allows us to perform that smart contract verification. Now, if we go back to our contract and update here, you will be able to see that the contract has been programmatically verified with a full match. So now we have a few more tabs, not just the bytecode. We have the actual source code and the API.

And something I didn't mention is that in the verification process, what was sent was the source code, was sent was the source code, right? The Solidity code and also the metadata that resulted from the compilation process. So, that verification simply makes this browser more useful. And what's more, they can interact with their contract's features directly from there. Now, we're going to send a transaction to basically write a value and change the state of that smart contract.

What we are going to do is a transfer. To do this, we use this object, or the client object, " this object, or the client object, " write contract". We pass the deployment address we want to call, the API, the function we're going to use, and then the parameters for that function then the parameters for that function . That is, the recipient and also the number of tokens we are going to send. So let's proceed with that.

Here it is . The transaction was successful. We see the state. We also see the URL in Hashscan here. And we can see information here about this specific transaction.

The entrance, which was the receiver; the amount of tokens we transferred and the output, which is "true", indicating that the transaction was completed. And there are more details about the call trail, the contract status, events, and so on. Very good. Now that we have sent a transaction, let's send a query. We're going to read about that smart contract, right?

This is not actually a transaction This is not actually a transaction . It's more of a reading query, since it does n't actually affect the status. So we use "read contract" for that. We are pointing to our deployed address. We provide the API, the function name, which is " function name, which is " balanceOf".

And then we're going to enter the address of the account whose balance we want to check. So let's proceed with that. And right there we see that there are 100 token units. The other part I wanted to show you, again, we just covered the deployment, interactions, and verification of a smart contract. That was an ERC20.

The other part I would like to show, although I do n't think we'll get to see it due to lack of time, is creating a token directly without even deploying a smart contract. And this is what we call a native entity residing in Hedera. Because of that smart contract, or sorry, because of the Hedera token service I mentioned earlier. As you can see, it's just an import from the SDK package. And then the deployment happens very easily using this token creation transaction, setting up the token properties, and then we go through the process of associating an account with that token and transferring it.

But this is code that everyone can inspect, that they can test very easily, and that will hopefully be useful for the hackathon portion of this event. So I'll stop here to see if there are any questions here to see if there are any questions , or if not, we can close and continue. Fantastic. Thank you all so much for tuning in and joining us live.