Fluence Labs Community, 30 Sep 2021

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Developer Community Call #2 | Aqua: motivation & Intro

Description

00:00 Introduction by Dmitry Kurinskiy, Fluence Labs CTO
00:57 Why are we developing Fluence? Motivation
02:42 Approaches to composition
05:08 Goals
07:28 Fluence Architecture
10:47 π-calculus as a foundation of Aqua language
13:37 Why we chose π-calculus?
16:45 Design the distributed workflow. Particle - smart packer that travels the network
19:57 Particle-Wave dualism
24:15 Aqua basics: the language compiles to Aqua Intermediary Representation
25:10 Why new language?
29:21 Example of Aqua syntax
32:54 More complex example, functionality
37:09 Will Fluence be on its own chain or it will run as DApp on other chain?
39:37 Aqua ecosystem
42:27 Distributed algorithms as libraries. Turn applications into protocols
47:34 What makes a Protocol
49:04 What’s missing right now?
51:22 Plan for community calls
51:59 Useful Links
54:00 BazaarEx, the project built on Fluence

Links & Resources:
Aqua in Browser https://fluence.dev/browser
Fluence documentation https://doc.fluence.dev/docs/
Discord Support https://fluence.chat/
Telegram https://t.me/fluencedev
GitHub https://github.com/fluencelabs
Join Fluence Labs https://fluence.network/join.html
Community calls wiki https://www.notion.so/fluencenetwork/Fluence-Developer-Community-Calls-2733beddb3ff4e4986c4fcc830fc796d

A

The second fluence community call this one is dedicated to aqua the main entry point into the fluence network and the way to interact it. Aqua is the language for web3 composition,.

A

So, first of all, this is a community call, so questions and discussions are welcome. You can interrupt me anytime, and this skull is dedicated to aqua it's past present and future, and mainly I will be speaking about what uh what's not covered by uh by our workshops and videos and documentation that we have like it's more about.

A

My my thinking about aqua, like reasoning, so, let's begin the first intuition- was to cast a spell to the internet, so we have so many things. Many resources, data apis protocols distributed protocols. We have three projects already there and brilliant minds, are making all of this available for us and it seems like uh the value uh different value in unknown can be derived thanks to all of these being right around there already. So the question is how to derive this value from what already exists.

A

So we need to have some magic to to do it and how the magic works uh in this case, in this case magic means that at first uh we have some spell some complex spell that we want to decompose into simple jobs which probably are solved or solvable by something that already exists.

A

Then we want to solve these simple jobs with the good tools available for us and finally, we want to combine these solutions uh to get the value that we want to have. Finally, so internet has solutions, but but it's not not so easy to to fetch the value from from internet if it's not provided, as is, if it doesn't fit us uh as it is so, there are different approaches to composition as a divide and conquer is the main approach to to solve complex tasks in general.

A

So it's applied widely, but the problems is that even though the internet itself is distributed, but it tends to actually be very centralized.

A

uh So this composition of small solutions is actually done within the walls inside the clouds and these parts which form the whole are not exposed to the public. There is no way to reuse it to extend it to study it uh to learn from it. So that's the first problem, of course,.

B

A

Many apis and web services and protocols, so so we can actually perform this composition on the client side, but it's also not so perfect. It works, but it is not efficient uh because uh we need to get for the data and for computations somewhere and then bring this data on client.

A

So we need to have this round trips and to consume bandwidth.

A

Then different vendors provide different security policies and the client needs to follow or to implement all of them, and uh it could be tedious, it would be harder. And uh finally, there is no short invariance.

A

This vendors apis usually don't have any exposed knowledge about each other, so they only know that they are used by the client and that the client does something provide some data or face something.

A

So uh actually they need to trust the client, absolutely as a client is in charge for what's being done um and if the client is deployed to server and nothing actually changes uh because, like it's still round trips, security policies and no short term variants.

A

So this desire to have this spell this magic.

A

It was finally converted to some goals that we had that we wanted to implement to achieve. So. First of all, we want to have zero trial security so that we want to have distributed invariance, and we want to make it possible for different parties to collaborate on solving a common task without knowing about each other in advance.

A

