Will 0:04

I'll just kick off by giving by saying a few things. The first is. I know that we've had sort of a lot of governance recently. So I just wanted to say thanks to everybody who's active and participating in those proposals. Because obviously, it's for the really important stuff for the DAO. Right now we have the snapshot that was put up by Jake yesterday for TIP 28|29, you guys know what that one is. We have the DAO Governor Bravo test run. That's that one's exciting, actually, because it's on-chain. We're actually using our governor Bravo contracts for the first time through boardroom. You can also use with Tally if you want, but we're kind of rocking with the Boardroom recommendation. You just go there, connect your wallet. And then you can vote. But make sure you're connecting via the account that you have delegation weight on, or that you actually have your own own weight on. And then we're working towards the last one that you guys will hear about pretty soon here is we're working towards a on-chain token mint proposal. So we already did the snapshot for that one, which we're just counting as like the temp check. And we're just going to move it straight into Governor Bravo, even though it was pretty much already validated by the DAO, but we actually have to have the DAO mint, more tokens, on-chain for inflation based rewards for node operators on the network. Pretty stoked about all that. And then the one other thing that I wanted to say was, I thought that the announcement from Ash and John today was super cool. I definitely want to, going forward, like continue to highlight more of the stuff that the guilds are doing in announcements to increase visibility there. So that's my spiel about governance and l some other cool stuff. With that, I'm gonna pass it over to Beau.

Beau Shinkle 2:02

