TFTC: A Bitcoin Podcast - #648: Simplicity on Liquid with Andrew Poelstra

Episode Date: August 6, 2025

Marty sits down with Andrew Poelstra from Blockstream to discuss the launch of Simplicity on Liquid mainnet, a formally specified programming language that enables smart contracts with mathematical guarantees of safety and predictable execution costs, representing nearly a decade of development to bring secure, expressive scripting capabilities to Bitcoin-based systems. Blockstream: https://blockstream.com/careers/ Simplicity: https://simplicity-lang.org/ STACK SATS hat: https://tftcmerch.io/ Our newsletter: https://www.tftc.io/bitcoin-brief/ TFTC Elite (Ad-free & Discord): https://www.tftc.io/#/portal/signup/ Discord: https://discord.gg/VJ2dABShBz Opportunity Cost Extension: https://www.opportunitycost.app/ Shoutout to our sponsors: Coinkite https://coinkite.com Unchained https://unchained.com/tftc/ Join the TFTC Movement: Main YT Channel https://www.youtube.com/c/TFTC21/videos Clips YT Channel https://www.youtube.com/channel/UCUQcW3jxfQfEUS8kqR5pJtQ Website https://tftc.io/ Newsletter tftc.io/bitcoin-brief/ Twitter https://twitter.com/tftc21 Instagram https://www.instagram.com/tftc.io/ Nostr https://primal.net/tftc Follow Marty Bent: Twitter https://twitter.com/martybent Nostr https://primal.net/martybent Newsletter https://tftc.io/martys-bent/ Podcast https://www.tftc.io/tag/podcasts/

you've had a dynamic where money's become freer than free if you talk about a fed just gone nuts all all the central banks going nuts so it's all acting like safe haven i believe that in a world where central bankers are tripping over themselves to devalue their currency bitcoin wins in the world of fiat currencies bitcoin is the victor i mean And that's part of the bull case for Bitcoin. If you're not paying attention, you probably should be. Andrew Polstra, welcome back to the show, sir. It's great to have you.

Hey, great to be back. Like I said, I want to say it again, congrats on getting Simplicity over the line. I know it's been a long, almost a decade journey for Blockstream. Yep, yeah, for sure. We got it on to the test network less than a year ago. That was a big deal. But this is our first production network with real money on it that you can use simplicity now with real money, which is a pretty cool thing. Yeah.

So I guess for anybody out there who's either newer to Bitcoin, unaware of simplicity, why don't we give a background? I was going to say brief background, but I like your verbosity and you have deep on it. So I'm not going to give any false promises to the audience. we're about to get an in-depth uh history on simplicity it really starts in 2012 when russell o'connor sort of sketched the design and then you guys decided to really lean into it and block stream in like 2016 correct yep yeah that's about right um i would even say it started a little before how about this i will try to be brief i always i always say that i don't know why while they're saying it but i'll try to be brief so uh even before even before simplicity in 2012

there was uh russell o'connor had been in the bitcoin space he showed up very early days um 2010 i think maybe 2011 i think it was 2010 and he had this concept called mast merkleized abstract syntax trees and this eventually turned into what uh is now taproot where the idea is rather than having a script system where you've got like if this then that kind of thing everybody runs this everybody has to download this whole program and then run it and then they've got various conditions that that apply under different conditions but they've always got to download it right they've always got to see the whole script what if instead every time there was a conditional if this thing then that thing what if we put them all in a merkle tree and so now you can have

hundreds or thousands or millions of conditions and when you want to spend your coins at the time of spending you know which conditions you're going to use to spend the coin so you just reveal that specific one and the premise behind a merkle tree is is you can do exactly that it's this big structure where you can commit to arbitrarily large numbers of things like up to up to billions before you're you're spending too much compute time on it and then if you only want to reveal one of those billions of things you have an overhead you reveal the one thing and then you have an overhead of you know some some fixed cost maybe like a kilobyte or something versus having an overhead of revealing a billion different things which is what you'd have to do

in the traditional model of script where the way you handle branches is by having a bunch of if then statements and everybody's got to download the whole thing so in taproot we have that we have what's called the tap tree you've got all these different scripts you can have if you want to do like a five of ten multi-sig for for some reason um one way you can do that is by taking all of the uh ten choose five possibilities that you might have if it's a number of a couple thousand put them all into their own little tap branch and then whichever five participants you happen to have at the time of spending you you uh take the branch corresponding to those so this is an idea from 2010, 2011, again, like the very early days

that eventually made it into Taproot, much, much later, of course. And Simplicity kind of came out, I promise this is relevant to Simplicity. So the premise behind Simplicity is what if we took that idea and we really went to the extreme with it? So one big thing that Simplicity has,

well, first off, Simplicity is the way that it fits into Bitcoin and the way that it fits into Liquid is as basically a drop-in replacement for bitcoin script or the drop-in replacement for tap script as it is now so you've got a tap tree you've got all these different scripts and rather than using the existing bitcoin script system you use simplicity instead okay and within simplicity you have these branches and these conditionals right so if if this person is available to sign then check his signature otherwise check this

other signature or if the coin is old like past a certain age then allow these backup keys to be used or whatever conditionals you might want then okay you've got these conditionals you you reveal whichever side that you actually take that's cool that's there's some efficiency there simplicity goes one step further and this is well conditionals are one way of composing two pieces of code or two programs right you've got uh some some sort of flag some something that makes you decide what to do and you've got these two things that you might do and based on your flag you pick one okay and you can compose things in other ways you could say i've got these two programs i want to run them both in a row bitcoin script is really good at this so it's called a concatenative language you

have a program you run it you just stick the other program right after and you run them you run them in order uh you might compose them by running both of your programs in parallel like on the same input and then somehow you you combine their output so there's a couple other things you might do and it turns out that you can start with two different programs one of them does nothing it takes an arbitrary input and throws it away and the other does nothing it takes the arbitrary input and just pass it along and you take those two programs arbitrarily many copies of them and you compose them with each other and other compositions and you can build up anything any computation this is this is something called the um the sequent calculus if you're into

uh computer science like historical computer science even it turns out you can build any computation just using these these um these two basic functions and these combinators and that's the premise behind simplicity is that rather than having an opcode based language where you have in bitcoin script you know 70 or 80 opcodes they all do different things most of them uh the bulk of them just push things onto the stack but then there are others that can duplicate items there are others that can compare them for uh to each other compare them to true or false uh do branches based on them uh and then there's a collection of five or six that do kind of cryptography right there's there's ones for four different kinds of hashes that are built into

bitcoin script there's one that checks a signature there's one that checks a multi-signature and taproot is tweaked a little bit but essentially it's checking a multi-signature and then there are a couple variants of these um there are things for lock times and that's that's pretty much it right but the the whole premise is that you have these built-in the small set of built-in pretty complicated functionality that are all one opcode and then you can combine these in various ways by pushing and pulling things from the stack of data that you can also kind of insert stuff on and that's that's how you build programs and there are a few problems with this model one is as i mentioned if you're trying to do conditionals if you're trying to do if statements

