 So, okay, I'm going to use the set of slides. The way to get started with Firefly is using its command line interface. One can spin up a local development environment in seconds and immediately start building an application against it. We'll cover the command line interface in detail during the workshop. What I wanted to cover in this course part is how the architecture looks like when running Firefly locally. That way, when we use the command line interface, we know exactly what's taking place under the covers. We're going to use two members. On the left, we have member zero. And on the right, we have member one. Now, since we're going to be doing local development, we're going to have the members, both members, running side by side on the same laptop. That way, we can build and test complete end-to-end flows. Each member will have its own Firefly core running. And also, each of these Firefly cores will have its own database. The blockchain component is used to run transactions on the blockchain and also to listen to events from the blockchain. What we have in between the two is the actual blockchain. Then we have another component that is called public storage. So this is used to share public data in between the members. Now, a quick clarification when I say public is always within the domain of these members. Now, the public storage uses peer-to-peer communication. So that means that these components can talk directly to each other from one member to another. The private data exchange component is used to send and receive private data in between the members. Just like with public storage, it uses peer-to-peer communications, which means that they can talk to each other across members. Finally, we have the client application. This is where their development will be focused on. Not that Firefly will orchestrate all of their own chain and off-chain logic and storage. The application simply has to be written against a very simple RESTful AP, like the Firefly. When running Firefly locally, the command line interface will spin up a number of other containers. These containers will have each of these items that we just listed now. Specifically, for the case of the blockchain, what we're going to get is a traffic ganache. For the blockchain interface, we are going to have ifConnect. All of these projects are available in the repositories for more information. Now, for the public storage, we use the interplanetary file system, or IPFS, and mutual TLS data communications is used for the private data exchange. Finally, Postgres is used for the database. Okay, so that was a very quick summary of how the architecture looks like when running Firefly locally using the CLI. So I'm looking forward to seeing the rest of the examples. We'll see if that's too unique. Cool, thanks Gabriel. Is it possible for me to share my screen? Great. Okay, so great to meet everybody. I hope everyone can see my screen. Okay, please tell me if it's doing anything funny. My name's Nick. Okay, super, thanks, Sophia. Yeah, my name is Nick Gasky. I was involved very heavily with Hyperledger Fabric Project many years ago, and really excited to work with the broader community on all things Firefly. So I'll be one of your main points of contact, and weekly or bi-weekly dev meetings in Rocket Chat and separate one-on-one Zoom meetings. So we really welcome everyone to the community, and really excited to have everyone on this really exciting technology. So this is the hands-on workshop. We're gonna actually install this stuff on our machines. We're gonna run some code. We're gonna look at those core interfaces that Gabriel just talked about, our Ethereum shim, the public storage IPFS, the TLS-secured private data exchanges, the Firefly core, and all of this functionality that's encapsulated and abstracted into a really simple REST API. We'll show you some running user interfaces and applications, and you'll get a sense of how easy this is to use and how extensible and how powerful it is. So the first thing I wanna draw your attention to, and I posted this in the chat, but I'm gonna post it one more time just so that everybody has this, is this getting started on Firefly cheat sheet that we have right here. Go back to the chat and just make sure everyone has this link. So again, I'd like everyone to please visit this and start taking a look at all of the different dependencies that we need. As Gabriel mentioned, the first thing, kind of the beating heart that's gonna make your life easy using Firefly and interacting with these different interfaces is the command line interface. It's a powerful, powerful stack of functionality, and it just takes a couple commands to stand up a full Firefly stack and then to actually start exercising some of the available methods and commands inside of Firefly. So this is the first thing that we're gonna need everyone to do is actually follow along with this section right here, the references and dependencies and the overall Firefly CLI section. So two non-negotiable dependencies that you have to have in order to get this CLI cooking on your machine. The first is Go. It will work with older versions of Go, but we do highly recommend kind of the more cutting-edge LTS version version of Go, 16.5. The other thing that you need, which I have to imagine 99% of folks have is Docker and all of you probably have Go as well. So I'm gonna sort of drag my feet for a couple of minutes and let any folks that don't have this installed go ahead and sort of start doing that in the background. And I'll also mention, as we're doing this, this is meant to be as interactive as possible. So oftentimes, things go wrong. We're trying to compile and build stuff locally. There may be just ambiguity in your own point of view. So this is the greatest session for you to raise your hand, speak out loud, throw any questions in the chat. If you're completely lost and completely broken or you really would rather have a business conversation or something, let us know in the chat. We have a lot of folks here inside of the room and that are hands-on deck with Kaleido and with Firefly. And we're more than happy to talk to you in sort of one-off or private settings or to answer your questions inside of the chat. So just want everyone to feel as comfortable as possible. There are no such things as bad questions and nascent open source projects or in technology in general. So don't be shy. We're friendly. We're here to help. And we really would love to get to know everyone and interact with you as well. So as you've sort of gotten go and gotten Docker, which again, I imagine everyone has, you're going to either call one of these go commands on your machine, go grab the latest CLI or if you don't want to update your go, you can go grab one of the tagged images, one of the pre-images right there. Okay, so I'm going to start showing you guys how this is going to work sort of in real time, the things that you're going to be able to do. The first thing we'll do is we'll actually check, right? We're going to check and make sure that we have Firefly installed. This command right here, the go install or the go get, this should have only taken about a minute on your machine right there. So I'm assuming that all the folks that had go and all the folks that had Docker have already gone ahead and issued this command and hopefully you have an executable FF command that's available on your machine. If you have that, you're going to see something like this. So this is going to show you the available commands and the available flags right here. What we really care about is just kind of three core commands inside of Firefly. We care about this init, which is going to be kind of a high level wrapper about the configuration of our stack. Namely, we're going to give it a name and we're going to give it the number of members that we want inside of our Firefly ecosystem. We're going to do this with three because obviously if we're just using two members and we're doing these bilateral transactions with two members, you could argue that they're private, but they're not private from anyone else inside of the system. So what we're going to do is we're going to stand up a Firefly stack with three members. We'll look at broadcast transactions where everyone gets the data and then we'll look at some of those private transactions where instead of using IPFS, we're using that TLS sort of peer-to-peer protocol right there to directly send messages to individually enumerated participants. So init is essentially just the config of your stack right there. Start is kind of the more exciting command. This is going to bring down all of those core Docker images onto your machine. This will give you the Ethereum adapter. This will give you the Firefly core. This will give you that Gnash CLI for local, lightweight, super fast blockchain development. And it'll also start up those corresponding containers as well and provide you with some local host endpoints where you can see a user interface for convenient interaction and inspection as well as an embedded swagger API. So you can sort of take a step backwards and get closer to how you're really going to interact with Firefly, which of course is programmatically. And then the last one that we see here is stop. So this will just stop the containers. And if you want to start from scratch, you can use Firefly Remove. So those are kind of going to be your babies right here for step one, but you'll get very familiar with in the shorthand. So I'm going to pause there. I'm just going to check the chat intermittently and make sure there's not too many questions going on here. I see Nico's doing a great job helping folks with sort of if you're running on Windows or you need to stand up a VM or you're running on Linux. So thanks for that, Nico. And then you have Peter and Andrew and all of our subject matter expertise. So it looks like chat is the greatest way to put your questions in. Okay, so without further ado, let's go ahead and stand some of this stuff up. So feel free to participate alongside with me or you know, this is a recorded demo. So you can just follow along. You can watch this and then you can use the recording, you know, as a guiding artifact if you want to do this after the fact. Okay, so let me give myself a little more space and I'm going to go ahead and create a stack called data transfer. So now it's going to ask me for the number of members. Of course you can choose two members if you just want to get started and you just want to see the core flows. I'm going to go ahead and choose three again. Could you zoom your command line windows? Yeah, yeah, of course. Sorry about that. Thanks, Nick. Are we getting closer? Is that a little better? Yeah, that certainly looks better to me. Hopefully for Anna as well. Super. Okay, yeah. Apologies to folks. I'm going to throw it in the chat and Peter or someone will yell at me and we'll make it even bigger. Okay, so again, this is just the wrapper for my Firefly stack. This is the config. I gave it a name of data transfer and we're going to do three members right here. So cool, we're happy. We can see the composed file right there telling me where it is. And now it's telling me that if I want to start this stack, I just say FF start data transfer. So again, I'm going to steal some more room. Remember, this is going to take some time. This is going to go ahead and download those Docker images. This is going to stand up your local ganache interface. This is going to instantiate a smart contract. It's going to do a lot of things, but what it's doing is it's giving you that core component architecture. It's giving you all the goodies that are inside of a Firefly stack and inside of a Firefly node. So we'll be able to see approximately how long this takes on my machine. If I have to give you my best educated guess, I'd say about a minute right here. But this CLI, which was written by Nico, who's on the chat, it's very interactive. It's very informative and it's going to let you know sort of what's happening as these containers come to life, as a smart contract is instantiated, for example, as new organizations and new members are onboarded into the system. You'll get all of those notifications. So at the moment, it's just pulling the Docker images for me. But now we can start seeing some more interesting information manifesting inside of the terminal. And again, I'll reiterate it probably 10 or 20 times, but just please, please, please, please don't hesitate to throw any questions inside of this chat. You can feel free to use our Rocket Chat. We're just at Firefly-Labs on Rocket Chat. We're doing a better job as a team of getting very interactive on that and putting all of the discourse about the Firefly project, about any errors that we see internally, any developmental progress, all of that's going to reside fully transparently inside of the Rocket Chat, inside of Firefly Labs. So love for anyone and everyone to please join that and interact with us through that medium. It's a little bit of a blast from the past for me. I spent a ton of time on there interacting with sort of the fabric folks. So maybe I need to close one of my terminals. Okay, let's go ahead and try this again. FF start at a transfer. So what we should see if this comes up properly is it should expose us, you know, all of the local host endpoints where we can get to that user interface. And again, you know, this, we would love for this to be perfect. This is a live demo. I'm shameless about doing live demos. And, you know, as every developer knows, you know, it probably makes you better to see an error too as you're doing a live demo. So, you know, this may be not go 100%, but, you know, we will do this in real time with you and this will be sort of a symbiotic relationship as we're looking at, you know, all of the different permutations and all of the different edge cases that could occur. So we see, you know, a little bit of sort of a possibility for an error. If you do see that as you're starting up a stack, you can always just do FF stop, you know, stack name FF start where you can take the approach that I just did. Just say FF start again with your stack name. If you have those images, if you have those containers and, you know, all of them are running, you're going to get success. It may be the case that perhaps, you know, maybe one container started and it exited, right? And that's not going to serve, you know, all of these end points. Before I think, Nick, as you hit this, I think you actually hit an issue which was fixed and we try a loop that got popped in this morning. So hopefully the latest release won't hit that issue. Just for background to chat while people are all typing on their machines here. What's sort of happening under the covers here is we've we've embedded Docker compose inside of the command line. And then in the CLI, Nico led the development of this, who's here with me in the room. The CLI does a whole bunch of orchestration on top of that. For example, you're going to have addresses that need to be generated. So it generates addresses and it injects those into the configurations. When you do fire flight in it, it lays out a file type system inside of a .firefire directory in your home directory. And underneath that, you'll find all the configuration files, the YAML for the core, the YAML for the data exchange, the key files and stuff generated for Gnash, et cetera, all of those inside of there. And then it starts everything up. And you can imagine there's a sequence here. It's like a launch sequence. You've got the database has to come up and be there. And the blockchain has to come up and be there. And the smart contract that's backing the private data exchange, a very simple example, but kind of like that foundational piece that needs to be installed. So that all happened and next environment. And it all stood back up again. And then it has to restart the firefire runtime so that they'll register their event streams using eave connect that will then listen. All this happens under the covers to reliably for events. And then the final stage is the network map. Each of those nodes has come up. It hasn't really joined the network yet. It actually needs to advertise itself to the rest of the network. And actually, the area you saw on the screen was that the CLI was trying to do that while one of the fireflies was still coming up. And it got a, oh, this firefly isn't actually running when you're trying to do it. So you shouldn't see that because it will get retried into the covers. But that's the sequence of steps that's happening under the covers as part of the CLI. And it was really important for us when we were thinking about this to try and, you know, it's a journey, but try and make it so that you don't have to understand every single one of the components inside out to be able to get up and running. And lots of developers can just focus on the sort of, the externals of firefly, which is the internals of the application, right? The development of their full stack app. So anyway, sorry, Nick, for the diversion now. No problem. And I'm going to actually restart it so that we can ensure that all three members are successfully joined to the network in the member map. So what we want to see inside of the UI is we actually want to see three network members inside of here. So I'm going to go ahead and restart this stack right here. And hopefully we'll get a happy result. I said stop. We want to say FF start. Yeah, you may need to remove it. I'm not sure if it'll, or you can manually register the board. I think just FF will move. Or as Andrew said, you could just go to the, if you just go to the swagger, let's, let's do this, Nick. Let's keep your hands tamed with a little bit of a dance here. So if you go to 5001 slash API, then this is the, oh, if I, oh, you've just stopped it. I stopped it. Okay, we'll start it back up again. Let's go ahead and start it. And this is good. This is the sort of, you know, the, the, the command lines there to give you an environment that you can, you can kick the tires with. So this is nice to like do a little bit of tire kicking life. So the, unless I mean, I'll probably waffle on a little bit about the API. Well, we're looking at it because what you'll see on the API is there's a lot more gaps than posts. There's a lot more things you can look at the, the sort of paddling feet of the swan, you can see every single one of those, but actually as a developer, you don't need to use, you don't need to actually perform all of those, but the UI is able to show you transactions, events, data, operations, all of the, all of the model. So if you've got 5001 API up, Nick, if you scroll down to network, the slash network prefix down in namespaces, they were going network, right at the bottom there. So, so you've got underneath network, there are nodes and there are organizations and you're running a node and, and nodes are owned by organizations, which is just a fundamental identity in the system. So in order to kind of exist to everybody else, you have to advertise yourself to everybody else. Well, what's an advertisement? Well, it's just a broadcast. So the system eats its own, eats its own dog food here and uses the broadcast mechanism in order to distribute the, the, the information to everybody. So if you click on, on the second node that failed, if you click on register slash nodes slash organization, the post, Nick, and you click try it on there and you click send. What this is a convenience to say, look, you know who you are, just broadcast yourself to the network. And that payload there, that's a message. It's the same payload that you get back if you were to send a message that was like an application level message. But in this case, it's a message that's gone out on the Firefly system, namespace. Namespaces, we, we thought it was really important to think about multi-tenancy from day zero because most of these business networks are thinking about like an app store of lots of different applications. So being able to have lots of different applications on the system from day one was important. It's a Firefly system namespace. So this particular message is a broadcast message that happened on the Firefly system message to say, system namespace to say, hey, look, there's an organization. And, and then if you go to a query on organizations, you do the get there, Nick, on slash network slash organizations, you do try it, send, scroll past all of the filtering options that you'd expect on a nice West API. And we should see that, oh, there we go. There must have been something else that's, that's the, all right, new organization. But this is the, this is, this is what you'd see an organization that's propagated through the network. So if you look on your environments where the CLI run all the way through completion, it looks like it may not have configured some of the connectivity here. The, the, you should see an organization for each member. And if you were to click into the UI and change the namespace in the top right hand column to Firefly system, and then click on messages and click on the timeline, you'd see the publishing of all of those, all of those, those organizations going through the system as broadcast, just like anything, anything else would be. All right, I'm going to start over one more time. We tried, I tried this before we got in the workshop. So I know it works. So I'm just going to start from scratch. I imagine there's other people out there still trying to perform a download. If I fail in this session, we'll just turn it over to Andrew or Nico for the last 20 minutes. But again, we've seen this, we've seen this working successfully. And maybe that I, I fat fingered something or, or, you know, had a, had a, you know, predated image or release. So we'll try this one more time on my machine. If I have bad luck today, we'll just use one of the other Kaleido and Firefly engineers to take you guys sort of to the finish line here. So I'll go ahead and remove that stack. Yes, I do want to remove it. And we'll go ahead and start from scratch where everyone else likely is. So let's say FF in it. We'll call it Nick test this time for good luck. So, and we'll say three for the number of members. This is also a shorthand you can do rather than, you know, using the interactive terminal right there. So, and then we'll say FF start. Yep. I wonder, do you, do you want me just maybe do a little bit of a tour of my, my UI, some of the stuff I was talking about earlier. Yeah, that sounds awesome Peter. Let me share my screen here. So this was one where I just ran, it was a two member environment, but I ran just immediately before we started this morning. And I've got the little sample running, but what I was talking about there is if, if the top right hand corner here, you change from the defaults namespace and you can create namespaces yourself as well. And you just change to the far fly system namespace. And this is my favorite view in the UI here. This is a view of messages in a timeline. And the thing on the left, this is your organization. This is stuff that you've published the network with the organization of the node that you're, that you're in. And then this is stuff in, this is all in reverse timeline order that newest at the top that's come in from other people in the network. So I'm there as a port 5000. That's as node, the first node. I can see that I broadcast a definition of a, an organization to the network. I had a blockchain identity. It gets allocated a UID within the firefight system and it has a short name, which is required to be unique. But it's a few, few cases where we found it really is important for these networks to do some things and choose to have some things and having just a unique name for orgs is something that's been really, really popular in the, in the networks that we've seen evolving. So you have a short name, but really what matters is the identity of that organization. And then you've got a node that gets defined and this is interesting, right? Because the node is, it's not an identity in its own right. So it has an owner, which is owned by that identity and it has an ID as well. But the reason why the node needs to be broadcast to everybody in addition to the, the organization is because of course we're not just communicating via the blockchain. So there's this DX section. Now the DX section is an example of plugability in the system. This is really important. So you're using a implementation of a data exchange, which is mutual TLS with HTTPS. And that implementation through its plug-in has specified this is the API where you can ask me who I am and get data from me that you can broadcast to everyone else in the network so that they can connect to. So on this node one, when the Firefly Core asked the data exchange, the mutual TLS data exchange came back and said, based on the certificates, I've looked inside of them, the organization name inside of my certificate is member zero. My certificates, because we're just using a completely peer-to-peer system here, there's actually lots of options inside of the mutual TLS data exchange, but at the moment we're just using deliberately self-signed, because it's a great map for the way a decentralized network would be managed with identity, that you advertise and say, look, here's me, here's me, this is my certificate. And here's the off-chain endpoint that you can use to talk to me. You can obviously broadcast a different endpoint in your configuration to your own IP address. So this can be a, you know, a nap-resolvable hostname all the stuff you'd expect. And this gives, this little piece of data, Firefly Core knows nothing about this schema. So if you wanted to build the NQP one, this could be a whole bunch of NQP endpoints addresses. This is completely puggable what this broadcast information is, but the way that the broadcast works is really important because this is being broadcast to the system via IPFS and it's being broadcast with the blockchain signature identity of the owner. I know this is really like simple, straightforward stuff for blockchain, but this is an example of the coordination, but anybody using a system needs to understand that you've got this great system to propagate things with signed authorization and signed identity that you attest to this data. So in this case, Node 1 attested to Node 2 that that data was valid. And Firefly has all the plumbing to check the hashes of the payload. Check everything matches up with the signatures that are on-chain, et cetera. All of that stuff is baked into the Firefly Core stack, but with the plugability that actually that blockchain can be any blockchain you like. The mapping, and this is a really important one, the mapping between an on-chain identity and something like a DID. That's a puggable interface. The only plugin implementation of that one right now is there the same. So the identity that you see in the message is the blockchain Ethereum address in this particular case, but that's a really important thing in these enterprise systems of how do I know the signature on-chain maps to a real identity off-chain because identity is not an address. Identity is something bigger like me as an identity is different to my name, Peter, right? That's a very different thing. So that sort of mapping is a key part of this. And then if I go to 5001 here, I'll go to 5001, and I look at the same timeline view. I can see, and I switch from the private where I was doing private messaging, I can see the events as they came in on Nesto with the difference of which ones were private and which ones were public. And I can see that same data that's described, that was published by the other endpoint. Now, I do want to just talk really briefly. Some of you might have noticed something, which I'll talk to Alex about off-line. The order was different on this pain than the other pain. Now, how could that have been? That's because the UI at the moment is using just the list of messages to display this, so they're not in the blockchain ordering. On the API, the thing that actually matters is that you have a list of events. And the events get propagated to applications through a a WebSocket interface, but there's more plugins coming for that. And the sequence of those events is what matters, not the sequence that things sort of exist inside of the database. So that's the reason why you saw that. It wasn't that the system didn't manage to do the ordering, that's like a core construct of the system. It's just simply that the order that the UI is displaying them is not that it's having this sort of order that they're delivered to applications. I'll pause there in case there were some questions. I wanted to go back to Nick. Super. Thanks, Peter, for bridging that gap. And of course, as soon as I stopped sharing my screen, everything worked perfectly. That's how it works. But in any event, if you do see little periods of the failure for all of the orcs to register, take down the stack, restart the stack, and you'll be good right there. So I've successfully restarted it. All of my orcs have joined. And now what we want to look at is we want to look at some of the accompanying program, specifically sort of a turnkey, just one-click CLI program that'll do a public broadcast to everyone, and then a very nice powerful React-based user interface, which will let you experiment with private messaging. If you have more than two members inside of the system, you can enumerate which members you want to send those messages to. So just for posterity, let's go and make sure that all of these are looking as they should. So we originally were seeing one network member because it failed to broadcast and failed to do that registry, but now across my three members, we see that everyone has that peer-to-peer communication and I even sent a test transaction in in the background. So what we're going to do now is we're going to transition, assuming that the CLI is built for hopefully the majority of the audience that's interactively following along, we want to transition into the Firefly Samples repo right here. And it has two folders. It's very, very straightforward, very clean and lightweight, but also very powerful. It has the private data transfer CLI, which like I said, this is just going to do a broadcast. And then it has the private data transfer UI, which will allow you inside of a GUI to actually, you know, pick the organizations, pick the members that you want to, you know, privately send, you know, sensitive or, you know, concealed data to inside of the system. So the first thing we'll do is we'll just do the CLI and we'll send a basic hello world message. And when we're while we're doing that, I'll show you one interesting thing. We can we can actually look at, you know, some of the lower level logs. We can see the true existence of these Ethereum transactions hitting our ganache. And, you know, we can see some of those JSON RPC methods that everyone's familiar with. And we'll be able to see, you know, transaction hashes and timestamps and all that good stuff from Ethereum transactions. So if we look at our running Docker containers, what we'll notice is that we have an ETH Connect container for every member has their own unique ETH Connect container. So when I kick off this, you know, this end to end CLI program, it's going to be org number one, member A, this container right here, the first organization side of my stack. They're going to be broadcasting that message. So we'll be interesting to sort of, you know, see the logs for this container right here, see the broadcast of that transaction and then see the subsequent, you know, commit of that transaction into their, you know, ganache ledger. So I'll go ahead and copy this container right here. We can open up the logs and then over here on the right side, we'll just kick off this program. And these are, you know, very, very lightweight, very, again, lightweight, I don't mean that, you know, sort of in a negative connotation. They're just very simple. You do a quick NPM install and then the programs will run. So it makes your life really easy. So we'll take a look at the logs for this container right here and then we'll go ahead and start sending some transactions into the network. So here's the logs, nothing overly exciting right now. When we start to kick off this program right here, I'm just going to do an NPM run start from the root of this private data transfer CLI folder. And we'll see the broadcast of, you know, a hello world message inside of the system. And we start seeing, you know, all of those familiar Ethereum things, right? We start seeing, you know, the, you know, the JSON RPC calls, right? Estimating gas, sending the transaction. We see the acknowledgement of the other nodes inside of the system that they've received this message. And we can now, you know, very closely correlate, you know, all of these things that have been abstracted, you know, to our trust anchor, to our ledger that's kind of sitting in the beating heart as a connector inside of the Firefly Core right there. So just wanted to point that out for folks to see. So that's just kind of the out of the box, you know, click NPM start and boom, it's going to send some transactions into your network. You can go into your user interface and you can see those transactions. You can do what Peter did right there. You know, you can click on, you know, sort of the messages. You can open up the broadcast. We can see the strings that came through because this was public. It was available for node number two right here. We can see the data hash. Essentially, any piece of metadata or any piece of detail that makes sense for your business process, this is going to be exposed if you're privy to that transaction. So we see that one come in. Now let's go a step further. Now let's open up this user interface and start talking about privacy a little bit. So similar to, you know, building that CLI folder right there. All we need to build the UI folder and fabric samples right here. Again, you go into here. You're going to clone this repository. You're going to CD into this folder and you're going to do an NPM install. Once you've done that, you just do an NPM start and it's going to expose a wonderful user interface for you hosted on port 3000 on your machine. So I'll go ahead and stand this up for the UI component now. So let me go back a directory and then we'll go into the UI component right here. So similarly NPM run start and fingers crossed since I'm doing a live demo, but this should ultimately serve on my local host 3000. And what we'll notice as this manifests on the page right here is I have a toggle. I can switch context now. So I can act as org zero or member A inside of this system. Feel free to use your own nomenclature. But what we have is three members, each of whom has that application that we looked at over here 5000, 5000, 15002. And we can toggle context right here so that we can, you know, do invocations to the blockchain, right? We can do message broadcast to the system. We can do private messages inside of the system. So let's just look at, you know, a broadcast where everyone's going to get this message, right? Welcome to the Firefly workshop, right? We'll go ahead and broadcast this into the system and this is going to go out to everyone, right? We're going to see that it was sent from myself. If we go and toggle the different components right here or the different members, we're going to see that they received it. They received it from my address right there. This guy's going to have the exact same string. And this is, you know, a very, very easy public message. And I even see that I sent this to the rest of the network. Let's drill down another layer now and talk about what's really important, though, and that's privacy in the scope of this broader ecosystem. So rather than broadcasting to the whole network, and again, there are clean APIs that will make your life do this, a common simple REST API that, you know, is not reliant on a user interface. This is emblematic and representative of how easy it is to program against the Firefly APIs and build out a nice powerful UI like this that Andrew and team, you know, worked on really, really quickly too. I shouldn't, you know, sort of toss that aside. The development on Firefly, you know, is really accelerated. There's easy interfaces, easy REST APIs, and easy components to wrap your head around. So rather than broadcast to the whole network, I'm just going to go ahead and choose, you know, a single recipient. So I'm grayed out right here because I'm the sender. I don't want to send anything to myself. I already know that information, but maybe let's send it to org number one and their address right here. Okay. Really private data. Okay. We'll do that. We can go and submit this to the system. We get that immediate asynchronous response, right, that the message has been sent, that it's into the system, and we see that we have this right here, right? We can see that it was submitted. So let's go ahead and now switch to org number two right here, and we see that they've received that message, right? They have line of sight into this really private data. We can go into their user interface over here, and we see that as well, that it was a private transaction, but it is available for this organization, right? They were privy to this. Just like, you know, you can make this analogous to, you know, something in using Tessara inside of Ethereum, right, using that private four parameter and just enumerating the public Tessara address of who you want to get that private transaction and who's going to be able to execute it or make sense of it in the system. And if we go back here, it should go without saying that if we go to org number three, member C, who I did not make privy to this transaction, they don't have any line of sight into the inputs, right? They're not going to be able to make sense of that private payload. They're just going to be able to see that, you know, maybe something came out into the system. So that's the UI and the CLI that you get out of the box in the fabric samples repository. As you stand up your Firefly CLI, you get these wonderful, you know, user interface dashboards, you know, that Peter did a much nicer job than I'm doing walking you through. But this is your core navigation over here on the left. This is going to, you know, give you all of that macro or granular information that you need. You can toggle between list and timeline right here. You can go, you know, over the course of a week or over the course of a month and you can change the namespace to the system or to default as well. One final thing that I'll point out here as well, and I'll save five or 10 minutes for our engineers to, you know, maybe take some other questions or show pieces that I've forgotten to show. But if you just remove the UI and you do slash API, which we did show earlier, it's one everyone to, you know, just know at your core that this is there and ultimately you're going to want the APIs, obviously. This will give you the interactive swagger interface and this will get you, again, you know, much closer to how you're going to program, you know, ultimately your server-side app and do your integrations with your core back office systems as well. So slash UI, slash API, these are both served after you successfully stand up a stack once you do an init and a start using the FFCLI. And again, you do a Docker PS, you can see all those containers. If you're into, you know, the actual blockchain transactions, we recommend that you look at one of the blockchain connector containers such as ETH Connect for Ethereum. Okay, 10 minutes left. I'll pause for a second and just ask a question to Peter and folks. There's another repository that we have. It's the data exchange one built with Visual Studio and also has sort of a nice flow and some exposed API. So I wonder if it's worth going through that or if we want to focus a bit more on any of these pieces inside of the CLI. Yeah, I think that was close. Yeah, absolutely. I think Nick had a few thoughts. Yeah, I just wanted to add a comment. I know there have been a lot of people that have been trying to get this running in the background here and running into a whole variety of issues. There's like 40 people on this call, which is probably 10x the number of people that have tried running the CLI before today. This is bleeding edge. And so we just appreciate you bearing with us as we are launching Firefly. We're really excited for this to be collaborative. So if you are running into issues, we definitely want to help out. I will drop a link to our rocket chat in the chat if you want to join and chat directly with us. We would love to help you get around these things and also thank you for reporting stuff that you're finding. As you saw from Gabriel's diagram, there are a lot of moving parts to this system. And so there's just a lot of things that may be unpredictable in different developer setups. We want this to be super easy for a developer to get started really quickly and just be able to focus on building their app and their business logic. So excited to work with everybody here to help make that happen. Oh, thanks. There's the camera. Hey, everybody. So yeah, I'll drop a link to rocket chat and feel free to open GitHub issues if you're running into trouble to help you guys out. Thank you. And on your suggestion, I will pull up the homepage of the MTLS data exchange and then Gabriel maybe could talk a bit about that. Yeah, and this one, as you're pulling it up, I'll just speak to it since I've used it a few times. This one's uberly convenient. Gabriel has abstracted a lot of the heavy lifting for you and it'll automatically generate a couple nested folders and some PKI artifacts that you need for authentication. And then it gives you, you know, a unique swag or interface for each of the members. So highly encourage everyone to use this. It works swimmingly with Visual Studio right out of the box. So over to you, Gabriel, for sort of the more deeper explanation. Sure. So when we store private data in one of the Firefly instances, it actually goes into the database of that Firefly core. And if we then want to send private information to another member, we need to be sure that we do it through a channel that is end-to-end encrypted. And this is where Firefly uses the Mutual TLS data exchange. So basically it relies on this component through applying interface and it basically delegates the responsibility of sending that message across securely to the other member. So for this to work, the CLI, what it did when everything was being provisioned is that it generated a number of certificates. This is private keys and public certificates. And so it uses those in each of the members so that the members can basically identify themselves and each other. So when data is being sent from one member to another, we use those certificates and those keys to encrypt the information and make sure that it securely makes it to the other side. And then we can know for a fact who that information is coming from and then the Firefly core will process that information, add it to the internal database and then continue with the coordination of the other elements. Is there anything you wanted to add, Peter? No, that was a great explanation, Gabriel. So I guess we're at a few minutes to here. Were there any questions that had come up on the chat that we wanted to surface and talk about a little bit? I think thus far the chat's mostly been around troubleshooting. We acknowledge we need to do more testing on Windows. And I think a couple of things for us to look at as a takeaway here. And I guess I'm really pleased to see so many people trying this. Certainly for everyone who's been involved so far, it's a pretty significant day for us that this is launching something. And it's launching something that's... What makes Open Source special is you're not launching tech, you're launching a community. Everyone here who's been trying out the DayZero copy of the Firefly command line to get everything stood up. That makes you there on DayZero of this community. And I'm really excited to see where it goes, how we work together as a group, how we do, as Brian was saying, like at the beginning of the day-to-day, that blockchains had... And Modify Systems as a whole has got these great, absolutely fantastic projects. The projects are a very specialist and niche in a particular area. And this project's trying to be a bridge, be a link between them. And for those technical folks on the call, I hope we've got people from a whole bunch of projects who are thinking, does this fit with my project? What's the relationship? Is this something that would allow us to reach a whole bunch of people who aren't going to be working inside of our box but suddenly would allow our box to be available to all those enterprise developers who just want to use this stuff and coordinate it together and build solutions on top of it. And I'm really excited to be just at that beginning and we're going to hopefully be working together with a real spectrum of contribution coming together and leadership from all of these communities not least Bessu and Fabric who've already been really involved over the past few weeks as we've been discussing this within the hyperledger community. But also, we've been talking lots to Avalon and we've been talking lots on the identity side as well. So it's going to be really exciting seeing how we can bring this all together. Nick, did you have anything to close out on this one before we... No, we just... Yeah, I have a few thoughts, I guess. Really, really appreciate the broad attendance and for folks sticking around even if things get a bit bumpy. That's how nascent projects tend to work, but we're here to get this mature and get this hardened hopefully with your help. I'll just reiterate, we really, really do want to hear from you in our meetups on Rocket Chat if you have requests for updated documentation or if you're a good Samaritan and maybe you even want to write some documentation. We're all for that. And we really just sort of want to be sort of co-stewards of this project with the community and with everyone. So we're here to help, we're here to build together. And again, we're as accessible as could be. So please don't ever be shy if you need to get in touch with us. If you have thoughts, if you have issues, if you have suggestions, our eyes and our ears are wide open. So just thanks to everyone and we're really excited about this project through the rest of 2021 and well beyond.