Then we want to make it efficient uh to avoid unnecessary round trips and if it's possible, to move.

C

A

To the same peers, where the data is stored, so that not the client is in charge of the workflow but the network, then, uh if you want to move these uh workflows into into the network, then it would be nice to avoid unnecessary constraints uh for the distributed algorithms.

A

So it would be nice to to be able to like unlock uh more complex algorithms, uh to run uh in this environment like uh to run consensus, algorithms, pub, sub and so on uh in this distributed network, and we want to have the built-in security for web 3 to have some common protocol, which is suitable for different purposes, different approaches and which can fit into different existing protocols and networks like we want to solve a basic uh uh authorization authentication to provide some cryptography.

A

uh We want to keep the network connected and uh like do such such things so that it can serve in the web, 3, environment.

A

This led us to the following architecture uh of the fluence network and uh flint's theorists. So we can, uh we can think of it as like. Four layers kick on the top. We have the network that provides us with a connectivity means that connects different peers to each other.

A

Somehow, and uh this problem in general is solved uh by uh by the protocol labs thanks to lip b2p being open sourced and implement it in different languages. So we use lib2p for the networking.

A

Then, uh when the signal comes from the network uh to appear to machine um the the signal that uh informs us that machine to do something and to participate in some workflow, um we need to have the coordination layer and uh influenced network. It's implemented with the aqua virtual machine, aqua, vm.

A

Then, when this control signal coordination signal comes to the pier, probably some computations needs to be executed on this year. Something calculated some constraints checked some rules applied and we have services to perform computations and it's done with with the help of web assembly and the marine runtime for web assembly.

A

And, finally, as we say that we want to to approach and to compose what was already here and around, we need to get out of the box out of the fluence protocol to the external world and to execute some effects like trigger, triggering an api or writing something to the file system or reading something from the network.

A

um This is done with help of uh yz web assembly system interface.

A

um So, finally, this means that we have the network where we can do some uh coordination and we we can instruct services to perform some effects and then bubble up to the network and continue the workflow.

A

In all these contexts, in this architecture, the main parts are aqua, the distributed workflow coordination in peer-to-peer networks and marine, which is used for computations and access to effects.

A

This time, we're focused on aqua.

A

So, um after that, we were thinking about how to provide this non-limiting foundation so that we can express uh even the algorithms which we are not yet aware about aware of, and we decided to use pi calculus as an unlimited foundation to express workflows, distribute workflows.

A

So we uh implemented here uh aqua, intermediate representation. It's a very, uh very small language, uh with these wonderful braces uh with a very limited set of uh instructions, uh and uh every instruction has a very strict contract uh in terms of cryptography um and uh data access and the execution flow.

A

A

We can express almost any distributed algorithm with this number of primitives. So finally, we want to delegate some communications to the control line solution like marine, and it's done with a call instruction. You want to combine results. We have just three combinators for sequential execution for parallel execution and for something like try and fail, try to to do the first one and if it doesn't work for any reason, uh switch to the second one.

A

We can have loops with the fold and we also have some additional operators new apply and actually we have mage.

A

um So this set of instructions is very limited, but it's flexible and like powerful enough to express almost anything. That's that's nice.

A

um Any any questions by the way about the motivation, part and the overall architecture and this switch to the pi calculus or everything is more or less okay.

A

Can you like show any sign.

A

I'll assume that uh everything's.

B

Okay, well I I I have a like a synthetic question, but I think it it can be suitable right now. So uh can you elaborate a little on why we did switch to bike outfits? Why did we didn't take some graphql or just like some any other language general purpose, language like skull or javascript.

A

Well, um we'll speak about why aqua, why we need aqua later, but now we are speaking just about the ways to meet these goals, so we have a very specific domain and like we want to handle topology to express distributed, algorithms, we want to have the built-in security and from from these goals, we made a transition to this architecture.

A

Where we have this um separation of concerns, we have a computations uh with their own, uh like uh with its own definition of security and sandboxing and effects, and so on, and uh the very important part of computations is that there is a single peer that does some some computations and there is a wonderful medium that provides a runtime for, for computations is webassembly.

A