then you wind up having to write a whole ton of code or well you always have to write a whole bunch of code as a validator you wind up having to download a whole bunch of code all right so even code that doesn't even get executed you got to download it because your whole program is in the straight line then another problem is that it's actually very difficult to reason formally about these things so if you've got a bitcoin script that is supposed to implement some sign of of crazy business logic and stuff you ideally want some high assurance that it's going to do what you expect to the extent that you can specify what you expect right um and and certainly you want some assurance that it's not going to do like certain surprising things right the money won't

move unless somebody signs off on it um the uh the the script has certain behavior until a certain time at which backup conditions become active so those kind of things and it's very hard to do this with bitcoin script because the way that every the way that you translate uh your your specification again today i'm glossing over i'm using the word specification in the interest of brevity I'm not going to say what a formal specification is, but it's a thing you can make that describes exactly what a program should do. And to the extent you have a specification,

to turn that into code in Bitcoin script, it's just, you really got to do a whole bunch of ad hoc. Like, well, if I were a Bitcoin script interpreter, how would I do this? Well, I'm going to like push this onto the stack and push another thing and compare them. And then I'm going to interpret this one as a public key and this other one as a signature.

And then I'm going to swap some things and I'm going to take the output of that, which is an opaque blob, but i know it's going to be either zero or one and i'm going to move that to the alternate stack so it's out of the way and then i'm going to do this you know you're you're kind of jumping through a whole bunch of contortions each of which is manipulating this arbitrarily sized stack of arbitrarily sized elements and you're using these op codes which do kind of complicated things the stack and which themselves are defined in terms of what does what happens in script slash interpreter

dot cpp in the bitcoin core source code versus if you were constructing a program by starting with these two dead simple functions the output nothing and the output what you give a function the unit and the identity function and then combining them in these various ways and in total by the way in simplicity you've got those two basic functions and seven additional combinators that's it that's a whole language nine nine combinators okay plus an extra one we add for witnesses and uh plus an extra one called disconnect maybe we'll get into it okay 11 11 if i'm stretching um plus blockchain introspection but we can also actually forget about this blockchain introspection is even though formally we have to extend the language to support

like how do you get what the current lock time is how do you get the current amount amounts how do you get the current output amounts etc uh all of those are very simple right they're just op codes op codes combinators that take no input and output whatever they're supposed to do so okay 11 basic combinators all of which are defined by like a single line of mathematical notation i've got a t-shirt i don't have it with me it's in the laundry but um you can it's so small you can print it on a t-shirt so we have these t-shirts with the entire definition of simplicity language printed on it and importantly it's not just simple in a kind of mathematical notation sentence is simple in a formal sense that can be captured by things

like the rock theorem proving assistant or the lean proof assistant or a language like idris or f sharp which has a type system that is capable of supporting formal proof and the idea here is that now if you well there are two big ideas that come out of this so as a user of the language if you can specify what your program is supposed to do and then you can take your simplicity code which itself is formally specified because it's defined in terms of these common errors that are simple enough to be be fit to these specification languages and then you can prove you can prove you can produce a formal proof that your code matches the specification and perhaps you don't have a full specification right which is it's difficult to create but maybe you can at least

say some specific things you can say um at worst no matter how this program executes how much space will it take on my transaction you can answer that very cheaply and now you can bound your fee rates you can you can do fee estimation uh very accurately for for arbitrarily complicated programs you can say well i don't really know i'm some countersigner right i'm blockstream i'm the Blockstream app. I'm BitGo. I'm whatever I am. I don't know or care what this code is supposed to do, except that it shouldn't run without my signature. It's whatever the customer says, plus my signature. How can I formally prove that there's no possible way to spend this code without my signature? Well, yes, you can prove something like that. So that's one big thing. And that's

huge for users. And the other thing is from an implementation standpoint, it means that when we're implementing our simplicity code we can be assured that it's correct so and we can be assured not only that's correct and that it matches the specification which we have that's super cool but also it's correct and that it matches our intuition so in bitcoin script there are at least once it used to be more frequent but like at least once every year or two there's some new novel behavior in bitcoin scripts that somebody will discover that as near as we can tell nobody knew before where if you kind of poke an opcode in exactly the right way then it will do something surprising and let me give an example of this kind of thing um the if opcode in bitcoin

script it takes an input which is supposed to be true or false and in bitcoin script you don't have true or false you have kind of blobs of data okay so you might think well probably false you might represent by zero and true you might represent by one is a natural way when you've got blobs of data well it uh it turns out that false is represented by the empty string okay and also zero and in fact also any arbitrarily long string of zeros except that also the left most zero is allowed to be a one okay that that specific bit doesn't count okay and that's what false means um oh and it can be arbitrarily long up to the 520 byte stack limit okay there's there's only one other opcode that takes arbitrarily sized inputs like that and it's if dup which is the same

and not if okay so it's three all these if opcodes for something to take arbitrarily long inputs even though nothing else will accept arbitrarily long inputs um okay so those are all the false values and everything else is true so that's a little bit surprising right it means that if you could construct a public key or a signature that happens to have this wonky shape of all zeros and then a one at the end, then you could create a signature that evaluates to false, even though every real signature that somebody produces would evaluate to true. And it turns out that you can't produce an ECDSA signature this way, because there's encoding rules that just force you to set other things to one. You can produce a Schnorr signature this way that will parse as a Schnorr signature,

but it won't validate, because when we added Schnorr signatures to Bitcoin, we designed them such that you cannot produce an arbitrary signature and then back compute what your keys and your message have to be. In ECDSA, you can do that with something called public recovery, it turns out. So you can do like arbitrarily badly formed signatures. So I go into all those details

to just kind of describe how insane Bitcoin script is because it was implemented the way it was, just like kind of, we need some extra functionality that's bolted on. And then there's kind of these like weird accidents of how certain opcodes interpret their input and they interact in crazy ways. And this is part of why it's so hard

to get new things in the Bitcoin script, right? Is that you can propose something like opcat, which is three lines of code. It's dead simple, but how do you know how it fits into the system? How do you know all of the behavior? It takes so long and so much mental energy to convince yourself that the simple looking function

is not going to do surprising things. And simplicity, by being the simple, formally specified model, saves you all of that effort. So I'll stop. What's up, freaks? This rep of TFTC was brought to you by our good friends at CoinKite. They make the cold card queue, my favorite hardware wallet, the most secure hardware wallet on the market. As you can see, it's got the BlackBerry form factor, full keyboard.

It's got two secure enclaves. You create your private public keys offline. The device never has to go online. never does go online so you keep your bitcoin secure if you have your bitcoin on exchanges and you're looking to get it off secure it in the best way possible pick up a cold card queue go to coin kite.com find the cold card queue use the code tftc for five percent off if you're a power user of bitcoin like i am if you're running a business on a bitcoin standard if you're just a bitcoin or wants to secure your bitcoin get the most secure hardware wallet on the market go get

