 So, hi everyone. My name is Axel Erickson and today my co-founder, Zach Lawrence and I are going to be talking about what we're building over at One Protocol. So, quick who we are. We were both studying at Stanford University, Computer Science and Mathematics respectively, and chose to do Ethereum Protocol Development full-time in the beginning of this year, and that is not a decision that I regret. So, for those of you who haven't heard about One Protocol or haven't heard about the concepts of virtual workers, the short version of this speech is essentially that, instead of signing machines up directly as validators in CASPER, or as solvers in Trubit, or more generally as workers in staking protocols, we can actually sign up smart contracts as these workers in these staking protocols. And in doing so, we can actually solve some fundamental problems inherent in all staking protocols, and we can also introduce some new exciting properties. So, to get to that, we're going to start by introducing a useful model that we can use to think about protocols like Ethereum, Trubit and Filecoin. And then we're going to explore different ways that we can ensure correctness in these protocols. And what we're going to find is that using staking, in the general sense, is a very cheap way of ensuring correctness. However, there is a fundamental problem with slapping staking onto a market protocol, so we're going to introduce that. And then Zach is going to introduce our solution, which are of course virtual workers. We're going to give you a sneak peek for what virtual workers may look like on protocols like CASPER, Trubit, and even Raiden. And then we're going to finish off by introducing you to the idea of the One Protocol, which is of course what we're working towards. So, to begin, we think that a nice and easy way to think about protocols like Ethereum and Trubit is simply that they are marketplaces for some digital service. And in marketplaces, of course, you have a set of sellers and you have a set of buyers. And what the buyers do is that they form jobs along with payments and they send them to the sellers. And what the sellers are expected to do is to return some service. And perhaps the protocol that fits this model best is Trubit, where of course you have a set of task givers, which are either Ethereum accounts or smart contracts themselves that want to do some off-chain computation. What they do is that they create what are called tasks in the Trubit system along with payments and they send those to the solvers on the other side that of course execute the programs. So we can imagine that the service being mediated across Trubit, the market protocol, is quite literally off-chain computation like we would expect. But this model extends to Ethereum itself. So in Ethereum, we can imagine that the buyers of the service or all the people that hold private keys and sign transactions, tasks that they send to the sellers are literally the signed Ethereum transactions that they broadcast across the network. And then the miners are of course the machines to plug in on the selling side to provide the service. But what is the service in the market protocol Ethereum? Well, it's quite literally having your transaction included in the Ethereum state. Okay, simple enough. There is however a fundamental difference between, you know, these market protocols and how we imagine a normal market to work and this is of course that they're both open and anonymous. And what we mean by this is that anyone should be able to plug in as the seller in one of these protocols and when they do, we don't know who they are. Simultaneously, the users expect the protocol to reliably deliver the service and the users really don't want to have to care about who they actually get matched up with on the other side. And if we think about it, this is of course the expected behavior in Ethereum. One, anyone can join as a miner. And two, when you as a user sign your Ethereum transactions and send them away, you never actually want to have to worry about which miner actually picks it up. So the question is, how can we achieve this? Well, in the general case, the short answer is that we use financial incentives. So we can imagine that for any worker that plugs in as a seller to provide some service, there's essentially two categories of strategies that they can employ. And the first category is the first strategy is the correct strategy, which is when the seller simply delivers what the user expects them to. He performs according to the protocol. This would be analogous to running the standard implementation of some mining software. And then the second strategy is the incorrect strategy, which is any other one. So this could be either that the miner accidentally faults, meaning that the software breaks down mid execution, or that he deliberately does something that he shouldn't do. Think selfish mining attacks. And there are of course expected returns to both these strategies. And using this notation, we can ask, well, what's the cost of incorrectness to the miner that chooses to cheat? Well, the cost of incorrectness is of course going to be the opportunity cost of correctness, which is the payment that he doesn't get because he doesn't perform correctly. And from the cost of incorrectness, we're going to subtract what he actually does make when he chooses an incorrect strategy. So in order to ensure correctness, all that we're really trying to do is just trying to maximize this difference. So how can we do that? Well, there's really only two options. So we can start with trying to maximize the opportunity cost of correctness. The problem with this is that we're effectively saying that the price in the correct case should be higher, right, which means everybody pays. This is analogous to block rewards in consensus protocols. And it might seem fine because it achieves what we're trying to do. But in a system like Ethereum, for example, these costs can go crazy after after a while. So with three new ethers being issued in every new block and one new block every 13 seconds, all Ethereum users are actually cumulatively paying about $5.5 million today to increase the opportunity cost of correctness on Ethereum. So a fun calculation to do is to simply take the number of ether that you have and divide it by 18, and then you'll find out how much you're paying every day to increase this opportunity cost in dollars. But there is, of course, a second thing that we can do. And we can try to minimize the payout of being incorrect. And if we're able to implement this correctly, what we achieve is that we increase costs only for the actors that choose that strategy. And this is, of course, what Staking tries to achieve. We make it a part of the requirement to be a selling machine to put up a massive security deposit when you join that you'll always lose if you cheat according to the rules of the protocol. So when implemented correctly, we can actually make this expected returns of incorrectness negative, which, of course, is going to maximize the cost of incorrectness. And the idea there is that for any incorrect strategy that a malicious miner can can find either accidentally or deliberately is always going to lose money if he chooses that path. So so what we found essentially is that Staking and the general sense is a very cheap way of of ensuring correctness. And this is, of course, why so many protocols have have you stake in different ways to ensure correctness. And we have, you know, often computation protocols, decentralized file storage, marketplaces, consensus protocols, etc. There is, however, a fundamental problem that's not talked about that much that is inherent to all Staking protocols. If you think about it, what we've done is that we've essentially taken a worker and we've changed what it needs to do. So instead of just performing a task and delivering some useful service, we've also said that this worker needs to put up a massive or a stake. So what we've effectively done is that we've limited the supply of viable workers, which in the short term means higher prices for the same security or lower security for the same price. And this in the long term creates a big, big macro inefficiency in any protocol that chooses the strategy. And I think this is all very, you know, up there and theoretical, but I think the pragmatic way to think about it is simply that which of the people that we would ideally want to run CASP or validators also have $100 million in ether to stake. And the answer is not that many. So this is the problem. And to present the solution is Zach. Thank you. So the solution is actually to divide the labor using smart contracts. So more specifically, you can imagine using smart contracts, which we term virtual workers to allow two parties. One, a capitalist who's providing some tokens. Another party, the operator who's providing the computational resources to work collaboratively for these different staking protocols that Axel is talking about. And then use the virtual worker contract to share in the returns. So let's take a quick look at the actual logic that we imagine to be contained in these smart contracts. So the first role of the smart contract would be in restricting how this operator can use the borrowed capital. So you can imagine in a virtual worker for CASP or the logic would ensure that the operator can only use the capital to sign up as a validator in CASP or and validate blocks. Now second also important point in logic is to ensure that the operator doesn't destroy any of the capital that is actually borrowing. So you can imagine in the case of CASP or you wouldn't want the operator to destroy the capital. And to protect against that, you would use the virtual worker logic to incentivize machines to be moderating this operator and reporting before he destroys any of the capital. And then finally, you would just use the virtual worker to handle division of the rewards. So you can imagine the virtual worker would allow the operator and capitalist to negotiate some sort of rate which they would use to split the rewards. So now we'd like to present a few of the virtual workers that we've been designing at one protocol. So starting with CASP. So as most of you probably already know, Ethereum is planning transition from its current proof of work based consensus mechanism to a proof of stake based consensus mechanism in one of the upcoming hard forks. And essentially all that means is that miners are going to have to supply a stake in order to perform work for the consensus. In other words, Ethereum is becoming a stake in protocol. So we have two ideas for how to create a virtual worker for CASP. In the first one, operator produces blocks and also supplies a small stake, which is lost if he loses any of the capitalist money. And then you have the capitalist as before just supplies tokens, in this case ether. So the other model we have, which actually applies to many different staking protocols, not only CASP is the producer signer model. So in this case, we actually further divide the role of operator into producer, which produces the blocks and proposes blocks to be signed. And signer, which actually decides which of these proposed blocks to sign and then broadcast to the network. So this makes a lot of sense in protocols where the computation being performed is very expensive. And it would make sense in CASP if the cost of running a full miner becomes prohibitively expensive, so a lot of players can't participate. So the second virtual worker we wanted to present is our virtual worker for Trubit. So for those that don't know, Trubit is a protocol on Ethereum, which allows users to hire a solver to solve a computational task. Notably, these solvers have to supply a security deposit, which is slashed if the task is performed incorrectly. And also, these solvers are chosen to solve tasks based on the size of their security deposits. So in the case of our virtual worker, again, the operator supplies a small stake, which is slashed if he performs incorrectly. And then this operator leverages the tokens it borrows from the token holder in order to increase his chances of being selected for tasks and also to be able to take on many different jobs. And now in this virtual worker, there's also logic, which incentivizes different workers to monitor the operator and replace him if he fails to perform a task correctly. So the final virtual worker we wanted to present was one for Raiden. So for those that don't know, Raiden is a implementation of state channels on top of Ethereum. Essentially, if Alice wants to send capital to Bob, or ether to Bob, they can create a payment channel and send an unlimited number of transactions amongst each other off chain and then close the channel only actually needing to interact with the Ethereum blockchain to open and close the channel. For many use cases that's good, but for some it's actually too much to have to communicate with Ethereum twice. So you can imagine if Axel is communicating with BBC and BBC is charging Axel for every web page he visits. Axel is not going to want to have to wait several blocks to begin visiting websites and BBC is not going to want to have to wait several blocks in order to receive confirmation of the payment. So Raiden does have a solution to this. It's in the form of mediated transfers. So you can imagine if Axel already has a payment channel open with a mediator who's also connected to BBC, then Axel can pay the mediator to forward a payment to BBC for Axel. The caveat here is that the mediator has to have enough tokens already in the channel with BBC in order to handle the request from Axel. So you can imagine some ideal mediator could be connected to all the major recipients like live peer BBC, New York Times, etc. and then users Axel Bob and Zach, etc. wouldn't even need to ever connect to these vendors directly. Instead, they would connect to the mediator and send all of their payments directly through the mediator. Now the caveat with this is the mediator is going to have to have a lot of tokens to be able to handle that. You can imagine potentially millions of dollars worth of tokens flowing through this mediator means it has to have millions of dollars of tokens in all of these channels. So we think that's a perfect opportunity for a virtual worker. And so as before we use the operator token holder model. The token holders put tokens into this virtual contract and the operator handles the job of being this ideal mediator and they split the rewards. Yeah so this is just a preview of a couple of the protocols we're building virtual workers for and we're playing design virtual workers for many more upcoming staking protocols. But the ultimate aim of what we're doing is actually to create a marketplace for capitalists and operators to match up be placed into virtual workers and then start working for arbitrary staking protocols. So we want to create this shared platform for a couple of reasons. The first one being that there's a huge benefit for virtual workers to be all in the same platform in that many of these virtual workers rely on a deep liquid pool of workers which can come in and replace their operator if he acts maliciously. And also some of these virtual workers rely on operators which are monitoring their operators ensuring that they don't lose any of the capital. And then additionally we just want to make it as seamless as possible for any capitalists or operator to find the protocol which can give them the highest returns and as soon as it stops giving the highest returns switch to some new protocol. So at this point in the explanation people usually start asking me okay so you know how high are my returns going to be on tokens if I put them into the system and my response to that is that potential returns are always a function of risk and you know there's risk associated right now with owning crypto tokens. It's also risk associated with interacting with one of these virtual workers and so the returns are going to be positively correlated with that and so it's hard to say exactly. So moving forward you can imagine rather than having individual users plugging in as a capitalist or an operator instead having smart contracts plugging in you know in the case of multiple capitalists plugging in via smart contract we term that a fun pool and you could further imagine these fun pools tokenizing participation. In other words issuing shares which then the participants can go to exchanges on making it even easier for people to start interacting with the system. And finally with what we're building with the one protocol we see that right now there's a lot of idle capital out there tons of people have you know millions if not billions of dollars in cold storage and ether and whether or not it's you know your ether and coal storage or your old smartphone and you know your drawer that you haven't seen in years we think that if there's an easy seamless way for people to start getting returns on that capital by plugging into the digital ecosystem that could make the whole digital economy a lot faster. So thank you guys so much for your attention so we're currently hiring so feel free to reach out and if you guys have any questions you know feel free to reach out to us via our website. Thank you.