BTC workshop with Proximity

Captions as YouTube publishes them, usually machine-generated, so product and people names can be misheard.

1. 0:01

   what you want what you want what you want want what you want you a n

2. 1:45

   hello hello welcome welcome welcome uh I am back again just from an hour ago uh we are back here though uh it does not stop here at near devhub and we have tons of great stuff going on uh in the near protocol with everything and we have an awesome Workshop this afternoon for you uh that we're going to do some more building on BTC uh if I could say one thing about the proximity team lately is that they love building on BTC there's so much content coming out with this and so we want to actually make sure that we are

3. 2:16

   capturing all of that for you uh so we have Greg and Edson coming from proximity to talk all about that and do some kind of do a workshop with everybody I don't want to hold anyone back I don't want to waste anyone else's time um the links are down below if you want to get started with anything else but otherwise let's jump right into the workshop uh let's bring up Greg and Edison to the

4. 2:39

   show hey guys hi guys hey hello hello hello so why don't you guys um talk a little bit about what what we're going to Workshop today yeah sure um yeah I was going to go through the uh uh near multi-chain um exam example that we have and just all of the Bitcoin Parts uh just give like a a short demo and then uh walk through the code a little bit yeah that sounds that sounds awesome feel free to share your your screen whenever okay how are you hey hi yeah I'm very good thank you

5. 3:18

   um yeah after Greg uh do his presentation I'm gonna um also walk through an example we did something called the Omni box which is a a small H development framework to create a chain abstracted applications and we're going to show an easy way to develop BTC apps with near awesome awesome looking forward to that cool uh I won't hold you guys back uh G whenever you're ready to show your

6. 3:49

   screen uh feel free to bring it up and we can jump into it uh sure sounds good okay here we go all right let's bring it up the stage there you go we'll head here um so yeah this is the uh the near multi-chain uh demo uh example um I'm running it locally um and so yeah when you first uh uh boot this up it's uh it's going to be on ethereum and so uh if you switch over to bitcoin uh this is your path this is the derived address and then this is the uh the two address so I'm just going to

7. 4:34

   send uh like a small amount of Satoshi to my own address and so the way this works is um you uh you sign a uh a near transaction uh that requests to signature from the uh MPC service and so I'll request that and approve this transaction yeah so this is the the uh testnet uh signer okay and then uh I'm going to go back to bitcoin and then so we have a um uh a signature here and so what the um what the app did was uh it it took that signature and um it created a signed

8. 5:23

   transaction uh which is a little different than um like uh most Bitcoin wallets you have a uh a private key that does it signing all locally but um we don't have a private key and so we have to request that signature from the NPC and so then um after you have that completed transaction you can uh broadcast that to the uh the Bitcoin Network and so uh that all that does is uh send the uh signed transaction to blockstream and then uh that gets included uh on on chain so here's the uh

9. 5:56

   here's the transaction um and uh yeah um so yeah it works uh this is a successful Bitcoin transaction and um yeah let me just uh go through um before you just I want to just level set for people a little bit here what's what's happening so uh on this process while you are generating a transaction to send to the Bitcoin Network here now this is obviously a happening pretty quickly but you are

10. 6:31

    still beholding to the the the you know the uh block timing of Bitcoin that still correct yeah correct um so yeah um so this isn't like um confirmed yet it's it's still waiting for all of the uh like confirmations um but it's it's it's in men poool and it's like on its way to being uh included right but but yeah it'll it'll take a few more minutes to be confirmed right so so something that

11. 7:00

    people should like need to consider is that even though you are simplifying this process you're doing it you know uh the the transactions being generated quickly being signed quickly but you still have to wait the normal time for you know the the Bitcoin to uh transaction to actually be uh verified and then on fully on chain yeah exactly right cool um so yeah I guess uh I'll walk through some of the code um just starting with uh everything that I just