the cold card queue. It's a beautiful thing. Sup freaks. Guess what? We launched a browser extension. It's called Opportunity Cost and it helps you see the true cost of everything in Bitcoin. Convert prices to Bitcoin as you browse the web. Opportunity Cost automatically displays fiat prices in Bitcoin or Sats, helping you think in a Bitcoin standard. It works on Amazon, Zillow, X, your bank account, QuickBooks. You can convert everything to Bitcoin. It's really cool. it's also 100 open source mit license we don't collect any data all of the conversions happen in your browser on your local device it's a great way to recalibrate your life and begin thinking in sats go check it out at opportunitycost.app that's opportunitycost.app

so just building on not only comparing it to bitcoin script as it stands today but like i I guess I think many Bitcoin developers would look at something like how Ethereum's implemented script and it's it's created these sort of attack vectors that have been exploited over time. And what I'm picking up from what you just described within Bitcoin specifically, like opcodes are sort of this like modular way of doing it. And I don't know if the intent of the design was like, let's do this modularly so you can have something out of the box. But as you described, when you do that, it's sort of clunky and you create a burden for somebody trying to build. So it's very hard to audit and know exactly what it's going to do. And so simplicity just tries to be expressive yet finite without having to have all that complexity built in. Is that correct?

Yeah, exactly. Expressive yet finite. That's a good way to put it. So yeah, EVM took Bitcoin's script and just bolted on. everything we want to be able to do that's bolted onto bitcoin script more or less um is roughly how evm is structured um and then they realize that the bitcoin stack language is not a good model for that so they have what they call rich statefulness where you've got these series of global database lookups that uh so every contract has a bunch of code it has variables it can save

and update and all this good stuff but it is very difficult to reason about they kind of inherited the difficulty in reasoning about Bitcoin's script and in some ways made it much more complicated. They also did some kind of unnecessary, like in addition to extending it computationally, they also added this rich statefulness notion where you have these global key value lookups and everything becomes very stateful,

which is hard to reason about. But then the big thing is this word finite that you mentioned. So Ethereum for a while advertised itself as being true and complete. And the idea behind that phrase is that a Turing-complete language can do anything at all. A non-Turing-complete language is kind of narrow and domain-focused,

is the intuition, right? So as an example, a programming language like JavaScript or like Python is Turing-complete. You can write anything that you can express, you can write in those languages. A language like HTML is not. HTML can only produce, draw web pages, basically. um some things would surprise you to learn that they're actually Turing complete so CSS

which is used to format web pages to set the colors and the widths and the styles and stuff it turns out CSS is Turing complete because they're like conditional stylings that you can put in and the loops and stuff uh PostScript which is a document formatting language that predates PDF is Turing complete um and I've I've exploited that to uh to do some paper computer kind of projects um there are there's a whole pile of languages that really shouldn't be Turing complete, but accidentally are. And Ethereum more or less is on purpose. But there's a small caveat there. Strictly speaking, to be a Turing complete language, you need to have an infinite amount of memory and an infinite or an unbounded amount of memory and an unbounded

runtime. And in real life, of course, you're always bounded by one thing, by the constraints of your machine. And then on Ethereum, you're bounded by this quantity called gas. Okay, so you write a Ethereum transaction, you decide how long you expect the transaction's contract code to run for, and then you set a gas budget based on that, which is just actual Ether that you have to put up and you pay. And where Ethereum runs into trouble, or one place where Ethereum runs into trouble, is that when you're trying to estimate how much gas your program's going to take you can't do that in general and so there's these whole uh kind of categories of smart contract bugs where it turns out that in order to call certain functions in a contract you have to use

more gas than is available which means that you effectively cannot call those so there's functionality that you built into your script but it turns out it's not accessible because of this external gas limitation and that's kind of a problem for users it turns out it's also a problem for validators because the way that you determine whether or not a script is valid whether or not is used uh all of the gas that it's been allocated is by running it you start running the script you figure out um did it run on a gas if it did then you got to stop and you might think okay if you're a validator you receive a transaction it runs out of gas it's invalid so you throw it away right well you can't do that that's a denial of service vector um you already did all the work to do that

So if somebody could just give you a program that ran for a minute and then failed, well, then you'd be churning away for a minute, right? And maybe you limit yourself per transaction, whatever. A bad guy gives you a million transactions that all take a microsecond, and now you still wasted a second. So in Ethereum, what happens is when you run out of gas, the transaction is still valid. You still pass it along. It winds up in the blockchain, but it doesn't do anything. It just burns your gas. And so there's this other category of kind of Ethereum failure modes where there are these transactions that wind up on the chain that don't do anything, that just burn gas and do nothing else.

And these are almost certainly accidental because there's no reason for you to just burn gas the way that I'm describing. And the way that Bitcoin avoids this problem, in Bitcoin if a transaction is invalid, it's invalid. It doesn't go on the chain. is that in bitcoin there's kind of a neat trick we use which is that every op code takes one byte to encode so bitcoin script has no loops so every op code can be executed at most once you can't go back and then redo stuff which means that if you see a byte you know the apps the absolute worst case that byte represents a single op code of work and so you take the whole size of your transaction and you use that to swag how expensive that transaction will be and then you look at the

transaction's fee and you compute what's called the fee rate which is how much did they pay per byte or i should say per weight of the transaction because certain bytes count more than others and that avoids this denial of service problem basically so you don't have a gas limit what you have is the size of your transaction represents how much work it is and then your fee you just attach whatever fee is appropriate for that and then miners and validators kind of order things but which has the highest fee per weight kind of thing this is cool this is this is pretty cool but it uh there's an obvious question then well what if we want to like surely we want to put loops and like go to like some way of doing this kind of stuff into bitcoin right are we just

like forbidden from ever having a way to execute an opcode more than once because then it would break this like how much uh uh the size of the transaction representing the computational cost kind of model um and any theory in the solution was gas they're like okay we're just gonna have to throw away the size size represents computation model and we're going to have to do this this unfortunate thing in simplicity we have a much cooler solution which is that you can as a validator you can scan through the program one byte at a time technically one bit at a time and you can determine the maximum execution cost how much cpu is this going to use how much memory is it going to use statically just like a single path through the program and the program this is

kind of cool you can have a sub program or an op code however you want it to think of it that runs exponentially often so you encode this bit of your program once and when you actually run the script it gets evaluated you know like a trillion times you can totally do that in simplicity and your validators will scan through the program they see your little bit they evaluate it once they say oh that cost a trillion because it gets executed a trillion times and moves on and then eventually it was you know the validator say you know what a trillion is a lot you can't you can't fit a trillion opcodes into into a single block kind of thing um but importantly even though you have this kind of arbitrary blow up um between the size of your program and the actual cost

you still only have to scan the small one you have to scan the bytes of the program to figure out what that cost is and we call this static analysis we call it a static bound and what that means is that we retain the bitcoin ability for a validator to just look at the transaction and immediately compute what the fee rate is and whether it's whether it should be prioritized or or whether it's never going to get into a block and we should just drop it without ever having to execute the code and we do that while still getting this arbitrary amount of execution and the reason this is possible is because what you're encoding in your program is actually a composition of all these basic um basic kind of building blocks of computer science

