NEARCON 2022 | Doomslug Stage - Day 3

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

1. 0:01

   hello everyone welcome to the doomsluck stage we are ready to get started for the first session of the day and for the first session we have vanquishing Smart contract bugs with Vanguard and we have a speaker Benjamin to the stage please welcome Benjamin cool hi everyone can you hear me first of all awesome um so yeah my name is Ben and I'm the vice president of research and development at Paradise where we aim to improve blockchain security using formal methods today I'm going to talk about one of our tools Vanguard which is part

2. 0:36

   of a suite of tools that we're creating to make blockchain development safer um so as all of you watching this probably know uh bugs and blockchain software are extremely costly right in the last year alone uh millions of dollars have been stolen in hacks below you can see a couple of the most recent examples of these hacks Each of which actually individually resulted in millions of dollars uh in losses right so I don't think I really need to stress too much uh how important blockchain security is

3. 1:01

   and actually the problem gets even worse right so new blockchains are being introduced all the time and each of these blockchains support a variety of programming languages right so for instance near alone supports at least three programming languages natively and obviously there's a bunch of other blockchains out there which each support additional languages like solidity and go and Haskell even to name a few so all

4. 1:23

   of this is to say that blockchain the blockchain development ecosystem is quite diverse right which leads us to one of the central problems in this space right in order to make blockchain development safe we need to stop bugs across all of the major blockchains and programming languages used by developers which includes new languages and chains as they appear right um so maybe at this point in my talk you

5. 1:47

   might be asking yourself should we just lose hope there's too many blockchains there's too many languages there's no way we can make this safe I guess I wouldn't be here giving this talk if I believe this in particular despite the fact that I I do think this is a hard problem I believe there are ways we can meet the challenge right so today I'm going to talk about one of those ways which is Vanguard a tool that we're developing to address this challenge so

6. 2:11

   in particular Vanguard is a static analysis tool which is capable of detecting common vulnerabilities in smart contracts so here's a high level overview of the Vanguard Pipeline on the left you can see that the user provides the blockchain being used like near for example as well as the source code of the program to be checked so that'll be something like rust or solidity that information is then sent to the Vanguard

7. 2:33

   front end which produces an uh instrumented code in a shared intermediate representation right so in our case that's llvmir which is the intermediate representation used by llvm which is a popular open source compiler infrastructure the instrumenting code is then fed to our back end which runs the IR against a number of what we call detectors which each check for a different kind of common vulnerability in smart contracts

8. 2:58

   uh to reduce the overhead of adding new detectors Vanguard provides access to Common static analysis techniques from the research Community including things like abstract interpretation and taint analysis currently Vanguard supports a number of detectors including a re-entrancy detector a flash loan detector and many others and finally once all of the detectors are run in Vanguard a report

9. 3:21

   is produced which describes the vulnerabilities discovered in the code and the layer location so overall the kind of the high level picture to keep in mind Vanguard takes in the code it runs a bunch of detectors and it produces a report of the issues that it found right so now that hopefully we have like a very high level understanding of what Vanguard is supposed to do uh let me

10. 3:44

    describe where I'm going to go with the rest of the talk so first I'm going to introduce a near smart contract that we're going to look at as an example then I'm going to actually run Vanguard live on that contract and show you what the output looks like and then finally I'll talk about some of the other things we're doing at Paradise to go beyond just static analysis in Vanguard so with that let's first explain the example we're going to be looking at So

11. 4:07

    today we're going to be looking at a raffle contract written in Rust for near and it enables users to purchase lottery tickets in exchange for a chance at winning a prize right so it operates pretty much as you would expect a raffle to operate on the right you can see the code which actually initializes the contracts it's contained in this lib.rs folder file and the raffle is initialized with the total number of tickets to be had in the raffle as well as the account ID of what we're calling

12. 4:33

    the prize distributor which essentially is the account that's in charge of actually sending the prize to the winner of the raffle when the raffle ends right so to give an example of how it would work on the left I pictured our three resident gamblers who are Charlie Lucy and Snoopy and in this case each of them buy a single raffle ticket right and they they pay for it in near which you can actually see on the right is calculated by calling this

13. 4:56

    self.ticketprice function in the buy tickets function um so now because there are no remaining tickets all the tickets have been purchased the raffle is closed and a winner is chosen at random as you can see in the highlighted portion on the of the close function on the right here the Rand range function chooses one of the tickets at random from the sold tickets database uh in this case Lucy has chosen as the lucky winner and Snoopy and

14. 5:22

    Charlie are sad right so note that when Lucy is chosen as the winner the raffle contract actually makes an external call to the prize distributor contract telling it to send Lucy her prize right and you can see I've emphasized that part with the red box on the right so this call will actually be resolved in a future transaction which means that Lucy will be Center prize only after the distributor receives the message from the raffle contract right

15. 5:48

    and in particular once the distributor receives this request they're going to attempt to send Lucy a prize and then the Raffles callback function is going to be executed which I'm now showing on the right here the Callback function uh first checks to make sure the distributor actually successfully sent the prize right so if there was some error sending the prize the portion of code highlighted on red or highlighted in red on the right is executed right which

16. 6:11

    refunds everyone for their tickets this is a bit conservative but essentially we're saying if there was some error and we couldn't choose a winner let's just give everyone back the money for their tickets and then after this regardless of whether or not we refunded um we reset the raffle so we can run it again in the future so this is kind of like a high level overview of how the raffle contract is supposed to function so

17. 6:36

    um now that we've had a chance to kind of get a at least shallow understanding of that I'm going to actually run Vanguard on this example and show what happens so hope this works Let's uh run over here so to run Vanguard we're just going to run this script it's going to build the contracts very quickly and then we can see that the output here Vanguard raises three different warnings

18. 6:59

    right and we're going to focus on the first warning here which tells us that this callback function that we've been looking at the called clean price callback has public visibility okay so let's actually look at the code to see why this is a potential issue so here's our claim price callback function this is the same function we were looking at in the slides and we were warned that it's public right and indeed it is

19. 7:23

    public which means any user can execute this code it actually looks like our developer knew what they were doing right they used this hashtag private annotation that they're supposed to which would make this ostensibly a private function however they made one mistake which is that they included it in a comment by accident so actually this is going to be completely ignored which means anyone can execute the Callback function right that's pretty dangerous because it means anyone at any

20. 7:48

    time they want can reset the raffle and they can also refund everyone right so probably not what you want certainly if you're the raffle owner so luckily here the fix is actually quite simple we're just going to remove the comment and let's rerun Vanguard and so it's going to recompile the contracts and we'll see that we're down to only two warnings and that warning has disappeared so here's our two remaining warnings and you'll actually notice that both of them

