Dev Updates - Mikhail, Matt, Anthony | Incubator WEEKLY

Episode Description

Dash Incubator developers demo the AutoShow content repurposing app with Dash payments and discuss two competing JavaScript SDK approaches for Dash Platform.

Episode Summary

This episode of Incubator Weekly features three developers presenting updates on Dash-related projects. Anthony Campolo demonstrates AutoShow, a content repurposing application that transforms audio and video into summaries, blog posts, and other assets using various AI models. He showcases the newly integrated login system and dual payment options—credit card via Stripe and Dash cryptocurrency via NowPayments—with plans to offer a discount for Dash users. The conversation then shifts to the JavaScript SDK landscape for Dash Platform, where two parallel approaches are under development. Mikhail presents his WASM-based SDK built from Rust code compiled to WebAssembly, along with a browser extension that securely manages identities and private keys without exposing them to web applications. Matt, taking a pure JavaScript approach that results in smaller bundle sizes and broader compatibility, pivots to explaining the proof verification system—a mechanism for confirming that data returned by a single node actually reflects the consensus of the network quorum. He walks through his proof-of-concept code demonstrating BLS signature verification and Merkle tree hash validation. The episode closes with a pragmatic discussion about prioritization, noting that while proofs are important for trustless verification, many Web2 developer use cases can proceed without them, and developer experience should remain a top priority.

Chapters

00:00:00 - Introduction and AutoShow Overview

Rion Gull opens the episode by introducing the three guests and outlining the topics for discussion, which include Anthony's AutoShow application and the JavaScript SDK work being done by Matt and Mikhail. Anthony begins by explaining that AutoShow is a content repurposing tool designed to help creators transform audio and video files into various outputs like summaries, chapter titles, blog posts, and even creative content like rap lyrics, with future plans for multimodal capabilities including image generation and text-to-speech.

Anthony demonstrates the app's login system and its two payment flows for purchasing internal credits: credit card processing through Stripe and Dash cryptocurrency payments through NowPayments. He explains the credit pricing model where one dollar buys 100 credits, with transcription costing around eight credits and LLM processing varying from one to 100 credits depending on the model selected. He notes that the app will offer a discount for users who pay with Dash, which serves both as a user incentive and as a way to gather analytics on cryptocurrency payment adoption.

00:05:05 - AutoShow Live Demo and AI Discussion

Rion examines the payment interface and raises questions about accessibility and the user experience of purchasing with Dash versus credit cards. Anthony acknowledges styling issues that still need work and explains that a redesigned interface is in progress. The discussion moves into a live demonstration where Anthony processes a recent Dash Core Group video through AutoShow, selecting GPT-4.1 as the model and generating key takeaways, quotes, and a blog outline from the video content.

While waiting for the AI to process, the conversation takes an informal turn as Rion asks Anthony about his views on AI's impact on jobs and society. Anthony argues that the job displacement narrative is overhyped, suggesting companies will pursue more output rather than layoffs, and that AI is a genuine productivity breakthrough that people should explore hands-on rather than dismiss. The generated results arrive, showing extracted takeaways about Dash development progress, direct quotes from the source video, and a structured blog outline with a first draft.

00:20:11 - Mikhail's WASM-Based SDK and Browser Extension

The episode transitions to SDK development as Mikhail presents his approach to building a JavaScript SDK for Dash Platform. He explains the two-part architecture consisting of the SDK itself, which handles transactions and API queries, and a browser extension that securely stores identities and private keys. The SDK is built using WebAssembly compiled from Rust code, resulting in a roughly three-megabyte bundle with full TypeScript support and autocomplete functionality. He notes recent migration to Dash Platform version 2.0, including token transition support and data contract methods.

Mikhail details the security model of the browser extension, which runs in a separate context from web pages so that private keys and seed phrases are never exposed to potentially malicious code. The extension provides a public interface allowing decentralized applications to request transaction approvals through dialog popups, while keeping all sensitive operations isolated. He also describes future plans for QR code-based integration with mobile wallets, allowing users to sign transactions from the Dash mobile app instead of entering seed phrases directly into the extension.

00:44:30 - Mikhail's Proposal and Development Roadmap

Mikhail walks through his upcoming proposal, outlining a week-by-week development plan. The immediate priority is releasing a first testable build of the Dash Platform extension that supports importing identities via private key. Subsequent milestones include adding seed phrase import functionality so users can see all their existing identities, implementing identity registration for new users, and building multi-wallet support with different storage options including seed phrases and keystores.

On the SDK side, he plans to integrate WASM-based proof verification, expose token transition methods, and conduct testing on both testnet and mainnet. The proposal also budgets for designer work on new UI screens and documentation. Rion expresses interest in having Mikhail demonstrate progress on the show regularly, noting that some of the weekly milestones seem ambitious but encouraging. Community members in the chat respond positively, with one commenting that the extension could attract regular users beyond just developers.

00:49:15 - Matt's JavaScript SDK and Proof Verification Deep Dive

Matt begins by praising Mikhail's work before presenting his own pure JavaScript approach to the SDK, which trades the WASM dependency for smaller bundle sizes and broader environment compatibility. Rion frames the two approaches using an engine analogy—internal combustion versus electric—acknowledging that it remains unclear whether these will become separate products or merge into one. Matt then shifts to explaining proof verification, the topic that consistently comes up whenever his SDK is discussed.

He walks through the conceptual foundation of proofs: when you query a single node for your identity balance, you receive a number, but a proof cryptographically demonstrates that the entire network quorum agrees on that value. Using BLS signature verification and Merkle tree hash reconstruction, his proof-of-concept code takes apart a real proof, validates the quorum's signature against their public key, traces the hash path through the tree structure, and confirms the root hash matches what was signed. He uses an airplane ticket analogy to explain why verifying the proof's validity alone is insufficient—you must also verify it corresponds to the specific query you made.

01:11:04 - Prioritization, Proofs Discussion, and Closing

The final segment focuses on practical prioritization of development resources. Rion emphasizes that while proofs are important for trustless Web3 applications, many Web2 developers can derive significant value from Dash Platform without them—simply creating schemas, writing documents, and verifying results through the platform explorer provides sufficient trust for numerous use cases. Matt estimates that completing robust proof verification with proper edge-case testing would take roughly a month of full-time work, though the scope can be narrowed incrementally by starting with simpler verifications like identity balances before tackling complex range queries.

Mikhail asks about Matt's timeline expectations, and Rion suggests a gradual approach where proof coverage expands over time rather than targeting full surface-area coverage by a fixed deadline. The conversation closes with Rion expressing confidence in both developers and stressing that developer experience should remain the top priority alongside proof work. Anthony's AutoShow launch target of end-of-month is noted as another important milestone for getting real Dash-integrated products in front of a broad developer audience, and viewers are invited to return for future progress updates.

Transcript

[00:00:04.29] - Rion Gull Welcome everyone to today's episode of Incubator Weekly. We've got Anthony, Mikhail and Matt with us today. How's it going, guys?

[00:00:13.25] - Matt Good, good, good.