none of which are a loop importantly none of which are a loop and none of which are a go-to but it turns out you can still get arbitrary um arbitrary computations this way and for each of those combinators as a validator you can say like well okay if this is a parallel composition i'm running two things in parallel the cpu cost is going to be you know the left guy plus the right guy the memory cost will be the maximum of either one of them that can you kind of do that kind of analysis over and over now people who are cs nerds or maybe just listening to me far too closely might be kind of suspicious about my claim that you can do loops uh that you can that you can do an arbitrary computation in simplicity and that you don't have a looping construct or a go-to

construct and i'll briefly say something about that which is that there's actually another form of composition which is not sequential or conditional or parallel or or these kind of basic things called recursive composition and that's where you have a function that's able to call itself and basically do a loop right go back so simplicity does support this through this extra combinator we call disconnect but it supports it in kind of a clever way where in principle you can put an arbitrary number of of loops into your program at the time that you define it at the time that you construct your address that represents your program code but when you actually go to spend it you are required to unroll the loop however many times you actually execute it

so disconnect commander allows you to attach arbitrarily many copies of code but you have to attach them as spending time and then if they are actual literal copies one after the other you don't have to write you don't have to write the same code 20 times in a row the encoding of simplicity will collapse it into a single copy but the static bound they're still able to see that is executed 20 times and assigned at a cost of 20 so in the end what hits the blockchain is in fact finite is in fact built up that what hits the blockchain essentially does not have this recursive um uh way of combining of composing computations in the end when you put it on the chain you have to enroll it and then it's just regular old composition where you're running one

thing after the other so you kind of get the best of both worlds where at commitment time when you're writing your program and generating addresses then you can do arbitrary unbounded computations but if you want to spend it on the blockchain you have to do the computation and it has to terminate and you have to bound how much that competition how long that computation took in order to put on the chain otherwise you can't even encode the results like it's just like a nonsensical transaction so so you the transaction creator get this full expressivity but validators don't have to deal with that expressivity which uh which they don't need right like a validator knows if your transaction is going on chain your program has to succeed right it has to be valid

right that's that's like the one thing validator's job is not to like run the computation and see what happens right their job is to validate that you did the computation and the right thing happened right and as cheaply they want to do that as cheaply and as predictably as possible serious about your bitcoin start acting like it unchained just launched the financial freedom bundle a curated pack that includes a premium bitcoin book a new hardware wallet guide and access to a private macro event with turd to meester legend it's time to take control of your generational wealth go to unchained.com slash tftc to request yours that's unchained.com slash tftc pretty hot package freaks go pick it up yeah so in short you're basically just

guaranteeing expressiveness with like formal safety guarantees that don't exist elsewhere and seems like has been a big problem needed to be solved for these particular types of systems yeah absolutely thank thank you for zooming out so much that's exactly it right um all of these elaborate constructions i'm describing have that goal of how do we have something that you can formally reason about where when you're when you're implementing the system you want to know that it's doing something predictable that's not going to blow up people's computers or crash when you're writing code you want to know that your code that you're writing does what you expect it to and when you're running a full node when you're validating this stuff you want to know

that very quickly you can figure out the cost of this validation and you can charge the transaction appropriately and with simplicity we've managed to do this in a model where we get the full expressivity of something like evm or chia lisp or any of these languages that are out there that you do arbitrary computations while preserving these goals well yeah and i think this has been a big a big theme in bitcoin for the better part of eight years now or nine ten years since ethereum launch specifically which is like bitcoin is an extremely important project we're trying to separate money in states and at this point it's a 2.2 2.3 trillion dollar market and is incredibly important that we make sure that the system doesn't fail and so with that in mind like

we have to make sure we build things correctly so that protocol the network can say stay sufficiently distributed and it actually achieves the goals it set out to and during that period you had ethereum other smart contracting networks come to the market and say look at us we're doing it better like we're faster we have more features than bitcoin and all the while bitcoiners myself included and i truly do believe this and it seems like it's beginning to manifest i've been saying it will eventually come to bitcoin we're just going to do it the right way and it seems like that's what you guys have been working on in simplicity for a decade is doing it the right way yeah yeah um everything everything ethereum added everything these other chains added right comes

there's some trade-offs and some of those are more reasonable than others right so a lot of these things have much faster blocks than bitcoin and i think if bitcoin had been developed if in 2008 somehow satoshi had uh compact blocks and mini sketch and all of this like peer-to-peer propagation tech that we have today probably we would have faster blocks right there's certainly a trade-off between fast blocks and decentralization um and it's not um you know it's not inherently obvious that the you know the 10 minute block was was the perfect optimal thing but then there are other things that are just clearly very very bad trade-offs right and ethereum introducing uh this super expressive language with the trade-offs they made where

validators have where you have to be able to put invalid transactions into the chain because validators can't determine whether or not it's valid without executing an arbitrarily long piece of code and where once a transaction is once they've even validated a transaction they can't know that it will stay valid until it's in a block because in ethereum it's possible to reorder transactions in ways that made previously valid transactions become valid there's another reason that um that you have to just put bad transactions into blocks is because um you need you have to charge the person who created the transaction and even if it appears while the transaction is on the peer-to-peer network that that it was legit maybe it turns out not to be legit because because

things changed um that's a terrible trade-off right like we would never have accepted an extension to bitcoin to add some sort of looping facility with these kind of problems we would never have accepted an extension to bitcoin that allowed you to introspect a transaction in a way where if the transaction appeared in a block in a different order or was reorged like back a block or two then it would suddenly become invalid and invalidate all the work that people did to cash the transaction validity um we would never accept any change to bitcoin that changed what we call monotonicity once a transaction is valid it stays valid forever so one exception of it might get double spent and then the double spend might might wind up in the chain um but that

doesn't require rechecking the scripts or anything that just requires knowing which inputs it spends and keeping an eye on them um those are terribly obviously terrible trade-offs um we would never accept a um extension to bitcoin that had rich statefulness that had a global key value store of all this contract code so that anybody could call an arbitrary piece of contract and then call an arbitrary function in that and that function itself had this map that you can update so that validating a single bitcoin transaction requires an unpredictably deep dive into this massive like terabyte size database that you've got to you've got to go through and so running a a full archival node on ethereum well jameson lopp i think did some some work trying to do this like five or six

years ago and it was i don't know i don't know that he succeeded this is definitely worth looking up and things have gotten even worse since then so that that led to a situation where nobody is running a full ethereum node and where there's a culture of if your node kind of like gets bumped off of the network because you um you know failed to validate something and then somehow you just got off the train then you've got to just like restart your node and kind of trust the state that's coming into you and then carry on from there kind of thing so those those kind of things i would say are obviously bad trade-offs like bitcoin would never accept right and as a historical thing it's kind of interesting to me that ethereum took so many of those choices

right not just like could we have faster blocks could we have bigger blocks what if we used uh pub key recovery in in certain places what if we structured our transaction even what if we had accounts versus utxos i think you can make arguments for both i think they were they were clearly wrong about that but it's a much more subtle thing but the rich statefulness and the loops and the the inability to cast transaction validity is either just fundamentally complete non-starters for bitcoin right and that's that's a big part but but without them it's so hard to do anything right which is why here we are in in 2025 um debating opcat and also debating what kind of crazy programs can you build just as a concatenation opcode and by like abusing