21. 8:20

    uh mentioned flash loan attacks so they're both related to a potential flashlight so before I jump into this one I'll just say at a high level you can think of a flash loan attack as being when an attacker can manipulate the price of an asset right and obviously that could be really bad right if you have a lot of investors who are invested in an asset and an attacker can tank the price of that asset at any time they want that's obviously not going to be a a good quality that the investors

22. 8:46

    are looking for right so let's actually look at what Vanguard says in particular so here it tells us there's a potential flash Loan in the claim price callback function that we've been looking at and in particular it tells us that after this transfer it can be manipulated by some call that's going to occur on line 91 of our contract so let's hop back to the code and see how there can actually

23. 9:10

    be an attack here so this is the transfer it's referring to in the Callback function so recall this is where users are refunded uh in the event that something went wrong and the winner wasn't sent their prize right and it we were told that the attack can occur through the the call on line 91 and on line 91 you can see that we compute the ticket price right so the bug is actually going to be in the ticket price function which we have defined down here

24. 9:37

    and so if you look at how we Define the ticket price we take the total number of tickets in the whole raffle we multiply it by some big number right 10 000 in this case and then we get oops sorry we get the current uh account balance of this contract right and it's actually this very last part that's going to be exploitable here in particular this is something that an attacker can change right they can send

25. 9:59

    near to this contract for instance and if they do that the denominator here so this is divided by right so if they make this value very large then the total ticket price will be very small right so a motivated attacker can tank the price of a raffle ticket here probably not desirable so we're just going to fix this bye see making the ticket price constant right so hopefully this should remove the flash loan right because now all tickets just cost a hundred right so

26. 10:30

    let's see if that solves the problem and now so contracts are compiled and we can see there's no more warnings from Vanguard so let's hop back to the presentation now cool so I hope that gave you like a taste of how I think Vanguard can be really powerful for making blockchain development safer right follow like finding these common vulnerabilities that are easy to have in the code but can have very serious

27. 11:01

    consequences right but now I'm going to kind of like take a step back and say that well Vanguard I think is a really important step towards a safe blockchain ecosystem it's not a silver bullet right so in particular Vanguard focuses on finding what we've been calling common vulnerabilities right like flash loans and re-entrances um but it's important to note that actually not all vulnerabilities are common right so for instance

28. 11:26

    um some errors are actually specific to a given blockchain so this scary warning is from the near documentation and you don't need to read it all but essentially it's saying that unlike many other smart contract languages near resolves external calls asynchronously right and this means that the result of an external call won't be known until some transaction after the current one um this means that callback functions are necessary to update the contract

29. 11:51

    state in the event of a failed external call right and this is actually exactly like the example I was just showing with the raffle and that callback function uh that helped us handle the case where the prize distributor did not send the prize to the winner right and this means that we need a new suite of techniques for reasoning about callback functions and vulnerabilities in general caused by external calls in near because of the

30. 12:14

    way that near is handling these differently than most other languages so for instance this affects the way that bugs like re-entrencies are actually even going to occur in something like near versus the language um you know like solidity operating for uh ethereum right so some errors are actually specific to a given blockchain or language and actually some errors aren't even specific to a blockchain or language but they're actually specific to a

31. 12:41

    particular contract right so this is actually the same callback code that we've been looking at the whole talk right and here pay close attention to the part that I've highlighted in Red so here the developer accidentally negated the condition of this if statement meaning that everyone's going to be refunded only if sending the prize succeeded right in other words after the prize is successfully sent all of the

32. 13:05

    ticket buyers will also be refunded right um this is definitely not the intended behavior and you would certainly be very unhappy about this bug if you were the owner of the raffle ticket right where you've sent out the the prize and then you've also refunded everyone for the tickets they've bought um but actually catching a logical bug like this goes beyond common vulnerability detection right because

33. 13:28

    this isn't a common vulnerability it actually needs to reason about the intended behavior of the contract um so in this case users should only be the the property that we're interested in is that users should only be refunded if the prize isn't sent right otherwise uh no one should be refunded because the winner successfully got their prize okay so um to address these concerns Paradise is

34. 13:52

    actually developing a suite of tools um that are focused on addressing all the security concerns that we can have in blockchain development um I could probably go on quite a while about these but because I'm super excited about them and we're super excited about them at Paradise but given time constraints I'll just mention a few here to wet your appetite so one really interesting effort we have going on is our V specification language which

35. 14:16

    allows users to write custom logical specifications like the one we were talking about for the raffle contract um another really cool project that we have is Magi which is is a symbolic executor for Cairo um and another cool project is Euros which is a attack synthesis tool for solidity um so if you're learning or if you're interested in learning more about any of these projects or Veritas more generally

36. 14:40

    give us a follow on Twitter check out our website we have a medium where we post blog posts about what we're up to so definitely check that out uh thank you so much that's the end of my talk do we take questions or no unless you want it to unless you wanted I I'm happy to take a question if there are any questions are there any questions maybe for Benjamin if I guess your presentation was amazing Ben thank you everyone thank you Benjamin yeah thank you so much

37. 15:25

    thank you once again for the amazing talk the next speaker is Igor from kalimero and the title of his talk is building the near building the near to kalimera bridge please welcome Igor to the stage foreign and I'm the core developer at calimero can everybody hear me great I'm the core developer at calimero and today I'll be talking about how we've built the bridge from near to calimero but first of all in case you

38. 15:59

    don't know what calimero is I'll tell a sentence or fuel so the kalimero is a near side chain which allows you to have a private sharding so what what does this mean is that if you're a government or an Enterprise you probably don't want to put all of your sensitive data on a public chain but still you want to have you have some use cases for you want to use the properties of a blockchain so we we try to come up with a solution

39. 16:31

    so that your data is not siled in a private chain but that you can somehow communicate to have some interoperability with a public mainnet so that's why we built the calimero bridge and what we what we did here is not only transferring FTS nfts but also we've built the ability to call any contract if it's programmed that way so that you can read some state from a public chain into the private and you can execute all kinds of

40. 17:04

    um logic right so what the kalimero bridge does it allows you to bridge fungible tokens non-fungible tokens and you can do cross-shard contract calls between near and the calamera private shards so some of the properties of the Calimera bridge is that it's trustless so what the what does this mean it means that anybody provided that you have the access to the kalimero network can run a little relayer and they can relay light