You can express computations with a web assembly, but the question is: if we uh want to meet all these constraints, uh and if we understand that there is a the workflow part of like the distributed part of the algorithm that can be separated from the computations, then how can we think about it?

A

uh How can we ensure that uh it's secure and like it is powerful enough?

A

That's how we got to the by calculus, uh like we were trying to think about uh what is the minimal language minimal model thinking model to express what we want to to do.

B

Makes sense yeah, so it's as simple as possible, yet as powerful as we need yeah. That's in the name of security and.

B

Our goals, yep, makes sense.

A

A

Let's speak a little bit more about the solution, so by calculus is actually a solution. There might be some different one or uh the pi calculus itself.

A

It might be translated to here as we did or to some another language, but uh that's that's what we actually have implemented and uh how we built our security uh like the fundamental building blocks uh and as we have workflow, uh we want to actually transmit it or the network somehow, uh and we designed some kind of smart packages: smart packets, that travels the network, and that holds both the code for this distributed workflow and the data that is collected on the way while it flows for the network.

A

uh This smart packet uh package uh is called particle and, uh in general uh the flow is uh like the following. uh The particle uh comes to the pier I appear roots it to the aqua virtual machine.

A

uh This virtual machine figures out uh what should be executed on the spear and sends like uh passes execution flow control flow to the local computations expressed as services, and it figures out uh where this particle should go next. It changes the data, uh so we have the particle prime here and it keeps the header.

A

So the particle continues to flow. um This is a uh what the particle consists of. It has some id. It has the pure id that sent this particle. It has time stamp and time to leave.

A

It contains the script uh in terms of this by calculus, with prices and all this stuff, and all these fields are mutable, so they are assigned and the signature can be provided by. They need your id that corresponds to the public key and also it has a data. Data is changed, mutated by aqua, ibm's, uh on peers, thanks to execution of services, uh and it contains different signatures of different peers.

A

uh What bureau executes something that pure science, the results of the execution along with the uh the arguments uh like to verify that everything is obtained.

A

uh That's about the particle and the particle actually is is termed from quantum physics, uh and we can compare it with the wave. So just some.

A

Somewhat somewhat.

A

A

Something something about the particles so uh particle.

D

A

Yeah, uh actually, that's that's about it. uh So the particle processing is a idempotent.

A

If it was measured or observed by a peer, then, if it's observed by the same period in the same state again, there will be no effect.

A

So if the particle sending is repeated or if you have a replication attack uh for household this kind of attack, so it's protected then for this pi calculus expression of the workflow, we can make an estimation of the consumed so-called network gas, like how many hops we are done, probably- and we can make a circuit breaker uh from it uh and what's more interesting here- is that a particle may interfere with itself.

A

So you can observe uh only a distinct particle, but actually uh there are situations when um the particle is splitted like, and then it's observed two times on on the same machine. Actually, it's about fork and join. You can fork the execution or fork the flow of particles and then uh join and uh collect the data or the results of many nodes of many parallel branches of execution on a single pair.

A

uh In this case, uh we need to understand how to how to deal with these independent, absolutely independent flows of computations of data mutation, which occurs on different branches.

A

So that's why data on the particle forms, a conflict-free, replicated data type and actually all the peers which participate in the handling of a particle in the workflow form a one-shot, a single-use coordination network. They coordinate.

A

uh And this capability to throw particles and to build these networks, which coordinate, uh makes it possible to program uh to make programmable networks to make the network behaviors programmable with scripts.

A

Usually it's done with a redeploying the network. So if you want to change the behavior of the distributed network, usually you need to change the implementation of the peer and then push this changed implementation to the network to make hard work, probably or something like that in the fluency network- is just a set of scripts.

A

So we have scriptable protocols for subprotocols which may coexist.

A

We have many particle waves, sub-protocols on the same peers on the same network running in parallel and actually fluence and aqua turns applications and user experiences into sub protocols. That's like the main shift that uh that we are making.

A

So that was the part about fundamentals, and now I want to switch to aqua to the high level language and I have only a few more slides.

A

So if any questions around about the uh by calculus pair particle, please ask them if no, let's switch to aqua.

A