[00:00:17.08] - Rion Gull So we're going to talk about AutoShow with Anthony. We're going to talk about the JavaScript SDK with Matt and Mikhail. A couple different approaches that we're trying to converge on a good solution or figure out whether, you know, it makes most sense to have two separate products is this one product that we're, that we're coming together on. So we'll discuss that. We're going to start with, with you, Anthony. And you've got a screen share, so I'll, I'll put that up. But how's it going? So other than, other than your, your demo, how's it going in general, how's. How's life?

[00:01:01.12] - Anthony Campolo It's good. Yeah. I'm in the process of moving right now. Not a crazy big move just to like a different apartment area. We're moving like, you know, just a couple miles away. So got me a little bit behind schedule, but we're actually in really good shape right now. I've got. Last time I did a demo, I showed you how it was. All the functionality was there, but there were still some stuff in terms like login and payments that needed to be put together. But that's pretty much all here. Now we have login and we have two ways that you can now buy credits. You can either do credit card payment which will go through stripe flow like so, or you could purchase with Dash cryptocurrency. So this is using under the hood is now payments. I decided to kind of use an API provider just because the SDK seems like it's still kind of in flux and not necessarily production ready. I think that's one of the things that we'll be talking about for probably, probably the rest of this episode. But so you can purchase credits through dash or through credit card and then the flow itself has pretty much stayed the same.

[00:02:27.25] - Anthony Campolo You could provide a URL to a YouTube video or a local file and then you can select your different transcription services and prompts. So we'll do titles and rap song lyrics.

[00:02:47.07] - Rion Gull And before we get too, too much further in the details, could you actually, could you actually step back for anybody who might not be familiar with this product and what your proposal is in general? Yeah. Can you, can you talk a little bit more high level for three minutes?

[00:03:06.12] - Anthony Campolo Yeah, sure. The main proposal is to essentially build a DASH payment integration in an AI app that I'm currently Building the app is a content repurposing app. So what it does is it takes audio and video files and repurposes them into different assets. Originally, when I first built it, it was just for things like summaries and chapter titles and stuff that you put like a YouTube description. It has expanded out wildly from that point. The functionality now includes multimodal stuff. You could generate images and text to speech and there will eventually be video capabilities as well. So you can almost. There will be a point where you'll be able to feed it a script and generate literally a show, like an AutoShow. That's pretty cool. But for now, it's kind of designed to help content creators accelerate their content production through various different means. And I'm not sure how much you want me to go into like the, the finer details of this, but the. It's been kind of hit or miss in terms of the funding. It was really supposed to be funded for six months and then it was not funded the first month, it was funded the second and was not funded the third.

[00:04:40.03] - Anthony Campolo And now we're coming into the. The fourth, so hoping it will get funded this time. It's pretty much with a couple tweaks to like, styling and just some UX things. It's pretty much ready to go to production. So I'm hoping to launch the app by the end of this month. And. Yeah, do you have any specific questions?

[00:05:05.26] - Rion Gull Yeah, so that makes sense. You scrolled through the proposal so people can pause that and read that if they're interested in the details of the proposal itself. Let's switch back to the app. And so the idea here is that you, your product requires credits to use. And I'm gonna, I'm gonna, I'm gonna scold you for right now because I see a little bit of a, an accessibility issue with your font color here.

[00:05:36.23] - Anthony Campolo I know. That's why I'm saying the styling still needs, still these work.

[00:05:40.04] - Rion Gull But it says send the exact amount of Dash to the address below.

[00:05:44.18] - Anthony Campolo So be for.

[00:05:46.04] - Rion Gull For this so you can buy credits. These are. This is an internal credit credit system to your app itself. These are not Dash credits. These are AutoShow credits that you can purchase either using credit cards or Dash cryptocurrency. So cool that, you know, Dash has got the prominent spot there. You're using now payments so you could expand to other cryptocurrencies if and when you needed to. So I'm putting myself in the seat of some potential user here and I'm thinking, okay, I like the product I want to buy some credits. I don't know much about cryptocurrency. If I wanted to, I could just go through the credit card flow. That's always a pain in the butt for me. Like, I always hate pulling my credit card out for stuff like that. And there's a little bit of a security issue with giving my credit card to random people, but if it's using Stripe, then that's not as big of a deal. But sell me on the idea of, like, a general user that is familiar with cryptocurrency but might not have some. Is there any benefit to using Dash at this point other than, you know, is there a price discount or anything like that?

[00:06:58.07] - Anthony Campolo Yeah. So that'd be the one other thing that I still need to add is that there you'll get a discount on credits if you purchase with Dash cryptocurrency. So I need to add the logic in for that and some kind of explanation in the UI so that people know that. But there'll be. I forget I said something in the specific proposal in terms of the discounted rate for. Guy says specifically how. How discounted it'll be, but yeah, it'll be like, you know, 10% off or something like that if you. If you purchase with Dash.

[00:07:35.16] - Rion Gull Yeah. And. And I would be. One of the things I'd be curious about with this is, you know, this is an example of something that the whole Dash community kind of wants to see, is that this, our Dash currency is used for in the real world to buy things. So I would be interested to see stats like, you know, one out of every 10 people are using Dash or something like that. Is that something that you can offer?

[00:08:03.17] - Anthony Campolo Yeah, that's included in the proposal as well. They'll be specific sort of analytics for. I forget exactly where I wrote it in, but yeah, that's included that you'll kind of get insight into how much payments are going through Dash versus the credit card flow and how much the incentive matters for the users. And we could tweak the incentive, maybe add a better discount if we feel like not enough people are using the Dash option. Yep.

[00:08:38.14] - Rion Gull Okay. And then back to the app itself again. Why. Why 1084 credits? What's. What's. How do you.

[00:08:46.22] - Anthony Campolo What's my current balance? That's just the amount of credits I have in. In this account right now.

[00:08:51.23] - Rion Gull And so when you're buying, when you're sending 0.051 dash, what does that get you?

[00:08:59.08] - Anthony Campolo So that. So it's so. So that's like that's $1 and it gets you 100 credits. And then if we. We see here generating it was like eight credits for the transcription. And then depending on what LLM service you use, somewhere between like 1 and like 100 credits for different models. So, you know, you could do a whole bunch of these if you're using like a really cheap model, or you could do like one for a dollar if you want like the very, very best model. It's one of the reasons why there's. There's a whole lot of different options in terms of transcriptions and LLMs. So if you want to generate like a whole ton of show notes, really, really cheap, you can do that. If you want to generate a few with a really high quality model, you can do that as well. So there'll be more kind of explanation in terms of kind of like what a credit is worth in terms of like some different examples. Like if you have a five minute video, it'll cost this much. With these kind of models, there's still more kind of maybe like a kind of walkthrough when you first start some sort of onboarding thing that I still need to build in.

[00:10:06.25] - Anthony Campolo But this is the core functionality right now.

[00:10:10.06] - Rion Gull Cool. All right, so what else did you want to show us on the app itself? And do you have a dark mode? I'm just curious there.

[00:10:19.05] - Anthony Campolo Yes, the styling needs a lot of work. I was working with a designer and wasn't super happy with where it ended up. I built a whole like new, fresh version of this that looks really nice, but I need to migrate it over to the new styling so the app itself will look nothing like this when it actually launch.