41. 17:36

    climb blocks from kalimero to near and back it's automated what does this mean it means that all the as I like to call it the magic as there are many calls being executed around it's it's all being done by the kalimero bridge service for you it's very easy to use since you only need to to send one signed transaction with the intent what you want to do transfer either from kalimero to near or back and it's fast we we we're able to bridge assets and do crushard contract

42. 18:10

    calls in 5 to 15 seconds depending on the on your use case so this will be a fairly technical presentation so um I assume that the audience knows some of these terms but I can quickly tell a sentence or two what what are these uh components so relayer is the simplest component of of them all for the bridge to work so what a real layer does it's it reads latest light clients block on a source chain and sends it to the destination chain so in in order to

43. 18:45

    have a bi-directional bridge you need to run a real layer from kalimero to near and from near to kalimerum what the light client contract is it's it's uh it's a contract that will verify whether a light client block is actually valid the and you can read about this on a Nomicon like the near blocks are valid if there's there's actually six rules probably the most important one is if at

44. 19:11

    least two-thirds of the staked validators have signed the the block if the signatures are valid then the added light client block to the contract is valid and of course we have the prover contract when you provide with some proof data which is which is essentially Merkel pets uh and the height for which you want to prove some transaction or receipts the prover contract will tell you whether the the transaction is valid or not

45. 19:41

    and for the bridge to work we have three more contracts we have the fungible token non-fungible token connector and the cross shard uh calls connector contracts but the ft and nft are pretty much similar so the only difference with ft and nft is actually in one method in the Ft transfer call with nfts it's nft transfer call and you say which token ID you transfer while in the FTS you specify the amount you're transferring

46. 20:13

    so this this is the same and I'll show you both boat connectors all three of them so first let's see how to bridge some fds or nfts from near to kalimero so these are all the components that are needed to make the bridge work so on the left side let's see if the laser works it doesn't but okay yeah it's not seen on the left side we have the calimero shards which is a private Network on the right side we have the near blockchain so we have already deployed the light

47. 20:50

    client contract on kalimero the prover contract and all three of the connector contracts also we have the validators the archival node and the indexer which are all needed for the network to work and to communicate with it and we have the same thing on near side as well in the middle we have the relayers the bridge service and the message Cube they're not on on either chain their their services ran separately

48. 21:15

    independently of of the blockchain so the first use case is that the user or adap wants to transfer some fungible tokens from near to kalimero so what happens is that the user will find a transaction where they say I want to transfer some usdns usns in on testnet is called usdn for some reason I guess the usn was taken that account ID so the user will call ft transfer call on the

49. 21:47

    usdn fungible token with the arguments that the receiver ID is the fungible token contract on near and he specifies how what's the amount of fungible tokens that the user wants to to transfer so what will happen next is that the Callback FD on transfer will be triggered on the connector contracts on near and it will emit the kalimero event that we call calimero event lock which says this FD usdn.testnet from ige.testnet account ID

50. 22:20

    that account wanted to send 400 usdns so what will happen next is that the events indexer will pick up this event propagated to the message queue and message queue will immediately send this event to the near to kalimero relayer so what is this this clicker is not working anymore oh okay so the real layer what it does next it'll go and fetch the light client block from the archival node on near and immediately when it's when it

51. 23:02

    fetches it it'll try to add the light client block onto the light client contract on kalimerum just to to recall what I said three slides ago if the height of that block is higher than the previously stored if it's in the same Epoch or the the next one and the most important if if two-thirds of the stake of the validators that signed it is valid then it will be added to the Lite client contract that block actually the most important information is the

52. 23:33

    block Miracle root hash for that height that will be stored in the Lite client contract on kalimerum simultaneously the bridge service also receives this event from the message queue what it then does it fetches the latest known height from the light client contracts and if this height is at least high as the block Heights as in the receipt where the lock where the where the Ft was locked on an ear it will go and fetch the light client

53. 24:07

    proof data with this the bridge service will call the prove methods it will call proven mint on the Ft connector contract on kalimero and it will try to prove through the prover whether this proof is valid for that receipt that we're trying to prove and that is that the events that the Ft was actually locked on near if the prover calculates the same hash as the block Merkel root hash that's stored in the light client contracts

54. 24:38

    this means that the user locked FD sonir and we proved it on kalimerum so now when all of this passes a new ft is minted on calimero sides and if this is the first time the bridge Services transferring that specific ft the bridge service will also deploy that bridge the token so the first transaction can take a bit longer maybe 30-35 seconds but all the other transactions for that specific ft

55. 25:10

    will be much faster um also the account that sent from near to kalimero they're being mapped one to one so if it's name dots near or near that sent FTS on kalimero it will also be name dot near okay let's now see how to withdraw FTS or nfts from kalimero back to near so the user or adapt calls directly on the fungible token that's deployed on kalimero that he wants to withdraw some

56. 25:46

    amount of tokens on that ft what happens is that essentially that ft is the amount that the user specified they will be burnt and what happens then on FD on on transfer the the Callback it will on the Ft connector the calimero burn event will be emitted and now we want to prove that this event happened on kalimero we want to prove it on near so again the event the events indexer on kalimero will put this data into the message queue and

57. 26:26

    the message queue will send it to all the subscribed parties which is the kalimero tunir relayer the relayer will then read what's the latest light client block on kalimero it will try to add this light plant block on near if it's valid it will be added simultaneously the bridge service also receives this event fetches the latest known height if this height is higher than the height where

58. 26:58

    the FTS were burned on kalimero it will go and fetch the light client proof data you'll then go try to prove and unlock on near so now the FTS are burnt on kalimero we just need to prove that this actually happened so to the original user on nearsight the FTS can be unlocked so we we try to prove called the prover if you calculate the same hash it's proven and the ft is unlocked on near

59. 27:29

    side so we've successfully withdrawn the ft is back from kalimero to near now let's see how we do the cross Shard calls from near to kalimero and back so here we actually have a depth and this depth is already deployed on here but I put it here in the middle so it's easier to follow the arrows so somebody some user called a method on adapt that will do a cross call to the connector or near so what this means is

60. 28:04

    when we execute such method on the depth on near this event will be emitted and it has a bunch of arguments the first of them let me see if the laser will work yeah it's not okay you should look at the lower right corner so you see this kalimero event cross call the first argument is the what's the contract ID on kalimero what's the method name start game on kalimero on that contract that we want to call on kalimero then we have the