Okay, so we have this intermediate representation, which is a very fundamental, but it's not user friendly. It's really like previously. We were trying to write this ar code by hand, but it's like pain, really pain. So that's why we have aqua a high-level language that compares to air, and here we have a wonderful question: why new language? What why not library? Why not these cells? Why not something else? Why one more language?

A

So we began with a dividing the domain in the computations and workflow and distributed workflow, and we want to understand how to express this distributed workflow.

A

This workflow is very special and it exists between languages, so we have clients on uh one languages. We have different languages compiled to web assembly. We have different implementations of peers, so it's not clear why to change one language or another, uh why to prefer like rust, for example like in web assembly, or why to prefer type scripts like on client or on typescript gears, so.

A

We want this dsl to express workflows to be like to fit for different audiences of developers. Another reason that existing languages like rust, are made for other purposes. They have like lifetimes memory operations.

A

You can have the plus sign here for a power or you can divide something, do something else, and it's an open question how to serialize things properly, so actually the languages that fit their purposes well might not fit the others and uh in uh in our domain of distributed workflows in peer-to-peer networks in web 3, for example, we have the aspect of topology.

A

We need to express what to execute where and we also need to express how to get there or not express but uh figure out from the code uh to to get it.

A

We need to express polarization and polarization means that we have independent uh branches of computations uh and it's kind of also special. You don't have mutex, you don't have sharp memory uh in uh in this aqua workflows.

A

um Another thing is data dependencies. We need to trace uh what data is used where uh what data needs to be delivered from the source to source peer to the consumer peer and what data does need to be delivered.

A

So it's kind of a distributed garbage collection, and uh this affects the work for conjoined behavior and also we want to care about the liveness problem uh to avoid deadlocks to analyze these distributed algorithms.

A

So actually we tried to made to make a dsl in host languages, but they don't help and that's why we finally end up with a designing aqua the new language and, by the way, it's very lightweight uh and easy to use. Aqua compiler itself is compiled to javascript it's written in scala, compiled to javascript and is less than two megabytes of not zipped code distributed with a npm.

A

So it's much more lightweight than, for example, downloading. The ros compiler.

A

So this is what aqua looks like you: can import something uh some aqua files or you can use them or you can export, uh and the main things here are services service is like a foreign function, interface for aqua. That's what you expect from the peer.

A

You expect that there is service with this id. You can identify the service. uh This id could be specific specified on a different layers differently. You can like compute what what is it and uh you expect that there is a function, for example, that takes a string and returns a string with this name. This is the name of the function and the second part is uh the func, the function, the aqua function that expresses the workflow.

A

You can name it a wave coordination network or something like that, but we decided to keep it simple and name it func. So here we have a hello world function that takes an argument and returns a string to get this string. It does some complex things. It goes to the hospital id to some peer that is well connected, like we can move computations to other peers with the own keyword, and here we fetch the result uh edge export.

A

We export by the way the data from this function, and finally, we return it. So this is what aqua looks like in the most simple uh scenario uh and uh I'm not going to explain like to to describe all of aqua. We have aqua for that and presentations, but if you have any questions about aqua syntax and why it's made this way, not another ask me later, please.

A

uh So aqua the language uh is a functional language. uh You can have arrows here. You can pass functions, uh arrow functions as values, there are first class radius is inspired by a language like languages like elma and scala 3 and just little bit by unison, but it's not not not yet implemented, uh and it compiles to ear with some wrapping for typescript or javascript if it's needed to simplify the execution flow.

A

The usage of this function so that, finally, you you just have an asynchronous typescript function uh that features promise and you can just use it. You can pass callbacks and dates and so on and finally, it runs on the fluence network, so the runtime for aqua is the fluence network like as a whole.

A

Here we have a little bit more complex example, so uh we can make exports and to compile the function to the host language. You need to export this. This function, we have some literals.

A

We can have the for loops. We can make the for loop in parallel on different gears and light like such things.

A

So a few words about the aqua ecosystem, echo system, any questions about aqua itself. I want to speak about ecosystem and uh what's going to be done and to finish with that, so if you want to ask about aqua syntax for semantics right now, it's a good good moment, if not I'll, continue.

B

There was a thing on the 14 slide: 14, dot, aqua, yep yeah here, and here is a service string extra. We have a function, add name to hello. uh Where is that executed.