12. 7:34

    did on the app um so there's just the um um like your react um like your react component that just does all of this uh but the the main thing here is um when you click the button um you're going to call this request signature to MPC I can increase this a little bit if it's easier to see um and then that's going to uh call this uh Bitcoin service um so yeah so request signature um it just takes your wallet uh the path um The partially signed Bitcoin transaction um

13. 8:16

    I'm going to uh yeah let me show you that next so there's this method construct psbt um psbt is a partially signed Bitcoin transaction that's the um uh the object that uh we had to use to uh like create these transactions uh because like I said earlier um uh typically Bitcoin wallets have access to a private key and so you can just um uh create the signature uh locally and then construct uh your transaction like the normal way

14. 8:51

    the uh our um our method like you have to break that down into uh like separate steps because because we don't have access to the private key and so what we do is um we construct this partially signed Bitcoin transaction that has like all of the information that uh it needs it just doesn't have the signature um and so this is where um it checks like what type of Bitcoin transaction it is um if it's like a a legacy uh paid to public key has um it needs to be formatted a certain way um

15. 9:24

    the one that the example is using is uh segwit um and so this just um constructs a transaction um it uh includes like uh the output which is um um where I'm sending it to um and then the input which is the uh the utxo that I'm using to uh to send and so um when we uh go back up to the request signature to the MPC um it uh takes in that psbt up here um and then it does do this um it does this dry Ron and so it um this like code right here is

16. 10:09

    um um it is going through the um psbt and it is um getting all the information that it needs to request the signature and so um um once it has that um then we uh uh send the near transaction to the MPC um hold on yeah and then once we have the signature back um yeah we can call the uh the real run so there's this difference between like the dry run and then um like uh after you um go through your my near wallet uh you make that near transaction you get

17. 10:56

    that signature back once you have the signature you can go through and um do the uh the the like real run um is the dry run sorry is the dry run just simply to like better validate the transaction is there other another purpose there for doing that well so the library that we're using um uh Bitcoin ja lib um it um it it uh we need to do it this way because um we need like a a very

18. 11:30

    specific like transaction hash we we need like a hashed version of that psbt um because that's what the MPC needs um and so that's why we have to do it this way so it's uh we um it's it's sort of a hack actually um but Bitcoin ja lib is just not like it's not set up to do these like um um like multi-step Bitcoin transactions and so you have to like pretend that you're um doing uh you have to pretend that you're constru a Bitcoin

19. 12:00

    transaction um like the normal way and then um but um uh but yeah oh basically we just do the dry run to get that transaction hash and then um we use that uh to send to the NPC and then we get the signature back and then once we have the signature we can complete the psbt and then uh we just call um um sign inputs a sync I'm trying to find where that is yeah um so yeah sign input a sync and then psbt finalize all

20. 12:39

    outputs and then you can uh return the thing and then um down here um You broadcast the transaction which so once you have the signed transaction it's just a normal like a uh like um API call normal post call to uh to block stream and then um that just sends you back like your um uh successful hash or error if something went wrong and then it just gets printed to the screen yeah so it's it's kind of complex

21. 13:15

    um the um uh yeah the the the the main complicated thing is that like dry run and then like completed run that you have to do that in two steps um that took us a while to figure out but um yeah this is uh this is how it works yeah that's nice and so now this is all like through um the service the developer doesn't actually have to worry about that it's just good to know what's happening there but like they don't have to now worry about that you've already built it into that service yeah exactly

22. 13:49

    yeah hopefully nobody else should have to uh figure that out nice um so yeah that's this demo um I can hand it off to Edson now yeah real quick before you this is this was good to see the the code behind some of this what are some things though that you think uh developers can start to do with this so like the demo obviously very straightforward of just like hey this how you sign a signature this how you sign a transaction but what are some

23. 14:23

    things that you guys see developers actually leveraging this for yeah sure um so yeah I mean this is just an example of how you can send Bitcoin using a near address basically with chain signatures and so any application that you have that you want to uh send Bitcoin uh but uh through near and and through um chain signatures uh this would be a good reference to just uh see how you do that um but um yeah I mean there's there's a ton of uh applications I mean I could see this