61. 28:37

    input arguments that are in in Json that are actually base64 encoded we have how we specify how much gas we want to pay on calimero's side how much we want to deposit to that contract what should be the Callback contracts on near when the when that method is executed on kalimero and what uh what method should be the Callback methods on an ear which is here game started and this event gets picked up by the events indexer gets sent to the message

62. 29:10

    queue the real layer from near to kalimero receives you have some interesting event try to uh let's let's let's do all the next steps oops so the relayer then fetches the light client block it adds the lights client yeah it's ah yeah it adds the light client block to the light client contract on kalimero Bridge service simultaneously receives this event as well it fetches the latest known height from the calimero Lite client contracts and if

63. 29:51

    this height is higher than the height where where we executed the where we started the cross call on near we can try and go and prove it so we'll fetch the Litecoin proof data from the archival node on an ear we call prove on the cross Shard connector on kalimero if it's proven we'll execute that methods on the depth on the contract on kalimero the connector after after it's executed

64. 30:24

    will emit this kalimero event cross response event which is which is seen in the lower left corner with the arguments what's the depth that should be called back on near was the Callback method and what was the execution result of that method that was called on kalimero and of course if that method fails you'll also get that it failed back as an execution result you'll get it in your callback methods and now we need to

65. 30:54

    prove this event that it happened actually on calimero we need to prove it to near so we just need to flip everything I didn't draw it draw this to not prolong it so we have some time for Q a So This Is How We Do the cross Shard calls if you have any questions we have few minutes left yeah go ahead one two three hello hello is it not the same like part um yeah it it could have been the same

66. 31:35

    but you can have redundancy you can you can run multiple relayers maybe some real layer is down yeah okay yep we also have a boat there and we can show you a demo if anybody is interested okay if that's it thank you and see you at the boots thank you thank you thank you once again Igor for the Lucid presentation on kalimero next on stage we have Italy from hoppy and his type his talk is entitled scam fairy guide hoppy on tracking hackers please welcome Vitale to the stage

67. 32:49

    I will try that again please welcome Vitaly to the stage hello everyone so it's kind of my private ASMR session today but uh yeah it's just a joke so instead of ASMR you'll get me rambling about this cyber security today so today I want to talk to you about the copy protocol so what we work on is basically an on-chain cyber security protocol uh bearing the kind of pretentious slogan we are actually doing something valuable I suppose so let's move to the what we

68. 33:32

    are doing exactly so the idea of happy is to be the AML compliance and kyt kind of uh on chain solution so right now the only compliance and AML you have is basically centralized entities pushing their agenda onto the D5 protocol so what we want to do is basically to have the equivalent of the centralized uh compliance that is basically on chain so how we are doing that uh basically we have on-chain database we store

69. 34:08

    malicious addresses on that database uh we store a lot of addresses there so we cover nearest near blockchain we cover ethereum we cover being B chain so uh the idea is to provide the D5 space with the ability to connect to our on-chain database and to have them use our own chain database to prevent money laundering to prevent terrorist financing to prevent any kind of malicious activity so you might ask how

70. 34:39

    it helps the ordinary user so for that we have a b2c solution which is business to customer we offer people uh Private Investigations so you can basically go to our website and have us investigate cases of malicious activity that you personally encountered on top of that we offer prize pool for the submission of malicious addresses so we have a kind of solution side solution of

71. 35:13

    ours that basically allows people to uh upload and submit addresses malicious addresses and get in return uh price Rewards so uh we our goal our objective is to create self-sufficient on-chain database that is basically supplied by users uh that is basically is free of charge uh you can use our copy uh protocol for free you don't need to pay you can use it either via API or by using smart contracts

72. 35:50

    so how does it work how does it work so so normally you have uh for example you have decks uh Dex is uh dexes usually connect via Smart contracts so what we offer to Dexys is basically the ability to cross-call uh Happy smart contract when you are doing that you are basically having the ability to vet addresses uh on chain so where do we get the data uh as you can see we have data provider what it means is basically that we have a

73. 36:31

    several sources of data so those sources are basically uh our data providers they are chain analysis for example our main data provider they are basically the leading ml compliance and crypto intelligence provider right now so we get data from several sources including our data providers but we also have our own happy Labs Department which is basically a investigative Department which investigates cases of malicious

74. 37:03

    activity around the blockchain so we aggregate all of the data we aggregate data from chain analysis from other data providers uh that is open source or not so open source sometimes we have to pay them that's how it goes but our idea is to create uh the aggregated data around malicious activity aggregate the data and basically to dish out the most accurate uh information and data on the malicious addresses

75. 37:33

    so with that data you can basically uh prevent some of the cases of money laundering how we do that so in order to prevent money laundering uh in terms of sex centralized exchanges you basically need to connect to them directly so for that reason we are partnered with several of them not all of them unfortunately but we have already partnered with cookware ascendex bitmart we work closely with them uh we are trying to establish uh the copy framework which basically will

76. 38:07

    allow to everyone who who is connected to happy the entities connected to help you to to basically instantaneously get the data about malicious malicious addresses malicious activity in general so they will get uh that data instantaneously they will be notified about any malicious activity and in in the case of any exploits hacks or any of that stuff they will get notification

77. 38:30

    and they can basically stop the transaction Blacklist transaction Blacklist addresses all of that stuff so however our main objective is to guard defy our main goal is to guardify and we are trying to do that uh by keeping the decentralized ideals intact so we are not trying to bridge the you know blockchain ideals any of that sort we are trying to create a solution that is basically equivalent of the

78. 38:58

    centralized entities that push compliance that push uh kyc and so on what we are trying to do we are trying to push new uh kind of meta we are trying to push kyt which is know your transaction and based on the transactions you can act on that address you can add it to blackly you can Blacklist it you can decline transactions in case of dexes for example if uh if a certain address is

79. 39:25

    considered malicious we can basically decline the transaction from that address uh again we are a protocol we are we as we are called happy protocol we are not a decision maker so our protocol is highly configurable you can configure a risk score you can configure risk threshold you can configure anything from you know how what kind of category of risk you want to allow or disallow Everything is configurable Everything is

80. 39:55

    up to you at your own discretion so uh the slogan kind of identify notify and prevent is uh our slogan we are trying to trust and foremost to identify whether the given address is malicious or or not we our goal is to notify again notification and not the decision making on our part and prevention which is in the case of uh adoption of hobby the prevention will come itself since uh hackers will kind of you know see the happy logo and uh they will they will

81. 40:30

    have less of a incentive to actually go and do their dirty stuff uh so as I mentioned briefly before uh we also want to push uh and have users contribute to our data directly so how do we incentivize users so recently we launched scamfari which is which basically allows you or ordinary users to contribute malicious data to contribute addresses directly to our smart contract so by doing so you get rewards uh the last time we had that we had a price