A

um It depends on the on the code, so in this case it's executed on the host sphere. So this is the scope. We have a.

A

Indentation, so, within this indentation level, everything will be executed on this host and host peer. Id is a constant that points to uh the known uh full fluent sphere, which is well connected. So the problem is that.

A

Actually, peers are different and we have a well-connected uh peers uh which are deployed on servers with ip addresses and you can connect to them and we have different peers like browsers or mobile devices or knotted devices, to which you cannot create a new connection and in the fluence network we have a relays the fully connected peers that help uh not fully connected viewers to get the messages uh from the network.

A

So in case of the web browser hostpure id is the first uh node to which this browser is connected and in case of the network node the full node. It's the current node.

B

So on lines, three and four, we basically say that we expect the host peer id to provide the api of to provide service string extra and it should have a function. Add name to hello. That's what we say like we expect this api to exist on this sphere.

A

Exactly and uh that's like f of I in some languages or native.

B

And f5 is for in function, interface, yeah, it's a thing to connect different languages to each other, yep yep.

E

Dmitry sorry, um there was a question from the youtube, a stream. uh Those who are watching us will fluence be on its own chain or will it run as dab on top of other chain.

A

uh I suppose that it will run as edf. Evgeny is the best person to answer this question.

F

Yeah so very simple, summary of fluence on the minute of 14 on the 40s minutes of this call, so uh fluency is off chain uh particular network. uh It's completely separated from the blockchains.

F

It allows to run per degree, applications and uh compose whatever uh logic uh you need in terms of distributed systems uh like kind of coordinate the distributed execution using aqua. So this all of chain, uh the one chain part we're gonna, have on twin part, uh which mainly will be the protocol governance and the future economics around the. uh How do I pay other nodes that would execute code influence network, uh but that's not like not there, yet it will be like if this is coming basically uh next months, so uh stay updated around that.

F

uh But the main point is that the aqua and the off-chain part that we're talking about this is the peer-to-peer network. There is no global state, there is no global consensus. This is about executing code uh on on on a decentralized network uh calling remote services composing uh into business logic using aqua to do it, and this is very cool, because this is open source. This is decentralized.

F

uh This doesn't have any limitations in terms of uh the blockchains. Have in terms of uh redundancy and costs and determinism and all of this, uh but obviously doesn't give you this blockchain level trustlessness uh so easily. So that's that's the short answer.

F

Yeah, you can probably.

A

Just go ahead: yep awesome thanks uh a few words about the aqua ecosystem. So, first of all, uh it's aqua virtual machine. uh It's the heart of the of the fluence network in general, uh it's the fluence network, uh which is a deployed and running uh via the, and it has typescript and rust. Implementations of of the peers uh and uh or the rust here has a scrape scheduler.

A

It's a part of the raspberry. I will say a bit more about that later then. After that we have the aqua compiler, which is written in scala and compiled to javascript, and it has a typescript and javascript as compilation targets, so it actually compiles to here and wraps it uh with the javascript or typescript uh to help uh with using using the that from the typescript or javascript years uh aquacode is distributed over the npm.

A

It's not javascript, not the compiled code is distributed. It's just aqua files and we have some default. Libraries which are available out of the box is aqualib appears that contains api and access to the most basic and fundamental functions like uh deploying uh web assembly binaries or creating local timestamp or uh interacting with the leap, p2ps, kadamlia and so on.

A

Then we have aqua dht. I will speak about it a little bit more later, but its purpose is uh routing uh finding a paths to some peers on the network and we have aqua ipfs uh ipfs is a built-in built into the fluence peers by default, and you can use it for file management actually, and uh you can push uh the files uh to uh like to ipfs daemons using aquascripts or you can use ipfs stored files from from microscripts or move them to services with the aquascripts we have.

A

We had a few workshops around fest. They should be on the youtube. The best source of knowledge about aqua is the aqua book, dev slash aqua book.

A

So with aqua we can turn distributed algorithms into libraries, so you can create a protocol, make it composable and then derive the new protocol from the more simple protocols like combine them, and we already have some protocols distributed as libraries. uh The first one that's uh available right now is a aqua ght.