24. 14:54

    being used for um uh something with like uh runes or um uh ordinals um um I mean yeah I mean even like um um like uh lending or borrowing um yeah I mean pretty much just like uh if you want to like uh do anything with smart contract capability with Bitcoin um this is a a pretty good way to to do that yeah yeah I I mean that's that's a really interesting so you're basically enabling smart contract Behavior Uh you

25. 15:37

    know on on bitcoin yeah exactly yeah yeah I think a good analogy for for this particular case is that the a smart contract on miror basically can take control of an address on the BTC side so you can have any logic that you you can imagine on on near taking advantage of the low transaction fees scalability and so on but then you can reflect all those changes on the BTC site in any of the forms where you can use runes you can yeah you can do anything that you can

26. 16:15

    imagine thanks to having a smart contract on near controlling that particular address neat okay I like that I like that okay I guess that's my is my turn yeah let's go for it okay there you are nice okay share the screen uh window can you guys see my screen we can now yeah okay so um Greg um presentation was more focused in the in the front end part and now I'm going to present more from the smart contract site and we

27. 17:09

    we've been trying to create examples for for um yeah creating a smart contracts with with the chain signatures technology and along the way we found that it's quite complex in general to to do cross chain chain abstracted applications and we created something called the omnibox which is like a an opinionated testing environment for this type of smart contracts or chain abstracted applications and what we

28. 17:43

    essentially did is to put together a lot of utilities and and functions that we saw are very common and we set up testing accounts and so on so if you're a smart contract developer coming from the EDM or you have in that side Frameworks like Foundry where you have a blockchain demo um yeah a blockchain that you can run locally and so on and in the in the BTC World there are also tools to do some s something similar and

29. 18:16

    also on near you have work spaces where you can do that but you see there are many many um Frameworks and when you are trying to develop this chain abstract application it can get a bit complex so we say okay let's integrate everything with omniox it's going to be an opinionated testing environment but we believe this is going to make your life super easy as a smart contract developer doing chain abstracted contracts so H there are some other

30. 18:47

    feature like I like like I said we are putting together yeah when you run the omniox you basically have available uh test blockchain for Bitcoin a test blockchain for for evbm chains and also uh the near work spaces available and another aspect that we do we have like I mentioned per configure accounts we have the capability okay these accounts are not enough for you you can create more

31. 19:18

    accounts and we also have utilities to to compile it and deploy this smart contract that you are developing now this compile and deploy to testet is because right now the MPC signer or network is only available on testet so it was very common for you as developer to okay I do the new contract but then I need to deploy the that contract and interact with the MPC signer on the test

32. 19:50

    net and we just make things way simpler um and also we had utilities for account derate signat construction and so on so um yeah we we we canot say this is aary way because I mean doing a framework like this from a scratch and adding all these capabilities to configure and so on it can get very complex especially because we are interacting with different chains so we say okay let's propose this Omni

33. 20:22

    box way and this is how the workflow is going to be we think it's a very simple flow and that's why we are proposing this flow so uh the typical workflow for a developer will be okay I'm doing a smart contract integrating the NPC signer and possibly I'm using the Omni transaction RS library that is going to help me to do transaction for Bitcoin for evm chains and also for neon okay okay then then you you deploy it to a test net and then you want to interact

34. 20:54

    with this contract let's say performing um a by executing a transaction which means you are calling the NPC signer then you get the signed transaction and you propagate this to the destination chain why this is important this is important the propagation part is super important because you can be signing wherever you want but at the end of the day you only are going to be sure that this particular sign transaction that

35. 21:26

    you got is valid when you can propagate that in the destination chain so a very simple example let's say I'm doing a new contract that is trying to create an nft on a particular evm chain then I do the new contract that is creating this transaction um is signing it and then the person that is calling gets a row payload that is fully signed and that payload was signed by the MPC signer but then you can propagate this to the