[00:10:43.01] - Rion Gull Okay, cool. All right, so what other functionality did you want to demonstrate, if anything, or talk about?

[00:10:51.27] - Anthony Campolo We need to get to the final part where you actually get the show notes. You first pick. So in the last step, I picked the prompts, which is what you actually generate. And then here is our output. So you get some potential titles and then you get some lyrics here. It's a fun use case. You can put in any sort of videos and get some. Some rap lyrics from it.

[00:11:23.23] - Rion Gull Can you. Can you do the. The latest Dash Core Group update for us on the fly or just status. Oh, no, Incubator Dash. Let's see, just do Dash. Yeah, I don't know if Dash Core group is. Let's. Whoa. 2020. That's the right. That's the right account.

[00:11:53.26] - Anthony Campolo Okay, so this would be the most recent one.

[00:11:58.05] - Rion Gull Yeah.

[00:11:59.14] - Anthony Campolo Cool. What do you want for the. For the prompts? I'll show them.

[00:12:09.14] - Rion Gull Whatever you think is best come up.

[00:12:20.20] - Anthony Campolo And there's a bottleneck here that I need to fix as well, because the reason why it's processing is because what it does is it downloads the audio and then uploads it to an S3 bucket. That can happen in the background. What I really need to do is just have it immediately give you the prices and the prompt prompts. That's one other thing that still got

[00:12:43.28] - Rion Gull to do some tweaking to do. Got it.

[00:12:45.25] - Anthony Campolo Yeah.

[00:12:46.13] - Rion Gull That wasn't too bad though, that even. That was okay.

[00:12:49.22] - Anthony Campolo Yeah. Okay, so let's do key takeaways and quotes.

[00:12:58.11] - Rion Gull How about a blog, too?

[00:13:00.07] - Anthony Campolo And a blog, sure.

[00:13:06.21] - Rion Gull Alexi says dash. And my buster says, I'm just tuning in. Great to see you all. So we're just, we're just going through Anthony's AutoShow product here. He's. He's doing the. The latest Dash Core Group video. And what model are you using for this?

[00:13:35.01] - Anthony Campolo Let's use. Let's do GPT 4.1. That's a good kind of mid grab between newer model, but still not super expensive and pretty fast.

[00:13:52.05] - Rion Gull While it's, While it's chewing on that, what do you have to say about AI in general? Is it going to take all our jobs kind of thing? What is your. Yeah, what's your take on this in terms of.

[00:14:06.02] - Anthony Campolo I think the, the whole job debate is a little overhyped. I think that, like, you know, Dax, he, he tweets about this a lot that if, like, imagine a company, they get 2x boost and productivity, are they going to fire half the people that work for them or are they going to try and generate twice as much output? You know, so the. I think that it's really not actually that realistic that just because firms get more productive that they're immediately going to fire half of their workforce. I think that on the individual level, you're going to be more marketable in terms of your skill set if you at least know a little bit about AI and know kind of how to use it. I, I think that on a societal level, it's going to have big impacts on the long term and not so much in the short term. Like people who say AGI is coming in like, you know, 12 months or whatever. I think all that's crap, you know, but it is definitely a genuine breakthrough in terms of productivity, in terms of coding, in terms of even if you're not a code.

[00:15:29.07] - Anthony Campolo Like my wife, she's a copywriter and she was very reluctant to use AI at first, but I kind of was nudging her and now she finds all sorts of ways to be productive with it. So yeah, I think AI is cool. I think that a lot of the naysayers about AI hone in on very specific issues that if you understand you can actually get around in terms of like hallucinations and just it not quite understanding things. You know, obviously it has limitations, it's not God. But yeah, I think just, you know, people need to get their hands on it and try and find a way to use it for their own stuff and then they'll find where its edge cases are, where it's actually useful and it should be kind of treated like any other new technology with pros and cons.

[00:16:20.20] - Rion Gull Yeah, so it looks like it finished there. I see some chomping away in your cli behind the scenes, but is it.

[00:16:27.19] - Anthony Campolo That's. That's fine. Yeah. So. So the key takeaways were ongoing improvements and major updates across DT DCG products. Significant progresses in man tools like Dash Evo Tool, dash Core and SDKs. The focus on usability, bug fixes and cross platform support, their tendency to communicate community feedback, blah blah blah. SDK development is accelerating future integrations. Recent advancements in SDKs, especially the Rust SDK, CFFI bindings and Swift wrappers are enabling greater platform compatibility and then automation. AI hey are enhancing productivity uses AI assisted tooling and automated backporting agents is rapidly increasing development speed and reliability, notably in complex areas like code backporting, verification and multi language SDK.

[00:17:15.11] - Rion Gull That's interesting sound. Sounds kind of self serving for the AI to talk about.

[00:17:22.21] - Anthony Campolo And then these are quotes from the actual thing is that if you made a token with a direct purchase and you were also the seller, it caused a mismatch of credits. Situations that are that cause a really bad thing like that. We try to halt the chain on purpose to make sure that it gets resolved.

[00:17:40.17] - Rion Gull That sounds important. Okay. So how'd the blog post turn out? Just. Just real briefly and then I think.

[00:17:46.19] - Anthony Campolo Yeah, so the blog. It's a blog outline, I think. Oh yeah. So it gives you an outline then a first draft.

[00:17:54.21] - Rion Gull Okay.

[00:17:55.07] - Anthony Campolo So. So do you want to see the outline or the. The beginning of it?

[00:18:01.20] - Rion Gull The outline's pretty good. Yeah, I see.

[00:18:05.10] - Anthony Campolo Cool.

[00:18:06.26] - Rion Gull What else did it spit out? Just want to scroll down to the very bottom just so we can see all of the output.

[00:18:14.26] - Anthony Campolo Let me go to the system where you see it actually on it. Again, all the styling is going to change. This is just the raw data you get. It's not rendering the markdown or anything that will obviously be fixed as well. But this is the full output. So the key takeaways, the important quotes, and then the blog outline. So those are the three prompts that we picked, our blog outline and blog draft. And then all the way down here, you get the actual transcript. So you could read through the whole transcript of the thing if you want. So that goes on for a while because it's about an hour. And then the original prompt we used to generate it. So if you wanted to tweak the prompt, rerun it, you could do that.

[00:19:02.14] - Rion Gull Very cool. Splaw says. Hey, guys. Anthony, Nice to see the progress on AutoShow app. It simply works. Nice.

[00:19:14.11] - Mikhail Cool.

[00:19:14.24] - Anthony Campolo Good to hear.

[00:19:16.26] - Rion Gull Yeah, this looks like. Yeah. So you said you're hoping to launch this live by the end of the month. That's nice. Dash payments are working and I think at a bare minimum, you know that it's a. It's somewhat of good advertising. I know you have a pretty wide audience of key influential people in the Web2 space. So just them seeing the word dash, there's value there even if they don't use it. But yeah, that would be cool to. To see what kind of discounts result in what kind of conversions. So anything else to say? And then we'll, we'll go over to the. The SDK stuff after. Final thoughts?

