Projects
![]()
No projects found
Investors
New
DAO Treasuries
DATs
Lend / Borrow APRs
Chains
Categories
Spaces
How to Create a Rollupwith @celestia
Recorded: March 31, 2025 Duration: 0:51:25Space Recording
Short Summary
Celestia Labs presents its modular blockchain, Celestia, which offers innovative features like a verifiable data layer and interoperability of rollups through light nodes. The discussion includes technical insights into Celestia's data availability and consensus networks, as well as upcoming upgrades and testnet details. Emphasis is placed on fostering innovation and flexibility in blockchain applications, encouraging developers to explore new possibilities.
Full Transcription
Josh, we are live.
So hello everyone who's joining us in this new stream.
And today we have Josh with us from Celestia Labs.
And Josh will be talking about,
or I should say demonstrating
that how you can create your own rollups
and he will also demonstrate how you can
even post your own blobs to the consensus layer
by talking to the consensus layer using Quicknode rpc all of that but
yeah that's for later yeah that's for later but first josh i will pass it on to you so that you
can greet the audience give a little bit introduction about yourself and then go on to
explaining us what celestia is and then actually show us how people can actually use the network
to create their own rollups so So over to you, Josh.
Yeah, thank you for having me, Sahil.
It's a good, I'm glad to be here.
Just realized I need to check my mic.
Cool.
Yeah, so my name is Josh.
I'm a developer advocate at Celestia Labs.
And at Celestia Labs,
we're working on Celestia the blockchain.
And Celestia is the modular blockchain
powering unstoppable applications
with full stack control. And what that means is you can basically take your existing blockchain
that traditionally is something that has all of its layers stuck together and break that apart
into little pieces, turning it into a modular blockchain. So you might have heard about
Celestia and the modular blockchain kind of paradigm, and that's really what we're focusing
on now. And yeah, I guess if you're not familiar with Celestia, Celestia is, as a blockchain,
a data availability layer through which you can post data and celestia's main goal there is to
make it available to everyone who's using it everyone running a light node and everyone with
an application so yeah i guess that's a good intro to what celestia is i guess there's definitely
other da layers out there too
that you might be familiar with as well.
Yeah, I guess in terms of the demo, though.
Close the window. You mentioned sending blobs through Quicknode.
And yeah, that's something we're going to show off today
is basically the superpower of Celestia
is that you can run a data
availability sampling light node and what this does is it samples little bits of data in each block
and using some fancy math basically verifies that to a really really high degree of certainty
the data is there and what this allows is it allows the end user
to have control over the verifiability of data
rather than trusting some centralized entity
that's running the infrastructure for you.
It's kind of a funny thing to say
because I'm going to show using QuickNode
as the centralized RPC endpoint.
But at the end of the day,
the LightNode is still going to be sampling the data on its own,
which does not require any centralized endpoint.
So I think that's a pretty good intro there.
Yeah.
I guess we could jump into the screen share
and start showing off how to do this.
Yeah, man. Wait a, whenever you are ready.
I guess before we do, do you have any questions that I should maybe cover a little bit more?
So I guess before jumping into the demo and before actually showing how it works, I think a lot of people sees data availability layer
as this just one single layer
where you can offload your data to
and just get the proof of data availability
and post that proof onto a chain, right?
But on a base level,
it's more than that, way more than that.
There are multiple layers which needs to work in consensus with each other.
Yeah.
Yeah.
So if you can talk a little bit more on that.
I think when we were doing like some prep for this,
I was trying to explain like the difference here between when you're running a light node,
that is a node that's running
on the data availability P2P network.
I'm gonna do my best to just like do this with my hands.
And if you imagine like the data availability network,
P2P network is over here.
And like the consensus P2P network is over here.
They're connected by something called a bridge node,
which is just like a really fancy DA node.
At the end of the day, those two P2P networks
are actually part of the same Celestia network.
So there's no difference there in terms of if I send a blob
through my light node to the consensus network,
or if I send one straight to the consensus network,
it's going to end up in a Celestia block regardless.
So yeah, I think it's just like a little nuance to explain there.
There's like a consensus network that's making the blocks,
and then there's a DA network that's
sampling the blocks, essentially.
I would say like for the end user and like the developer,
the DA network is probably the more important piece here,
the P2P side,
where you're going to use your light node to post data
and retrieve that and sample it
and make sure the data is actually there for your application.
Got it.
So not exactly, but in a way like Ethereum
where you just interact with the main layer,
not with the consensus layer, not with the main layer,
not with the consensus layer, not with the beacon chain, where usually people running the infra
and people running validators need to interact.
But you as a user of Ethereum,
you do not interact with that chain,
but you just interact with the main Ethereum chain
and deploy your apps there.
Like not exactly like that, but.
Yeah, I guess like similar and different all the same time.
Yeah.
I think, yeah, here like the focus would just be, you know, if I,
you and I were playing tic-tac-toe, for example,
were playing tic-tac-toe for example and we want to be able to verify each other's moves
and we want to be able to verify each other's moves,
like even further away from like the traditional roll-up let's say we have like a tic-tac-toe roll-up
and i'm running a light node on my end with my id basically and you're running a light node inside
an application on your end with an id when i post move, you want to be able to verify my move without trusting me.
Like if I just tell you that I did this move,
then I mean, I could trick you.
Let's say there's something at stake for this tic-tac-toe game.
And the purpose of Celestia in this case as a DA layer
allows you as an end user to verify that yourself.
This could even be something where I
build my own little application where
I'll show you something later. I don't want to give too much
away, but I could even build my own application that only I
have access to that I'm using Celestia for.
But yeah, I guess
I feel like we're at a good point.
I can start playing around with the light node,
kind of showing more quick node comes into play here.
But yeah, I hope that gives a good overview.
And I guess the biggest thing about, yeah,
like this basically a verifiable data layer that anyone can permissionlessly post to and retrieve from.
It really allows people to build whatever. And that's what we mean when we say build whatever.
We want people to start thinking outside of these boxes that we've made
where like something has to be an EVM or it has to be an SVM or it has to look a certain way.
And we're really looking forward to people building
these unstoppable applications with full stack control.
And you can think of this as full stack customizability
in the sense that like when you go to build a normal Web2 app,
you're able to plug and play different pieces
to figure out what is the best stack for you to use
for your specific use case.
And we kind of want people to do the same thing with blockchains.
Got it.
So going back to the example or analogy you gave Josh, for example, we both are running
those light nodes for our tic-tac-toe game and you do a move and that moves then gets
posted to consensus layer via your light node and then
my light node which is again in sync with the consensus layer pulls that in and since it's
coming from consensus layer it's already verified in a way i mean i'm just asking you i guess like
most cosmos chain i mean every cosmos chain that I know exists, I guess,
has single-slot finality.
So as soon as a block is made by the, like, validators,
that block is final.
There's no reorgs.
You don't have to wait on, like, you know,
X number of validators to verify this after the fact.
It's, like, basically done through the voting process.
But I guess it's also important
to not really think of these as two different networks.
I think it might cause more confusion than clarity
in the sense that you can think of your light node
just posting to Celestia.
Exactly which part of the P2P stack that is in the network,
I think is kind of irrelevant to the end user.
And you can really just think of it as,
I know that since I posted this blob to Celestia,
I received a commitment,
and the height that it was included in,
I know that that data is there.
And then once that's done, what you do with your light node
is you go back and sample it to make sure that it's actually there
because you don't want to just trust the validators.
You want to actually be able to go and sample that for yourself
and verify it for yourself really.
Understood. Yeah, that makes much more sense.
I think I confused you like when we were talking about,
yeah, just like how quick node comes into play here
and why you need quick node.
Yeah.
But yeah, I wanna get to that a little bit
in the demo here.
Sure, yeah.
So yeah, I guess first things first,
I mentioned like running a light node
is pretty much the superpower of Celestia.
This is something that you can do on your web browser.
I'll just do, this is fun because it's possible.
You can start sampling directly on mainnet
inside your browser.
This is going to run the binary directly in my browser here
and verify the data that's coming in,
sampling each new block.
It's also gonna go back and sample
from the very start of the chain.
So this will take a while if you're running it,
but you can see here the different block sizes
that are coming in in the latest hash.
You'll also see a visualization
of what the square looks like,
but I'm realizing as our blocks get bigger,
this visualization is like a little bit harder to see.
Like in the past, there's been eight by eight squares.
There's literally 256 on either axis here.
So it's kind of a lot,
but I'm gonna go ahead and kill this right now,
and we're gonna run a light node locally on my computer.
There's not much functionality
like actually attached to this right now,
but there are things like LeapWallet
that are adding this Lumina light node
inside applications directly.
And kind of the end goal of this is to allow rollups
that are rollups or applications,
like you can think of those as the same thing,
that are all posting data to Celestia.
They can interoperate with each other
with basically lower trust assumptions
and lower resource requirements
by all using the same thing, which is the light node. So splitting my screen a little bit here and clearing this off, we're going to talk about
how to run this with quick node. So when you run a light node, I guess a good way to show this off would be that
if I start a light node on our Mocha testnet,
and I want to check my balance,
what's going to happen is I will be able to, well, with this light node, I'm running
it purely on the DA network, like P2P network. So I guess this is important. So I'm running this
purely on the DA. It's getting blocks and sampling their headers. And basically it's doing all the
fancy things a light node can do except for posting.
So if I were to split this and try to check my balance,
I'm going to see that the node is running without state access.
So what this means is I'm running without an endpoint that is able to get me state information about my account, meaning it can't get my account address.
Even though I have the key here locally,
it can't check my balance.
And what I need to do to be able to post and retreat blobs
is check my balance and check my account address
because otherwise I couldn't send a transaction.
So what we'll do here is plug in a endpoint in this case we're gonna plug one in from
quick node and what i have set up is my auth token in json locally i have my custom URL from QuickNode
that I'm gonna use as a core endpoint.
And since this has SSL, I'm gonna turn TLS on here.
And we're gonna run this again on Mocha.
and go ahead and make this a little cleaner.
And go ahead and make this a little cleaner.
And now that we're running with core access,
we're gonna be able to get our account address.
We're also going to be able to get our balance.
And in this case, this is denominated in micro TIA.
So 1 million micro TIA equals one TIA.
So it looks like I have like 167 TIA in my wallet here.
And now what we can do is post a blob.
is post a blob.
So in this case, we're gonna just post something simple.
Submit and this lull.
I have this old quote, I guess, in here.
And what's gonna happen is this is sending a transaction.
It's basically constructing the transaction
with the light node and then sending it to that core IP.
And I guess as a proof of concept,
I'll show you that we can retrieve that
with and without the core endpoint.
And if we put the height here,
that namespace, I believe, and the commitment,
we're gonna be able to get that back from the network.
As I mentioned, I wanna do a proof of concept real quick,
just restart the light node without any core access.
And we'll see that the next time I query that,
we're able to get that back directly.
Can't spell retrieved.
So we can see that from the, like just directly through the DA P2P network,
we requested the blob at height 55.4 million something 36
from the namespace that we use.
So that's like the superpower of LightNodes.
It allows you to retrieve data without actually just
trusting that core endpoint.
I trust the QuickNode endpoint.
But you don't want to have to do that every time.
So we're going to go ahead and start this back up
because the rest of the demo is kind of bunk
if you can't post blobs.
And once again, we have this running again
with a QuickNode endpoint.
While we're doing that, I'm gonna actually jump over
to this dashboard that QuickNode has,
which honestly is really cool to be able to use
because this hasn't been possible
until this Quick note integration,
where you can see the actual requests
that you're making from your light node.
Oh, I can't do that on the free plan.
So for the last hour, we can see a few minutes ago,
I started to make some calls to this endpoint
where we're querying my account,
we're getting latest blocks,
we're getting the transaction status
of the transaction that I sent.
We can also see the broadcast transaction
just a second later, I think.
And yeah, I mean, this is just super useful.
As a developer, I can know a little bit more
about what my application is doing
i guess while we're there any questions in the chat um if you just have gm and yeah big boy
I'm just saying hi.
Thank you for tuning in.
So, yeah, I guess that was like how to get your LightNode running.
If you're playing around with this and you want to know what version I'm on,
if you're watching this later and you maybe are wondering why this doesn't work,
I'm on version 0.22-mocha, and I'm using a Mocha testnet.
I think now I'm gonna go ahead and play around
with something I built kind of for this demo,
kind of just for people to be able-
Josh, maybe a silly question or just a dumb question.
I see that there are,
I have seen that there are two testnets, right?
Mocha and another one is Arabica, if I'm not wrong. I have seen that there are two testnets, right?
Mocha and another one is Arabica, if I'm not wrong.
Yeah, so what are the difference?
Like just version differences or they are meant for different?
So basically Arabica is where we start testing changes out.
And Arabica is technically a proof of authority testnet with, I think, four validators.
It's run by our DevOps team at Celestial Labs.
And this is where we test out the newest software changes
to make sure things work.
Mocha testnet is what the second step of testing,
where we move this to a testnet that has much more realistic setup
compared to a mainnet.
So this is where we have the same number of validators
as we have on mainnet.
And basically, the parameters are, for the most part,
one to one with mainnet.
Once that's been successful on Mocha,
then we push theone with mainnet. Once that's been successful on Mocha, then we push the change to
mainnet.
TBD on exact timing of it,
but we have an upgrade coming up soon
for version 4 of our consensus
network, or the consensus
side of it, the chain, I guess.
And in this version 4,
we'll just
start out Arabica, Mocha,
and then made that.
So yeah, this is just kind of how the testing pipeline exists
or how it is as it exists now, sorry.
Got it, so maybe you can say that Arabica
is more of a DevNet kind of as it?
Yeah, I guess like actually it is DevNet.
Like that's how I have it written in the docs and such.
Nice.
And Mocha is a more stable.
If you really want to play around it,
yeah, go mess around on Arabica.
I guess like the Arabica chain ID
has increased more times than Mocha.
But if you're just starting out,
but if you're just starting out, but if you are just starting out,
I would say maybe go with Mocha first.
Yeah.
And then once you understand the chain
and once you understand all the workings,
then maybe go with Arabica.
Yeah. And Arabica is like definitely not used
as much as Mocha.
So if you want to go like fill up blocks or something,
Arabica is probably a good place to try that out.
And I guess for what it's worth,
the tooling around Mocha is better too.
So like QuickNode supports Mocha and mainnet,
not Arabica for good reasons.
Yeah.
Yeah, thanks for clearing that out.
Oh yeah, you're welcome.
Excuse me.
So I'm going to put this back at our...
It looks like now we just have some ABCI queries.
I don't really know what this is doing
underneath the hood of the light node.
I think it's some sort of health check
to make sure that we're at a good,
like at the right point of the chain.
And what we'll do is jump over here to something that
for now is called the Mammoth Control Panel.
This is really just a silly name.
You can think of it as like a LightNode Control Panel.
So over here, I guess earlier I did the,
I checked my account address.
You can see that on the left side of the screen here,
we're using the same account that our LightNode is using. So I'm not like mocking this up or anything. We're connected via WebSocket. We can also see
our P2P ID. And this is the P2P ID from the DA network, like DA P2P network. And we can also see our balance, which is that 167 and some remainder of UTA.
I guess the first thing we could show here
is probably not the best example,
but I'm gonna send one to you to myself
And we'll be able to see that on the Explorer.
and we'll be able to see that on the Explorer.
And this is available at gmemo.vrcelle.app right now,
if you want to play around.
And this should not have taken that long.
All right, cool.
The transfer is successful,
so I just self-sent some to myself.
We can see this on the block explorer as well.
Nothing really exciting in there
because I sent it to myself, but yeah,
it has basic transfer functionality.
So you can kind of think of a light node also as a wallet,
one that you have total control over.
And then if you look a little deeper,
we can see that our light node is still sampling
to catch up to the head of the chain.
So we're trying to right now sync the last 12 blocks.
You can see the workers down here
that are sampling those blocks individually
as they
are getting retrieved from the other da nodes
i guess before i go further here any questions on that
um there's no question from the audience's side but uh yeah so so So Josh, you did a transfer, right?
So once you have
the LightNode running on
let's say some machine,
in this case, your local machine,
you should see those changes
in LightNode as well,
right?
Yeah.
Let's see um so this is like not a da operation and i don't i only have like normal logging on um i don't actually know if i should have seen much log here on that because
it's not really related to actually like DA.
But we can just check the balance and see.
I mean, I didn't send it to myself,
so that doesn't really help.
I don't really have another address handy.
I guess we could get one on Selenium.
We'll just go ahead and send some to this address
that Eclipse is using.
So I'll send 10 out into the void.
Whoops, the wrong field.
Let's see.
But we shouldn't really see anything over here
related to this.
It looks like we're having some trouble sampling recent headers,
which means we're just basically waiting on that to be ready to sample.
And this is really the best example I have,
where in a second you can just see that refresh.
Yeah.
Yeah, so every time you're doing something state related,
it's gonna use that quick node endpoint.
It's not actually really doing too much with the light node
except constructing that transaction
and sending it where it needs to go.
Understood.
And it looks like the blocks were pretty big for a while.
And it looks like we're still catching up.
This also could have something to do
with the fact that I'm streaming right now,
not totally positive.
But anyways, we're gonna go and jump to the fun part
of this where you can post some blobs.
So this is a little utility tab
that allows you to pick a namespace.
We'll do quick node.
And I can enter some data in here.
You can think of this as like the thing
that you want to post to be able to verify.
I made a little base 64 encoder.
So we'll just say GM quick node and copy that over.
And when I post this,
what I can do is sample it
both through the CLI and through a curl.
But the first thing I'll do is I'll retrieve it
directly from the DA network.
And you can see over here that, yep,
the blob was requested from the namespace
at the height that we just posted it at.
But question.
Yeah, one question here would be Joshosh and maybe it's not valid but
that just popped in my mind so i thought i'll just ask so you are just posting data over here right
now right and is it possible to post a schema and then post yeah that Yeah, for sure. I guess you're trying to get me to speed up.
So yeah, if you look over here on the namespace,
just real quick as a like proof of concept,
we can see that a minute ago,
this address posted to the quick node namespace
with a GM quick blob that's hex encoded.
But I guess like if I were trying to do something private
or like some application where users have accounts
and things like that,
and you don't wanna reveal everything,
maybe this isn't the best way to do it.
So like, as you're alluding to,
maybe I want to come up with some schema
and require that the application that I'm using
posts to that namespace with that schema.
Before we get there, I'll just show you real quick
that this also has like demo section built in
where you can retrieve the blob through the CLI.
You can see again on the light node logs that we retrieve that through the CLI. You can see again on the light node logs
that we retrieve that through the CLI.
You can also do the same thing with a curl.
Whoa, AI, chill out.
You can do the same thing with a curl
and it's going to be a little messier, so zoomed in.
But we can see that data in base 64
just like we posted it from here.
So yeah, I guess like getting to the,
how to create a rollup part of this,
that's like, I think we've covered all the basics.
Sorry, it took a while,
but this is a demo that I've made
that is basically what you were talking about,
where you can create a private database on Celestia.
And I think this is a good way for,
to try and help break people's heads out of the boxes
that we've built where like a rollup
has to look this way and that way
and start thinking a little differently.
So what this is gonna do is going to store
and retrieve data using blobs on Celestia.
And it's going to treat this as a database.
What we're gonna do is pick a random namespace to post this
And I haven't really talked about namespaces, I guess.
And I think that's an important thing to cover
before we go too much further.
You can think of a namespace as basically
a folder or directory that you're
going to put your information in on Celestia.
So this is a way that you can categorize
different applications.
Earlier, I was on Selenium, and you
could see that we were in the Eclipse namespace.
Now we're in the QuickNode namespace.
For this use case, we're going to generate a random one
so that it's like relatively more private.
So this has just generated some random base64 string
that is gonna be used as a namespace
for all the blobs that I'm gonna make here.
And what's gonna happen is my database will be encrypted
with a browser token
that's gonna get stored in my local browser.
So like once I make this database
or once I initialize the schema,
what's going to happen is it's going to retrieve
the schema from it.
It's gonna keep a start height in my browser
along with that auth token,
and then be able to read back the data from Celestia
every time I want to. So we'll do something really simple
in terms of the schema here.
We're just gonna use a user with a string
and a DA layer with a string.
And when I initialize the database...
What?
Hold on a second. And when I initialize the database, what?
Hold on a second.
I added like some validation to this that I think, okay.
I don't know what I did wrong there. We're just gonna stick with one field in this schema.
And you go to the Selenium Explorer,
you can see that 11 seconds ago,
we have this blob that was posted.
Gonna refresh again.
Sounds like there's some construction going on nearby.
So sorry if it's coming through hopefully
it's not uh we can see that we're in this random namespace uh we see a blob here and it's not good
it's not found um i think we're just trying to do it too soon uh well anyways there was a 152 byte blob that was posted.
Not 100% why it's not loading.
I think this is just an indexing thing on the explorer.
Let's see.
Nope.
Okay, rip.
Well, anyways, good thing is our light node is doing some magic here,
The good thing is our light node is doing some magic here
and it is retrieving that from Celestia.
and it is retrieving that from Celestia.
So now that, hold on a second here, I think I need to,
I wanna show you that that's actually the right thing.
Okay, so if I go and add a user to this,
what's going to happen is it's posting the blob to Celestia,
but also it made sure that that schema matched.
So at this 6134 height,
it went and retrieved that schema
to make sure that we're constructing this database
or adding entries to this database the right way.
If I were to try and do something like user
without the S and Josh,
it's going to fail
because it went to validate that against the schema
and didn't work.
So this is like the most basic version, I think,
of like what I see as a rollup
or like an unstoppable application
because all I need is my light node.
I honestly, I don't even need to be able
to use the Explorer apparently.
All right, there we go.
We've loaded now.
So if you look at this,
this is pretty meaningless.
Like to anyone else who stumbles across this,
they can't really just decrypt it without that auth token.
So that's going to be the same deal with this blob.
And this is my username that I added.
And we can't, from the outside, tell what this is.
But if I'm using this application, or I'm the one who made it, I can't.
We'll go ahead and add another entry.
But in the meantime, do you have any questions?
So the authentication part is happening via your node client's wallet?
It's happening through my LightNode. You could think of it. Light node client's wallet? It's happening through my light node.
You could think of it as-
Light node's wallet?
You don't need to, like,
I guess the wallet is kind of a, well-
Not the right term maybe, but-
No, no, no.
It's pulling everything from this namespace.
So if you actually were, okay, no, only I can do this
because the application itself is pulling things
from the namespace that fit the schema
that are also decrypted with the auth token.
Good.
So maybe I would rephrase the question.
It's hosting it through the wallet on the note, though.
So if I were to look at this namespace again and go look at this address on music,
you can see that for the past 10 minutes or 20 minutes, the only things that I've done or the things that I've done in the demo are on this account and this is
the same account that's running with the light node yeah so that's that I think that was my
question so because it's the same account which is being used to post that data and you are using the
same light node to pull that data in again that that is why we can see the data, right?
Yeah.
And I guess the real magic is happening.
It's a combination of my browser here.
I'll pull the application.
Storage up.
One second.
You can see that the browser is keeping this auth token,
and that's being used to decrypt each,
it's being used to decrypt the schema,
and it's being used to decrypt both of these entries.
We're also storing the namespace and the start height here,
and this is so that the application over here
knows where to go look back to.
So let's say I wanted to restart this and clear the cache.
Actually, that was probably a better way to do it.
So if I go ahead and clear this database cache, it's going to warn me that I'm clearing out everything in the auth token,
the encryption token. Basically, this database is gone. If I'm not saving that, there's no way
to encrypt it. And the next, if I wanted to go and initialize that again,
Yeah, I can go ahead and start a new database just as easily.
And we'll go ahead and say that the RPC in this case
is from Quicknode.
And then this is gonna create a new auth token.
It'll save a new namespace.
Actually, whoops, I don't think I changed the namespace.
Anyways, it'll be on the same namespace,
but it's only going to look back at this starting height.
So we've effectively just made a new database
in the same directory.
And we've basically reinitialized it.
But still, you won't be able to retrieve the older data
with this auth token, right?
Right.
So I could retrieve the data, right?
But I couldn't decrypt it.
Oh, true.
Because I mean, technically anyone can retrieve the data,
but cannot decrypt it.
Yep, exactly.
Yeah.
So this is like a single player, I guess,
way of building something.
I think you could have a use case where you and I
are doing something together.
Maybe we have an auth token to hide or move or something.
I don't know.
I'm not a big gamer, so the examples aren't really
that clear in my head.
But yeah, this is something.
Yeah, something like this can be used
even in a very huge institutional kind of transaction landscape, right?
Where you are sending a bunch of stuff,
but you do not really want the entire network
to know what you are doing between point A and B.
Definitely.
Yeah.
So like whether that's like, I don't know, you could even just publish proofs here, encrypt them.
I don't know.
There's like so many different things you could do.
And that is really why we say that Celestia is a place where you can build whatever.
We really want people to think differently and start building more weird stuff.
Yeah, and I think you guys did a really good job
with Mammothon, and I'm sure you all must have seen
pretty amazing and interesting projects.
Yeah, I don't want to single any out,
just to honestly be fair,
but I think if you go through a winner's thread,
you'll see that there's some pretty unique applications
of what you can do with DA,
but also what you can do with other things on top of DA,
so just ways that you can put together this full-stack application
and control every little piece of it.
And that being said, I guess, if you didn't see,
you're tuning in, learning about Celestia for the first time,
I definitely recommend checking that thread out.
Maybe we can put it in the description.
And if this interested you, please reach out with questions.
My DMs are open pretty much everywhere.
Like Twitter's a good place to reach me.
But yeah, I guess I wanna kind of leave
the floor open here to you.
I did wanna jump back and look at our
Quick Note dashboard real quick.
You can see the logs of everything I've done
during the demo, which I think is really useful.
I think I could run this, like, I mean,
this isn't doing that much,
but I think you can just like benefit
from using this dashboard to understand
like what exactly your application is doing.
For sure, 100%.
And I mean, you can keep track of what's happening
under the hood, what kind of method calls, API calls,
in this case, REST calls are being called.
I guess on that front, it is probably,
I don't have the link handy and I don't wanna, let me see.
The quick node endpoint itself is actually like a really fancy endpoint and I think it's worth highlighting that what's your docs link so anyone who's watching
they can basically go to the link in the description to check out quicknode Celestia page and they can find the docs there and the
official docs from Celestia are also linked in the description below so for anyone who's watching you
can just click on those links check out Celestia's documentation as well as quicknode's documentation
and I wanted to highlight I think the sweet part about this endpoint is it's you have one endpoint, but you can basically access like the DA API as well as the Tendermint API.
Yeah, so if you want to just the matter of.
Yeah, if you wanted to like really not run a late note, eventually it will be possible to just use something like QuickNode to retrieve the data that you're posting so your application can verify it.
Yeah. Yeah, hopefully. the data that you're posting so your application can verify it. But yeah.
Yeah.
Hopefully that was a good overview.
Oh, more than that.
So, Josh, I guess now we can open it up for questions,
like open it up for audiences if they have any questions, anything.
For sure. If not, too um it's all good
but if you're here yeah i mean happy to answer i'm pretty sure i'm pretty sure you and the devril
team at celestia have done uh like very good job on docs and they're creating those tutorials.
I keep seeing a lot of tutorials popping on YouTube and you keep on doing a lot of streams as well.
So I am pretty sure the audience who are watching us...
Yeah, yeah.
Yeah, I'm pretty sure the audience members
who are watching us are pretty well aware
about Celestia and a lot of things
which you meant talked about, but still having the demo
where they can see what actually can be built
is very helpful.
So, yeah, I mean, if you have any questions
for people who are watching,
feel free to ask them in the comment section below
and Josh will be, I guess, more than happy to answer them.
Yeah, definitely.
And for those of you who are
watching this as a normal video once this is posted on youtube feel free to drop your questions
in the comment section below and i will make sure to forward them to josh and get your get those
answered yeah and i guess like uh if you are starting to build with Celestia and have questions, Discord is also a good place to reach us.
But yeah, looking forward to helping out where I can.
For sure.
So everything from the thread which Josh mentioned,
where you can learn about Celestia
and see the interesting projects from Mammathon, which was the recent hackathon Celestia
did, and links to their developer channels, Discord,
and if you have any other.
We will link them down in the description below as well
so that you can quickly jump into their developer channel
and talk to their team, talk to Josh,
if you have run into any issues. And I guess
joining developer channels is always good because in that way, you can,
I guess, talk to other developers. A lot of time, you also find your co-founders or
good team members in those channels. Plus, being connected with a community building on same thing is always
so much valuable okay so it looks like there is one question josh and uh they asked that
hey how should i get my wallet address in celestia on cel. Good question. I have questions for the question though.
Like, are you using a light node?
Are you asking about like something
like getting it in Kepler?
I guess if you're running a light node,
you'll need to run it with a core IP
and to get the account address,
like exactly from the CLI,
you can just do Celestia state account address.
And I'll send that to Sahil just in case it's useful.
But yeah, I guess if you just wanted to set up a wallet like the easiest thing would probably be to use something
like kepler or leap um which both support slasho
got it so if you're using a wallet client i guess like i don't know yeah i don't really know what
what the context is where yeah yeah where are you trying to get it from? But yeah, if I didn't answer it right there,
Sai, please ping me.
Yeah.
And Josh, I am also going to post the thread
which you were talking about earlier
in the comment section below.
Yeah, sweet.
Oh, no.
Yeah, no.
What?
Yeah. The follow-up question is like, yeah, and we get any free tokens from Celestia? Well, actually, I said not too quickly.
I guess they're talking about testnet.
Many free tokens on testnet as you want. Yeah.
Yeah.
So for the testnets, so there's a faucet for Arabica. That's a browser faucet. There's
also a faucet for both Arabica and Mocha inside the Discord.
But yeah, no.
I guess the superpower that you get with Lightnode is not free tokens.
It's being able to verify data and know that you're not being tricked.
And I think that's like...
It feels like a cop-out sort of answer. But that really is
the special thing about Celestia is that you don't need to trust someone. And that's like
the real benefit. So no way, Josh, you're saying that no, no free mainnet tokens? No, no. Yeah.
The freedom is the verifiability.
I mean, yeah, that's given, right?
Like you can get as many, not as many technically or practically,
but you can get few testnet tokens by going to a faucet.
But for midnet tokens, of course, you will have to.
It's a good question, though, because like now we're talking about testnet tokens.
Like if you do run out of testnet tokens, your application's like chugging through more than the faucet gives you like this
is a case where please reach out to me i'll send you some uh so that you don't have to keep like
waiting on the faucet or something yeah and i mean if you have uh like actual application not like
like actual application not like i mean i'm i'm just guessing if you are just uh
running out of funds by doing nothing or just i'm not i'm i mean i'm just you'd have to post
a good bit of data to run out of uh to run out of funds but like yeah it's pretty easy to do it
if you're filling two megabyte transactions up.
I didn't show, like, yeah, if you were to use the Gmemo,
like the application I was showing you earlier,
you could actually dump in two megabyte transactions
into that of whatever text you wanted.
But it'll cost a little bit more, like significantly more
like significantly more than just you know sending 100 bytes
than just sending 100 bytes.
understood and josh with that i think we can conclude here because there's no question as of
now but again if there is any question or you need testnet funds make sure to hop into celestia's
discord because they have a faucet there as well and
someone from their team will be happy to help you if you need any support on the
dev side for sure yeah thank you again so all right thank you sai hunter um uncle big boy
jandeep for tuning in it's always good to have some people in the chat
Thank you, Jandeep, for tuning in.
It's always good to have some people in the chat.
Poshy 100% keeps the morale going.
All right, everyone, thank you so much for joining us.
And first of all, thank you so much, Josh, for joining us.
Thank you so much for having me.
You're welcome.
Thank you so much for showing us that awesome demo.
And yeah, the same person said and yeah,
yeah, the same guy said, the same person said, yeah, and you guys should be give airdrop.
Not anymore.
Verifiability though, come on, verifiability.
That's a superpower.
Not everyone can have that.
Better than airdrop, I guess.
But yeah, you can get your like testnet tokens airdrop to your wallet if you go to Fawcett.
Yes.
On that note, we can end the stream.
And thank you, everyone, for joining us again.
Thank you again.
Don't forget to build whatever.
Thanks, Josh.
Peace.