A

It solves the routing and resource location, and you can do publisher subscriber pattern with it. Fundamentally, uh this is what it does. It maps arbitrary keys over the network uh into zero or more uh tuples of peer id optionally service, id and optionally relay or the path how to get to this peer id.

A

So if you know the key of some pops up topic, then you can find out the peers interested in this topic and deliver them. Some message and delivering message actually means calling a function on the service on the peer. So we have all the data required for that in this records data structure, then you can use uh kadamlia from uh from aqua, but uh that's like one of the beauty to do's. uh That's what we want to implement in aqua itself and academia actually is used to form the network.

A

But if we have it as a library, it will be possible to to have sub networks. Many academia networks running on the same network so that uh it will be possible to have some protocols uh some sets of nodes uh which provides some specific api in terms of services and which form a sub network with no need to leave or to fork the fluency network.

A

Then currently we have uh work in progress, trust graph implementation, that's um influenced native dpki implementation, decentralized, public infrastructure.

A

That's going to be used for spawn protection uh to prioritize, appears on the network to ensure connectivity and to manage connectivity of the networks and also to form sub networks, and uh actually we want to make much more uh in aqua or we want to have, and we have the demand uh to solve for many different problems in aqua like service location, you can do it with aqua dht, but probably we will need some more specific solution for that for data replication data replication is a very general problem and we can say that it's solved because, for example, in a in aqua dht, the key replicates itself uh in the caden neighborhood, but it's not.

A

It doesn't fit all the all the purposes and all the problems or all the situations. So probably we will need more different solutions for data replication, uh it's possible to implement consensus engines uh on in aqua.

A

For example, you can do raft and it will be not just rough but cryptographically secure draft, like kind of permission draft. If you want to uh or is possible to well goddamn. There is also a consensus algorithm about eventual consistency of the network participants.

A

Then we want to have a loss, balancing libraries and uh failovers rerouting from the failing mode to some others and such stuff. So a lot of things to do not just.

A

To to have this language, but in this language and uh like we have demand for that, uh just one more slide about the protocols. So uh I said that with aqua you can turn applications into protocols uh or you can make a data replication or consensus as subprotocol, but what makes the protocol so. First of all, it should be some services and data declare declarations to express what is expected from peers which are participating in this protocol.

A

Then it should be shared in variants which are enforced by services.

A

With that by calculus script, you can trace what data team comes from what appear and what service and what function and uh thanks to that, uh it's possible to make distributed invariants and like check them on the service level.

A

And finally, there should be some export functions uh in aqua uh to be used by clients on the client side or to be scheduled on peers uh like to synchronize data, for example, or to fetch something or to push something somewhere.

A

So that's why we have scripts scheduler in the raspberry implementation.

A

What's missing.

A

More integrations we want to have more integrations. We need to have more integrations, more libraries and more protocols written in aqua and uh with help of marine, so that it's reusable and that's it it's available for uh for the community uh to simplify development of more complex uh things.

A

uh Another meeting missing thing is uh calling aqua from aqua. Currently, the only way to call aqua function is to compile it to typescript or something like that and then to call it from typescript. But that means that to check the function or to play with it or to develop it, you need to have at least some environment for running uh aqua.

A

This presentation is currently done within the aqua playground, playground repository. That does exactly that. It provides some means to simplify running aqua from typescript, but it will be better to call it from aqua. uh Aqua rapple is a work in progress. uh Estimation is november 2021. So soon we will have it well. The main thing is uh aqua virtual machine.

A

This is what makes the limits uh and what provides capabilities for aqua so fundamentally, uh what's possible uh thanks to aqua vm can be then expressed in aqua and was not possible. It's just not possible.

A

So after we make some improvements for aqua vm, we will be able to switch to aquacademia implementation and implement the missing parts of security.

A

So that was uh uh the goal, the call the short presentation about aqua. uh This is the second one uh in the series of community calls.

A

uh The first one was uh just an overview of everything influence now about the language uh and the next time uh we will have a call dedicated to aqua virtual machine how particle works. What is here, what contracts we have and so on? It's expected to happen in two weeks.

A

F

A