[00:20:11.05] - Anthony Campolo Just that, you know, if people are have any questions or comments, hit me up. And yeah, hoping to. Hoping to move forward with this.

[00:20:21.11] - Rion Gull Okay, cool. All right, so moving on to SDK discussions. So for a while now, we've been, Anthony, just as a segue, you know, we, we had 10 or 15 people from, from your circle of developer friends test. Yeah, we're gonna do that again at some point. Yes. I did one more additional one recently with one of my developer friends and things are still basically the same, but we obviously do need an improved JavaScript SDK to work with. And so that's what we've been working on with both Matt and. Matt and Mikaela are working on that. Mikhail, do you want to. Do you want to start us off with what you. The approach that you're taking to do your. The SDK stuff? You have a proposal as well. You had one a couple months ago. As long as I remember, you have a current one for this coming month. So do you want to talk about what you're working on?

[00:21:36.02] - Mikhail Right, right. Yeah, I wanted to show the whole progress what we did and what the proposal about. Where is it? SDK. Yeah, so the SDKs that we do. It consists of two parts. The first part is the actual SDK that can create transition. It can make queries to the Dapia and stuff like that. It's pretty simple. Part.

[00:22:14.10] - Rion Gull Sorry, can you bump up the font about four notches?

[00:22:18.03] - Mikhail Yeah. Right. So it's. Yeah. So there are two parts. The first part is actual SDK which have all of the methods to work with for the web developers. There is a second part is the wallet which will keep your identity private key secure, which can hold your identities. What we want to do on the web basically is we want to have a way for developers to connect the wallet, connect the mobile wallet. We want to connect for example through extension. An extension is also wallet and developers want to simply through the, through the JavaScript Connect their wallet and then create some transactions and ask value to sign it. Because we really don't really want to ask users for private keys or seed phrases on the DAPP application itself. I guess in other case you would have to. You have to ask user for some secure information that can be very easy leaked. Yeah. So what we did in the previous months, last two months we was working on the JS SDK and the Dash platform extension. The first one is pretty much done for. For the regular operations like creating transactions, siding, signing it, basically the document, the basic stuff, the Dash platform.

[00:24:01.29] - Mikhail Yeah so we did that with. With the help of the wasmdpp. So there is a DCG wasmdpp which doesn't work really good. It has certain limitations, it has certain complexity and I was. We were trying to improve it in the beginning of the year but it wasn't really like the efforts was was too much to refactor all the things and stuff like that. So we did the completely different wasmdpp project which basically uses the Rust code, the Rust TPP and it bundles into the WASM bundles and these WASM bundles get loaded into the GS. So the SDK, the SDK is. Is using that wasm. Yeah, it adds some complexities to when you work with Window js, but at least we have something to work with. And yeah, it let us build an SDK which weights not really much, like 3 megabytes. It's optimized, it has all of the typing systems. Recently we added all of the types. So when you use it, you can use the TypeScript or JavaScript. If you use the TypeScript you have all of the types. So when you work with it, it's the after completion is working and you always see what the methods, what the fields, the classes have yeah, right now we are, we just recently migrated it to the dash platform.

[00:25:53.07] - Mikhail We 2.0. I'm talking about the DPP layer because it's the most significant part. Like we upgraded it to the dash Platform Vite 2.0. It's working. We have added all of the token transitions there. We have added the data contract, the methods to work with the data contract to create a new data contract, the one which have tokens, like to create tokens and make tokens. I haven't yet exposed it in the Dash Platform SDK itself, but it will be pretty quickly. I just need to create functions and just execute the methods of the DPP itself.

[00:26:36.05] - Rion Gull Okay, do you mind if I, if I give a little bit of a high level explanation for those people who might be wondering what, what all these acronyms are talking about? It's a little tricky because people who are developers probably know what's happening and people who aren't developers probably won't know what's happening even after I try to explain it. But I'm going to give it a shot. So Dash Platform has some function, some functions that you can, that you can call to the, the service side or the network side or the blockchain side. It exposes certain methods, certain functions that you can, that you can call. It does that over. Not JSON rpc, but the grpc. Grpc. It does that through grpc. In order to get the structure of the data. Correct. To do those function calls, you need to know what is the structure of the data, what fields do I need, what data does it accept, what are the types of those fields? And that's what DPP is all about. Correct. That's what DPP stands for, Dash Platform Protocol. And it tells you the data structures and the function calls that are supported by Dash Platform.

[00:28:07.17] - Rion Gull And that's independent of whatever language any language can implement that those data structures. And currently the easiest way to do that is using webassembly. That's what Wasm is referring to, was WebAssembly. Because WebAssembly is JavaScript engines support WebAssembly to execute those functions. So instead of executing them in pure JavaScript, like literally writing JavaScript code and then throwing that through the JavaScript engine and having that send that up to, through the GRPC to Dash platform, you can do it through WebAssembly as well. And Rust is specifically a good language to that, that throw, that spits out support for WebAssembly pretty easily. So that's, that's the approach that you're taking is you're not, you're not doing, you're not writing a JavaScript SDK. You're writing, you're creating an SDK that is WASM based and that, that by nature is supported by JavaScript engines. What did I get wrong? What did I miss?

[00:29:24.28] - Mikhail Well, I wouldn't say that. I would say it's still JavaScript SDK, but it internally uses the WASM webassembly to create transactions, use sign transactions and stuff like that. Decode, encode stuff, stuff like that. It's still a JavaScript SDK.

[00:29:44.12] - Rion Gull And the end result of that is that you get a big WASM bundle that you said was 3 megabytes big, which is a significant improvement over Java over the existing SDK, but still quite a bit bigger than what most JavaScript developers would be using used to 3.66 megabytes. I think what matters probably more to people is how quickly it performs than how big it is. But those are just some aspects of the trade off.

[00:30:19.27] - Mikhail Yeah, yeah. It will be slightly increased when we implement Proofs in the Dash SDK because Proofs is also VASM based. So I think it will double in size, but it's the least that we can get right now.

[00:30:37.02] - Rion Gull So the last time I looked at the, I looked at your proof package and I thought I saw that was 13 megabytes.

[00:30:46.19] - Mikhail And you're saying, yeah, stuff like that. Yeah, it will be optimized.

[00:30:50.13] - Rion Gull It can be optimized.

[00:30:51.19] - Mikhail Yeah, yeah, I think it will be something like five megabytes or six megabytes. So the problem, yeah, the problem is not in the size itself, because when you use webassembly you can just use regular reverse, like from the packages. You have to download the whole wasm binary, the whole WASM buffer, and then compile it in runtime and then use it in JavaScript. So you have to pass down the compiled instance instead of just importing your function. This is the one thing. The second thing is that it has to be downloaded so the page will be loading. So you can't use functions until the page will be loaded, but the vasm is still not there and you will always wait until it downloads. But with such size, it's pretty much acceptable.

[00:31:50.09] - Rion Gull Yeah, and I was just going to ask you, you did some of this, but I'll probably ask the question anyway. Can you describe what's the user experience that you're targeting here for both application developers and the users of those applications that the application developer has built? Is it going to be, is your target something like the Developer creates an application that talks with the an extension that all of the users of that application are expected to have installed. Or give us an idea of the the high level user experience for both that developer building an app and the users of those apps.