36. 22:02

    destination chain and and that's it so um in order to give more clarity how this looks like and there are some examples here in the Omni RS repository we have a lot of examples for complex cases for instance for set with transaction with multiple utxo uh here we have calling from Ros clients here we have examples propagating to a test net and here um this example is basically yes you are signing a legacy

37. 22:43

    transaction but you are propagating into your local Bitcoin node that the only box is spinning up for you so first the smart contract um here we have a the logic of a smart contract where basically here you are creating what is called so right now we are speaking about a BTC transaction okay so in the BTC world you have this s hash that has to be sign and then um you basically form a transaction

38. 23:20

    using um the signature so first okay we create the sash this sash is created by using the Omni Library here you pass a Bitcoin transaction that is serialized you pass extra required parameters in this case the Bitcoin POP key so you can do everything in one single transaction and here okay I create this the I encoded I create the Sig has and then I call the MPC signer so when I

39. 23:57

    call the MPC designer I'm basically creating a promise and probably yeah I don't know if it's very small can you guys see properly yeah I can see you good yep yeah so here basically we are calling the MPC contract and then because we are using a promise we are calling the Callback this callback is receiving the original transaction payload that we are passing plus the Bitcoin po key that we require so we can

40. 24:31

    do everything in one single transaction and here once we receive the signature we put everything together and we return to the client so basically as a smart contract developer I create this contract I do one transaction that is calling this function and what I get as an outcome from this contract is a payload that I can propagate to any well to the Bitcoin um node that is running locally or in testet it depends but um

41. 25:09

    here in this example is local okay so from here I want you to picture there is a smart contract on near that is going to be deployed to test net that is interacting with the MPC signer and that I'm creating locally okay I'm developing so okay here is my contract here is my function integrate NPC signer I get the payload boom done okay now let's see how we um propose to develop this and this is mostly following a test driven development environment um yeah test driven um

42. 25:49

    development um approach where okay let let let's do this contract but since the beginning Let's do an integration test and this test is deploying to test net is interacting with the real MPC signer and then I need to propagate this to a destination chain either test net either locally it can be maget too that's up to you if you want to spend um that money but for now um in this example is locally okay so as I said the omniox

43. 26:24

    will help us and then we simply say okay omnibox new start okay so here the Omni box is has already started it started a new work spaces Anil that is the evbm chain that is running locally and Bitcoin cor note in reest mode so we have Bitcoin evm everything there available we can override the options if we want to so let's say I just want the evm functionality and new functionality yeah that's possible but by default you have everything ready then we call

44. 27:02

    something context so everything about BTC is available in the BTC context property and as I mentioned we have um prec configure accounts most of them all of them exist in the different context so here I I have B already created it's a legacy address and I simply create um a variable referring to that then I can derive the address of the contract that I'm creating because remember this contract is going to be deployed to testet and this contract is

45. 27:41

    interacting with the NPC signer so the contract with the NPC signer will basically will have an address that this contract is um controlling Okay so this derived address is the address that the new contract will control and then H we get this a script POP key that's something mostly from the BTC world and that is useful once the transaction is complete um but then we need utxo so if you are

46. 28:24

    developing uh BTC applications you need to have UT so and this is also a reason why we like this approach because the test Nets in the BTC War are very difficult the facets sorry are very difficult to to really get the utxo some of them doesn't work I mean the experiences um definitely can be improved but when you have the Omni box that internally is using a BTC node in reest mode you essentially have the

47. 28:58

    power to give utxo to any address so here we are giving um we are giving utxos to the address that the smart contract that I'm developing is controlling so I'm saying okay this is my contract um this is the derived address that the contract in the address is in the BTC War this is the address in the BTC side that my contract is controlling now I'm going to give utxos to that address in the BTC war and then um we simply get the utxos here there are some gotas about