Hey, everybody. If you are not clicked into sort of my Discord stream, this would be the time to do it. I'm going to be doing some whiteboarding stuff as well as talking over it. So video is going to be at least half of what's going on, it would be useful. I have a nice nine item list of Agoristen’s wonderful questions to go through. I'm going to do those first. And then we have some other ones. I think they'll be nice as well. First up, how is the audit going? I have to be a little bit evasive here. Unfortunately. We have an audit from Trail of Bits and Least Authority. Trail of Bits has been more communicative than Least Authority has been. We've gotten some weaknesses identified. And and shoring up those weaknesses may take some additional time. But also we might be able to deliver as, as intended. How's the client work progressing? Still according to schedule? Yeah, as far as we can tell, we are on schedule. So things are still going well, client side. And then getting into the sort of the meat of it. Can you explain the relay used in v2? And how it differs from v1? Who funds it? And the potential risks and centralization risks with the relay? This is a this is a huge question. I think it's like, it's an incredibly important one. And so I want to go through a lot of the context here. Starting sort of like from the beginning. So in order to explain what a relay is, what the v2’s relay is and what and how it differs from v1. If this were to explain, like what we what what we're trying to relay and why we need to relay information in the first place. Like why we have to tell Bitcoin about or Ethereum about Bitcoin and what exactly we're telling them. So the idea is that whenever we make a deposit or a redemption, or whenever we want to make a deposit or redemption, for tBTC, we need to prove that that actually happened on Bitcoin side, otherwise, the system would be vulnerable to like rampant fraud. Hopefully, that is, that part's clear. So this is. The idea for Bitcoin, which is a proof of work network, is that. That was a weird sound. Yeah, we got recordings set. The idea for Bitcoin is you have a bunch of transactions. So you have like TX one, TX two, like TX three. And then this all makes up, like a block.. And what we're going to do is we're going to hash this. So this goes through something called SHA-256. And so when you put this through SHA-256, it's going to spit out a, this huge sequence of, of hex numbers. So like, in the same way, you have an Ethereum address that might look like 0x19F2, like whatever, it's gonna spit out a huge sequence of numbers, that 256 numbers or, bits long. So the idea is that we want to hash this whole block, and it's going to spit out a singular, hex string. And whenever you hash this block, it's always going to spit out the same thing. So what we're looking for, is to hash a block and have this hash number, cause this is always a number, be less than a difficulty. So that's, the first person that can find that wins. The issue is that whenever you like, are trying to hash a block, you're always gonna get the same thing. And so like a miner takes all of the transactions they want to include. And then then they hash it. If it if this number is greater than difficulty, they didn't solve the problem. So then they're stuck. So rather than picking a new set of transactions, to potentially hash, they include a nonce. Which is just like, their favorite number. So for instance, like maybe this is seven, or maybe this is like 1932, or 4,392,800 935. And so they're just trying like random nonces. And every time you pick a different nonce, you're gonna get a totally different hash, and that totally different hash might be less than the difficulty, which never changes, for this particular problem. And so the idea is that the only way you can, you can get a hash because you can't know what the hash is going to be until you actually hash it, is by trying different nonces. So you pick one to start, and then just increase it by one over and over and over, hashing it over and over and over until you randomly arrive at a hash that's less than the difficulty. And then when that happens, you've done a lot of work. So if this difficulty is like, if this number is very low, then the chances that you would randomly pick a hash that are that low, is very low. And so we on the Bitcoin network, people are just making so many hashes all the time that we set this difficulty number to be low enough that out of all the computers on the network, only one person solves this problem once every 10 minutes. And that's how we get one block every 10 minutes. And in addition, when you're creating your transaction set, we also include the hash of the previous block. And that's the blockchain. So that's Bitcoin. You have the hash of the previous block, all the transactions in the block, and the nonce at the block. And then that's and it just keeps going. So part of the trouble is that this is like a lot of data. And so we have this idea for a Bitcoin header. So one of the problems that often comes up is, like, let's say we want to store information about this chain in a compact way, that allows us to say like, Hey, like transaction two happened. And I want to prove that it happened without showing that like showing the entire block. And that the fact that transaction two is part of this whole block, and that when we hash this whole block it includes the hash of the previous chain, which includes the hash of the previous chain, all the way back to the original ones and those all paths difficulty, that's like, that's how you would do the whole really involved proof. Like, I sent money to you, that’s transaction two. Transaction two is part of the block with the nonce, we hash it, it's part of part of the difficulty, it includes the previous block, that one's also verified all the way back to beginning of time, thus, my money is valid. That's way too involved. So instead, what we typically want to do is we just want to include three things. Sorry let me write this a little better. All we care about is do the headers, we have the previous block, this block, previous hash, this hash, then we had something called the Merkle root. So rather than including this whole giant list of transactions, what we're going to do is transform these into the Merkle root. And then we're going to store just that information every time. And then the way that this works, is like this. so say you have a transaction, whose ID is 0x Alice, and just like picking nice simple names here for demonstration. And then like her block, imagine, for demonstration your block only has four transactions, you've got a 0x Alice, got 0x Bob, you have 0x Carol, users transactions names, then you've got 0x David what we can do is we can hash 0x Alice and 0x Bob together, and then this is this might give us like, a get like Alice plus Bob hash is gonna give us something, when we run that through SHA-256, it's gonna be this long string of letters and numbers. But let's say for convenience sake, this is gonna give us 0x dog and then if we hash Carol and David this might give us like 0x cat, it won't but like, I don't want to write out what it actually would be. If we hash 0x cat and 0x dog, maybe that gives us 0x apple. The point is that we hash these two together we get this, we hash these two together, we get this. Then, we do this and it looks like you know, like a final four NBA or college basketball tournament bracket. This is the Merkle root. So the idea is that we can take the whole transaction list and then hash everything up into this like tournament bracket and end up with just one hash at the end and then store just that one hash. And then if anyone ever wants to prove that for instance, Bob was in the block, then they can do so by providing Bob, Alice, and then that with dog yields the root of Apple. Sorry, that's going to make dog and they need to provide cat. So this is like their bracket path. So if you like imagine like your favorite basketball team is, is the Bobs and that the Bob's are going to play against the Alice's, and then once they win, they're going to play against the Cats. And then the grand winner is the Apples. And so when you want to prove that Bob was actually in this tournament, you provide your bracket path. And that ends up with Apple. Because we know that Merkle root which was published on-chain is Apple, that's proof that Bob was in the bracket. And so that lets everyone know that Bob was in there, he was one of the transactions that made up this Merkle root. Otherwise, you could have never gotten there. And so what this does is it makes it so that we can prove that transactions are in blocks. While on-chain, the only thing that we're storing is 0x Apple rather than this whole huge list, which could be you know, like a 1000 transactions per block, or like even more. So it massively cuts down on the storage space, in exchange for having to do this longer proof every time you want to show that something is in here. So that's part of it. The next thing is that Bitcoin, every 2116 blocks, changes its difficulty number. So the difference between the full relay that tBTC v1 uses is that tBTC v1 uses the header, which has the previous block, this block, and the Merkle and then, you know, uses that again, previous, for this Merkle it does that every 10 minutes. It publishes this information. So one ID, one ID and then one ID. So it's publishing three pieces of information from Bitcoin to Ethereum, every 10 minutes, that's the v1 relay. And then whenever you want to prove something like a deposit or redemption, you prove, you find the block that your thing, like your your Bob transaction was associated in and then you you you show the whole transaction path that gets you to your Merkle root, and that shows that that your transaction was valid. On top of that you normally also provide the next six blocks to show that like you're not in in like a weird offshoot of Bitcoin. That's additional complexity I don't want to get into. But that's the basic idea. So every 10 minutes, the current v1 relayer is publishing information to Ethereum. The light relayer. The main thing that it's doing is that it only it only publishes the blocks immediately surrounding when the difficulty changes. So Bitcoin does a retargeting, which means that it's changing its difficulty every 2116 blocks. And that means it like the number you have to get when you hash a block in order to to make a block part of the chain changes. And so what we want to do is take some number I think we picked 10. So that we want to publish the 10 blocks before and after the difficulty changes. and just those. So rather than publishing all 2016 blocks, we're just publishing, like 20 of every book of every 2016. So it's like way less, then, when you actually want to prove that you're part of the Bitcoin, like, when you want to prove that your transaction is valid, what you do is you show A, that you, your transaction has the same difficulty, as the as the most recently published, relay block, and B, that it's held up by an appropriate amount of work. And so the amount of work that's held up by is demonstrated by the fact that each of these headers that you're publishing, couldn't have been made, unless enough computing power, could have found all of the blocks via these hashes to find the correct difficulty, so like, because it's so difficult to find the hash of something the hash of a block where the hash is less than the difficulty. And then, if you do find one where the hash doesn’t meet the difficulty, that must mean you were either a insanely lucky or be there was a lot of work done. And so when you provide multiple blocks in a row, where the next block includes the hash of the previous block, that means that like, you're either getting, like, out of this world lucky, or the work was actually done. And so now, this is proof of a lot of work, but but it might not have been on the correct chain. But then when you show that the difficulty is exactly what it should have been, according to the relay, that now we're also sure that it's on the correct chain. And so when the different one, the proof of work is done, and it's on the right chain, according to the relay, because we're checking based on this retargeting, then then we're good. So we have drastically reduced the amount of on-chain storage, from every block to, like 20 out of 2016 blocks. So we're able to, in current estimates, reduce the amount of costs from the current v1 relay to the v2 relay by about a factor of like 500, which is good, very, very good. So that's what we got relay wise. I know that was really dense, but wasn't sure how else to answer in like a, in an honest way, how relays work. Alright, so next up, do we have enough nodes? What is the minimum? And what is an ideal amount? So the way that the way that nodes work, and I can draw this. It’s kind of a complex question, because there's a lot of balancing between economics and sort of like security going on and also optics that and that makes it confusing. So I wanted to, here's what I mean by that. We are at launch, and this is subject to change, a 51 of 100 multisig on every new wallet. On every

East 24:16

I’m sorry Beau, Beau?

Beau Shinkle 24:21

Hey, what's up?

East 24:23

No, I think you got some questions from the previous subject.

Beau Shinkle 24:28

Yeah.

East 24:29

From Agoristen in the in in chat in call chat.

Beau Shinkle 24:34