You can run aqua in uh in the web browser with fluence.dev slash browser. uh We have discord, please join telegram, fluence dev for developer updates. uh We have github on slabs and finally, uh we have. We are hiring so fluence.network slash join and we have at least two open positions for uh related to aqua is aqua virtual machine engineer. uh Aqua vm is written in rust, so you need to know rust or c plus plus for that position and an aqua protocols engineer to cover in aqua and complementary technologies. So this one is pretty unique.

A

A

I'm finished. I'm done. I'm good.

F

Cool amazing um yeah that was nice that took a bit longer than I think that that I expected but uh great presentation metri. Thank you.

F

So we also supposed to have some uh some demos today. As far as I remember right,.

E

C

E

Deya's mission, yes, today, to tell us about your project, guys you've done lately.

G

Hey um stages is just gonna present, so.

C

Awesome, um can you see my screen.

F

C

Okay, great so yeah thanks so much guys for inviting us to uh present our project as rx. um This was part of our submission to the um encode hybrid system. That was just a few months ago. uh My name is tjs and I'm joined by nishkant. Who is my team member, um so we initially started bazarx to title a problem which was the e-waste that's generated by functional and but unwanted goods, and it was also partly inspired by our experiences of buying second-hand smartphones.

C

Whenever we went out, we couldn't really figure out how long that smartphone was used for who had owned it, how many owners did it have and so to tackle this problem, we built bazarx a secondhand marketplace with decentralized logistics where anyone can buy, sell or deliver electronic goods, um and so how does this all work? Well, the way it works is when you list a product on bizarre x.

C

What actually happens is there is a one-of-a-kind nft, that's created, based on that serial number of that electronic load, and whenever that good, that physical product is moved between people, so it can be from the seller to the delivery person or from the delivery person to the buyer.

C

That nft is also transferred to the respective owner and so that that's what gives uh bazaar x, the products listed on bazaar x, a chain of ownership, and so whenever a subsequent buyer buys the product on bizarre x, they can actually query this chain and figure out how many owners um that product had and how long it was owned. For, and on top of that, we also enable decentralized logistics by implementing an escrow and the way it works is after a seller and buyer. They agree on a transaction price.

C

A delivery person can basically elect themselves to carry out that delivery, and, after that there is an escrow where all three parties deposit certain amount of money, and that basically means that they've got skin in the game and that basically, they have an incentive to play honestly, meaning. There won't be a case where, like the delivery, person just runs away with the product, and so this mechanic, these mechanics of escrow and incentives, allow anyone to be a delivery person and allows the seller and buyer to transact items um in a trustless way um and yeah.

C

I'd love to show a quick demo that we made for the iphone.

C

I mean it's might be some technical problems anyways. I can show you the back-end code instead, um so right now I've got a ganache development environment, running with the erc, 721 nft contract deployed and in the second terminal I have got the marine repel running, that's interacting with with the bizarre x service. So if I try to register a user right now, um you can see that the response I get is a ethereum.

C

um Basically ethereum address uh public key along with some other details, and now, if I want to let's say, post another, an item for sale, so I will simply input all of the details and you can see the token id that represents the nft id pops up and we can actually verify this. If we go to truffle and then yep, you can see that that nft is actually owned by the person that was registered um well, it seems like yeah. So this is the a ui prototype that we built um using figma.

C

So here's the marketplace where you can see all the products, um their prices- um you can choose to list products, of course, including uh images um and other details um and yeah, and you can also you know. If you choose to be a delivery person, you can choose to make a delivery happen um yeah, and that is the ui demo.

C

And so uh moving on to the technical side um what's happening is when you actually register for an account on bazaar x what's happening, is we actually create a ethereum address on the west rx service alongside the public and private key, and those keys are stored in a sqli database?

C

So every time, every second time you use rx to let's say, post an item for sale. We use those keys to create the nft, and one of the good things about using fluence is that we never really have to worry about the cost efficiency, because the only transactions that are happening on the ethereum blockchain are just the minting and transferring of nfts.

C

That means it's very cost effective because all of the other you know, visual, um the visual data and the really text heavy data they're all stored on the um sqli database blockchain, which makes it much more economic, economically friendly for us to host the service and, of course, fluence being an open application platform allows us to basically.