82. 41:10

    full of thousand five thousands usdt uh right now uh the second season will be 10 000 usdt prize pool so we expect people to provide us with valuable data and we give them in return rewards so last time we had a scamfari season one we had around 20 000 addresses uh submitted so that's a huge success for us and I hope you guys can also get to share the success and we also are rewarding you for that so uh that's basically what I wanted to talk about uh today so our main goal you

83. 41:52

    can basically separate it between B2B solution and b2c solution our main objective is of course to guard defy from the potential malicious acts that can happen in the D5 and uh I hope that user engagement can be a lot more active in this Regard in the cyber security space in general because you know right now we are kind of uh resorting to centralized entities pushing their agenda in terms of compliance but I

84. 42:24

    think in D5 we can make our own mind on how we want to structure our security how we want to structure our cyber security and so on on top of that right now in D5 we have only one layer of security basically it is smart contract orders what you do after that if a hack or exploit happens and as we all know the uh smart contract over these are in no way uh the 100 proof that it won't happen so what do you do next for example when it happens this is why coffee is basically exists

85. 42:56

    to help the uh post factum of the case of the case of exploit so we are trying to help defy protocols again for free we are not charging anything uh you might ask how we make our Revenue that is yeah that is a question we make our Revenue based on the Private Investigations as I mentioned mentioned briefly mentioned before so uh we basically tackle Private Investigations from users also from businesses uh we work again with a sandex coupon bookmark we help them to

86. 43:29

    trace identify and track the activity within the blockchain we also get a lot of cases of malicious activity from our partners like analysis they provide us cases that we jointly work on so uh I think that's basically it what I wanted to talk to you about and I hope that as many people as possible can cooperate together on creating this cyber security Hub not only within the new record system but also outside because happy is cross-chain protocol and we hope to cover all of the chains and and we need your help in this regard

87. 44:03

    because the community around blockchain the community within the blockchain space is basically what makes it uh great so thank you any questions you have please uh yeah hello and so you said that you wanna prevent the hacks to happen on defy So you you're gonna like have a list of Bad actors so we don't have a list of Bad actors the only thing we have is a list of addresses our goal is to not de-anonymize the users our goal is to

88. 44:47

    have a list of addresses have their rescore respective rescore respective risk category and that's it that's all we do okay so you you track respective like good addresses not better addresses or sorry so which kind of addresses do you track with track or we try to track all of the addresses however it's impossible because we need a lot of uh processing for that we try to re react on the cases that happen so the most important thing in the cyber security space within the

89. 45:20

    blockchain is to react promptly so if you are to react promptly you can basically help to Stave off the laundering of assets for example if a hack happens the perpetrator tries to launder their assets on centralized exchanges within this time frame that he has to launder their assets to get there to to the sex we act on that time frame we notify sex we notify decks automatically because we have it in our database uh given that we already have

90. 45:52

    it reported to our database so we react to that we notify them they freeze freeze or block the transaction block the funds in case of sexes and in case of taxes they can just decline the transaction if there if there aren't any more questions please think Vitali once again for the great talk thank you since we are running about 10 minutes early we'll give everyone a break get some drinks get some Donut from the donut wall and we'll be back in 10 minutes with pavel's talk from pagoda

91. 46:33

    hello we are ready to get started again for the doomsluck stage sessions we are back with the near data stack easier and faster with Pagoda and as our speaker we have Pavel from progoda please welcome Pavel to the stage hi everyone you hear me okay oh there's a bit of echo awesome how's everybody doing it's the last day of the conference tired excited learning a lot I'm definitely learning a lot let's uh I need to learn how to use this clicker now uh today we wanted to present you

92. 47:06

    some uh uh uh some data stack achievements that we made with the team I wanted to first say they present Tiffany she could make it today for the conference but she joined near two years ago and most of this work she continued contributed to most of this work she now is based in the US and I hope you can chat with her in Twitter and other platforms leave feedback on our Pagoda platform as well she reads it but I'm Pavel I joined

93. 47:37

    Pagoda this year I'm excited about data I spent 15 years in the industry working on different data products I'm a blockchain user since 2017 and this year I decided to make it my career and I live in Vancouver Canada so if you're ever in Vancouver want to chat about crypto and near make sure to message me um what is what is Pagoda so Pagoda is the easiest web3 startup platform to build your dabs on near you may have used many of our open source tools

94. 48:12

    already you may know about them already they power our devs over there where the largest contributor to the near protocol as well and now we're adding even more tools to make it easier for you to build devs on near and some of these tools I want to talk about today uh so what's data stack uh we set ourselves on the mission to make it easier and faster for you to unlock to build adapts to unlock the full power of data and to accelerate your build

95. 48:45

    essentially to get to Market much faster to understand your smart contracts better and to empower your growth so as a builder you want a better user experience right for your adapts and obviously you spend a lot of time building indexers and getting data from the blockchain so we want to make it easier and faster you want to understand what's going on with your smart contracts faster and you also build indexers to do that so we're gonna just give you some tools for that and once

96. 49:17

    you get to the draw stage your product owners want to see the insights to the the usage of the app the adoption so we give you these insights out of the box as well let's talk a little bit more about that actually Beyond indexers anybody used indexer framework before anybody knows what it is uh no great okay so I need to introduce indexer framework basically if you want to quickly query historical data from the blockchain you need something called

97. 49:50

    indexer and uh for uh many I would say more than a year maybe more than two years we're offering uh something called indexer framework you can spin off your own near node and you can rest uh run it in a with a flag to index blockchain and you can run some custom rust code to aggregate the data and put it in some database and then build an API and and serve it to your users and many of our divs on near are actually using just that but as I mentioned uh you actually

98. 50:23

    need to maintain a node which means you need to have a developer and you also need to have a rust developer and you need to scale it and you need to make sure it always works otherwise your users won't see the updated data right so a few months ago we introduced something called near Lake anybody heard of near Lake awesome okay well that's great you heard about your league but you didn't hear about index service and that's awesome but the good thing about near lake is

99. 50:48

    that you can build your indexer without running a node you don't have a node anymore and you don't have to maintain this node in the cloud and you don't need to know rust we essentially stream Json files from the cloud right to your server with a very small delay this reduces your monthly cost by up to 25 times you can get started much faster it's very low maintenance you can use