[00:32:40.06] - Mikhail So yeah, the Dash platform extension will be targeting to two types of people. The first is obviously just regular users who, who owns a seed phrase, who have a seed phrase, who have identities, who wants to create documents on the depths, who wants to buy tokens and stuff like that. So it's basically the, the separate wallet. So it's basically a wallet which allows you to keep keep your identity safe While allowing the JS the JavaScript to request some information. For example, developers would like to retrieve a current identity ID from your account. For example, you have chosen one identity and you want to use it on the DAPP application. So we have to have some kind of interface which allows you to retrieve that data. And this is where Dash platform extension comes in. So there is a public interface. It's not through some sort of the messaging player which allows you to

[00:33:53.24] - Mikhail For example it can request a transaction approval. So you just ask here is my state transition, I want user to sign it and then the dialog on the user will pop up and he will either can reject or sign it. I was building the Dash platformer this extension with keeping in mind that we would possibly would like to use a mobile app instead of putting the seed phrase in the, in the extension itself. So it will be possible in the future but in order for for us to have it, we will need some kind of interface from the mobile wallet to exchange that information. To request sign transit. To request sign the transaction, it could work through QR codes. So the DEP would just ask to send a state transition but instead of rejecting or signing it there will be a QR code which you just scan with your mobile and approve it from you. From. From the Dashboard. From Mobile Dashboard. Yeah. And the second the second type, the group of people is actually the developers who wants to build the dev applications. And it works by injecting some small piece amount of of code that will that will inject into the web page.

[00:35:31.05] - Mikhail And once you visit some some depth application on the domain it will be possible to connect your wallet and and yeah, this the similar dialog will will pop out. Yeah. So the SDK itself works pretty much like this. You first first you create from from the developer's perspective, you first install the SDK sorry, like you just import it or if you're using the Dash platform, split attention it's already there in the window. So yeah, wherever you visit any page, it gets injected, but later we will change it. So on the approved tabs will be injecting the Dish platform SDK code. Yeah, you have some data, for example, we want to create some document. We have our identity identifier, data contract, which document type we want to post this data in. And then you create some things like you. You create a private key identity. You request to get. You request identity contract also, which is needed to create a document. And then you ask the Dash Platform to sign it. It's currently integrated straight into Dash Platform SDK, but it can be moved out separately. So basically, the transaction that you ask dashboard firm to sign it could be.

[00:37:08.26] - Mikhail Could be made by. By any application. Not, not by. Only by Dash Platform SDK. It could be for example made by mobile application on any other SDK and we can simply pass it to the same interface. So internally, Internally I would like to. I would like to tell you how it works internally. So there is a. Oh, wait a second. Yeah, it's the different branch which has all the code right now. Yeah, so internally, all of your keys, for example, you import your private key, so import your seed space in Dash Platform Extension. We just made the feature. So it will be kept all encrypted. So once you get into the Dash Platform section, it will ask you for the password to. It will ask you for the password to set. You set the password and then all of the secure information like private key seed phrases will be encrypted with it. Dash Platform extension itself running in the separate. In the separate context. So we have two contexts right now we have the web page and it has the Dash Platform extension. Wherever we put any information here, for example, the private keys, it does not share that it is.

[00:38:36.24] - Mikhail It doesn't have access to the regular web page and regular webpage doesn't have access to the platform extension context. So I built two sets of APIs. The first one which is used inside the extension itself to get information about your identities. For example, a list of your identities. Like stuff like that, like your transactions transaction actually required, but platforms are explorer right now. But, but anyway, it's completely different kind of different set of RPCs and the regular user if, if he's got hacked, all right, and some malicious code is there in his browser, this, this code will not have any access to the Dash Platform internal internal things. It has only public interface which allow you for example to connect the application or request the state transition approval internally. There are all other RPCs to work with which is needed internally in the dash platform extension like create identities. It's like importing the identities, creating wallets, switching wallet and just stuff like that. Yeah, so I made it so it's pretty much secure to use it. Every like private keys and seed phrases are encrypted. Even if you are of course you can. You can just look into the application and see the storage for example right here doesn't have much right now but.

[00:40:22.21] - Mikhail But yeah, you can see all of the data which is stored right now into the extension. But all of the important information will be secured so people. So user can of course manually watch all of the information, but it doesn't get shared with their regular web pages. Yeah, yeah.

[00:40:47.10] - Rion Gull Do you have a sample app at this point that does connect with the extension?

[00:40:52.24] - Mikhail No, not yet. This functionality will be done. Will be done next. So it doesn't have right now functionality to connect your app. So what connect app does. It basically writes the dev application that you authorized access to into the internal database. So when people. When. When we. When people visit the dev application and try to use for example. Oh, sorry again. And for example people want to. I'm sorry. So want to request a state transition for approval. It will only work if user approve that specific tab application inside the extension. So on any other page these methods will not work. It's another layer of security.

[00:41:58.26] - Rion Gull How far do you think that you are from being able to create a very simple web page that connects with the extension and does one simple thing say creating an identity.

[00:42:13.17] - Mikhail Right. Yeah, it's already working. What we did last time, I was doing last time this flow where you can create a document and ask extension to sign it. We reworked the UI interface. So right now it's mostly the same but it has reworked interface and

[00:42:39.19] - Anthony Campolo we

[00:42:39.25] - Mikhail are very close to finish it. So what we did, I did a really huge refactoring of the code and right now we are trying to adapt the front end to the new code changes. I can't show you the work right now. We're still finishing stuff. We need to. To make it in the final bundle test everything. But we expect to have a solution with a. With a single identity and you can import the private key instead of seed phrase. We will have it on this week. So we will release a first testing, testing bundle testing release open testing which people could use to how it's working in the testnet.

[00:43:33.11] - Matt Okay.

[00:43:34.17] - Rion Gull Halawi says this is the When SDK edition and Alexi, who I believe is your developer.

[00:43:42.10] - Matt Correct?

[00:43:44.15] - Mikhail Yeah.

[00:43:44.26] - Rion Gull Alexis, he's one of your developers. I think that we'll be able to attract regular users to use the platform, not just developers. Indeed. So, all right, that's a good overview of what you're working on. I am eager to see the, the, the hello World application working with the extension to do something on platform like creating an identity, a contract or a document. And speaking of which, Matt, do you want to. Did you first of all, did you have anything else to add, Mikhail, before we move on?

[00:44:30.00] - Mikhail Yeah, I want to talk about the plans about the proposal. So basically what's included inside this proposal?

[00:44:39.16] - Rion Gull And by the way, just real quick, we are going to have a discussion about proofs with both you and Matt at the end here because I know that that's, that's an important part to discuss, but I just. Yeah, I want to do that at the end after Matt's done some of his presentation. And after you're done with. Can you bump up the font on, on this so that people can read what you're.

[00:45:02.20] - Mikhail Yeah.

[00:45:04.08] - Rion Gull So go ahead. Go ahead, Mikhail.

