Dash Platform Walkthroughs Part 2b with Nick Taylor

Episode Description

Anthony Campolo and Nick Taylor continue their Dash Platform tutorial walkthrough with Rion Gull, registering names, creating data contracts, and exploring the platform's two-blockchain architecture.

Episode Summary

This second installment of the Dash Platform tutorial walkthrough picks up where network issues forced the previous session to cut short, with Anthony Campolo guiding Nick Taylor through the remaining setup steps after successfully creating an identity. The discussion centers on understanding the conceptual differences between wallets and identities, with Rion Gull providing detailed explanations of how Dash operates two separate blockchains—a proof-of-work chain for funds and a proof-of-stake platform chain for data—connected through a credit-locking mechanism. The participants work through retrieving identities, topping up credits, registering a name (jakeperalta.dash), and creating a data contract with a defined JSON schema. Along the way they encounter naming regex constraints, network slowness, and TLS errors that require retrying operations. Rion clarifies that Dash uses data contracts rather than smart contracts, providing decentralized database functionality without executable methods. The session also touches on an active proposal to accelerate platform mainnet release, which would resolve many of the testnet stability issues the team encountered during the walkthrough.

Speakers

• Anthony Campolo
• Nick Taylor
• Rion Gull

Chapters

00:00:00 - Reconnecting and Reviewing the Identity Creation

Anthony welcomes viewers back for the second part of the Dash Platform tutorial, noting that network issues had previously prevented progress past identity creation. Nick reflects on the experience of digging into new technology despite blockchain's mixed reputation, expressing genuine curiosity about exploring the platform. Rion jokes about cracking whips to stabilize the network, and the group confirms they successfully completed a speedrun of the early tutorial steps before going live.

The team revisits the identity creation code, walking through how the simple register function on the platform client returns an identity that gets logged with a link to the Platform Explorer. Nick pulls up his identity in the Explorer interface, noting it's built on Next.js, while Anthony explains that the identity create transaction was logged on the blockchain seven minutes prior, demonstrating the transparency inherent to blockchain systems.

00:04:23 - Block Explorers and Multi-Chain Tools

Anthony introduces the concept of block explorers as essential tools for blockchain interaction, explaining how they exist for Ethereum (Etherscan), Bitcoin, and other networks since blockchain data is publicly accessible to anyone willing to build a frontend with search functionality. He outlines the various sections of the Platform Explorer including blocks, transactions, data contracts, and identities that the tutorial will reference as they progress.

Nick asks whether the explorer is Dash-specific, prompting Rion to introduce Blockchair as a multi-chain alternative that capitalized on typing mistakes for early SEO advantage. Rion provides extensive context about Dash's dual blockchain architecture, distinguishing between the original proof-of-work chain and the upcoming proof-of-stake platform chain, where validators are specifically EvoNodes—a subset of masternodes—rather than traditional miners.

00:09:57 - Masternode Architecture and Platform Explorer Origins

The discussion moves into how masternode redundancy provides security and reliability, with Rion explaining that hundreds of nodes could fail without compromising the network because thousands run the chain simultaneously. He notes that the Platform Explorer they're using was built by Mikhail Shenmik from the Dash Incubator, who runs a node listening to public network traffic and indexes blockchain data into a local database surfaced through the Next.js interface.

Nick recognizes the white 404 error page as characteristic of Next.js applications, drawing on his prior experience working on the frameworks team at Netlify. The team transitions back to the tutorial to retrieve identities, with Nick creating a new script that calls the platform API. He's surprised to discover his account has two identities rather than one, which Anthony attributes to possibly being a remnant from the previous failed tutorial attempt.

00:15:33 - Wrestling with Wallet vs Identity Concepts

Nick navigates to the Dash documentation to understand identity definitions, expressing genuine confusion about how identities relate to wallets. He reads through the platform docs explaining identities as low-level constructs based on public keys, but finds the explanation insufficient for distinguishing them from wallets. Rion suggests checking the concepts section for better conceptual overviews while acknowledging he's testing the documentation alongside the code in these livestreams.

The conversation reveals fundamental documentation gaps, with Anthony noting that while the docs are comprehensive, they lack easy navigation and clear hierarchical explanations of terminology. Rion explains that wallet terminology varies by user—some think of it as the 12-word seed phrase, others as a public-private key pair, and others as the user interface itself. The team agrees a clear hierarchy diagram showing how seed phrases derive both fund-related keys and platform identities would significantly improve onboarding.

00:24:36 - Understanding Credits and the Two-Chain Bridge

Rion provides a detailed conceptual explanation of how Dash funds move between the two blockchains, describing how the testnet faucet provided proof-of-work Layer 1 funds that can be locked through a special transaction. This locking mechanism makes those funds unusable on the proof-of-work chain while simultaneously unlocking corresponding credits on the proof-of-stake platform chain, with the same process working in reverse to convert credits back to spendable Dash.

He uses the analogy of exchanging dollars for one-cent pieces at a bank to illustrate that credits are simply a different denomination of Dash existing on a different chain. Nick confirms his understanding that freezing funds on one chain unlocks them on the other as the exchange mechanism. The team then moves to the top-up identity script, which iterates over the user's identities and adds credits, with Nick humorously noting he gets to top up with what he initially thought was a billion units.

00:30:01 - Duffs, Credits, and Name Registration