100. 51:13

     JavaScript Python and rust out of the box we have sdks and actually you can use any language you want you can write your own SDK very easily it's a very small piece of code and with stream data right from AWS but if you don't like AWS you can run your own near Lake indexer and run your own AWS S3 compatible storage in the cloud so how do you get started you log into Pagoda and you navigate to indexers tab on the left bottom and you go through

101. 51:49

     the tutorials there it literally takes you well six six minutes is probably exaggeration it takes you less than six minutes to start streaming blocks from the blockchain with JavaScript you spend more time setting up typescript project than setting up near League uh and uh there is a great tutorial on the nft indexer over there with typescript so you can just start indexing nfts right away with that example um and if you find yourself indexing

102. 52:20

     fungible tokens uh non-fungible tokens balances of different accounts uh and you want to show it to your users if you find yourself building indexers for that you don't have to do it anymore at this conference we announced enhanced API it's available in Pagoda you grab your API key and you just start using it right away we indexed over 1000 fungible tokens and we're indexing them as they appear so every time somebody creates a new token it immediately and if it follows the standard it immediately

103. 52:53

     appears in the enhanced API so you can just hook it up to your front end and see it right there you can see the balance history you can see the metadata of all the tokens the icon and everything there are interactive documents on Pagoda you can just log into Pagoda dot consolepagoda.co get your own API key for the enhanced API navigate to document annotation that you see on the screen here and just try it out and you can see the curl requests over there you can integrate it directly

104. 53:25

     to your front end and then if you find yourself writing indexers to alert yourself or your product managers about something or just just to integrate to web 2 world with HTTP requests or some other way you also don't have to do it anymore because we are into we have introduced alerts um you log into Pagoda you go to alerts section in the alerts section you can create uh you can input the smart contract name and it doesn't have to be a specific smart contract it supports

105. 53:59

     Factory pattern as well and then what we will do is in the back in the background we will start listening to uh everything that happens with that smart contract essentially we spin off our own listener our own uh indexer and then we execute a rule that you specify and the rules are successful actions failed actions events and other important things so you put the balance drains you set up this uh this Rule and then with this rule you

106. 54:31

     can Target all the actions to let's say a web hook and this with this web hook you actually have unlimited possibilities of integration to any app and you can create your own Lambda function your own server whatever you want or if you just want to know when something fails it's a great observability tool because with this tool you can be alerted on all the failures in your Telegram and if some of

107. 54:56

     your product owners doesn't use telegram which is a bit weird but you you can do it with email right right away as well with some distribution lists let's say so log into pagoda.co console.co try it out it's super easy less than one minute to set up and you can get reminded of let's say all the errors that happen in your smart contracts inside of your Telegram well yeah and if you miss this alert you can always log in back and see the history great so alerts is a great observability

108. 55:29

     tool for on-chain data now what about the RPC usage if you get an API key for the RPC service that we have you can log into Pagoda go to RPC stats page and you can get almost real-time insights to all the requests that are being made to RPC nodes basically all the view calls all the transaction requests everything you will see right on the page you will see in the number of field requests you will

109. 56:00

     see the latency and you know with alerts and RPC stats you actually feel more in control of what's going on under the hood of your app that's great what happens with you know uh with the users with the usage as a product owner as a builder I'm always interested uh to see the adoption of my software you know it feels great to see new users and you know you launch an app and uh today and uh you you need to build some sort of analytics maybe you have Google analytics but you don't know

110. 56:32

     what's going on on chain right you want to see what's going on with your smart contracts on chain so with uh background analytics you can get it out of the box actually every time you add a contract to Pagoda project you can navigate to analytics and analytics is ready there right away you can filter by all the smart contracts that that are of your interest and you can filter by time you can see 21 important metrics there basically daily weekly monthly active

111. 57:03

     users transactions and volumes transacted gas spend balances basically all the important things about your smart smart contracts so what did I show you today I spoke about near Lake now you can build your own custom indexers 25 times cheaper and much faster and not only in rest I showed you enhanced API where uh with with which you don't have to build indexers for tokens and nfts with alerts

112. 57:29

     and RPC stats you get Fantastic observability Tools and Integrations with alerts and with analytics you get great Observer a great uh overview of what users are doing so you can grow your apps faster let me talk very quickly about what's next and what is what is our vision here we spoke about a lot of our open source tools many of these tools are actually these features are powered by open source tools and we see hundreds of projects using them today to deliver all the dabs that we all are using that

113. 58:02

     everybody is talking about on this conference but we want to bring It Forward um you know it still takes time for Builders to show aggregated and historical data on the uis so on the left you see that you you need to have an RPC node or a lake indexer you need to use some public Cloud you need to use some database probably an SQL database you need to use all these tools together build a custom API host it in the cloud scale it if it doesn't work react to the

114. 58:33

     errors you basically need to have a software engineer that does just that what if we offered something that just works from day one we want to bring data infrastructure to you through Pagoda apis right away and with Bugatti apis you can get all the key data you need query historical data build aggregations shape it in the way you want and get it right to your front through a simple API that scales that doesn't work that does

115. 59:03

     work without any extra maintenance uh and and very much less engineering effort um if you want to chat more about it I'm very excited to talk about it you see how excited I am please come to the our booth uh we we can chat more about your use case if you're struggling with building indexers I I'm I want to do some user research so please come and talk um oh there was an animation here we go

116. 59:28

     uh Pagoda API will replace all that um so subscribe to our Twitter uh get Pagoda account if you haven't gotten it yet try out all these features uh I'm excited to see what you build with them uh so how how I will know when you log in there is a small button on the button on the bottom right the feedback uh don't only leave feedback but leave uh something some information about your project so we know what they're

117. 1:00:01

     rebuilding with that because we really want to see how it helps and where we can make it better we're really looking forward for that and um of course come to our booth as I said we will be there if you want to have a walk through a demo of these features or if we can even set it up for you over there so we're looking forward to seeing you there uh thank you so much I have a little time for questions but I'm not sure this audience doesn't ask me any

118. 1:00:25

     questions but I'm ready thank you all right so see you at the booth uh thank you Pavel for the excellent presentation next up we have Dennis from the near foundation and they will be talking about test driven design for near smart contracts please welcome Dennis to the stage great thank you hello tests yeah just gonna set myself up here for a moment I will uh be screen sharing so

119. 1:02:07

     I was scheduled for 120. shall I wait until that time before I start or I go yeah all right well uh welcome everybody uh to this uh short presentation on tdd of near smart contracts uh before I kick off I want to do a quick show of hands who here already implements tdd and their uh depths or applications okay oh wow this is great this is great okay so I've got a treat for all of you