48. 29:45

    them that we basically need to give again utx so just for confirmation aspects that the Bitcoin core node in reest mode requires but basically what is happening here is okay Omni box is starting everything I get a BTC address control by this near contract that I'm developing and I'm giving utxos to that um address that I'm controlling that the contract is controlling so now the

49. 30:21

    contract so it's that okay I'm giving um UT EXO now expend that and here is where we basically create a transaction this is um a traditional a normal BTC team you have the input you have the output and then you create the real transaction where you pass the outputs here you have two outputs one is to the person who is going to spend it and then my change um and I still remember I I

50. 30:53

    mean if you are new to the BTC uh War the utx so are like bills so in mind I have a bill of $5 and thanks Greg for this great analogy I have a bill let's say $5 I give you the $5 bill but um probably I'm not paying you $ five I'm paying you one so here is the spending okay I spend $1 and give me four so that's why you need the here the input is here is my bill of $5 you are spending one

51. 31:28

    will give me four back so that's why the there are two outputs okay here we are creating the Bitcoin transaction again using the Omni transaction library and and then the we are simply sending this transaction to near to the smart contract remember that the smart contract has this create s has and sign P2P k H which is get this one okay so this um oh and by the way the omniox is automatically recognizing that you have

52. 32:11

    a smart contract in a in Source lea. RS so your smart contract is automatically compiled we are recognizing if you have done any changes and in case there are some changes we um we deploy a new version on testet in case not we simply don't deploy so you you save some some Er test net funs but here we are simply H calling to that contract that you are developing that is now in testnet but as you see the abstraction that we did is super simple

53. 32:51

    the Omni box is enabling is giving you also this friendly near J Jon RPC client where you simply say Okay onni box friendly near Json RPC client send action and Bam you just call this function pass the arguments that's it here I get the the transaction ready and then I deploy I propagate to uh Bitcoin Network that by the way the BTC context in the Omni box is giving you also so you have B BTC Contex

54. 33:28

    client call and you send the outcome that is coming from the um NE yeah quick question about this so from like a design pattern standpoint here one thing sounds like it's different and correct if I'm wrong here is one is that like this test Suite really is about what's testing that is actually deployed versus just testing locally during like you know um like after compile or something like that right

55. 34:02

    we're saying we want to actually test what's being deployed yeah I I I think you could see this more like an in to and probably I I call it integration test but it's really I'm deploying the contract I'm executing a transaction I'm getting the outcome this transaction that I'm executing is interacting with you know it's in the test net is interactive with the with the real NPC signer is giving me something and I'm propagating that to a either real

56. 34:39

    Network and like a Bitcoin core note in reest mode or it can also be a test net but you are essentially testing the full flow and that is a different level of testing because you can have your unit test directly here right the contract so I guess uh I call it interation test but you could even say that it is an end to end test or I don't know if the end to end test involves the yeah I think it's

57. 35:11

    interation test because the the end to end might invol also the front end the front end yeah yeah so I want to ask another question here with this so this is two different approaches here right so like one so what Greg was showing is obviously front end B um and it's focusing on you know creating and sending the signature this is a little bit more integrated this is at the Smart contract level from your recommendation um I say you person like I guess from proximity

58. 35:44

    standpoint is the you know when you're thinking about like software design is the focus here to be more uh at the Smart contract level and is that where you feel the greater benefits coming from is that why you developed omnibox to better support that or is it really kind of leaving it up to the end developer of like what makes the most sense yeah that's a good question and I guess it will I guess the best answer is it depends

59. 36:15

    no and and and and I guess different developers might have different approaches I personally like to have proper um integration test um and always segregating the different layers like you have the smart contract layer and if you are coming from the web web to world you can see that that's an API right is an API this is is living in the back end it has internal functionality it has utilities it and so

60. 36:47

    on so what is exposing to the word and I guess that API or function um are can be isolated on what could be the front end and I I I think in my opinion it would be more difficult to do the full team um manually probably at some point might be faster but as you continue um growing and yeah your pro gets more complicated you're going to get into problems because you you are going to need the faets you're going to need a lot of

