 Before we jump into the demo, I have just a couple of slides just to kind of set the context for what we're going to be looking at in the demo. So we kind of know what we're looking at as we are looking at it. So I'm going to go ahead and share my screen and hopefully you can see my slides. Nobody's complaining. Okay, great. All right, so just want to start off briefly with talking about what we're going to see. When we built Firefly, we wanted to create a really easy to use developer experience. We wanted it to be quick and easy for people to get started with. We wanted the experience to be powerful enough to meet the needs of experienced Web3 developers, but also kind of help people get started who maybe this is their very first Web3 project. We wanted it to use tools that felt familiar. And we also wanted it to be able to run everything offline on a laptop, even if you are on an airplane. You can work on building an app against Firefly's API completely offline once you've downloaded everything ahead of time. So that's the developer experience that we're going to see. So here's what we're going to run today. I'm going to run the Firefly CLI and I'm going to create a local developer environment on my machine. This is using all open source tools. You can find the source code for all these tools in the Hyperledger Firefly Git repose. So that the CLI behind the scenes will use Docker Compose to run all of the components of a super node right on my laptop. So what does that look like? Here's a little picture. This is a picture of two different super nodes that we're going to be running. I'm actually going to be running three. I didn't show the third one here just for the sake of space. But within our super node, there is a Firefly core. And this is the brain that Peter was talking about earlier. This is the orchestration engine and it also provides the API layer. And it also hosts the web UI layer that we'll be looking at as well. The Firefly core talks to a lot of different systems. Each of these is going to be running in a different Docker container on my machine, including a database, data exchange, a blockchain node, a tokens connector, and a variety of other things. Outside the super node, we are also going to be running an application called the Firefly Sandbox for each member of this Firefly network that we're going to be building here. At the Firefly Sandbox, you can think of as an application, an end user application that's written to use Firefly's API. So it's both an example of how you can build an app. And it also provides code snippets that you can use to copy and paste into a back end application using the Firefly SDK to build your own app. OK, so this is kind of the topology of what we're going to look at. So I'm going to be running Firefly in what we describe as a sort of a multi-party network, a multi-party mode, where there are multiple Firefly nodes. You could think of each of these as being run by a different organization in a network. So we're going to look at the Firefly dashboard and the Firefly Sandbox. Those are screenshots of them, but even better than a screenshot is actually seeing the real thing. So let's hop over to my other desktop here. This is the Firefly Explorer, or the Firefly UI. This is a web front end that is being hosted by Firefly Core. And it's sort of an inspector of view into the system. So in here, we can see a network map. We can see I have three members, and I've labeled them red, green, and blue. So here's the red number. And I've also have three different Chrome browsers up in here, a red browser, a green browser, and a blue browser. Just so we can visually compare. So here's our network map. Right now, I haven't run any transactions on this network. So that's why you're seeing no activity. But let's do some transactions now. I'm going to open a new tab, and I'm going to open the Firefly Sandbox. Actually, before I do that, what I didn't show you is that while before I started sharing my screen on my other desktop here, I run the Firefly CLI, and I've started a network of three members. And it prints the URLs for the Web UI and for the Sandbox for each of these members. And those are the URLs that I open to my browser. Separately, I've also deployed an ERC-20 and the ERC-721 contract to this chain. On the right-hand side of my screen, you can see this Liberty source for the ERC-20 contract. It extends and opens up one ERC-20 contract. And it adds just a little bit of custom functionality on top of that to be able to mint and transfer tokens with data. So we'll come back to this in just a little bit. But what I want to show you first is the Firefly Sandbox. So like I said, this is both an example and user application and also shows you how to build each of the different things that you can do with Firefly into your own application. So on the left-hand side here, we have a form that we can fill out. And across the top, we have these three tabs. And these are really the three major buckets of features that are in Firefly 1.0, the things that provide the functionality, those three pillars that Peter talked about, apps, flows, and digital assets. These can be grouped into these three categories here. So what I want to start with is custom contracts, because that's the thing that people oftentimes think of first when they think of, hey, I want to build a blockchain application, oh, I need a custom smart contract. How am I going to do that? So excuse me, for this example, we're going to use a custom ERC-20 contract, the one that I just showed you a minute ago. But this could be any custom smart contract. It doesn't have to necessarily be an ERC-20. It could be something entirely different. What I'm going to do first is I'm going to define a contract interface. A contract interface in Firefly is a way to describe a custom smart contract, or any smart contract, in a blockchain generic way. So it encapsulates important specific blockchain information. But it also describes the entire contract in a way that Firefly, I could describe both a Solidity contract or a Fabric Chain Code using a Firefly interface. So for blockchains that have a built-in format to describe smart contracts, their events, their functions, their parameters, and all the type of information, such as Ethereum's ABI format, there is an API built into Firefly to automatically do this conversion for you. So if you have the ABI for your contract, you can actually copy that right into the Firefly Sandbox, which is what I'm going to do here. So I'm going to pick ABI, Solidity Application Binary Interface. I'm going to go back over to my source code. And after I've compiled the contract, I get a JSON output. And I'm just going to copy the ABI here. It's long. And I'm just going to paste that right here. I'm going to give this contract interface a name. We'll call this just ERC20 with data. And we'll say this is version 1.0. And I'm going to run this. What happens when I run this? We'll see off on the right-hand side. There are some things going on. But before we look at the events, immediately we get back a 202 accepted. We get an ID here that we can use to track that request through the system. So Firefly has a very asynchronous programming model that's event-driven. And so when you submit things to the system, if it is accepted into the system, you'll get a 202 and an ID back. And then the general pattern is that you either have a web socket or web hooks that are listening for events coming out of Firefly. So in this case, we've received some events. Those events indicate that we have broadcasted this Firefly interface to all of the other members of the system. And so what this means is now we can go into our dashboard. I can reload this. And we'll see that there was a batch pin transaction that happened. Let's go look at the off chain. We can look at data. And we can see there was a definition that was created here. And this is the definition of my smart contract that I just uploaded. Well, that's great. We submitted it so it's appearing in our dashboard. But because it was broadcasted to all the other members of the network, I could hover over to the blue node as well. And I could look at the off chain data tab here. And I could see the same definition. So when we created a definition in a Firefly network, it's a way of defining a piece of data or defining some sort of structure that all the members of the network should know about. In this case, it's this contract that all of these members will be interacting with here shortly. So that's great. Now, how do we actually use our contract? So the next step is to build an API endpoint for it. So to do that, we're going to register a contract API. We're going to select the contract interface that we just created here. And I'm going to call this ERC20. And then I need to give it the contract address. So I'm going to go back over to my terminal where I deployed this earlier and just copy the contract address. I'm going to paste this here and run that. This will also get broadcasted. As we can see, we received an event that the message was confirmed. And now what this has done is this has built an API endpoint that we can use to interact with our smart contract. In addition to just creating endpoints, it's also created full open API three spec and a swagger UI that we can open and we can interact with our contract right here in our browser. So let's mint some tokens now. I can invoke methods on the contract. So I can invoke mint with data. I can click try it out. Let's mint a thousand. We can send some data with it because this is our custom mint with data function. I don't need to send any particular data right now. So I'm just going to use a null hex string. And then I need to provide the two address. This is the Ethereum address that I want to mint these tokens to. I'm going to mint them to myself for now. So to find my Ethereum address for the red node, I'm going to go back to the Firefly Explorer and I'm going to look at the network. Under organizations in the network, I can see the list and I can see this is my org or your org. That's what it says. I'm going to click here and then under the verifiers section, there's an Ethereum address. And this is the address of the wallet for the signing key for the red node in the network. I'm going to go back to my swagger UI and paste that here and I'm going to click execute. So immediately we get a 202 back and what I'm also going to do now is we're also interested in when tokens are transferred on the network, we would be great to receive events for those as well. We can see on our swagger that there are listener endpoints as well to set up a listener to tell Firefly these are important blockchain events to listen to. And I would like you to notify my application when you receive them. We can do that right through the sandbox. So we're going to create an event listener or a contract listener for my ERC 20 contract on the transfer event here. And then we'll send this to a topic called sandbox. I'll run that. So we've created that. And now I'm going to go check the just to make sure we have some balance in there. I'm going to do a query now. This is a read-only operation. Click try it out. I'm going to paste again my address here and we should see we have a thousand. Yep, we do. Okay, great. So let's do a transfer quick and we should see that event come in. So we're going to go back up here to we're going to invoke because this will perform a blockchain transaction. Try it out. Let's send a hundred and let's get the address of the green node this time. So again, we'll go back to the dashboard and look under organizations. And under the verifiers, we'll get the Ethereum address of the green node and we'll paste that here. Okay, we get 202 back. Let's go check the balance of the green node now. So we'll go back down here to query the balance of it. Let's check our own balance first just to make sure. Yep, so now we only have 900 and we'll check the green node and green node has a hundred. Okay, that's great. Let's take a peek back at the sandbox. We see that while we were doing that we received some blockchain events and that was because we set up that contract listener. We can start receiving events from this custom smart contract as well. Let's go take a look at the Firefly Explorer and see what was going on inside Firefly while we were doing all these things. So we can look at the blockchain dashboard. We can see that there were several batch pin events from broadcasting the contract and the API. We can also see that there were two transfers here as well, one was the actually the Mint because Mint actually just does a transfer behind the scenes and the other was the transfer of the 100 tokens to the other node and we can click on it and see the output. See it was from this address to this address and we transferred a hundred. So that's great. I realize I'm running out of time here so I'm gonna try to speed things up here a little bit but this is the sort of the kind of the building blocks of being able to work with custom smart contract logic with Firefly and just really developer friendly APIs. Now, as Peter was talking about earlier, hypothetically, what if this was a token contract that's been on a public chain as an example for maybe even years and there's been a lot of transactions on there and we wanna build a history of what has already happened on this chain. That's where the Firefly token connector comes into play and that's where the concept of a Firefly token pool is used. So to do that, even though this contract has only existed for about five minutes and we've only had two transactions on it. We're gonna use this as a hypothetical example here. So let's create a new token pool. We'll call this FFC for Firefly coin. We'll give the symbol as FFC. This needs to match what was in the smart contract when it was deployed and I deployed it as FFC. It is a fungible token. We could also select non-fungible if we wanted to reference our ERC 721 contract. But I'm gonna go back here and grab the contract address of my deployed ERC 20 and I'm gonna paste that here and I'm gonna run that. Now, what we'll see is there was, we created a token pool and then a bunch of other things came in. And what that was was the token pool, sorry, that the token connector was talking to the blockchain and it began indexing all the transactions that were already on chain. So now if we go back and look at our Explorer, we can go to the tokens tab here. Under the token section, we can look at the dashboard and now this is a brand new page that's just lit up because we've created this token pool. We can see account balances for everyone that has a balance on here. And you'll notice that there's a lot of zeros here. That's because our contract, if you're familiar with the ERC 20 has the concept of decimals. And so this lets people work with fractional tokens even though the Ethereum EVM only supports integers. So that's what we're seeing there. Likewise, the Firefly Sandbox also provides ways to mint and transfer right here, right in the Sandbox UI. So you could go straight to here and you don't have to actually interact directly with the Swagger if you wanted to. I just wanted to show that sort of building up from a custom smart contract all the way to these rich tokens APIs now. So let's mint 100. Now again, this is going to be 100 times 18 just because of the way this is represented in the user interface. So I'm gonna run that. And then I'll demonstrate a transfer now to let's see, I think we transferred to green last time. Let's transfer some to blue because he doesn't have any. And we could optionally attach a message to this as well. For the sake of time, I'm just gonna kind of scoot through this here a little bit. And then finally let's burn one just so we can see what that looks like in the dashboard. So I ran several different token transactions there. Let's hop back over to the Explorer and refresh. Now we can see our new account balance has been reflected immediately here. And we can see the other transfer. You can see who it was from to the signing key that was used, the actual data from the event. And here's our burn as well. So some amazing things just make it super easy to do stuff with tokens. I don't have time to also show non-fungible tokens, but you can do all of the same things with non-fungible tokens as well through here. And it's really powerful, really easy quick up to get up and started. The last thing that I want to touch on just real quick and then we'll do some Q and A is messaging. Messaging is a foundational component in Firefly. It's a very foundational component in building distributed applications. I have data on one system that I need to send to another party or to another system. That could be a simple string. It could be a JSON object. It could be a JSON object that conforms to a certain JSON schema that I've defined that represents an important type that members of the multi-party network have agreed upon. And it could actually just be a file as well. I could click here and I could upload a file directly to here. So for this, I'll just send a string. So this is going to be a broadcast message. Just like when I was broadcasting the Firefly interface, this is just going to broadcast a string to everyone. So I'll run this. I'll wait for my batch pin to be confirmed here. And then let's go take a look at the blue node here. We should see under off-chain data, which is where we're at already actually, I could click here and here is a message. Let's take a look at the green node and look at off-chain data as well. And here is the message as well. So in these cases, as someone mentioned in the chat earlier, yes, there is a blockchain transaction and the payload of the message is hashed and it's pinned to the blockchain. The actual payload remains off-chain. It remains in a shared storage mechanism. And this is what we're seeing here. This is what's why the data is under the off-chain tab here. Likewise, we can also send private messages as well. So under private messaging, we could send one just to green. We'll say this is a secret message to green. We'll run that. We should be able to see this in our own dashboard. Let's go look at off-chain data. Indeed, there's our secret message we sent to green. Should be able to see it in green's dashboard. There it is. But if we go back and look at blue's dashboard, we'll notice that the blue node does not see that message at all. So that's just a really quick snapshot of messaging. Messaging is really important. There was a lot of different features in it as well. I don't have time to go into all of them, but hopefully this was just a very quick taste of some of the things that you can do with Firefly and gives you an idea of how you can get up and started with it. There are guides in the documentation that will walk you through using a Firefly CLI, installing a Firefly CLI, using it to set up this same environment that I just built, running the Firefly Sandbox and begin walking you through each of the three sections of messages, tokens and contracts. So thank you all very much for watching and listening. I hope this was informative and I can't wait to see what you will build with Firefly. Thank you very much.