C

Basically allows us to publish, run and compose applications without interacting with a lot of these large corporate companies like google or aws, and, of course, it's censorship, resistance, which is important when you're dealing with people's monies and products um and yeah here's some of the use cases.

C

Anyone can be a delivery person if they choose to which means that they get an extra source of income and because we're using cryptocurrencies. Of course, um anyone can transact in their local currencies and yeah. That's it and I just wanted to add some advice if any of you developers are going to be building um on web 3 on fluence.

C

um The a big problem that I faced, which I had to um solve over maybe five days with a lot of coffee and red bull, is that uh wasm mozam doesn't actually support any asynchronous uh runtime, um which means that you cannot simply use the rust, uh web3 library, the the really popular library.

C

Instead, what you would have to do is create your own custom website library and actually use another library called abi to create the ethereum transaction blockchain um and after you do that you have to connect it to the actual curl service, that's provided by fluence, so that so that your fluent service can send requests to the ethereum node, and on top of that, when you're signing raw transactions, you can use this library called ethereum tx sign. But it's currently using a implementation of um the ecs dna signature which is not wasn't compatible as well.

C

So you would have to use um this library instead, uh basically modify it um to run this instead of this one um and yeah. I hope that helps you build more interesting and cool applications on influence, yeah- and I thank you so much and I'd be happy to um take any questions about the project.

F

Thank you they just that was. uh It was amazing, um so on lettuce, anyone has any comments on latest uh ethereum integration issues. Bernard. Do you want to share any thoughts on this? Can we make the life of these guys or other guys easier.

D

Not really, but not entirely easier in terms of uh taking full stack, uh crates or modules, because most of the websphere modules are actually built around the transport layer and the transport layer is. uh Is your genesis point, but a lot of them decompose in sub libraries or sub crates and like signing and a few other ones and those all compile or we're very close to having them all compile as web assemblies? So it's it's better than when they asked and the team started out. We made some progress.

D

We figured out how to do certain things, but uh yeah a turnkey isn't quite possible yet getting there, though,.

F

Right so like I guess we uh if we have uh some best practices uh in terms of working with the theorem experience uh published somewhere in our docs, that would that would save a lot of time for people.

C

um I think there is a um I remember: there is some code uh that allows you to send transactions, um but it's somewhere. It like deepens some git from people yeah.

D

It hasn't been updated, so I archived it until I get around to updating it, because we wanted to use more libraries as opposed to uh our custom, which it was originally.

F

All right, I also had a question about the um so like who who runs the these backhand that sits like this marine services uh uh that that runs on backhands, like in, in terms of like your app uh architecture, how you design like who are supposed to run it? Is it supposed to be you guys, so you kind of, like your all users depends on the nodes that you run what's supposed to be community nodes? How how you, how you think about this.

C

um So initially we thought of just running it ourselves, um but then we realized that um this, this app could kind of be generalized into other marketplaces as well. um So we're thinking we thought of just creating like a vanilla version where um it doesn't have to be electronic those. It can be basically any goods that um that have a unique identifier attached to them.

C

So I think the initial idea was to run it ourselves, but then eventually move to having community running.

F

Yes, I mean like because, like if you think of community running nodes, then like marine nodes, uh then you will need to make sure uh you know how you, how you work around uh the for this node being available right like who?

F

How do you make sure that this node is available right now, when the client does a request to it? And how do you route the computation from one node to another node if it's not available, for example? So it's all kind of solvable with aqua uh at the like in kind of in theory right. um But uh there is, I just kind of uh see that that this could be addressed in many ways in many different ways.

F

uh We at some point will be um providing some also like some best practices for this and that and which we mentioned, like some future uh components regarding consensus and replication and stuff. um But at this moment that's definitely one of the questions that um I think you should think when you like. If you want to allow community like rely on community nodes because they might just disappear right, that's not a blockchain! So that's this node might just disappear. So you need to figure out how to surf like still serve the backend.

F

If some nodes disappeared.

C

Okay, yeah, I think we'll probably continue working on this uh for a few more months and then we'll see where it goes.

F

Yeah yeah, okay,.