61. 37:22

    things and with this approach you are you can isolate okay I'm doing a smart contract this is what it enters this is what it comes out so you have very clear your box this is what it comes in out all these things are tested I I'm having an integration test I know for a F this thing will run I can set up this um Suite of test in my pipel in my repository and I'm going to sleep um you know okay if someone is calling at midnight there is a bug or something I

62. 38:01

    know for a fact that it's not going to be mine I don't know for me gives me peace of mind it gives me peace of mind so as a developer I always try to Advocate this thing like okay and I think this is a very cheap way of having peace of mind because it can get very very complicated but I think this is a very cheap way I mean you don't even need to do unit test and you know have all these layer of test but in 120 lines

63. 38:31

    you can really have be sure that your near a smart contract is you know bulletproof and then you can simply integrate the front end and interact with it but you are going to avoid a lot of manual testing you know like let's say you you want to do a transaction and you will need a lot of fund for the facet in near but also on BTC so yeah I think it can get more complicated and yeah but if you isolate I'm focusing one side first then the

64. 39:08

    other you wouldn't need to do the full thing all the time yeah I I I I do also appreciate where uh there are options right so as a developer a little bit you know right if you feel more comfortable doing a particular way you know here are some best practices but you know there are options to go um and which I think is always an important piece for anyone building is you don't want to always you want to feel comfortable with what you're shipping yeah no exactly I I

65. 39:38

    think yeah it all depends of the developer uh how you feel comfortable that's why we were very very um direct and honest this is unopinionated Destin environment yeah this is the only box way this is what we propose we are not obviously are open for feedback no I mean the community can give us feedback that would be super good uh the more the better but we we also didn't want to to to to tackle all the parts because it's

66. 40:11

    going to be super complex but we were okay let's start small I think this is an opinionated way let's be transparent what is our um our intention and from this point uh we will see for us the benefit is that I'm not going to lie but this test at some point was 400 lines sub code and now it's just 100 lines so for us that that's a huge impact and and is is very simple now well more more

67. 40:48

    simpler that's why we create all these utilties and we expect okay let's start like this we hope developer see the value and we can iterate and you know be open and flexible too why not yeah no I love it uh this this is great and I think will be definitely helpful to developers looking to build on this for sure for sure uh good stuff yeah this is awesome uh as we as we wrap this up here a

68. 41:20

    little bit uh any last kind of things that people should know in getting started building with this especially whether it's either part of it or just in general what do you think uh Greg do you want to add something yeah sure um yeah I would just uh encourage people to download the example play around with it and um see if they can um tweak that into uh um something that suits their needs um yeah I I will say that um just

69. 41:51

    um uh piggybacking off of uh edson's presentation it's it is significantly harder to build tests in the front end um and so if that's uh if that's important to you then um uh then uh doing it through the back end like smart contract approach might make more sense um but uh but yeah there's there's a lot of benefits to doing it all on the front end too yeah just kind of depends on on

70. 42:16

    your use case and the de the developer definitely great um any last words Ed Edon that was great presentation there um yeah get us started building BTC on there yeah perfect perfect yeah awesome uh if uh anyone has any questions or uh they get stuck with any of this stuff what's the best way to uh Reach Out The Chain abstraction telegram group is that probably the best yeah I would say so um I I usually see uh all of the messages in there if

71. 42:58

    there's a question about the example or or um anything technical I can I can usually respond to those there awesome perfect perfect well uh thank you so much guys for uh coming on and doing this workshop and I hope everybody learned a little something today thank you all right thanks guys thanks uh great stuff uh I hope this was a a fun workshop for for everybody uh we have again uh tomorrow we have our kickoff for the one trillion agent hackathon uh that's coming down the pipe

72. 43:38

    uh tomorrow and then we have uh next week again on devhub live on Thursday 4 pm UTC nightly wallet so uh until tomorrow and until then uh give this stuff a try hope you guys are are building and we will talk to you soon thanks everyone byebye