it to like fold back in on itself and like run through the signature it's like it's crazy the kind of hacks that we have when um kind of to somebody looking from the outside they'd be like guys this is crazy just put some freaking arithmetic into your blockchain so people can do math already and do some computations and then move on with your lives right um it's hard it turns out it's hard to preserve scalability and decentralization um it's hard to preserve the properties that bitcoin has that make it scalable and decentralized while getting this extra expressivity yeah and you said the word scalable there so this is obviously gone live on liquids mainnet which is a federated side chain blockstream's been running for almost

a decade now too and let's jump into that like the really exciting stuff which is like the use cases that this this unlocks whether it's covenants and bolts uh on-chain financial primitives programmable delegation like there's seems to be endless amount of potential applications that can be built on simplicity so let's jump in why liquid how does it work on liquid specifically compared to how it could potentially work on bitcoin at the protocol level if it ever does in the future maybe we could talk about if that's even a good idea um and what do you expect to see get built sure so uh so liquid for people who don't know this is a side chain that was developed by blockstream and that has been running

yeah since 2018 uh october 2018 was was our launch date uh liquid is what's called a federated side chain they're a set of 15 mutually distrusting parties like spread across the globe uh who together every minute 11 of those 15 come together to sign a new liquid block um and so liquid well liquid is a side chain so in addition to being this this kind of blockchain that has this federated signing model it's a side chain meaning that it's possible to move bitcoin from the network on to liquid and move it back and the mechanism by which you do that is uh is you know a little disappointing i would say right which is that you you literally transfer the bitcoin into custody of the 15-member federation.

And then any 11 of those are responsible for moving the money back when you request it on the Liquid blockchain. So that's how the pay-in and pay-out mechanisms work there. And the Liquid has also made a couple trade-offs that are no-goes for Bitcoin, for sure. So one is a federated model, right? That's just completely alien to the Bitcoin proof-of-work-based security model. and everybody has well everything comes down to proof of work ultimately in bitcoin um as well as

not your keys not your coins right so even even if like miners all shut down if you just held on to your utxos that you couldn't spend even if you didn't want to nobody else can take them right which is is kind of nice um so that's one another trade-off that liquid made that bitcoin never would is it has multiple assets that are native on the chain and the reason liquid can do that is because liquid has block signers who are not being paid in kind so so bitcoin by using miners that are paid by new bitcoins needs in order to function in order to have the long-term economic properties that it has bitcoin needs to be the asset on the bitcoin blockchain you can't have economic economic activity that's happening in other assets at least not to a to a significant degree that

would rival bitcoin because then your minor incentives suddenly are not aligned with always extending the longest chain liquid doesn't have that problem because it has block centers liquid by virtue of being smaller and by virtue of being developed by a block stream is something that we can do cool crypto experiments on much faster than we can on bitcoin and here's really you said why liquid why liquid we know liquid and we can do stuff fast on liquid um so liquid historically has has been um kind of a demo for many things that wound up on bitcoin eventually so liquid or i should say the precursor to liquid what we called elements alpha had segwit before bitcoin had segwit um and actually it turned out the fun history there

the version of segwit and elements was like terrible it would have been a hard forking change it had all these bad properties and stuff and then luke dasher looked at this and he said wait we could tweak this and then it's a soft fork and then we could do this way better thing And then James and Lopp and SIPA and all these people kind of pulled together and produced SegWit on Bitcoin, which we all know and love. And then we pulled it back into Liquid. Yeah, that one's way better than ours. So that was a cool back and forth. Liquid also had Check Sequence Verify, which is how you do lock time checks in script before Bitcoin did.

Liquid has what's called confidential transactions, which are a way of hiding the amounts and the asset types of all of your inputs and outputs in a transaction, which gets you a pretty big part of the kind of privacy that Monero or Zcash have without the worst of the scalability trade-offs. And there's an uncomfortable privacy scalability trade-off that Liquid showed a different place. That wound up being pulled into Monero, for example. And, and so now we're working on simplicity, right? And so we took simplicity, the nine or 11, if you want, combinators that define the language. We added a few extra bolt-on facilities for introspecting liquid transactions, which actually would be much harder than doing the same thing on Bitcoin. and then we deployed it there as a tap leaf version so liquid has taproot um the frustratingly bitcoin got taproot before liquid did and we were like internally we're like everything's harder on liquid because we have multiple assets and we have confidence transactions and stuff but that one we were like internally it was a race in our hearts in my heart it was a race and we lost um but okay

we have we have taproot we have taproot on liquid now um so within a taproot output on liquid you can choose um for every every script you choose either to use scripts or to use simplicity and well and there you go that's that's how it fits in right and the trade-offs that we make when before before i jump into use cases right so so why why do we do that on liquid and why couldn't we just turn around and do it on on bitcoin well um simplicity is an entire replacement for the script interpreter right it's this giant blob of c code uh which is is uh you know several thousand lines at least it uh it has some some cool complicated things where it identifies programs by these these merkle roots it like builds this abstract tree of how your program

is constructed and combined at a smaller thing computes these merkle roots it has a type system and a type inference system uh it has this notion of sharing that allows you to collapse repeated pieces of code into one and it has these new consensus rules related to how sharing has to being enforced to ensure that uh certain kinds of transaction malleability are eliminated and certain kinds of denial of service sectors are eliminated and the whole thing is just a very new there's a lot of code that's like a really core piece of consensus and it's a new model and it's a scary thing and we wouldn't even we'd be laughed out of the room if we even proposed that for bitcoin without having some real world usage kind of thing whereas on liquid we can just kind of do

it right um we got to get we got to get uh approval from the 15 functionaries they all all these participants think that it's a pretty cool thing um liquid well we have very high assurance that simplicity is correct and it's not going to like lose money and it's not going to crash the system or something um certainly nobody is at risk from simplicity who isn't directly using it right which is nice that would also be true on bitcoin but uh but on bitcoin there's always this worry that like what if it turns out that you can like crash nodes with it or something and liquid just by nature of as federated like that is not i really like it's not going to happen it's like not i'm not suggesting that we would deploy

something where it's possible but if it did we would pick up the pieces and move on and on liquid we can kind of do that because it's a federated system um and because ultimately all the coins are are uh backed by bitcoins and and real bitcoins that are not moving on the bitcoin chain and stuff in a way that bitcoin just can't right you you can't you can never never risk bitcoin doing that so um so we launched it on liquid and in our kind of long-term vision of getting simplicity into into bitcoin into real bitcoin users hands and like um getting out into the real world outside of liquid um this is a place it's deployed on a blockchain that's got some kind of neat asset features which are useful for demonstrating simplicity uh and we can we can start to learn