[00:45:06.08] - Mikhail Yeah, so yeah, on this week we will release a first dash platform extension like the release build and it will allow you to import identity where the private key it does. It will not allow you to create an identity or import a seed phrase, but it will just showcase the, the minimal. So it will be the minimal functionality. What we plan to do is we want to add seed phrases so you could import your existing seed phrase and see all of your identities. We want to implement a registration of identities so people who don't have identities yet, they will be able to register with their first identity for extension. Yeah, this dash platform will have multi wallet support, meaning that people could change their seed phrases, have different wallets. For example, one could have a seed phrase wallet. You could have a keystore wallet. If you don't want to mess with the seed phrases, you won't just have your identities stored on your dat, the SHIVA tool, but have some specific private keys imported to the dash platform extension. Yeah, the SDK we are kind of finishing, I believe, because we, we have vasom proofs, proof of concept working that we are going to integrate.

[00:46:47.28] - Mikhail We need to integrate the token transitions. That I believe wouldn't take too much time, I think like a week or maybe even less. You, you will need just expose methods in the SDK itself. We will test everything on the testnet and mainnet network. So the both SDK and both SDK and extension. Right now extensions work only in testnet when we have been working with Testnet So that's another thing. Finally the SDK documentation and there are also a huge screens that we need to make with our designer to. For new screen that front end. Our front end dev Alexia will be implementing like the seed phrase flows, flows home screen, reworks home screen which will include more information like send credits, withdraw credits. So we need screens for this front end. And this is another thing that this proposal will be budgeting. Yeah, I think this is it. Yeah. Okay. Did it all about the proofs? Yeah, we will integrate proofs as well. Yeah.

[00:48:14.07] - Rion Gull Thank you for breaking that down into weekly things. I mean from my perspective, I would love to have you on incubate or weekly. You know, maybe not every week, but every other week to demonstrate your progress on this. The second week showing proofs integration and SDK seems ambitious to me, but if you can pull that off, great. Anything else that you wanted to add before we move over to Matt?

[00:48:45.08] - Mikhail No, I think, I think I'm. I'm good. I think I discussed everything what I wanted.

[00:48:52.23] - Rion Gull Okay. All right, Matt, let's bring up your screen here. Do you want to anything that you wanted to add or talk about with Mikhail before you move on or just general statements or you just want to jump right into your demo?

[00:49:15.25] - Matt Yeah, I think the work that Mikhail's doing is wonderful. Being able to get an SDK into the hand of developers now is really important. Getting an extension out there that people can actually trust and use and don't have to trust every silly little application with their private keys, I think is super important. That's all work that I wanted to do before I even heard Mikhail was doing it. And I'm glad that he's doing it because I don't want to do it myself. But yes, I think everything that's happening there is awesome. So good job.

[00:49:47.12] - Mikhail Thanks.

[00:49:51.10] - Matt So did you want to prompt this or should I just get going on proofs?

[00:49:58.01] - Rion Gull Yeah, I'll say just a few words about kind of the compare and contrast. So Mikael, like we talked about, is focusing on doing WASM based SDK and you are focused more on doing JavaScript native code without WASM, which has trade offs. I'll say one of the big benefits is that it's much smaller and that it's potentially more supported in more environments, for example, and a little bit easier to use. A little bit easier to use. Potentially quicker to load things like that. But I, I think that this month is going to be critical in kind of figuring out between the two of you where the lines are and where the overlap is with what you're working on. Because I think that there's, there are certain things that you're both building that are kind of like the same. Like the, the analogy that I drew yesterday and yesterday's that you're both kind of building a motor, an engine where, you know, one of them is, you know, an internal combustion engine and one of them is an electric engine, electric motor. They're both, they both kind of do the same thing, but they do it in different ways and they have different trade offs.

[00:51:28.25] - Rion Gull And it's not clear yet to me even where the overlap is, where whether these will be end up being two different products or whether there will be. Or whether it can merge into one product. I think that there are benefit, there are pros and cons to both of those approaches as well. To some degree it's good to have competition between products that are competing for the same thing and. But that takes a little bit more resources. But on the other hand, and on the other hand it could be better to have to just have one product and focus all the resources on that. So there, there are trade offs there. But I think, I think that we've made enough progress on both of these sides that it might make sense to have. It does make sense to me to have both of you pursuing this and to see where those lines end up and which. Yeah. Which. Which products fit better into which environments and use cases. So do you want to. Yeah, just go ahead and demo. We can talk more about that if we want later on and if anybody has any questions about that, please feel free to ask.

[00:52:45.20] - Rion Gull But go ahead. And I wanted you to at least show a little bit of a review, like a three minute recap of what we did in the last show that I had on with you where you created an identity and then a data contract and then a document using your libraries in Node JS and. Or the browser.

[00:53:11.08] - Matt Yeah, so this is just everything that I showed last week. Maybe don't know why it is refusing to allow me to move this window. What is going on? Okay. I don't know what is happening. I'm sorry. I am trying to try a new browser. I don't know if you've ever heard of arc and it's nice but like it's, it's really misbehaving right now. So I don't know what is wrong.

[00:53:50.14] - Mikhail No, we've seen some video. You're sharing the different display things.

[00:53:54.09] - Matt I know I'm showing a different window. I'm trying to move this one and it won't let me do it now it's split and I can't even unsplit it. So. Not impressed.

[00:54:09.20] - Rion Gull Alice,

[00:54:13.20] - Matt we have something now. I got it moved. This is just something I showed last week that it's just the identity creation stuff that we had. I think I was doing like 42 last time. I think I was doing 41. This was like it's asking me to create the identity. This is stuff that's been demoed a couple of times. I can fund this and then it will create an identity. I have not yet fixed the issue with asset locks. At this point, I'm not going to actually try to create one. But you can see that at index 40 on the wallet, I already have an identity and we can use that index to create a data contract. And of course, something is broken. Maybe we're not going to be able to demo this today. I've been messing around with my code base too much. But long story short, I have the code working in a browser most of the time.

[00:55:13.02] - Rion Gull People can review the. The previous video in this.

[00:55:15.13] - Matt Look. Go look at my last video. Okay.

[00:55:22.13] - Rion Gull Yeah. So what. What else did you want to. To discuss?

[00:55:28.27] - Matt Sure.

[00:55:29.09] - Rion Gull Do we want to move? Yeah, because I. I at least want to discuss the proof system, because that's kind of one of the major things that is still in the roadmap with you having done the Create identity, Create data, contract, Create document against that contract. That's showing that there's a very clear light at the end of the tunnel as far as getting Dash platform Support in your JavaScript SDK. It's just a matter of creating more convenient abstractions on top of that for a better developer experience at this point in terms of that. But what else did you have to talk about, if anything, before we move on to the discussion of the proof systems?

[00:56:21.08] - Matt Well, I guess we were going to talk more about extension. We're going to talk more about SDK integration stuff a little bit later. Right? Or do you want to do that now and do proofs after that?

[00:56:32.23] - Rion Gull Either way, whatever you think is best.