Anthony directs Nick back to the blog post for the explanation of credit denominations, where Nick reads that one Dash equals 100 million Duffs (Dash's equivalent of Satoshis), and 100 million Duffs equals 100 billion credits. They share a laugh about whether Duffs reference Duffman from The Simpsons, with both confirming that was their immediate thought. The conversation explains that interacting with platform applications decreases credit balance, requiring periodic top-ups.

The team transitions to name registration, which requires adding a chosen name to the environment variables. Nick decides to register Jake Peralta as a Brooklyn Nine-Nine reference, but encounters a regex error because the tutorial used underscores in the example label. Anthony acknowledges this as a tutorial bug worth fixing, noting names accept only characters, numbers, and dashes, with dashes prohibited at the beginning or end of names.

00:36:55 - Mainnet Release Proposal and Reconnection Issues

While Nick experiences a USB headphone failure that briefly interrupts the stream, Rion takes the opportunity to show Anthony a proposal on dashcentral.org from Quantum Explorer at Dash Core Group. The Evo Accelerated Release Schedule proposal asks the network to launch platform on mainnet rather than continuing on testnet, accepting that some originally planned features would be missing and accepting slightly higher risk of platform halts, though without jeopardizing Layer 1 stability or platform funds.

Rion explains that approving this proposal would resolve many of the testnet issues affecting the tutorial, with a target timeline of mid-to-late July. Once Nick reconnects with a different microphone, the team returns to running scripts, successfully registering jakeperalta.dash and viewing the result on the Platform Explorer, where the connection between identifiers and human-readable labels becomes clearer.

00:43:25 - Name Resolution and Data Contract Concepts

After successfully registering the name, Nick runs the retrieve name script which resolves jakeperalta.dash to the underlying identity. He initially confuses the owner ID with his wallet address, prompting Rion to acknowledge that using inconsistent terminology like "identity ID" versus "owner ID" for the same string causes unnecessary confusion in the documentation. The team agrees uniform naming would significantly improve clarity.

The discussion moves to data contracts, which Nick initially compares to smart contracts. Rion provides a crucial distinction: while smart contracts have both methods and properties allowing execution, data contracts contain only data fields without any execution capability. He frames this as Dash Platform being the Web3 equivalent of a decentralized database rather than decentralized cloud functions, eliminating the possibility of bugs that could siphon funds since no executable code exists in the contracts themselves.

00:53:46 - JSON Schema Validation and CRUD Operations

Nick examines the contract registration code, which defines a note object with a message property of type string at position zero. The team puzzles over what "position" means since Anthony asked about it before the stream and was told it had been added only days earlier. They focus instead on understanding the contract as JSON schema validation, where the user defines that the contract holds notes with specific structured properties.

Rion clarifies that the platform itself performs CRUD operations rather than user-defined methods, with optional configurations for whether documents can be updated or deleted. Nick connects this to how a note-taking dApp would work: requesting the contract retrieves the schema template, and the chain validates new notes against that schema, rejecting invalid submissions like notes missing required messages. The contract registration succeeds but the script hangs without completing properly.

01:00:09 - Network Errors and Contract Creation Retry

Nick attempts to retrieve the just-created contract but encounters a TLS error indicating the operation was not permitted. After multiple retries failing with the same error, the team checks the Platform Explorer and discovers the contract wasn't actually registered despite the script outputting a contract ID. Anthony realizes the issue: the contract ID is client-side derived before the chain confirms registration, and Nick's earlier interruption of the hanging script prevented the actual publish step from completing.

They run the create contract script again, this time waiting through the lengthy network delay. The team discusses whether two different identities creating identical schema would generate the same contract ID, with Rion guessing the IDs would differ to prevent collision conflicts. Mikhail joins the chat as the team waits, providing context about SDK execution hanging due to syncing transactions from the seed phrase to the latest block.

01:08:00 - Successful Contract Creation and Wrap-Up

The contract creation finally completes after roughly five minutes, allowing Nick to retrieve it successfully and view it on the Platform Explorer. They examine the contract details including the identifier, owner identity, system field showing false (indicating user-created rather than network-blessed contracts like DashPay), creation date, document count of zero, and revision count showing one due to the duplicate creation attempt. Nick then successfully runs the update contract script, adding an author field to the schema.

The team agrees to continue with a Part C session to complete the remaining tutorial steps including writing to the contract and building the Express backend with React frontend. Rion announces that another developer will attempt the tutorial the following day, joking about who can finish in just Part A versus needing to extend to Part C. Nick maintains his open-minded approach to exploring blockchain technology despite current sentiment, and the stream ends at 01:16:43 with plans to preserve the project state for the next continuation.

Transcript

00:00:02 - Anthony Campolo

Alright, we are live. Welcome back to Part B of Part 2 of Dash Platforms.

00:00:13 - Nick Taylor

Appendix A.

00:00:15 - Anthony Campolo

And this time the network works. So, Nick, welcome back. For those who did not see our first part, we are running through our Dash Platform tutorial, which gets you started with doing everything on Dash Platform. We went through the first part of the tutorial with Nick last time. We made it up to creating an identity, which has been a kind of sticking point as a difficult thing for the network to handle for whatever reason. This is something that I was kind of dealing with as I built this tutorial. So we tested it out right before we went live and it seems to be working. So, Nick, you want to give any kind of thoughts or just things you felt after the first time and things you're looking forward to for this time?

00:01:00 - Nick Taylor

Yeah, it's always fun digging into interesting technology. I know blockchain's got a bit of a rap at the moment, but regardless of that, I'm always just curious to try out stuff. And obviously we didn't accomplish what we wanted to do last time. There were some network issues, like you mentioned, Anthony, and stuff. But, you know, we gave it a good go. And I think Ryan went back with some feedback, and I think some things got stabilized in the network.

00:01:29 - Rion Gull

I'm guessing if I were only so powerful.

00:01:33 - Nick Taylor

Yeah, well, there's some good karma today.

00:01:38 - Rion Gull

I cracked some whips and things are in line now.

00:01:41 - Nick Taylor

Yeah, so, um, yeah, so I guess, do you want to let them know, Anthony, how, like, where we are, I guess, right now? Like, we, because we did part of the tutorial in a speedrun just before the live stream.

00:01:53 - Anthony Campolo

Um, yeah, yeah. So basically, we created a wallet, we put testnet funds into that wallet with the testnet faucets, and then we created an identity. So just real quick, let's just look at the code for the create identity one specifically and kind of go over what's happening there. Yeah, cool. Scroll up to the top.

00:02:17 - Nick Taylor

Oh yeah, sorry. Yeah, great.

00:02:20 - Anthony Campolo

We're importing our client, which is what has our wallet mnemonic. That's how you authenticate yourself. Then we're just running— this is really simple. It's literally just run a single function which is .register on identities.platform.client. Then you have your identity. Then it console logs out the identity ID. Something we haven't done yet actually, which we should do— it also gave you that link to the Platform Explorer. Let's take your identity ID, put it in that URL and we can go look at it on the platform. This is the new Explorer, which is different from the one we were using when we got the testnet funds on. This is going to be more specific to the identities, the documents, and the things like that.

00:03:10 - Nick Taylor

That 404 is— it's because I don't have my ID in there yet.

00:03:14 - Rion Gull

Yeah, it's in your terminal.

00:03:16 - Nick Taylor

Oh, okay. Sorry, sorry.

00:03:17 - Anthony Campolo

Or your .env, either place.

00:03:20 - Nick Taylor

Oh, I think it got— I cleared my terminal. All right, identity.

00:03:24 - Anthony Campolo

There we go.

00:03:25 - Nick Taylor

Uh, well, right away I can tell they're using a Next.js site. Um, okay, so all right, let's load this up. Okay, so here, I'll make this a bit bigger so we can see.

00:03:39 - Anthony Campolo

Yeah.

00:03:40 - Nick Taylor

Oh, that's a little too—

00:03:40 - Anthony Campolo

yes, we see here. Yeah, that's perfect. Yeah, so we got your identifier, you can see your balance, and then the identity create. You can see that that just happened, what, 7 minutes ago. So if you click on identity create, you can see more information about that specific transaction on the right.

00:03:58 - Nick Taylor

Okay. Yeah, okay.

00:04:01 - Anthony Campolo

So what these are— basically every time you do an action, it's all logged on the blockchain. So this is like the cool thing about blockchains is that they're very transparent, they're very inspectable, and you can kind of just go in and see what everyone is doing. And then obviously there's ways to have privacy with things like CoinJoin and stuff like that.

00:04:23 - Nick Taylor

But, um, have you ever used a block explorer before, Nick? Uh, I don't think so, unless we did in the tutorial last time.

00:04:34 - Anthony Campolo

But yeah, just that was just the— this is the one time when we checked your funds. Yeah, these are really important tools for blockchains in general. Like, if you're using like Ethereum, there's Etherscan, and Bitcoin has their own, and there are things that anyone can make because the blockchain is just this thing out there with all the data and someone just has to basically make a front end that has some sort of search functionality to it. We'll be referencing this as we go through all the next steps because we'll be creating data contracts. If you see at the top, there's home, blocks, transactions, data contracts, and identities. And if you go to the API, you can kind of see all the different things that are viewable here. So you can even check the status and things like that.

00:05:33 - Nick Taylor

Okay. And this is— we're on the Platform Explorer. Is this specific to only the Dash network? Because from what I remember, I think from blockchains, like, you typically wouldn't have, like, an Ethereum and a Dash on the same network, I don't think. Or is that possible?

00:05:57 - Anthony Campolo

Yeah, so you're totally right. Yeah, so each blockchain is kind of an island of itself in one sense. So it's this network, a bunch of computers talking to each other, they're syncing with each other, they're validating each other's blocks, but they're all just doing it in the confines of whatever blockchain, whatever cryptocurrency they're using. So there's other kind of like multi-chain things out there that can combine different chains, or there's some chains that are made so that you can have kind of different cryptocurrencies on the same chain. But this Dash is like, it's like old school. It's like Bitcoin. It's just its own chain. And if you want to work with other things like Ethereum or Bitcoin, you can use kind of like services that will translate between the two, or DEXs, decentralized exchanges, stuff like that.

00:06:48 - Rion Gull

I will, um, I'll jump in and give a little bit more context there as well.

00:06:52 - Anthony Campolo

Okay, thanks.

00:06:52 - Rion Gull

If you could, if you could open a new tab on your web browser and go to blockchair.com. Um, Blockchair— these guys obviously were capitalizing on muscle memory mistakes when people—

00:07:10 - Anthony Campolo

I've never heard of Blockchair. Blockchair.

00:07:13 - Rion Gull

So blockchain obviously is the closer word that you're familiar with, but sometimes when you're typing, instead of like your muscles just take over, instead of writing chain, you write chair. So these guys got some SEO boost early days from that alone. But in addition to that, they also have one of the best blockchain explorers out there because they are multi-chain. Yeah, so they've got Dash. And just as a refresher from some of the things we discussed last time, Dash has actually two blockchains in the Dash ecosystem. There is our first blockchain, which was the proof-of-work chain, and that's what you would see here on Blockchair, the proof-of-work typical Dash blockchain. But then coming up very soon, we also have this second blockchain that will soon be on mainnet that is now on testnet, and that's our platform blockchain, and it's a proof-of-stake blockchain where the validators, which is a term for the node operators in proof-of-stake chains— it's similar to miners in proof-of-work chains. But the validators on Dash's proof-of-stake chain, which we call the platform chain, which is for data, which we'll get into a little bit more in this video today— the validators are masternodes, and not only not all masternodes, but a specific subset of masternodes called EvoNodes. So I'm going through a lot of terms here. You don't have to remember them all. There will not be a quiz, but just for anybody that's interested, and you too especially— how it works. So you will not see the platform on— you will not see a platform Block Explorer on Blockchair because it's just not even on mainnet for one. And when it is on mainnet, it would be something that we would have to partner with them to get their engineers to inspect our proof-of-stake blockchain and index it and surface it to their user interface and things like that. But they could, and that's what— to Anthony's point, all of it's public data that anybody can tap into. So, but they do have our proof-of-work chain, obviously.

00:09:57 - Nick Taylor

Cool. And just a quick question— the validators you're speaking of, they're on masternodes because it's super critical work, so you need it on something that's guaranteed to be up? Like, I imagine there's like a failure mechanism for the masternode if one goes down, like some kind of round robin or some kind of networking thing going on there. But yep.

00:10:18 - Rion Gull

Yeah. So all the masternodes, all the validators, they host the same blockchain. And so if one goes down, it's no problem. You know, hundreds, hundreds could even go down in our proof-of-work chain and that'd be no problem because we have thousands, literally thousands running the chain.

00:10:35 - Nick Taylor

Okay.

00:10:36 - Rion Gull

So that's part of the security and reliability that's built into blockchains. So let's go back now. I just wanted to show you that, you know, there are like total third-party block explorers that can just tap into any blockchain and surface lots of different blockchains.

00:10:54 - Nick Taylor

Okay.

00:10:55 - Rion Gull

One user interface. So, but this particular block platform explorer website, this was built by Mikhail Shenmik. He's part of the Dash Incubator and he's one of our other strategists. So he made this site and he did that by running— he does that by, uh, he has a node that's running and he's seeing blocks of data come through on the public network. So he's listening to the right traffic on the right ports and things like that. And then he— you can just index whatever data you're interested in, throw that in a local database, and then surface it to this user interface, which you correctly identified as being a Next.js app.

00:11:41 - Nick Taylor

Yes. I used to work on the frameworks team at Netlify, but also that white error page, the 404 is pretty common. It's kind of like when somebody goes, oh yeah, that's a WordPress site.

00:11:54 - Anthony Campolo

Yep.

00:11:54 - Rion Gull

So enough of the boring stuff out of the way. Let's maybe get back into some action with the tutorial and see if we can— we've now got past the step that we couldn't get past last time. We registered an identity, we've got an identity ID, and now we can start doing things with that identity.

00:12:12 - Nick Taylor

Yeah, cool. All right, so you just take it, just follow along from here.

00:12:17 - Anthony Campolo

I'll just kind of observe, and if things go wrong, then I'll hop in.

00:12:22 - Rion Gull

And I'm gonna go grab some water.

00:12:24 - Nick Taylor

Okay, cool. Early, we saw a few transactions. Cool. Yeah. Okay. We already saw my ID in the list. So that's all good. Okay. Yeah. This is just what we were kind of showing before. Okay. So let's go ahead and create a new file here.

00:12:44 - Anthony Campolo

What do you think it will do?

00:12:46 - Nick Taylor

Yeah, yeah. Is the browser still pretty readable? Or I'll make it a bit bigger, actually. There. Yeah.

00:12:55 - Anthony Campolo

That's probably fine.

00:12:57 - Nick Taylor

Just, uh, it's my paranoia from live streaming, always making sure people can actually see what I'm doing. Um, okay, cool.

00:13:05 - Anthony Campolo

All right, and it sounds like also my internet is going in and out. I'm at a hotel right now with some hotel Wi-Fi, so if I totally crap out, then you can continue on. I'll come back in whenever.

00:13:19 - Nick Taylor

Yeah, yeah, no worries. Uh, cool. All right, so I'm just following instructions here to create a script to retrieve the identities. And I imagine, yeah, we'll have an npm run get identities. So let's make this— I'll just make this bigger so we can see. All right. So this is going to retrieve my identities, I believe. I'm assuming that means my wallets. Is that— identity is wallet, obviously, right?

00:13:50 - Anthony Campolo

Or you should explain the difference between a wallet and an identity, Ryan. You'll probably be able to do it better than me.

00:13:55 - Rion Gull

Let's see what the docs have to say about it.

00:13:58 - Nick Taylor

Okay, cool. All right, cool. So yeah, so this is retrieving them just like when we were creating the identity. I think it just takes a bit of time. Also, I imagine running on a testnet or a devnet would run slower than production as well. So because it's— but yeah, okay, cool. So we'll just let that finish running.

00:14:24 - Rion Gull

Yeah, I don't know actually where the speed issue is coming from. It's something I would like to look at.

00:14:31 - Anthony Campolo

You go back to your client real quick. Let's see where you're syncing to.

00:14:37 - Nick Taylor

Yeah.

00:14:38 - Anthony Campolo

Yeah, that should be— that's like very, very recent.

00:14:41 - Nick Taylor

Yeah, it's the— yeah.

00:14:42 - Anthony Campolo

Okay.

00:14:43 - Nick Taylor

Yeah. And my internet's pretty fast. I have like gigabit up and down, so it's definitely not on my end. Uh, yeah, can do, can do a speed test, but I'm pretty sure we're good. Okay, so we'll just let that go.

00:14:56 - Anthony Campolo

We can go to the docs to look up the identity definition while this is happening.

00:15:03 - Rion Gull

All right, docs.dash.org. I'll give you the shortcut there. Okay, and then, um, once again, we are— you see now that what we discussed, we've got user docs, core docs, and platform docs. We're going to go to platform docs. This is what we're dealing with now.

00:15:22 - Nick Taylor

All right, so introduction. Oh wait, uh, okay, it looks like we got our identities. So it returned an array of two identities. Um, we can go look at that in a second. So I guess some background information. I'm inclined to look up identity, but, uh, let's see.

00:15:41 - Anthony Campolo

Sure. Yeah.

00:15:42 - Rion Gull

And just for the—

00:15:43 - Anthony Campolo

it's interesting that you have two instead of just one. I'm not sure how that happened.

00:15:48 - Nick Taylor

Yeah. Okay. So, okay. So identities are low-level constructs that provide foundation.

00:15:58 - Rion Gull

Zoom in a bit.

00:16:02 - Nick Taylor

Okay. Okay. So yeah, it's a public key. That makes sense.

00:16:06 - Rion Gull

Uh, sorry, Nick, could you zoom in just a little bit?

00:16:10 - Nick Taylor

Oh yeah, yeah, sorry, man.

00:16:11 - Rion Gull

Yeah, no worries.

00:16:13 - Nick Taylor

Let's make this bigger.

00:16:16 - Anthony Campolo

Boom, boom, boom.

00:16:18 - Nick Taylor

That okay, or a bit more?

00:16:20 - Anthony Campolo

One more.

00:16:20 - Rion Gull

Yeah, that's good.

00:16:21 - Nick Taylor

Well, okay, yeah, one more. Sure.

00:16:24 - Anthony Campolo

There you go. Perfect.

00:16:25 - Nick Taylor

Um, cool. Yeah, so it's essentially— I get that it's a unique identifier for you, so that part I get. I guess you can have more than one wallet associated to your identity, I'm guessing.

00:16:40 - Rion Gull

Just reading through.

00:16:41 - Nick Taylor

Okay, so the ID— okay, whatever. That's some hash calculation. Okay. It's regarding each public key associated with the identity. Multiple identities may use the same public key. I guess that's just for encrypting or not showing they're valid, I'm not sure. I'm definitely no cryptographer expert or cryptography expert, but I do know don't expose your private keys. All right, okay, okay, this is more super technical, so that's less what an identity is. It's, yeah, it's really here— it's a unique identifier, but I guess if I look up wallet, it's going to say you can probably have more than one.

00:17:34 - Rion Gull

Yeah, this is probably going to take you down not a relevant path regarding—

00:17:41 - Anthony Campolo

That GPT gave a pretty good answer.

00:17:44 - Rion Gull

But let's go back to the— I think there's a concepts section in the documentation.

00:17:52 - Anthony Campolo

Okay.

00:17:53 - Rion Gull

And that might be a better conceptual overview, which is what you seem to be looking for. And just so that everybody knows, I'm trying to test the documentation as much as the code in these livestreams. So I want to be able to have people find their answers without—

00:18:13 - Anthony Campolo

Yeah. All the information is in the docs. It's just hard to find. Like, the docs are pretty comprehensive, but they're not easy to navigate.

00:18:22 - Nick Taylor

Yeah, well, I think one thing is, as a user of just like searching a site in general, typing something in here should definitely bring me somewhere relevant for what I'm looking for. Like, when I put in wallet, like you said, there's information about wallet, but it's not like— maybe have a like intro to wallet because this is just like how you fund it and stuff. But like, I mean, I think most people understand the concept of a wallet, but just I'm getting back to my question about the identity and the wallet. So, um, but okay, so you're saying glossary, scroll down the left-hand navigation, and see.

00:19:02 - Rion Gull

So we're in the tutorial right now, and then there's explanations, and under explanations there's identity. So maybe that might be a better approach.

00:19:13 - Nick Taylor

Okay, yeah, so again, like, it's identity so we can identify each other. Um, identities are separate from names. That makes sense because I could have like a vanity name or a username like Nikki T Online, but my actual account is linked to my actual identity. Um, just because it's typically not— I don't think people memorize their identities or wallet IDs usually. Maybe they do, I don't know. Okay, cool. Yeah, so it consists of one or more public keys recorded on the platform chain that can be used to control the user's profile and sign their documents. Each identity also has a balance of credits. Okay, so that's where I'm confused already because the identity saying it can have credits makes me think it's a wallet now. But also maybe credits here is a different type of credits. What is this? Oh, that's weird. That didn't bring me to—

00:20:24 - Rion Gull

Yeah, I think it's one of those weird links that it's just going to pop, do a little—

00:20:29 - Nick Taylor

Oh, it's an anchor tag. Yeah, it's in the page down below. Okay. Yeah. Okay. Oh, yeah. Uh, credits are the mechanism for paying fees that cover the cost of platform usage. Once the user locks Dash on the core blockchain from its ownership, create a top-up credit. Okay, so to me, at least from reading this, it makes it sound like the identity really is the wallet, which I find confusing because I know it's not.

00:20:57 - Anthony Campolo

Yeah, so here's part of the problem. Understanding the difference between the wallet and the identity is something that's pretty specific to the difference between Dash itself and then the Dash Platform and what the difference between those two are. So the wallet is what lets you just transact and have money, and that's like Dash itself. That's the main thing.

00:21:17 - Nick Taylor

Oh yeah, yeah, yeah, yeah.

00:21:18 - Anthony Campolo

Okay, yeah. The platform thing is where we have identities which are going to allow us to create documents, which are going to allow us to persist storage, and allow us to create things like dApps and all that kind of stuff. So I don't think that explanation is anywhere in the docs.

00:21:31 - Nick Taylor

Yeah, okay. Yeah. So, like, wallet is like a physical wallet, whereas my identity is— think of it as like one of the credit cards in the wallet. But the wallet, since the wallet doesn't physically exist, it needs an address. And that's why wallets have an address. And your identity— I don't know.

00:21:51 - Rion Gull

Yeah, they're very similar concepts. They're all based on public-private key pairs. And whether something is a wallet or— the term wallet itself can be confusing because everybody uses it somewhat differently. For example, I think of a wallet as the 12-word phrase because that's what derives your—

00:22:20 - Nick Taylor

Okay.

00:22:20 - Rion Gull

That's what you can derive your public-private key pairs from. But some people think of wallet as like a public-private key pair itself, and other people might think of a wallet as like the user interface that takes in a 12-word phrase or a public-private key pair.

00:22:39 - Anthony Campolo

Or it gets more confusing because you have the 12-word phrase and then you have the address, and you can create multiple addresses in your wallet.

00:22:46 - Rion Gull

Yeah, so maybe what I'm getting from this conversation is it might help to have right off the bat— and maybe it is there and maybe we just missed it in the intro section because that's where it would be— but something that shows like the hierarchy of these terms and these concepts where— yeah, 12-word phrase that you use to derive this and that, which is used to derive this and that. And then on the platform side, you have the 12-word phrase, in addition to deriving wallets or driving public-private key pairs that are associated with funds— they also can derive identities, which can then derive other things that are related to wallets as well. So I'll make note of that and we can move on. But go back to—

00:23:45 - Anthony Campolo

Yeah, last thing to say on this also is that I don't think this is just a Dash problem. This is, I think, a blockchain-wide problem, which is like it's really hard to just explain things in a simple way that lets you get it. Like, it's really— and I've worked with a lot of blockchains, and it's really only through actually going through a tutorial, and by the time you get to the end and then do it a second time, that you actually have a framework where you can kind of put everything in. It's really hard to just give a high-level explanation of this tech because it's so specific and works in a very specific way.

00:24:18 - Nick Taylor

Yeah, yeah, yeah.

00:24:20 - Rion Gull

Okay, so I don't know if you finished with the identity paragraph. Yeah, we should finish that paragraph and then we'll move on to continuing with the tutorial because that might make things a little bit more clear.

00:24:36 - Nick Taylor

Yeah, uh, yeah, yeah.

00:24:40 - Rion Gull

Okay, yeah, each identity also has a balance of credits. Yeah, that's a— no, that's blocking layer 1 funds.

00:24:47 - Nick Taylor

That, that makes sense to me. Um, so let me—

00:24:52 - Rion Gull

Yeah, let me explain that one just a little bit further conceptually, just because it is kind of an important concept. And, you know, we've discussed that we have two blockchains. Um, the proof-of-work blockchain, that's where you're getting funds. So the way that we got testnet proof-of-work Layer 1 blockchain funds is from that testnet faucet. That's how we originally got the Layer 1 funds. Now, when we want to convert Layer 1 funds to the platform chain, which is a completely different blockchain but happens to use the same— well, it doesn't even use the same funds per se. What it does is you can do a transaction on the Layer 1 proof-of-work blockchain that locks funds. It locks funds on the Layer 1 blockchain and says these funds are no longer usable.

00:25:58 - Anthony Campolo

Okay. Okay.

00:26:00 - Rion Gull

And by doing that, you also unlock a certain amount of funds on the proof-of-stake chain. And that's what this whole process— when it says credits, it means Dash that is living on the proof-of-stake chain. And has a certain denomination that we'll get into a little bit. But credits are Dash. They're a denomination of Dash. So you can think of like— you could have dollars in your wallet, and then if you give that to some kind of— you give that to a bank and then they give you 100 1-cent pieces back. Like, that's the difference between Dash and credits— it's just the same money, but it's in a different form, on a different chain, with a different denomination. So that'll hopefully make a little bit more sense as we get through the examples as well. But there's—

00:27:01 - Nick Taylor

Okay, so the credits freezing on the proof-of-work and then having funds accessible on the proof-of-stake is kind of the way of exchanging them, I guess?

00:27:13 - Rion Gull

So there's the same transaction that you can do in reverse where if you want to take your platform credits— the Dash living on the proof-of-stake chain— and convert it back into the Dash that's living on the proof-of-work chain, then you can do a transaction to do just that and move those funds back. So I'll have to think about better ways to explain that, but that's basically what's going on.

00:27:40 - Nick Taylor

Cool. All right, let's get back here and I'll just get my editor back up. Okay, so we got the identities. I have two, and Anthony said he wasn't sure why. I wonder if that's somehow from the last tutorial that didn't work.

00:28:00 - Anthony Campolo

Maybe, I don't know. It could have been because we created a fresh wallet at the beginning.

00:28:05 - Rion Gull

Okay, yeah, I'm a little surprised by that too, but that's because I haven't played around with this that much. That's why we're doing this series.

00:28:13 - Nick Taylor

Okay. So, okay, so this one seems pretty self-explanatory to me. We're gonna create a script called top-up identity. So we're gonna put some Dash in there, I guess. So let's go ahead and copy this. Okay, let's paste that in. So just gonna look at this real quick. So another async function importing from the client API. So we're getting the wallet account and then getting the identities associated to it. Then we're looping or iterating over all the identities we have. And this is a testnet, so I guess I'm allowed to give myself— is that a billion? No, sorry, that's 10 million Dash, I guess, I get to top off. That's pretty sweet for a livestream. Not too bad.

00:29:15 - Anthony Campolo

Those are not Dash, they're Duffs. A Duff is like a Satoshi, which you don't know what that is either, so that doesn't help.

00:29:20 - Nick Taylor

I've heard of Satoshi. He's the supposed creator of Bitcoin, but I guess there's a coin named after him too?

00:29:28 - Rion Gull

So Anthony, just real quick, are you sure that the 10 million is a Duff value or is it a credits value?

00:29:39 - Anthony Campolo

I thought credits are Duffs.

00:29:41 - Nick Taylor

Let's see here.

00:29:43 - Anthony Campolo

I explained this specifically in my blog post, so go back over to the blog post and either scroll up or down.

00:29:48 - Nick Taylor

It's—

00:29:49 - Anthony Campolo

there's a specific explanation for this.

00:29:51 - Nick Taylor

Okay, here. So, okay, okay, 100 million.

00:29:55 - Rion Gull

Go ahead and read it out. I'll read it all out so that, you know, we don't have to rush through this.

00:30:01 - Nick Taylor

Yeah, yeah, okay.

00:30:02 - Anthony Campolo

Yeah.

00:30:03 - Nick Taylor

All right. So it says when an identity is created, a special— here, I'll just make this a bit bigger. Might as well. Boom. So when identity is created, a special transaction transforms Dash into credits, which are used to interact with the Dash platform. One Dash is equal to 100 million Duffs. Is that like Duffman from like The Simpsons? Just curious.

00:30:26 - Anthony Campolo

That's what I thought.

00:30:27 - Nick Taylor

That's exactly what I thought. Dash's version of Satoshi, which is I guess a lower value coin. And 100 million Duffs is equal to 100 billion credits. Since interacting with Dash platform applications decreases your credit balance, at a certain point you need to top off the balance by converting some Dash to credits. And that makes sense, like if you're using it—

00:30:52 - Rion Gull

I just described—

00:30:53 - Nick Taylor

yeah, yeah, okay. And if you're working with a dApp, a decentralized application, right? That's what that stands for. Uh, yeah, decentralized. Thank you. Um, yeah, so it makes sense we have to throw some credit to use it. Um, okay, so we're gonna run the top off here. Let's go back down here.

00:31:15 - Rion Gull

Before we do that, let's open the— did we get a blockchain Layer 1 blockchain explorer working for us?

00:31:24 - Nick Taylor

Uh, which one was that?

00:31:25 - Rion Gull

Which shows the balance of the address that we've funded.

00:31:29 - Nick Taylor

Uh, okay. Oh yeah, uh, we were there before. It's here, I believe. Yep.

00:31:36 - Rion Gull

So let's see how much we have in this address so far, or at this point.

00:31:43 - Nick Taylor

So it says, uh, 4.1712 Dash. This is when we created it.

00:31:50 - Rion Gull

Surprising because it has a final balance of zero.

00:31:53 - Anthony Campolo

Just refresh it. This is old, I think. Okay, it should have been confirmed by now.

00:31:58 - Nick Taylor

There we go, 7.62.

00:32:00 - Rion Gull

Okay, still has zero balance for some reason, so that's going to be—

00:32:05 - Anthony Campolo

I think that might be an error with the UI. This happened to me when I was using this the other day.

00:32:10 - Rion Gull

Oh, you're kidding.

00:32:11 - Nick Taylor

You mean it's not, uh— you mean it's— like, it's okay? No, it's got zero in the markup. You mean it's just calculating something wrong client-side or the APIs?

00:32:22 - Anthony Campolo

If it was zero, we wouldn't have been able to create the identity, so it can't be. Okay, as we know for a fact, it's not zero. That's why I say all this stuff is broken, man. Your whole deal is broken.

00:32:33 - Nick Taylor

Well, this is the summary up top, but can we see the individual transactions? Like, there's 10 confirmations.

00:32:39 - Rion Gull

Yeah, scroll down to the bottom. The bottom will be the earliest transactions. Let's just kind of follow this.

00:32:45 - Nick Taylor

Okay, so the 4 is the initial one when I created the account. Um, this I don't know.

00:32:53 - Rion Gull

So what's this here? 6,240 confirmations is way long ago. So the address that we're looking at, let's make sure that this is the address that you own and it's not like some—

00:33:06 - Nick Taylor

Oh yeah, yeah, other—

00:33:08 - Anthony Campolo

I feel it.

00:33:10 - Rion Gull

Yeah, I wonder if YZPZ— okay, there, YZPZ at the end. Okay, so that is your address.

00:33:21 - Anthony Campolo

Uh, that's the identity, Nick. Sorry, that's the identity.

00:33:26 - Nick Taylor

Oh yeah, yeah, sorry, sorry, sorry.

00:33:29 - Rion Gull

Um, so your wallet address is that, but how on earth could we have a wallet address that we just created have some activity 6,000 confirmations ago.

00:33:43 - Anthony Campolo

Nick, you dropped the wallet in the chat just so I can— yeah, try. I want to try searching this on the regular old Explorer, not this other one.

00:33:54 - Nick Taylor

Yeah, okay. And well, uh, the confirmations are what exactly? That's like the chain just saying this transaction is valid, and then there's a bunch of nodes that confirm?

00:34:07 - Rion Gull

Confirmations is how many blocks have occurred since a certain date.

00:34:14 - Nick Taylor

So, oh, okay, certain action.

00:34:16 - Rion Gull

So this is saying this tran— this is a list of transactions that we're looking at, and the very earliest activity on this is, you know, 6,240 confirmations or blocks ago. And as you can see, that's June 3rd. We haven't done anything. We should not have had any activity on this until today. So why we're seeing something from June 3rd, I don't know. Uh, so scroll— any ideas, Anthony? Scroll up to— let's see what the first thing was that happens today instead of June 3rd. So just scroll up a bit on this. Are you— oh, you're muted, Nick. Uh, go ahead and scroll up on that page.

00:35:11 - Anthony Campolo

Nick, you're muted. Yeah, I cannot unmute him, I think. Oh, cannot unmute your guest, their mic isn't connected.

00:35:19 - Rion Gull

Oh, he's having some technical issues, so. So any ideas on this, Anthony? I mean, I'm just like, I think it's a bug in the code somewhere.

00:35:32 - Anthony Campolo

I mean, this isn't the actual Explorer, this is this weird extra Explorer on this different link, which probably means there might just be a bug in the code somewhere. The way it's reading in the blockchain, it's getting messed up somehow. I mean, like, I remember there's like a— used to show me there was like a status page, and the status page said it was like November or something, so it could be a similar thing, you know. Nick, we still can't hear you.

00:36:13 - Rion Gull

He's talking for some reason. I wonder if he can hear us. That's the question. Okay, I think he probably bailed on purpose to reconnect. Let's see what the private chat says. Okay, that's just you.

00:36:28 - Anthony Campolo

Yeah, I think we should just keep going through the tutorial and not worry about this.

00:36:31 - Rion Gull

Okay, I mean, yeah, I was looking at this so that we could see the actual when you did that transaction to see how much was taken out. But anyway, on the top of transaction. But yeah, we'll— when he comes back, we'll just keep going through the tutorial. We'll forget the conceptual stuff.

00:36:55 - Anthony Campolo

'Cause part of the issue is that there's this weird separation between, you know, the Dash and the Dash Platform. So if we just stay in Dash Platform world, create an identity, create documents, like that's the point of this tutorial. So I think we're going out of scope by trying to worry about all this other stuff.

00:37:10 - Nick Taylor

So I think we're going out of scope, I think, by trying to worry about all this other stuff.

00:37:11 - Rion Gull

So Nick says he'll be back in a second, not sure what happened. While he's gone, just so you know, if you haven't seen yet, Anthony, there is a proposal up. And if you could bring, share your screen for a minute, this might be interesting for viewers, and you if nobody else. Um, bring up your website. Share your screen and then go to dashcentral.org. This is somewhat relevant to this conversation, that's why I'm bringing it up. Now go to budget. Uh, yeah, so these are all the active proposals. Not all of them are budget proposals, most of them are proposals requesting funding, which is how the Dash Incubator is funded. But this one at the very top here, Evo Accelerated Release Schedule, click in there. This is a proposal by Quantum Explorer, Sam Westrich from Dash Core Group, basically asking the network— telling the network, we're basically at a point where we could actually launch platform on mainnet instead of testnet. But there would be, you know, if we do it now, then there would be some features that would be missing that we wanted to put in the version 1 that goes to mainnet. But there would also be a little bit higher degree of risk that there might be a platform halt, like a chain halt. But nothing that should jeopardize the stability of the Layer 1 blockchain or steal funds from platform. And part of it is that you won't be able to withdraw your funds from platform, but at least we could get it on mainnet. So the reason that that's relevant to today's discussion is all of these issues that we're seeing with like block explorers not working and not reliable. And those would all kind of go away once we get to mainnet because—

00:39:30 - Anthony Campolo

Exactly, that's what I'm saying. I feel like it's kind of out of scope for us to really worry about too much right now. Yeah, because it'll just work itself out. So this is cool. So what— when it says accelerated release schedule, what does that mean? How accelerated? What would the actual schedule be?

00:39:47 - Rion Gull

Yeah, so it's in here somewhere in the text, we'll find it. It's not a long proposal, so we should be able to find it pretty quickly. I think it says, let's see, middle July. So the paragraph right above the underlined bolded text.

00:40:10 - Anthony Campolo

That would be tight.

00:40:12 - Rion Gull

Yep. So basically like a month from now, it would be— I would say that that's going to be end of July. But that would be nice because then we wouldn't have to deal with these testnet issues that are unrelated to what we're doing.

00:40:31 - Anthony Campolo

Yeah.

00:40:31 - Nick Taylor

Hey, what's up?

00:40:32 - Rion Gull

Hey, Nick, welcome back. Perfect timing.

00:40:34 - Nick Taylor

That was really weird. My internet didn't go down, but my USB headphones and mic just— they just died.

00:40:43 - Rion Gull

they just died.

00:40:44 - Anthony Campolo

Well, not died, but it just— do you go to your settings real quick and make sure you're going through the right mic right now? You sound kind of echoey.

00:40:51 - Rion Gull

I think that's probably the issue. He's on a different mic now because that one wasn't working. I would guess this should be okay now.

00:41:00 - Anthony Campolo

There we go. Yeah, stuff.

00:41:02 - Rion Gull

All right, let's get back in business.

00:41:04 - Nick Taylor

All right, back into the decentralized matrix.

00:41:08 - Anthony Campolo

All right, so let's, um, did you run the top-up identities yet?

00:41:15 - Nick Taylor

Yeah, I ran that. So, all right, cool. Uh, just gonna take Discord off the screen because we don't need that there. Okay, yeah, I ran the top-up, but we— and then we were just looking at the, uh, I'm gonna have—

00:41:27 - Anthony Campolo

Yes, let's just go back to the tutorial and go forward with the function, whatever function is after top-up identity. Okay, so I did top up. I don't know. Run the retrieve identities one again and then we can see what you're at. Okay. And then while that's going, you can kind of scroll to the next section after top-up identities in the blog. Okay. This is a good place to get to because this is where I think the identities makes more sense once you understand how it connects to the name.

00:42:06 - Nick Taylor

Okay, so, okay, this output— that's from the top-up identities that already happened. Okay, so we'll create this file. Let me just open up another tab. Okay, and let's exit that. Okay, cool. And then I'm just gonna pop this here and register. Cool. Why did it—

00:42:35 - Anthony Campolo

Sorry, so that's a little bit—

00:42:37 - Nick Taylor

Oh yeah, .env.

00:42:38 - Anthony Campolo

This is for your .env. So this is whatever name you're going to want to give yourself.

00:42:43 - Nick Taylor

So, um, all right, uh, let's go, uh, Jake Peralta or Pontiac Bandit. Anybody, uh, watch Brooklyn Nine-Nine?

00:42:57 - Rion Gull

The reference?

00:43:00 - Nick Taylor

Sorry, yeah, it's a TV show I really liked. Uh, okay, so let's just check on the script here. Okay, that's still running.

00:43:09 - Anthony Campolo

I'm not sure if you could have underscores in your name. I know you can do dashes.

00:43:15 - Nick Taylor

Okay, if that's the case, I would suggest that the tutorial not have them in it.

00:43:20 - Rion Gull

Well, we could see what happens when it doesn't work.

00:43:23 - Anthony Campolo

Yeah, let's find out if it works then. Yeah.

00:43:25 - Nick Taylor

All right, fire it up. Hashtag YOLO. Let's do this.

00:43:28 - Anthony Campolo

Yeah.

00:43:29 - Nick Taylor

Okay. This is still running in terms of retrieving identities.

00:43:32 - Rion Gull

So the retrieving identities is forever slow. Got to make a note of that.

00:43:37 - Nick Taylor

Cool. Okay. So we're going to register a name here. I'll just read through the code here. So we've got the my identity ID, which is coming from my environment variables. We get the unique identity on the Dash network, and then I decide on a name, and this creates— it registers my name.dash. That's not for a file name, is it? Or is that just a syntax for a name registration? And then here, okay, we're just going to say view on the block explorer. Okay.

00:44:15 - Anthony Campolo

And then I can see my name, and that will be my ID, which comes from .dash is because— do you remember a couple of years ago when everyone had like ajcwebdev.eth in their Twitter handle?

00:44:30 - Nick Taylor

Okay. Yeah. Got you. I was getting confused. I thought this was a template string issue, but this is actually the property on the object, $id.

00:44:43 - Rion Gull

I do believe so, yes.

00:44:45 - Nick Taylor

Okay, cool. Let's just go check on— this is still running the retrieve identities. It ran faster last time. I'm not sure why it's slower now, but okay. Well, just okay. Anyways, this is going to— am I able to register my name even though the retrieving identities is happening? We'll just let that do its thing.

00:45:10 - Anthony Campolo

Cool.

00:45:11 - Nick Taylor

Let's come here and let's go register name. Alright, boom. Okay, we'll let that go and— oh, okay, there we go. Let that go. It should output my label. Is that what it's going to do?

00:45:58 - Rion Gull

Let's go ahead and open that Platform Explorer again. Go to the main page. Let's see if there's activity on— yeah, okay.

00:46:16 - Nick Taylor

So just go to the homepage, uh, yeah, okay.

00:46:23 - Rion Gull

And let's, let's see, go to the transactions and just let's see if—

00:46:32 - Nick Taylor

Okay, I thought those were links there, uh, trending data. Okay, here. Yeah, okay.

00:46:38 - Rion Gull

Identity create. Um, I wonder if that was us that did that. 6:13. So there's documents batch. I wonder if that's all of our transactions.

00:46:53 - Nick Taylor

I'm just gonna go see in the terminal. Yeah, okay, okay. So it looks like the retrieve identities finished.

00:47:01 - Anthony Campolo

Yeah, so I need to fix this in the post. It's just because my environment variable brain just writes everything with underscores, but it only accepts characters, numbers, and dashes. Dashes cannot be at the beginning or end of the name. There's a regex constraint that runs on what's showing right here.

00:47:22 - Rion Gull

That was a good error. That was an error where we expected an error and it happened.

00:47:27 - Anthony Campolo

Yeah, exactly. Yeah, I'm gonna push that fix right now.

00:47:31 - Nick Taylor

So the regex can bring you to your knees. All right, noted. Okay, um, all right, so yeah, so we got the— do I need to do anything with the retrieved identities? Do I need to just copy that array, or was it just more informational?

00:47:45 - Anthony Campolo

No, this is just— I wanted to see the balances and see how they changed, but we don't really know what they were beforehand because you keep clearing your terminal.

00:47:55 - Nick Taylor

All right. Little trash talk, but I'll take it. Okay. So we looked at the explorer. Okay. So I should I go to my— like this says document here. So, like, what is this document specifically? Because, like, I know, is that a specific block on the chain?

00:48:16 - Anthony Campolo

We should actually get— we should rerun the register name function, get it actually working. And then that will output the link for you. Then we can explain it. So just go fix your label.

00:48:26 - Nick Taylor

Yeah, it's running right now.

00:48:28 - Anthony Campolo

Oh, it's already running? Okay, cool.

00:48:30 - Nick Taylor

Yeah, and I'll just get out of this one here. Okay, cool. Yeah, so okay, we'll let that finish. Um, just gonna go back to the tutorial for a sec. But so, okay, so when I go to it—

00:48:43 - Rion Gull

Well, because that's running and there's nothing we can do to make that any faster. Yeah, it is.

00:48:51 - Anthony Campolo

Yeah, so just click that link. All right, there you go. Here we go.

00:48:54 - Nick Taylor

Cool.

00:48:55 - Rion Gull

Okay, so you are on the network. Good.

00:49:00 - Nick Taylor

Jake Peralta. All right, cool, we did it. All right, so yeah, I guess so— identifier, this is like my kind of network name, and this is just like a label to make it easier, kind of like a URL redirect like you were saying, like JakePeralta.dash would go to my block explorer or address or—

00:49:25 - Rion Gull

Um, well, this is okay. So I— we should probably keep going with the tutorial before I talk too much longer about everything. Uh, let's just see how far we can get and then we'll circle back and answer questions.

00:49:40 - Nick Taylor

Yeah, sounds good. Cool. All right, so we got some data back. We did the retrieve. Let's do retrieve name. Let's copy that. I will not clear the terminal for Anthony. Cool.

00:49:59 - Rion Gull

Also, hopefully the tutorial— I think the tutorial does answer the question that you may have been asking there. Anthony's tutorial usually tells you what you're doing or what you just did.

00:50:12 - Anthony Campolo

Kind of, it depends.

00:50:14 - Nick Taylor

All right, cool. Uh, let's see here, let's come back here. Okay, we've got that. Let's do npm run retrieve name. Just gonna hide that. Okay, cool. All right, let's let that run. And so looking at this, it's going to take our label, which is Jake Peralta. It's going to say go and resolve that, I guess, network address, which is jakeperalta.dash— like you were saying, kind of like the .eth. And then it found me. And this is my— no, that's not my identity. That's not sure what that is.

00:50:59 - Anthony Campolo

I don't think that's your identity ID.

00:51:03 - Nick Taylor

Oh, is it? Yeah, okay.

00:51:04 - Anthony Campolo

I think so, yeah.

00:51:05 - Nick Taylor

I'm confusing it with in the .env with— I'm confusing it with the wallet address. That's why.

00:51:13 - Anthony Campolo

Uh, yes, that's why I say as you go on, hopefully it should become more clear what the difference between the identity ID and wallet ID, wallet addresses.

00:51:21 - Nick Taylor

Okay, cool.

00:51:22 - Rion Gull

Owner— yeah, I see there is a little bit of an issue there because one's called identity ID and one's called owner ID. Same string.

00:51:30 - Nick Taylor

Yeah.

00:51:30 - Rion Gull

String.

00:51:32 - Nick Taylor

Yeah, I'd say in terms of like when you're talking about the docs and stuff, Ryan, just keeping the uniform naming would definitely help. But, uh, okay, but that makes sense. Owner identity. Okay, and let's continue. So we got all that information and we can go view it on the block explorer. We saw that before actually. So we don't need to do that. Okay, so data contract on the platform serves as a blueprint for the structure of data that an application tends to store on the network. Okay, yeah. Contract validates stuff. It's the same thing as a smart contract, right? Saying contract is equivalent to saying smart contract, or is smart contract a specific chain term?

00:52:28 - Rion Gull

It's kind of a more specific— most contracts are smart contracts in blockchain world and Web3 world, but Dash is doing different things. We have data contracts, but you can— so instead of like a smart contract has both methods and properties on an object, you can think of it as that, where you have execution and you can perform functions with a smart contract. With a data contract, it's just data. So if you're thinking of it in terms of an object, you just have data fields, no methods. There's no concept of execution in data contracts.

00:53:11 - Anthony Campolo

You just can't have a bug where you accidentally can siphon off all your funds to someone else.

00:53:16 - Nick Taylor

It's awesome.

00:53:17 - Rion Gull

Okay, it's— yeah, so the difference is instead of a cloud Lambda function— that would be like the Web3 version of a cloud function would be a smart contract. The Web3 version of a decentralized database would be Dash Platform. So we are just doing a decentralized database, we're not doing decentralized cloud functions.

00:53:46 - Nick Taylor

Cool. All right, I'm registering the contract. I got the contract ID back, which is good. Um, and then it'll show us the contract registered. And imagine this is the definition of the contract. So the contract documents— I'm assuming this is a standard structure for a contract, or is this the part of a contract where— well, I guess the properties are the thing that can be whatever you want.

00:54:15 - Anthony Campolo

See if this makes sense to you just reading the code.

00:54:18 - Nick Taylor

Yeah. So there's the— this doc has a note of type object and the object has the properties message and it's strongly typed. It's a string and it's the first position. And I guess the in the block in the chain, which is the contract, I'm guessing. Kind of like a memory.

00:54:40 - Anthony Campolo

I'm not entirely sure what the position means, actually.

00:54:47 - Nick Taylor

I feel like it would be kind of like old school—

00:54:52 - Rion Gull

Position is something that was literally just added like a few days ago to these documents.

00:54:59 - Anthony Campolo

So I actually asked somebody about this before we got on the stream because this code was written over 2 months ago, though. It was in the docs somewhere.

00:55:12 - Rion Gull

Yeah, we'll skip the position part because neither of us really know what it is.

00:55:16 - Anthony Campolo

Basically it's just an object that has a message. The message is type string. This is a hello world example.

00:55:24 - Rion Gull

Yeah, yeah. And even further up the chain there, note is something that you define. So, you defined that this is going to be a contract that holds notes.

00:55:37 - Nick Taylor

And— okay, okay.

00:55:38 - Rion Gull

Note is of type object and has these properties where you have a message that's of type string and so forth.

00:55:47 - Nick Taylor

Okay.

00:55:47 - Rion Gull

So, this is JSON schema validation, basically.

00:55:51 - Nick Taylor

Okay. So, here is whatever you want it to be. And you're saying there's no methods on here. It's just properties. Because you can't, I guess, because it's immutable. But when you— if you create the contract— so here we're saying it's a note and it's an object and it has— so note.message is a string. How do you— if this doesn't have methods, how do you— maybe this is further down in the tutorial, but how do I set the message then?

00:56:19 - Rion Gull

So the platform itself, the thing that's the chain side of this whole process basically has CRUD operations. You can create these things. You can edit these things. You can update them. You can delete them, depending on how you set up your properties initially. So initially, you can actually make it like— this can't be deleted, or this can't be updated. But you can optionally make it that it can be updated and deleted.

00:56:50 - Nick Taylor

So, you can—

00:56:52 - Rion Gull

the blockchain itself is performing the CRUD operations. The user can't define methods at this—

00:56:59 - Nick Taylor

Yeah, okay, okay. So if I were to put new data on, like, let's just say I have a note-taking dApp and I want to create a new note, uh, I'm going to say go get me this contract and it has this shape of an object and I can basically say use that as the template to actually do the CRUD operation? Like, the contract will validate to say, like, I want to go add a note, and it's going to go check the contract and go like, oh, that's an invalid note, you didn't put a message. Like, that's basically what it's doing?

00:57:33 - Rion Gull

Yeah, yeah, that's the chain side or the server side validation will allow or not allow that.

00:57:41 - Nick Taylor

But all right. The register contract worked, but I don't know why the script isn't finishing. I'm just going to stop it for now, but just mentioning that in case that's an issue. Okay. So we're going to go and create a retrieve contract script.

00:58:04 - Anthony Campolo

Did you put the contract ID in your .env?

00:58:09 - Nick Taylor

Nope, not yet. All right, um, so we created the retrieve contract. Cool, let's copy this. Again, it's gonna just get the contract that we just created, so the note object in that particular contract. Let's go ahead and run this.

00:58:44 - Rion Gull

Anthony, just a quick note for you and the tutorial itself, maybe we should edit note to like my note or something so that it's obvious that it's like a user-defined field kind of thing.

00:58:58 - Anthony Campolo

But I think I'll just include an explanation. That will make that clear.

00:59:07 - Nick Taylor

Okay. That ran. Okay. We got an error. Or what's this say? Okay. So, yeah, we're getting a TLS error.

00:59:20 - Anthony Campolo

I think there was a point where we were supposed to edit our client. Okay. Did we not get to that yet?

00:59:30 - Nick Taylor

Um, I don't think— well, it wasn't in the steps because I've been literally going through here. So like we hit data contracts. Yeah, no, there was nothing about altering the client before retrieving the contract. Okay, the register contract worked. It's just this is just at the retrieve contract point now. Um, I can scroll down a bit to see if it mentions something about—

00:59:56 - Anthony Campolo

No, no, that's— that's the different— we're gonna update the client with our document ID, I think, is—

01:00:04 - Nick Taylor

Okay, so I'm just gonna paste this error in the private chat if you—

01:00:09 - Anthony Campolo

Well, yeah, what it's just saying is that it's the— there is no output. Yeah, for the— we're running retrieve contract right now.

01:00:20 - Nick Taylor

Um, yeah, it's saying not permitted. I don't know why I'm not permitted. But, um, and then this is just a JavaScript error because obviously it returned— it can't read the JSON because there's nothing to read. So that's just a side effect error.

01:00:40 - Anthony Campolo

Yeah, I've had issues with this specific function in the past.

01:00:44 - Rion Gull

So, um, retrieveContract—

01:00:47 - Anthony Campolo

This one's—

01:00:47 - Rion Gull

let's do what all great programmers do and just try it again.

01:00:51 - Nick Taylor

Yeah, that's what I'm doing. I'm burning a candle beside me, you know, pouring one out. Uh, cool. All right, so same thing, same error.

01:01:03 - Anthony Campolo

Um, so, okay, okay, let's just get past this one because this doesn't really do anything. This is just to read back the contract that you created, so it's not really important. And I've had issues with this in the past, so let's just go to update.

01:01:23 - Nick Taylor

Contract. Okay, and before we do this, um, okay, so we're going to get the contract schema, which is note. That's the freeform JSON that we had in there in the contract to decide how we wanted the shape to be. And once we get that note, it looks like we're going to add an author property to enhance the contract. And then the existing data contract, we're going to set the document schema to note again. And okay, that's the document schema there. And then it's just going to update it. So yeah, okay, so literally just adding an author field. So let's just copy that. And this is— I mean, this is blockchain stuff, but I'm just reading JavaScript. This is like just CRUD stuff happening. That's— yep, even if you weren't doing blockchain, that's pretty straightforward, I think.

01:02:21 - Rion Gull

Yeah, that's the whole point, is that we want to make contract and blockchain decentralized app development as easy as developing a traditional app.

01:02:35 - Nick Taylor

Okay, so we've got the same TLS error now.

01:02:41 - Rion Gull

Okay, interesting.

01:02:45 - Anthony Campolo

So what I'm thinking right now is, um, when you created the contract, we got the ID back, but then it was kind of hanging and you cut it off at the end. So I don't know if that may have messed anything up, but—

01:02:59 - Nick Taylor

Oh, okay, for like a bunch of minutes.

01:03:02 - Anthony Campolo

Yeah, could we find the contract on the Platform Explorer?

01:03:06 - Nick Taylor

Uh, didn't look. So let's, um, so the Explorer, is it the same Explorer? Uh, this one?

01:03:16 - Anthony Campolo

Yeah, so just go to scroll up to or open up the hamburger and go to data contracts and then just append it to the end. Or actually, it should be right there at the top.

01:03:31 - Nick Taylor

Not found. Okay. So it didn't create it.

01:03:34 - Anthony Campolo

Sorry. No. I mean, just put it in the URL.

01:03:36 - Nick Taylor

Oh, okay. Gotcha. I thought it was gonna search for it. Okay. So it gives a 404. Okay. So that makes sense. So it—

01:03:51 - Anthony Campolo

Check your URL.

01:03:52 - Nick Taylor

Double check. Here's data contracts slash—

01:03:59 - Anthony Campolo

Yeah, could you copy paste what you're doing, right? I can't read any of your things. Your URL is so freaking tiny.

01:04:05 - Nick Taylor

Yeah, that I can't zoom in here. Let me— here, I'll do it here.

01:04:08 - Anthony Campolo

Could you just copy paste what is in your URL right now?

01:04:12 - Nick Taylor

Yeah, here, I'll paste it in the chat. You can see it. Um, it's definitely 404-ing.

01:04:20 - Anthony Campolo

Um, okay, so that means the contract wasn't actually created.

01:04:26 - Nick Taylor

Okay, so we can run that again. So the problem was, because it was hanging for like a good 5 minutes, so even though it spit that out, it didn't necessarily— maybe it hadn't finished.

01:04:38 - Rion Gull

Maybe we need to try to create a contract again.

01:04:41 - Nick Taylor

Yeah, let's do that. Okay, uh, all right, and I'll just comment this out. Uh, npm run create contract. Oh, whoops.

01:04:57 - Anthony Campolo

Yeah, not— yeah, I see exactly what the issue is, because if you look at the code, it creates the contract, it console logs contract ID, and then it awaits contracts.publish, then it console logs contract registered. So we didn't wait for that part, we cut it off too soon. Yeah, okay.

01:05:14 - Rion Gull

The contract ID, in other words, is not something that the chain gives you back, it's something that can be client-side derived, and so it can give you the contract back without actually having registered it.

01:05:28 - Nick Taylor

Okay, so to be clear, that was my bad, but it was hanging for like a good 5 minutes, so there's something on the network. Yeah, so it did it again, and it looks like—

01:05:40 - Anthony Campolo

Yeah, just— oh, wait it out.

01:05:42 - Nick Taylor

Yeah, and it gives it— go ahead, go ahead. I was just going to say, is it normal it gives the same contract ID?

01:05:51 - Rion Gull

Um, that's a good question.

01:05:52 - Anthony Campolo

I don't know if it's, um, I don't know if these contract IDs are deterministically— if it's just hashing the content hash, it shouldn't change if it's just doing that. I'm not sure if it is. I'm not sure where that comes from, but that's what I would guess. It'd be like IPFS, you always get the same hash back. Your content doesn't change.

01:06:14 - Rion Gull

Yeah, it would probably give you a different one if you were registering the exact same document data schema, but from a different identity. I would guess it would be a different contract. If it wasn't, that would be a problem because then two people that wanted to create the exact same contract from different IDs would have the same contract and that would be a problem.

01:06:41 - Nick Taylor

Yeah, yeah. Um, so we'll let this run. I don't know how long it's going to take.

01:06:47 - Anthony Campolo

Um, well, so we're getting close to the end of our time.

01:06:52 - Nick Taylor

Yeah, so, so basically, uh, we'll wait for the contract to get created. There's the retrieve contract just to show that it's there, and then we're going to update it with the new author field. Um, that all seems pretty straightforward. I think it's just, yeah, just waiting on the network.

01:07:12 - Anthony Campolo

Uh, so it says here if you're updating an existing contract, the identifier will stay the same but the version of the contract is incremented.

01:07:19 - Rion Gull

Okay, that doesn't really answer the question that we had. So, Mikhail, if you're still listening, uh, I was wondering if two completely separate people with completely separate platform IDs try to create the exact same data contract, meaning it has a note and each note has a message, blah blah blah, and all that schema data is the exact same, would it have the same contract ID? Um, that's what I would guess would be different, but we'll see if Mikhail has anything to say about that. By the way, that comment that just came up, that's the guy that made the Platform Explorer. So if we have any—

01:08:01 - Nick Taylor

Okay, yeah, yeah. I know. Well, I think there's just the things that you were mentioning, Anthony, like the calculation for the total and the summary. Initially there it was zero, even though there was— well, there was something going on with the totals from like when the identity there got topped up. That's the only thing I can think of, but cool.

01:08:30 - Rion Gull

Yeah, so if you're listening still, which you are, um, is it supposed to— like, does it usually take this long for you when you're creating— what are we doing here?

01:08:41 - Nick Taylor

We're, uh, creating a contract, the sample with the note.

01:08:46 - Rion Gull

We're coming on 5 minutes now, right?

01:08:47 - Anthony Campolo

Things like the retrieve identity were also going really slow, so I think it might just be the network itself just moving at this speed today.

01:08:54 - Nick Taylor

Yeah, but we made a lot more progress than last time, obviously. At this point, I'm going to assume once this finishes, I'll be able to retrieve the contract and then I'll be able to update it. I know we don't have a lot of time left, but we can just show that again. So if we go to register contract, like you were saying, Ryan. So this is where you define what your contract is going to have in terms of data. And so in our case, in the tutorial, we're just saying we just want a note, and it's an object, and then it's got these properties. And this is the type— we weren't sure what position was— and additional properties false. Does that— what does that mean exactly? Because we updated the contract. Well, we didn't do it yet, but we're adding author to it. So I'm curious what additional properties false means, because I would have thought reading that, that means that you can't change this contract. That's what it kind of reads like to me.

01:09:59 - Rion Gull

Um, yeah, that's definitely not what it means.

01:10:03 - Anthony Campolo

Uh, go back to your client real quick, or this is— sounds like this is an issue with—

01:10:08 - Nick Taylor

Oh, finished.

01:10:09 - Anthony Campolo

Oh, it came out. But real quick, I want to make sure we're on the same page here with Mikhail. Go to your client and show the synchronization part. So this is—

01:10:21 - Nick Taylor

We have—

01:10:21 - Anthony Campolo

So is this, um, skip synchronization before height? Yes. So we've got that set. He's giving us a slightly different number, but it's still pretty close.

01:10:29 - Nick Taylor

Okay.

01:10:31 - Rion Gull

Yeah, so that shouldn't be the reason that it's slow because we have done that. Coming back to this comment here, the execution of the SDK hangs because it syncs the transaction of the seed phrase from the first to the latest. That I would guess, you know, you can skip any amount of blocks to make it faster. I don't know exactly how to do that in this context, but all right, so you said that it did finish.

01:11:02 - Nick Taylor

Yeah, and I'm just retrieving the contract.

01:11:05 - Anthony Campolo

We should look at it on the Platform Explorer.

01:11:08 - Nick Taylor

Yeah.

01:11:10 - Anthony Campolo

And then I might want to just call it here. Is this it?

01:11:16 - Nick Taylor

Here it is. Okay. Still gives a 404.

01:11:23 - Anthony Campolo

You should be able to just click the link in your terminal that it spit out.

01:11:27 - Nick Taylor

Okay.

01:11:27 - Anthony Campolo

Yeah, just click, just go straight to that. There you go. Okay.

01:11:31 - Nick Taylor

I don't know if it matters, but it's data contract here, but I think before it was data contracts in the Explorer. But anyways, okay. So identifier— so if we look, that's the contract there. The owner, this is my identity. System— I'm assuming that false means that it's from user land, it's not the network that created this contract, because I'm assuming there's probably network-specific ones. Uh, creation date makes sense.

01:12:07 - Rion Gull

I'm not sure about that, but I think that is true. So like, for example, the name that we registered, where you registered that funny name— that itself is a contract. So that's one of those core blessed contracts, I believe. It's called DashPay. And registering a name to DashPay is probably would be a system contract.

01:12:38 - Nick Taylor

So— Okay. And we got documents count is zero because we've created the contract but nobody's actually created data with the contract yet?

01:12:47 - Rion Gull

That's probably the next step in the tutorial, just to create a document against that schema, against that.

01:12:52 - Nick Taylor

And yep, and in terms of revision, this is what like Mikhail was saying, uh, I ran it again, so it looks like it tried to create it a second time, so that's why there's one revision maybe. Okay, cool. Um, yeah, okay, so let me just run the update contract real quick. Uh, I imagine it'll go pretty quickly because the retrieve went quickly, or maybe not. But, um, but yeah, I know we're wrapping up here, so I don't know if you wanted to take us out, Ryan or Anthony.

01:13:23 - Rion Gull

Um, how far do we have left in the tutorial?

01:13:27 - Anthony Campolo

Um, I mean, if we don't dally too much in the next one, we should be able to get through it in one more episode. We need to still write to the contract and then create the whole backend and frontend with Express and React. Oh, okay.

01:13:42 - Rion Gull

So there's plenty of stuff to do then. Let's cut it off here. We'll make a Part C from this series if Nick's willing to come back again.

01:13:50 - Nick Taylor

Yeah, yeah, no, I'm good to hang. Like I said, it's just interesting exploring other technologies. So try to keep an open mind. I know there's a lot of people that are not fans of blockchain right now. Not that I'm like an avid lover of it, but I think it's still worth it to explore these things. I think it's—

01:14:13 - Anthony Campolo

And you've actually owned crypto before, which helps.

01:14:16 - Nick Taylor

Yeah, no, I do own crypto right now. Yeah.

01:14:21 - Anthony Campolo

Cool.

01:14:22 - Nick Taylor

All right, so it did update the contract. So that's at 3:59. So we can just show that that happened.

01:14:29 - Anthony Campolo

And then hold on to this project so that when we do our next one, we can go right where we were with the same .env and everything.

01:14:37 - Nick Taylor

Well, yeah, uh, okay, let's do that. Let's do, uh, git— uh, did you create a .gitignore? Yeah, I did, I believe. Uh, hold on a sec. All right, cool. Well, I guess we can take it out here. Uh, I think I've got your .gitignore you put there. Okay, cool.

01:14:57 - Anthony Campolo

Great.

01:14:57 - Nick Taylor

Uh, git init, git add. Okay, all right, cool. Yeah, I think we're good.

01:15:07 - Anthony Campolo

Great.

01:15:08 - Rion Gull

All right, well, yeah, thanks, Nick, and we will pick this up in a Part C and hopefully get through. It's going to be a race from here on out because we've got some other people that are other developers that are going to come on. We'll see who has to go till C to finish the tutorial and who gets through it with just an A.

01:15:30 - Anthony Campolo

Yeah, on Friday— who gets that? Yeah, on Friday my buddy Noah is coming in to do this, who's actually the person who got me working at a blockchain company in the first place. So he knows a lot about blockchain, so it'll be fun to have him on because he'll just blast through this, hopefully.

01:15:45 - Rion Gull

Yeah, and in case that wasn't clear, definitely not Nick's fault that he's on B and then soon to be C on this series.

01:15:52 - Nick Taylor

Definitely, I'm just a C, folks. Couldn't be an A, sorry.

01:15:57 - Rion Gull

Yeah, those are the letter grades that you get after the end.

01:16:02 - Nick Taylor

Yeah, yeah.

01:16:03 - Rion Gull

All right, uh, thanks everybody for watching. Um, Anthony, you alluded to it, but we'll be on tomorrow to have another developer try this out, for tomorrow, right? Uh, what time is that going to be, Anthony?

01:16:17 - Anthony Campolo

Oh, I'm in time zone land right now, so let's see. Um, I've got your—

01:16:25 - Rion Gull

It's gonna be 11— 10 o'clock your time, so that's um, that's noon Eastern time, I believe. Um, okay, something like that. Anyway, um, yep, tomorrow.

01:16:40 - Nick Taylor

Cool. Later, everybody.

01:16:42 - Anthony Campolo

All right, bye.