how simplicity behaves on the blockchain so as you hinted at um simplicity includes covenant support it includes the ability to look at transactions and make decisions based on the shape of your transactions so that's pretty cool so that gives you vaults uh that gives you kind of rate limiting kind of stuff um those are those are kind of the big ones it gives you um jeremy rubin has a construction i forget the name where where um if you're in exchange you can process like a thousand withdrawals in one output and then each person takes their part and puts the rest back into the output so the recipient pays for fee in this model uh which which um greatly improves the incentives around exchange withdrawals and setting network fees you can do all those kind of classic

constructions on bitcoin but then because simplicity allows you to do arbitrary computations there's a whole bunch of cool new stuff that you can do so you could write a zero knowledge proof verifier in simplicity you could write a quantum hard signature scheme in simplicity you could write a um kind of like code that checks arbitrary cryptographic instructions arbitrary merkle roots these kind of things you can write kind of like weighted threshold constructions where you say if um this is going to be a two of three multi-sig except if the fee rate is super low then it needs to be three of three say because like then like you know you need all everybody has to agree to do something that kind of screwy right you can like do constructions like that

you can do delegation you can do rebindable signatures um so uh in bitcoin we talk about sig has any prep out as like this extension that would allow lightning to be implemented with with backups that aren't growing linearly right uh in simplicity you can just implement sig hash any private you can implement whatever sig hash mode that you want um you can implement sig hashes where you sign the output of an arbitrary computation on your transaction which sounds like just crazy cs you know wankery but but there's real applications here where for example um i could sign i could have a two of two with my child where i sign the transaction such that his signature is only valid if the output stays like within a certain range within

a certain fee rate uh only going to a certain destination you know i can kind of sign the high level parameters um of the transaction and he can he can fill in the rest and sign the rest of that kind of thing and i don't have to choose that up front right in my script code what i say basically is if andrew's key it's signed some conditions and the kid's key needs to um needs to follow needs to sign the whole transaction following those conditions right end of story and you can imagine like less personal right um kind of corporate settings where you have business policy that you want to enforce in this way where you've got some sort of hierarchy of of trust and hierarchy of business logic and you uh you can implement that directly in simplicity

and like kind of no matter how arbitrarily complicated what you're describing is if you can specify it you can prove that your program meets the specification um one more example is you can create a signature where you sign that your fee rate has to be a certain amount but then based on how old your output is the allowable fee rate goes up so if you write a transaction it doesn't confirm rather than you having to re-sign it um you can just say or anybody can just kind of edit the transaction maybe the second party was a weak key who has to re-sign it which you probably want um you don't have to go get your keys out of cold storage to re-sign it with a higher fee rate just by dint of being old enough and having not confirmed to spend

the new higher fee rate becomes valid with your original signature and you can you can define these kind of ramping up signatures kind of stuff so uh there's a whole pile of stuff that uh that really nobody is talking about on bitcoin because you really need this this total arbitrary computational ability to do these kind of things on bitcoin and even with something like rusty's great strip restoration project some of these are are too out there to to describe like having these exponential ramp up curves of um of allowable fee rates or having or trying to do like zero knowledge proofs or giant merkle tree reductions or you know all this kind of crazy stuff so yeah it's fascinating and you guys have built what seems to be from the outside looking at i

haven't played around with it uh but like a sort of a ui front end with simplicity hl so is is this sort of just trying to abstract everything and make it uh easy for people to interact with simplicity and without having to get deep into the weeds yeah for sure so simplicity itself um it sounds so wonderful it sounds so simple when i say it oh you just compose these things um every time somebody new at blockstream tries to write simplicity they get so upset by how difficult it is to wrap your head around this this programming model and how difficult it is to to construct these programs um that they like turn around and write their own programming language that compiles down to simplicity it's kind of funny this happened

like three times uh in a row and uh the the latest iteration which we're letting the public use that we really want to be out there and usable is simplicity hl as you said so while simplicity is a very low level like you know contort your computation into this composition of identities and units uh kind of construction simplicity hl looks and feels like the rust programming language um you can tell as you're writing it that like secretly you're doing some sort of functional construction thing but it looks like you do like do this then that if this then do this um do this that loop over this at most this many times kind of thing. And that at most restriction

is because these programs are finite. We would like to remove that using the disconnect opcode, but there's more work to be done behind the scenes there. So simplicity, so you can go to simplicity-lang.org is where our sandbox and documentation, sandbox, our playground, that's the word. We've got like a web interface. You can write the simplicity HL code

and compile it to simplicity. see what it looks like and so on and simplicity hl we expect will be the way that people interact with simplicity programs um until somebody makes a better language than simplicity hl that can also compiles down to it um so yeah so directly interacting with with simplicity that's that's for compilers and for proof of systems right it's really not for humans because it's such a solo level and such a strange way to think about computation so simplicity hl is out there it works we've got a compiler you can use it uh there's a lot of stuff still to do um so one of the first things people come to us and they're like well i want to use libraries and i want to like call to

these other functions and have modules and stuff well we don't have a module system and we don't have libraries yet like you just got to kind of write all your code and you can break it into functions but it's all just like one giant file with all your functions listed so so that's not great and we'll hopefully have that addressed in the coming weeks and months um there are kind of unbounded loops um people want loops that feel unbounded it's a little bit tricky because remember behind the scenes this has to turn into disconnect it has to turn into something bounded and we still want to make sure that we're showing users what the actual cost will be right not you know an ethereum style like who knows how much this will cost like good luck you can

deploy this but you know you might be paying an infinite fee rate or an infinity fee to to satisfy it kind of thing um there are a few other kind of just extensions to the language i talked about how in simplicity you can implement sig hash any prev out you can't do that in simplicity hl unfortunately because we don't we haven't exposed enough of the like low level sig hashing kind of mechanisms and stuff but um if you want to write a zero knowledge proof verifier you totally can if you want to write uh any of the crazy like delegation code that i described if you want to write a program that restrains your fee rate to some sort of curve based on the age of your coins you can totally do that um although i think parameterizing it by the

signature i think you can do it i'd have to i'd have to think about that for a sec um there's Most of the things that I described in my description, if you want to implement vaults, you can totally do that. If you want to implement delegation, you can totally do that. All the big Covenant applications that are out there, you can totally implement today in Simplicity HL. We have the compiler. You can produce Simplicity code.

He's got a tool that will produce addresses from that. Once you're actually building transactions, you better be a programmer who's developing a wallet because right now we don't have the user-facing tooling to do cool stuff like this. We've got to build that into wallets over the coming weeks. That's not something that today, as a user of Bitcoin, just hoping to move money around, write these simple programs.

We're not there yet, but we're certainly at the point where we're wallet developers who say, I want my users to be able to do these arbitrary cool things. Well, I will have the toolkit to make that possible. yeah and on that point like who's out there the museum aqua bull bitcoins implemented liquid uh there are a few others what uh from have you guys been having conversations with these wallet developers and what are they most excited about yep yeah for sure so there's a couple people i'm not sure who all i'm allowed to to talk about here um the uh the one one big

one that you can find on github and they'll um i don't know when this podcast is is going live but they'll have a blog post out soon is that the starkware folks have developed a stark verifier a zero knowledge proof verifier that works on simplicity so that's personally i think the coolest thing that people are building um and then as far as as wallet development goes what we're uh we're in the very early stages what we're hearing is that we need to implement simplicity we need to integrate simplicity into for example lwk the liquid wallet toolkit we've got to we've got to provide higher level interfaces so right now we are talking to several people who are excited about using simplicity and we're at the stage right now where they think is