120. 1:02:41

     um so let's go um yeah I'm Dennis um oh yeah that's a key Palm on my face right there this is uh Benji's laptop colleague of mine and keep on this is Project's mascot uh yeah by the looks of it hey hijacked my presentation and I think there's like a finding Waldo of this logo everybody everywhere um but yeah I started my uh my career in data and analytics making dashboards for corporations and then I went into uh

121. 1:03:07

     fintech API development and uh January this year I came across the year and um uh yeah got to know a little bit more about it and uh quickly fell in love with it and then I uh I wanted to choose a starting date and I chose uh well appropriately February 14th to start uh to start a year and ever since then it's been uh it's been a a very passionate Romance uh yeah who are we here at Pagoda

122. 1:03:32

     um well if you guys haven't heard the previous chat uh it's uh we make sdks we make uh the docs for near we met we're uh the main contributors to the core protocol um yeah you name it uh CLI tools these kinds of things to make uh uh yeah the life easier for developers on on web3 and uh near protocol so yeah let's get to the Jews so um what STD our contents will be uh yeah we'll go by the definition run through uh the

123. 1:04:03

     costs and benefits I'll be asking some questions see if some people have some input there uh and then uh I'll get coding so I'll show you guys how it really looks like um yeah so what are the costs and benefits of tdd um yeah I'll start by the costs uh nothing comes for free so uh yeah it's gonna take you some time to learn it uh whatever framework you're doing uh if you want to automate that that's also

124. 1:04:27

     going to take you time to learn and get used to um yeah the CI CD overhead as well you're going to have to implement that too uh it's all a little bit of extra time at the start until you really get used to how to do it and uh it's it's a mind shift uh it really um yeah ux may fall behind the scenes if you're focused too much on learning I expect if you haven't done this so far that at the beginning you'll probably be so much so focused on testing that

125. 1:04:58

     you'll let some things go perhaps uh so yeah that will take just more time and as such requires a coding strategy it's a different way of approaching your your application development uh first thinking about how you're going to test it and then yeah building that out and the pros uh things I love I love about it is you get to automate your QA so forget about you uh booting up stuff and

126. 1:05:24

     uh testing it yourself doing repetitive tasks uh no please uh a developer should automate everything I I believe you should focus on design and uh not uh doing repetitive repetitive tasks on a computer that's a waste of your time and that's what machines are for um yeah it's less iterations it makes your code intentional it really makes you think about okay how exactly is this

127. 1:05:47

     going going to be is this going to work and you set it in stone or even better in code makes your code less error prone as such creates a standard for the repo yeah you might not feel it if you're just doing it yourself but uh if you have you're working on a team or you want to welcome new people that have never seen your project your tests are your dogs uh devs read your test first and if you

128. 1:06:11

     wrote them well they know exactly what it's about so uh great that's the first thing I look for if I go in a new repo where are the tests I read them oh no I know how it works now it's a it's a it's developer magic um yeah yeah as I said easier for newcomers uh yeah but I'm wondering these are the things I could think of when I was making these slides uh does anybody have any other ideas for pros or

129. 1:06:37

     cons no Maybe no I couldn't think of anything else myself either I mean I'm I'm in a Reddit group and uh in this Reddit uh page and often I see memes about how painful tdd is but of course it's a funny thing but uh at the start it is funny but uh once you do it it's like uh it's like being a deaf 2.0 it really is it's like super saiyan version of yourself um okay I think I skipped the the

130. 1:07:09

     definition yeah oh yeah so what is it yeah sorry about this I think I clicked too quick uh but yeah for those that don't know it it's uh as I said before shortly it's a way of thinking I think in my experience first comes to mind then comes the code if you wrap your hand about a head around something then writing the code for it just takes a few minutes you don't even feel that time at least for what cost me a lot of time is thinking what exactly it's supposed to do and how exactly it's supposed to do that

131. 1:07:39

     um yeah the rest we've covered I think in the in the last few points oh yeah the definition by the book is that you're supposed to First write the tests and then write your app that's a little bit contradictory because you start thinking about the functionality and then how you're going to test it and then you keep in the test it's like Abba instead of a b a b so that's a little

132. 1:08:02

     bit counter-intuitive but um and we'll do I'll do it in a moment that's not how I do it myself when I start thinking about an app I usually think about the functionality I comment all my tests and before I run my app I write my test code and then I run the app so but that's not really how it's supposed to go and we'll do it how it's supposed to go in a moment yeah no manual Q8 so uh we're not going to do that

133. 1:08:27

     so let's get going so what I'm going to do here is um I'm gonna SSH into my machine that is compatible with all the dependencies this has quite strict compatibility checks uh and we are going to go to my coding folder and we're going to use this uh nice um this nice uh Pagoda little uh CLI tool create new app and what it does is it's like a scaffolding solution so it will set up the project structure for me

134. 1:09:07

     let's call it my demo Oh My Demo yes do that it will set up the project structure for me without uh me having to do that so uh yeah that's also nice right yet again less wasted time and more time for design so in the meantime um what what it's doing right now it's it's grab a bunch of template folders and template files and it's now uh gonna going to put all that in a in the folder

135. 1:09:39

     my demo that I just named and um what else does it do oh yeah it's going to install all the dependencies already so I don't have to do that in a moment as well uh this is two gigabits per second so this should be done quite quick yeah there we go great so let's go to vs code and open My Demo no not postgres let's go uh great okay I think it's open now yes code My Demo I don't like this get started screen

136. 1:10:27

     but it's not my computer um great so here we go this is what npx create in your app did for us right so we have our installed packages and node modules or Contracting contract and the tests and integration tests um what I'm going to do right now is I'm going to delete the contents of the contract and delete the test from tests and then I'm gonna explain a little bit what we're gonna do so let's just delete what this does and let's delete what that does

137. 1:10:59

     and uh we can comment this out machine maybe uh yeah I'm not a native Mac guy but let's just delete that like this yeah okay let's go to the tests I hope this is uh this is legible for for everybody right not too small okay good okay so uh I will delete the contents of both tests and I will explain what this is doing so before I go into the tests and then we'll think about how to write this app so um our key dependency here is in JS it's called near workspaces

138. 1:11:38

     it uh and the key dependency of that is called near sandbox and that's that's the one that has the strict uh environment uh dependencies and that's why I SSH into this machine because it does not accept m2s it does not accept n1s it does not accept windows but it it does accept uh Linux or Ubuntu so yeah that's that's what we need in this case we're using Ava that's uh that's a testing library and JS that uh runs all tests in async by default that's very