[00:56:36.04] - Matt Well, I'll show you what's on the screen now. Proofs keep coming up every time we talk about the JavaScript SDK that I'm building. Every time I mention it, somebody says, what about proofs? What about proofs? What about proofs? Why do we even care? For example, what if I called the Dash API and this was the implementation of the Get Balance function? I say, hey, what's my identity's balance? And it says five. Cool. How do we know that that's right. How do we know that that's correct? How do we know that that's up to date, all that stuff? That's what proofs are all about. Proofs are all about. What does the dash network quorum actually believe that your identity balance is right now at the most latest block. That's what proofs are all about.

[00:57:26.26] - Rion Gull Why don't you describe how you get that data in the first place?

[00:57:30.14] - Matt Yeah, so we do. I think it's this one right here where. This is where I'm getting a slightly different thing. I'm asking for the nonce. But we find an existing identity, and once we get that identity, then we send this RPC call directly to one of the platform masternodes and we say, what's my current identity, nonce or balance or whatever? So we're sending a message over the Internet and it's sending it back and it says, here's what your balance is. Here's what your nonce is. Whatever you're asking for here. In this case, we asked for it and then it says here it is.

[00:58:13.28] - Rion Gull That one node said, here's what it is.

[00:58:16.07] - Matt That one node said, that's what it is. You got to think about like, maybe we don't want to have those nodes publicly accessible at some point because that means they're easily like, they're easily targetable by denial of service attacks and things like that. So maybe at some point in the future it's actually not an actual master node and maybe it's like a follower that just has all the data, has access to everything. But it's not one of the masternodes and nobody cares if it goes down because it's not important for the network to function. So there could be a front end caching node that we're asking instead. The point is that shouldn't matter. We should always be able to get a proof that the network actually believes that that is the correct value and that's what a proof is.

[00:59:11.17] - Rion Gull Let's rephrase that again, or emphasize it again. What a proof is is a proof that not only a single node thinks that some data is some value, but also the whole network accepts that that specific data is a specific value.

[00:59:29.16] - Anthony Campolo Right?

[00:59:29.28] - Matt Correct. And if you use that information to create a transaction, you'd be guaranteed that that transaction is going to work unless something else has changed in between you asking and, and getting that. But assuming you're the only one that has access to that key and you send a transaction, you should be guaranteed that that's going to work because you just asked the network what your balance was, and you know that that's. That it's been proven that that's actually what your balance is. So in this case, like, there's. There's two different options you can get. You can ask it to just give you your balance, your. Your balance or your nots. And then in that case, it just gives you a number. But you can also ask for a proof. And when you get a proof, it's this giant pile of cryptography stuff that you have to look through and check that the proof actually does say what you expect it to say based on what you asked. Every time we talk about the JavaScript SDK, they always ask, well, what about proofs? What about proofs? That has to be done. And so I've heard this so many times, and people seem to think that it's super hard, and I still kind of think it's not that hard.

[01:00:45.06] - Matt It's definitely work, but it's not like, impossible to do. And so I decided to just try it and see how far we can get. And so I want to preface all of this. This is very rough. This is not complete. It's not checking everything it's supposed to. It's more of a proof of can it be done? Rather than is it good yet? If that makes any sense. So this is. This is some code that's walking through an example. This is actually the same. I don't know if anybody any of you saw, but Mikhail posted the proof of concept with their wasm proof findings that they're going to be using in their SDK in a few weeks. This is actually using the exact same identity and the exact same proof that they were verifying. Just to show that this is a real example of something. All of that proof information is in this file that we're reading. Then what we do is there's a couple of layers to this proof. The, the main, the layer that like, goes to everything that we're. That we were talking about. Does the Quorum actually believe this? Does the Quorum actually, like, this is what the Quorum actually knows to be true.

[01:02:06.11] - Matt And the way that you get that is the Quorum has a public key that they all kind of work together to. To make signatures that follow this public key. And so this kind of goes back to.

[01:02:15.20] - Rion Gull It's a quorum public key in the sense that the whole quorum has arrived, has to prove that the nodes all

[01:02:24.12] - Matt have to work together in order to produce these signatures that match this. This public key. There's Some like threshold. I don't remember how many nodes have to work together. Some percentage of them have to work together in order to do this. So these are, these are BLS signatures. You don't need to know what that is. It's a cryptography thing. But long story short, we're passing the signature from the proof and this other hash and making sure that the public key matches the signatures. We'll go backwards.

[01:03:01.09] - Rion Gull It says prints out verified at the end I saw.

[01:03:03.25] - Matt Right. It prints out verified true. Just to talk about what things would go into this. And I'm not an expert in all of this, so I'm just kind of explaining what I understand here. But we have this structure called a canonical vote. And I think the thing that makes the most. The thing that we need to care about right now is the state ID hashes here. We also know which block it came from. We have the hash of the block, we have the height of the block, so we know where that's coming from. We also know which chain ID that comes from. But then there's a state ID hash and the state ID has some other metadata in there, like what time it was made, also, again, the height. But we also have this root hash. This root hash is the root of the grovedb Merkle tree that has all of the data that the platform has stored in it. That's what this hash is referring to. You have to have all of the data or at least a portion of the hashes to be able to create this hash. So then what we do after that is we take it apart.

[01:04:19.14] - Matt The proof comes in layers. Let me show you here. What we're doing when we ask for the identity balance, what we're doing is we're asking for a subset of this, this, this database, this Merkle tree, where we just want a piece of it. We don't want the entire database, we just want the piece of it that proves that we're getting the part that we wanted. So what the platform code does here is it creates a path. And this path has, sorry, this one, we have this root tree and there's a couple of different kinds of trees that are in here. And, and we specifically want the balances. So we're going to go into the balance Tree, which is 96, which is 60 in hex, 96 is in decimal. So we're going to go down this path, the balances path, and then we're going to ask for this particular identity in the database, which you would have known because you asked for it. But this is the hard coded identity that was given to me. And it only just now occurs to me that this doesn't match. And I think that's because it's being encoded in a different way.

[01:05:40.17] - Matt This is base 58, whereas this is hexadecimal. But anyway, we're asking for that identity in this path and then what we get back is a proof that takes apart the Merkle tree for just the parts of this that we asked for. At layer one we're going down 60, which is the balances tree. Then the second layer we're going through and we're looking for that particular identity id. Inside that identity id we have this value and this value is encoded and we take that apart and we get this as our current balance. The important thing is that we have all the hashes for everything on all the different sides of the tree and the bounce down in the middle. So as we recombine the hashes all the way up the tree, we zip it back up, we get to the same root hash that was encoded in that proof. You can see here that we have this hash is the same root hash that was encoded in that state id. I know that was super confusing and all over the place. This is very bad code. I did this last night, really late night, getting all this workings together.

[01:07:00.24] - Matt Please don't think this is the final state of everything. All I'm doing is showing that we can take apart the proof and we can find the information inside and we can verify that it's all there. Very much not done.

[01:07:16.20] - Rion Gull Yeah, well that, yeah, you've, you've actually taken it further than I, I thought you would. I had no idea that you would be working on proofs even yet. So the fact that you've got the proof of concept for proofs relatively worked out as a proof of concept, that's significant in my opinion. And I know that you've mentioned several times before that proving something involves more than just, you know, comparing Merkle hashes and seeing that they're the same.