very cool but there's a gap between how do i take the simplicity code and how do i integrate it into my existing wallet like how do how do i make it real and there there's a couple layers of integration work that we are we're putting together in particular integration into lwk because that's that's the wallet toolkit that's what lets people you know connect simplicity to real utxos that the wallet's taking care of yeah it's exciting stuff then is your hope that there will be an incredible amount of development activity around simplicity on liquid and then sometime down the line it'll prove to be sufficiently robust expressive finite secure that a conversation will begin to potentially implement on the bitcoin protocol or is this

something that should exist on a second layer federated side chain like liquid no no we'd like to go towards bitcoin so the uh there's a long we've got a long road map here right so so what we're doing right now is this launch on liquid is like the very first like um identifying like if we want to use simplicity in real life what are the gaps that didn't even occur to us on like the product and usability front like this is great we've got the language we've got a front-end language we've got a compiler we've got this command line tooling like this is great we did we built the whole language here and then you try to use it and you're like oh wait a minute how do i how does a wallet how is a wallet supposed to reason about these like fee rates

that are increasing how is the wallet supposed to like figure out how to work with covenants how is the wallet how is the wallet supposed to do anything is this whole so that's what we're doing right now on the low level like simplicity on liquid uh how do we get it past liquid is liquid aside from being a small federated side chain off of bitcoin and not not bitcoin itself it also behaves in some ways it's the same as bitcoin it's still the utxo model right um still you work with wrapped bitcoin so it's the same currency uh but in other ways it behaves quite differently because of the multi-assets and because of confidential transactions are the two big things so our next big plan is that we are working on the bitcoin integration branch

right now so you can go to the simplicity repo there's a branch that's that's reasonably up to date it should be up to date as of today um that is an extension of bitcoin core that includes simplicity and our game plan here is that we hope by the end of the year maybe maybe early next year to be able to go to one of the more uh experimental uh test networks out there right so so so as people may know right there's bitcoin at the main net there's this thing called test net four which is like the official bitcoin test network that exactly matches what's on bitcoin but then there's also something called signet which is a signing based uh a network that um has signed blocks it matches bitcoin but with a few proposed extensions to bitcoin that people want to

experiment with and then there's mutiny net which is like signet but like even more just like let's just put crazy stuff on here that like we really want to see what would happen and then it turns out there's like even more of these networks out there that some of which are pretty widely used And a couple months ago, I was talking to Jeremy Rubin, who's one of the main developers or admin kind of people for one of these networks. And I said this to him. I said, yeah, we're going to propose it to Cignet, but maybe then we'll try muting that. And then that seems more likely. And then we'll try.

And he says, put it on mine. Do you have a branch? I'll deploy it right now. I laughed. This is like in April, right? I said, I have a branch, but don't do it. um it was it was super cool to get that kind of enthusiasm so we're we're very confident that we'll be able to find uh one of these these test networks that is based off of bitcoin where people

really want to deploy simplicity and that's where um that's probably where we're going to start seeing like experimentation from the wider bitcoin community and like cool like can we so i said we can implement any say gosh any prevo in simplicity well is anyone going to actually do it uh can we try to use simplicity as a specification language for any prevo or for opcat or for ctv or any of these proposals in principle you can implement them all in simplicity and do so has the benefit that then you can say this is exactly the behavior of my proposed opcode and you you uh your qa problem of how do we know what's going to behave well is reduced to how do we know that the c++ code will match the simplicity code which at least is a more tangible target um that's the kind of

exciting stuff that i'm looking forward to seeing and and right now with the liquid launch we're at the step before that where rather than what are all the cool stuff that we can build and deploy it's like how can we build and deploy something that's like do a full end-to-end stack what what all is involved in doing a full deployment of something novel using simplicity doing a full uh full end-to-end stack and frustratingly like like with all such things it's bigger it's bigger than we expected right we're we're a small team right now um the simplicity team right now is it's four people um and uh and and one of us is not even a developer and we're uh we really thought we could get all of this pulled together um we thought we could do it even sooner uh but it

turns out that that um there's a lot more to writing a blockchain language than just writing the the blockchain validation code um ironically the uh all of the the low level consensus code the stuff that we fight so much over on bitcoin is actually the easy part of uh of any of these things when you actually want it to to change things for real users so so yeah we're excited this is like this is a huge step like despite me like oh we're still in the early days this is a huge step getting this launched onto liquid and this is this is what lets us start um like now it begins basically but uh but what's beginning is a pretty big project it's been a 13 year journey from paper and well you said even longer from math to here yeah it's that way and so

many people will hear like simplicity if it ever makes it on the bitcoin will enable all this stuff and get worried that it uh it will disrupt the fee market you'll have all this perceived junk on chain implementing this stuff via simplicity sort of uh prevent like like you said like you You know exactly what's going to happen. You have that certainty. Does that prevent sort of unknown consequences that many people surmise these individual opcodes, if added, will introduce to the network? Yeah, yeah. No, it will not prevent it.

But using simplicity as an upgrade mechanism should make these things tractable and manageable. So let me try to, but let me first say is that if we want no mev and no, like none of these kind of risks that people will find a way to like build new assets on the Bitcoin kind of thing, then probably we can't do any extensions at all, right? Like it seems like almost everything we do and even maybe doing nothing still makes it possible to do these kind of elaborate things. But one nice thing is that one reason this stuff is such a problem on chains like Ethereum or Solana is that the easy path for wallet developers is one that enables these kind of things. The Ethereum really encourages the creation of DEXs that enable front running and contract code where the behavior changes based on your reordering of transactions. The account model also contributes to that, which Bitcoin doesn't have. So if we were to develop code, if we were to have a simplicity interpreter as a mechanism for adding new features and new functionality to Bitcoin, then wallet developers would have the tools at their disposal to say here's how i can make sure

there's only one path wherever the user chooses to do that is that is what's going to happen and it's not going to be other weird things that happen to the transaction along the way here is how i can bound the total size of my witnesses so my fee rates are manageable and here's how i can change my code to tighten that bound to improve predictability because a a fortunate economic truth right is that mev is bad not only for the network but it's bad for individual users and the reason that mev happens is because it's it's just difficult to design these giant complicated systems but but if we give people the tools to avoid mev then they will use those tools because it's valuable to them that's very fortunate because sometimes sometimes in economics you get

the opposite we're just like your incentives are inherently stacked against you and then that's a that's a very difficult a very difficult problem um then your problem becomes like how do we just ban all bad behavior how do we make it impossible to do anything bad because the incentives are are so awful but but fortunately with things like mev they're not um will simplicity related to mev right will simplicity enable these like alternate asset markets on top of bitcoin and then will you have economic activity on bitcoin that is not in bitcoin and that skews mining incentives and and all this terrible stuff and it will i don't think it will make it any more possible than it is today so i've been surprised and kind of disappointed at how much ordinals took