139. 1:12:09

     nice because these um these uh are near workspaces Library what it does is it creates a local uh virtualized um near blockchain on your machine and then uh yeah that takes a while to to boot up and it takes a while to run those tests too so if you can run them in async it's again saves you time so you know and the interface is nice and the colors are syntax highlighting looks cool too um great so what happens here is we initiate wow the comments are very

140. 1:12:44

     useful now but it initiate it initiates the sandbox server so that that localized environment uh then you get a you get the root account you create an account and you deploy the wasm file of your smart contract so a smart contract that lives up there in in contracts and source is compiled into a wasn't file and that wasn't file is deployed into your local virtualized near blockchain so and then you're all set up pretty much what I want to do right now is because I always like to do this is I like to make a user

141. 1:13:19

     account so I love GitHub copilot it does all the work for me but that's wrong right create sub account that's what I want otherwise it creates another root account uh create sub oh hold on there and we want root to call this great and we can return Alice as an output great so now we have a user um and now we're all set up you can either do this for all your tests with uh before look here we're using a before each hook so that means this sequence of

142. 1:14:06

     commands from line 10 to 26 runs before every single test case so um be mindful of that think about how you want to do that sometimes you want some tests to have shared state I don't do that personally but some people might like that um yeah and then it tears it down after each test so now we get to the juice what do we want to build um I was thinking we would build a guest book like the one in the example but

143. 1:14:37

     everyone can ride on it and it fetches the uh messages for every account ID because it's indexed by a county so it will just keep an object and then we'll save the strings by account ID as the index so very simple so I'm thinking it should definitely do that and if there is no account ID it should return some kind of message so should uh return not found if account ID not found

144. 1:15:15

     and the second test is our happy path so should um save message and return by account ID so let's see if get a copilot is smart for this smart enough for this let's see a tab it's doing magic let's see does this make sense we have Alice we want that contract view that makes sense yeah and Alice hasn't written to it yet because we're using the before each right and we have nothing yet there with our current setup no state

145. 1:15:54

     and then it should say not found great so that makes sense should save the message very good so let's look at this we have uh yeah uh that's wrong so Alice should call the contract set me yes hello I am Alice and that's wrong and this syntax what it's actually doing and it's wrong right now too I'm gonna explain it in a second okay so what what that line is doing right now it's it's performing Alice is performing a call to that smart contract saying I want to call that function and

146. 1:16:36

     these are my parameters I'm not providing the gas or the storage uh parameters you could also do that yourself optionally but uh if I do this it just I think it provides some default ones but not like Max gas Max gas is right now I believe 300 Terra gas I think I think the default parameter is something like 30 Tera gas so you can always increase that if you see in the famous the infamous exceeded prepaid gas error um

147. 1:17:02

     so yeah uh then we get uh then we're gonna query the contract uh that's something the contract itself can do uh can do so get greeting we pass a count ID from LS and then it should say hello I am Alice so I mean if if we were to be pedantic we would make a a variable and put the string in there and just pass the variable to the test I mean that would be much better right but um I'm a little

148. 1:17:26

     lazy right now and I got a little bit of a hurry so I'm gonna do this so we called get greeting and set greeting and get greeting requires on yeah account ID and this is because we're in typescript we have to tell it what it is a string and we have our greetings and no I don't want to use I just want to use the native types yeah thank you thank you and uh set greeting is the same thing okay very well so let's uh let's see what this does I love Copilot

149. 1:18:11

     that's great that's really great uh okay sure let's accept that uh that's wrong let's let's do something free the assessor account ID and I believe this is a function looks right right yeah I see some nods okay so let's go for it npm test so what what this is oh oh I'm in the wrong file CD My Demo in the wrong folder yeah now let's go great so what's going on right now it looks like it's doing a lot but uh in

150. 1:18:49

     essence it does what I shortly explained previously so it creates that wasn't file and that takes a long a long time with JS now and rust that happens very quickly but in JS that takes a very long time it does a four different five different things that's another another chat for another time uh but uh yeah it won't create that was on file and then it will deploy it on your local version of your uh of near blockchain and then it will run your

151. 1:19:13

     test so now we got to the test part now it's running Ava and uh hopefully I did this right and we get no failing tests yeah it works so uh that's it yeah yeah thank you thank you um awesome uh yeah uh so I think some yeah you can you can see this in uh in GitHub uh there's a workspace there's the workspaces repo is there of course uh if you want to do some test logging you could do uh I think uh where is it

152. 1:19:44

     uh you could but this is uh this is of course Ava specific you could do like a t DOT log and let's see what uh what co-pilot says yeah you could do that and if you want to do uh this too you could do D DOT log results and we can we can even run it again I see I got a couple minutes so uh so yeah I don't know if anyone has any questions or remarks in the meantime no no great great cool

153. 1:20:12

     yeah this is uh this is a thingy but uh I could have just run Ava this time and skipped the whole uh awesome filing file building stuff but uh let's see what else do I have in the presentation I think I've pretty much done yeah yeah now it's got to the test so now we can see the logs here come the logs no I didn't log it I think it misses the verbose parameter but that's an Ava thing so uh if you if you run Ava with dash dash for

154. 1:20:47

     both you'll get to see the the logs I think oh yeah I got just one minute left so I'll continue with the presentation now um yeah you can see more of these examples we have a yeah like example depths very simple depths like the guest book like uh I think of uh fungible token one an nft one uh you can see all those examples in this URL um yeah they all have tests too it's actually I've done myself uh so yeah I actually have improvements on that I'd love to hear that as well

155. 1:21:19

     um yeah so please check it out and uh yeah we're looking for people for for some research if you want to help out and maybe earn some veneer you can scan that we're also looking for new devs so uh if you like this kind of stuff and you like Pagoda then yeah come by the booth and uh yeah say hi that's it uh any questions otherwise I'll conclude question yeah we got a question hey yeah how do you compile JavaScript

156. 1:21:53

     to webassembly oh that's a question yeah sorry um uh I think they of they use quickjs and um I think they send it to nah I'd be guessing I'd be guessing it's it's two less two less concrete I can come back to you about this so uh uh if you come by the booth uh we'll exchange contact info and I'll give you a proper answer because otherwise I'll say something crap right now uh anything else

157. 1:22:24

     okay great that's it thank you guys yeah um thank you everyone for joining the doomslog stage today that was indeed our last session thank you to all our speakers and people in the audience please go out enjoy drinks food and everything available at the last day of nircon thank you