[01:07:49.15] - Matt Right.

[01:07:49.24] - Rion Gull Do you want to talk about that? I also know that you've got a stop coming up soon here, so I

[01:07:55.21] - Matt can do that real quick.

[01:07:56.16] - Rion Gull Give us, give us that, that explanation real quick. And then I have some, some things to say. You can. You feel free to drop out when you need to though.

[01:08:05.00] - Matt So the analogy that I want to give here is if you go to the airport and you try to get on an airplane and they ask you for your airplane ticket, what they're asking for is a proof that you're allowed to go on that airplane. A proof that you paid to go on that airplane, if you hand them your driver's license, that is a valid proof is a valid proof that you are allowed to drive a car in that country, at least as of whatever date is on that, that, that that driver's license, it is not an airplane ticket. And if they ask you for an airplane ticket and they, and you hand them your completely valid driver's license, they're going to look at you funny and they're going to kick you out. And it's the same kind of thing here. We're getting a proof. We can verify that the proof came from that quorum. We can verify that the hashes that they gave you are correct. But if you don't check that the hashes they gave you are for the identity you asked for, you're getting the wrong proof. And it doesn't matter how valid that proof is, if you don't verify that it is the right proof for the thing you asked for, then you're still not.

[01:09:20.02] - Matt It's not actually helping you. And so that's the three parts. I say that we need three parts to this. We need to verify that it came from the quorums public key. We need to verify that the hashes all validate to the same root hash. And then we have to verify that the query matches the proof. And the query matching the proof is kind of a little bit tricky because these queries can include things like range queries. These proofs can be combined. If you example, ask for your identity and a document at the same time, the proof is going to have both information in it and you need to be able to check that all the parts that you asked for are there. There's some tricky stuff that, like if you say if there's an index in a DITA contract and you ask for all the names between all the names that start with B, for example, the proof is supposed to show you not only all of the names that start with B in that proof, it's also supposed to show you the names that start with one of the first name that starts with C and it's supposed to show you the last name that starts with A because that way you know that it didn't skip some of the bees and only show you some of them.

[01:10:30.03] - Matt There's a lot of nuance there to making sure that you actually got the query or that you actually got the proof you're supposed to. In my code, I'm printing out all of the information you can see it all in the terminal. I'm not actually checking any of it. That stuff is definitely not done yet. It will need to be done before we can say that this is ready. But this, this, what I'm showing here is that we can do it in JavaScript. I understand what's going on. I can write the code for it if I can get funding to do that.

[01:11:04.07] - Rion Gull Yeah, and right now you're just going to be. We're going to be working on fumes, even if my proposal does pass to get you to continue to work on this throughout this month. But the plan would be that next month you submit your own proposal to continue the work. So this month will be kind of like proving, extending the proof of concept to something that's more usable to developers. I know that this proof stuff is very nuanced because for a lot of people the proofs aren't even really necessary in order to get some of the value out of what Dash Platform is giving you.

[01:11:50.15] - Matt If you don't care about trust, you don't need proofs.

[01:11:53.04] - Rion Gull Exactly. And a lot of my target market with the Web2 developers, they aren't going to care a lot about any of this. And so even if we didn't get the proofs done, the fact that you can create a schema, which we call a data contract on Dash Platform, in a permissionless way, and all you have to do is pay a few cents to do that, it's a very simple to use SDK and you can verify by going to platformexplorer.com which Mikhail made, and see that, hey, that thing that I just wrote in code, it actually showed up in somebody else's interface. That's proof enough for me that things are working and then I can have the users of my app create, create documents against that schema. And all of that is extremely valuable if you can wrap it in a good developer experience. Even without proofs, these formal proofs. I just wanted to mention that at the very end as well, that this proof system is like icing on the cake. But don't forget that the cake is valuable and nice to have. Even without the proofs.

[01:13:01.08] - Matt Proofs will never add functionality, Right?

[01:13:04.14] - Rion Gull Exactly.

[01:13:05.05] - Mikhail So.

[01:13:05.17] - Rion Gull So the proof system in general as a whole is more about the Web3 crowd that really has some absolutely necessary critical data application that you need the proofs for specific, very specific reasons. And I do think that there are valid use cases for that, but I think that there are a lot more use cases that are going to be achievable without proofs, but you still want a good developer. Like, developer experience is in my opinion even more important than some of the proof stuff. If we can get it all, great, but with limited resources, you have to prioritize certain things in certain orders. I think that's about all the time that we have today. But I wanted to open up to anybody else to say anything else that they wanted to. And we also have top shelf anarchy saying, hey Dash, folks, you all should pursue getting DASH on Cake Wallet, which, you know, sure, it's a permissionless system also, so feel free to integrate it if you are part of Cake Wallet. But anything else that anybody else wanted to say? Any. Yeah, any questions from.

[01:14:24.05] - Mikhail Yeah, I have a question to Matt about this verification that has to be implemented. What do you expect? How much of the work are there necessary? Like one month, two months? Do you have any expectation how, how easy will it be?

[01:14:45.23] - Matt That is a very good. I think if I was able to work on this full time, I could do it in less than a month, maybe a month. I don't know. It's hard because I would really like, if I was going to, if I was going to come on record and say that I actually did trust this code, I would want to have like, I would want to be really darn sure that everything was there. I would want to have tests for all the edge cases. It's not, it's not, it's not nearly as easy as what I've just shown here, which was mostly just taking apart everything and just hashing it again. So I would say a month is probably, it's probably decent. If I was only doing proofs like the whole time, I could do that.

[01:15:37.09] - Rion Gull And I would probably add to that

[01:15:38.26] - Mikhail that,

[01:15:41.04] - Rion Gull you know, having proofs for the whole surface area of platform is one thing. With all of the edge cases ironed out, that's one thing. Having ironclad proofs for three things, that's another thing. And I don't think it's going to be this thing where there's a specific deadline and you get all of the whole surface area done. It would be more of a gradual thing where after one week you've got a very good proof system for creating an identity and verifying its balance.

[01:16:11.15] - Matt Absolutely. We don't need to do the complicated range queries for things like just checking out an identity balance. So those, those verify verification is much easier.

[01:16:26.06] - Mikhail Great, great. That's really, really nice to hear all of this.

[01:16:35.00] - Rion Gull Okay everyone, thanks for, thanks for joining our show today. There are, or at least should be more questions about this SDK stuff because there's a lot going on. But I'm. I'm very confident in both of you guys. Mikhail, you and your team are doing a great job with your approach. And Matt, I have full confidence that you can accomplish anything that we. I throw at you. That's. That's been my experience so far and, and actually more than that. So, yeah, just thank you guys both for your work. And as far as I'm concerned, I just want a good product that I'm not embarrassed to share with people that have high standards. And I think that that's what we. That's the kind of. That I have. So, yeah, we'll see how things go in the next few days as far as funding goes, and we'll keep plugging away. Thanks, everybody, for joining us. And join us next time for some updates from both of these guys. And Anthony, hope your proposal goes through well as well, because getting real products in front of a good wide developer audience is very important as well. So catch everybody next time.

[01:17:52.26] - Mikhail Thanks.