off where ordinals or sorry um inscriptions which which are based on on ordinals um where there's no bitcoin script um functionality being used at all for inscriptions right the way that inscriptions work is you take bitcoin's utxo model and we say well certain utxos outside of the network are assigned a special number or they were created with a particular jpeg attached to them or um you know some somehow or other just the virtue of how they were created on the bitcoin chain external to bitcoin there is a set of value this has been kind of layered onto that which has created this market and all these distortions and stuff and so as disappointed as i am by that it takes a little bit of the pressure off of script extensions and

new functionality for bitcoin to see that actually what's blocking this stuff is not extra functionality right what's blocking this stuff kind of nothing right it's just like the cost of using the bitcoin network and then when you frame it that way well if we can make legitimate uses of the bitcoin network more productive and more valuable then that should help crowd out these kind of inscription type uh behaviors and then that will make bitcoin be used for bitcoin and if we can make bitcoin more valuable so that people aren't creating like wrapped versions of other assets they're just using bitcoin and that again it means that bitcoin is in an even stronger position as the asset on the bitcoin network that um that miners are being paid in and that

that are incentivizing miners to continue the chain working correctly so my feeling is i'm not an ossificationist i don't think we should stop dead where we are and given that i think that if we're going to move forward at all on these extra script expressivity projects i think the simplicity is a really good way to go in that direction um and if we were to try to implement kind of like arbitrary computations of the form that you would need to introduce like new quantum hard signatures or other like crazy new cryptography i think simplicity is pretty much the only way to go where we would we would preserve the ability to to reason about transaction code while while having these extra abilities

yeah that that makes sense like you say you know simplicity enabling like one of the examples i've been a big big advocate of for years hasn't uh hasn't hit the scale or adoption yet but like something like dlcs where you have like these external events that are basically feeding data to a conditional transaction sending bitcoin one way or the other depending on what the conditions of the particular contract are like you can see people building financial sort of products on top of that denominated in bitcoin which make a lot of sense today yeah dlcs are so cool i i agree like they should be so much bigger than they are um and it's it's a slow burn i think in part because it's technically difficult to build big stuff with dlcs right i guess it's a pretty uh

that's clunky right yeah yeah that's a good i was gonna say like a rigid building block right you're clunky right it's hard to hard to build complicated and flexible it's hard to build flexible things with with dlcs but those are super cool um and simplicity in some ways kind of takes the fun out of it because in simplicity you can directly check oracle signatures um right so if you have some external event and you have some some third party that's willing to sign on on that event being uh having happened one way or the other you can directly check that in simplicity although the one crazy thing that dlcs have that almost nothing else has is that you have a third party in oracle broadcasting that like a game came out one

way or another or you know a hurricane did or did not devastate a particular lot unit or whatever kind of insurance slash gambling product you're trying to to build with it in um um with dlcs you can use that in your script and you can't the person making signatures can't tell property that you get which is that you can use these signatures without um without having to reveal that you're using the signature so that the person producing the signature can't like come after you and say like you were using our signatures in violation of return to service or like we don't like the particular construction that you did or or what so um i'm gonna stop because your screen has locked up i saw it stopped for like 10 like 10 seconds during dlcs but i

think okay perfect the um so you're just explaining there's like this oracle problem that exists yeah yeah so let me the brief summary is right simplicity you can do oracles directly dlcs do oracles in a way where the oracle can't tell even after the fact that you're using their signature yeah so that's a really cool anti-censorship property the dlcs and a lot of these kind of like tweaking signatures kind of tech house so that's super cool um and what where simplicity will help that stuff i think is in the unhappy case um so so a lot of the the kind of trick with a lot of these dlc type constructions and adapter signatures and ptlc and all these related things is that they as long as the parties are both online and following the

protocol correctly they work perfectly and then if somebody goes offline or is providing inconsistent data or somehow misbehaving you got to have this backup condition right and you dlc themselves can't do it right so so you wind up as like it's cool dlc stuff plus this extra backup condition and simplicity hopefully can make those backup conditions more subtle or flexible and make dlc's user more user-friendly and usable in other contexts basically um but yeah no i think those problems are also further mitigated by just using like a threshold of multiple oracles providing the same data yeah yeah yeah exactly um and that i mean bitcoin's great at doing threshold of signatures um simplicity can improve on that but like

in ways that matter no right um the bitcoin is really good at threshold signatures so that's part of why dlc is so exciting yeah well it's been awesome i'm gonna say it again i'm pumped you guys i think yeah thanks university has been talked about for most of the time that i've been paying attention and involved in bitcoin it was uh really cool to see that you guys got on liquid mainnet and hopefully people that already have like liquid implemented into their wallets start start playing around with it obviously as you mentioned there's some development kits and sort of interfaces that need to be built out but it seems like we're finally at the point where all right i mean get cooking with this stuff yep yeah absolutely we've got launched on mainnet we

have a high level language it compiles to simplicity you can use it today simplicity if you've been wondering like should i pay attention to simplicity now the answer is yes finally the answer is yes well congrats again thank you for all the work and for coming and explaining this to us i i hope at the beginning when i prefaced to the audience that that you uh like to go down uh rabbit holes and explain things thoroughly you didn't take it as a dig i love speaking with you because the the extent of the detail that you go into just like really triggers like my nerd my inner nerd and i like i get giddy when you go down these rams so thank you and don't ever don't ever try to be brief is what i'm trying to say all right thank

you there we go i'll stop apologizing yeah thanks uh any any final parting messages for anybody listening uh no i'm just going to repeat the website again simplicity lang.org simplicity dash lang.org um and uh and keep an eye on our github as well github.com slash blockstream research um is where our simplicity and our simplicity hl uh and rust simplicity we have a whole rust library for building this stuff that's where all those things live uh if you want to get involved if you want to be a developer if you want to be a tester uh that's great if you want to work for us we are we've got some simplicity related positions open uh so definitely keep an eye on our jobs posting i forget the url for that now um or just you know shoot me an email shoot any of us an

email and we'll figure it out so so yeah thanks i will uh let me see company careers blockstream.com slash careers if you're looking for those jobs uh perfect andrew thank you uh excited to see what gets built yeah thank you all right peace and love freaks freaks thank you for listening to the show i hope you liked it if you did like it please make sure you subscribe rate review the show it helps us out a lot and also if you like these conversations i've come to realize that many people listen to the podcast they don't know we have another sort of layer of this media company we have the newsletter the bitcoin brief go to tftc.io make sure you subscribe there a lot the topics that are discussed on this podcast i write about five days a week in the newsletter

we also have the tftc elite tier if you sign up for that become a member we have a private discord server for the elite freaks out there where we're dropping ad-free versions of this show and having discussions about everything we talk about a day early logan wanted me to make sure if you want to get the show a day early become a tftc elite member you will get that we have our discord server right now it's conversation between myself and tftc elite tier members but we're going to expand that we'll probably do closed q and a's with people in the industry i may be doing macro mondays so join us go to tftc.io subscribe find the button in the top right corner of the website. Become a TFTC Elite

member. Thank you for joining us.