Starknet Architecture
The picture loads from YouTube. The player loads only when you press Play. Turn on captions in the player if you need them.
A speaker teaches a long class on the StarkNet architecture while students ask questions throughout. It covers sequencers, provers, nodes, transaction types and finality, data availability and layer 3 app chains, with comparisons to Ethereum validators. The session ends with advice to contribute to open source projects through a developer platform.
Not by We Them Media Channel: Web3Bridge. Published Monday 10 June 2024.
Titles are the owner’s. It plays from their channel.
Watch it on YouTube (opens in a new tab)
Transcript
This transcript may contain errors. This video belongs to Web3Bridge. Letters mark each change of speaker.
These are the speakers’ own words. We have not checked their claims.
1:09 A: All right, so, um, let's, let's get right into it. All right. I hope everyone can hear me.
1:49 B: Yeah.
1:52 A: All right, so today we want to talk about the StarkNet architecture. So we want to look into the StarkNet architecture. So what are those things that makes up the StarkNet? So when you hear the word StarkNet, you know, there are a couple of components that makes it up. So we want to look at and understand each of those components, their roles, so that when you start hearing stuff like sequencer or app chain or, you know, STWO, like that, like that, like that. You won't feel that, ah, is the StackNet that these people are talking about, is it different from the ones that we learned? So firstly, the, um, so these are introductions to StackNet Layer 2. So StackNet is a coordinated system. So with each component, so the components that we have, we have sequencers, approvers, and the playing a specific yet interconnected role. So each of them, they have their roles, and the roles are very specific, though interconnected. So although StarkNet hasn't fully decentralized yet, so which means that currently StarkNet is still a centralized system, so it's actively moving towards the goal. So this understanding of the role and the interaction within the system will help you better grasp the intricacies of the StarkNet ecosystem. So let's have a high-level overview of everything. So the StarkNet operation begins when a transaction is received by a gateway, so which serves as the mempool. Now we all know what mempools are, right? Yes. So what are mempools?
3:56 B: They are where transactions are kept temporarily until they are executed.
4:04 A: Okay, so it's a- it's like a queue. It's a queue of unexecuted transactions. So the transaction is initially marked as received. So which means that when it gets to the mempool, it is marked as what? Received. Then the sequencer then incorporates the transaction into the network state and tags it as accepted on L2. Final steps involves the prover, which executes the operating system on the new block, calculates its proof, and submits it to layer 1 for verification. So this is the simple- so we have the gateway which serves as the mempool. So, and the transactions are, you know, they are sequenced. So when you say that they are sequenced, those are- they are arranged or they are ordered, and then they are executed. So when they are executed, they are marked as accepted on L2. Then the prover, the prover is now going to generate, you know, the prover will first and generate the proof. The proof will then be submitted to the layer 1, which is the Ethereum. Now at layer 1, the layer 1 will then update the state. The layer 1 is going to update the state root of, of the StarkNet based on the validity of the proof that is sent. So the StarkNet architecture in essence Sidechain architecture involves multiple components. So we have the sequencer, which is responsible for receiving transactions. It operates similarly to validators on Ethereum or Bitcoin. So we know what validators are on Ethereum, right?
6:01 B: Yes, sir.
6:06 A: What are validators on Ethereum?
6:07 B: Um, they, uh, I think execute transactions. They are the ones that create blocks and, uh, uh, I like add those blocks to the blockchain.
6:25 A: Okay, so how do they create blocks?
6:33 B: Um, if you are using, um, uh, proof of stake in, uh, in Ethereum, the execute- Yes. The- sorry?
6:42 A: I said that's what is used on Ethereum.
6:45 B: Yes, yes. So, uh, they execute the transaction and, uh, uh, so those transactions are batched into blocks, then they are added to the network and is being broadcasted to other nodes.
7:07 A: Okay, so you know that the way the proof of stake works on Ethereum- okay, let me ask you a question. What is the consensus algorithm that is used on Ethereum? Proof of work. You guys just finished developing. Let's see what the consensus algorithm-
7:33 C: who wants to take? Who wants to take? Hello?
7:41 A: Consensus?
7:44 C: Yeah, I'm not sick.
7:45 A: Consensus mechanism? I'm saying the algorithm. Is it,
7:51 C: um, are you referring to when I went to touch of, uh, to touch, um, of, um, to touch of the notes, uh, in agreement to add the blockchain? Huh?
8:07 A: What's the name?
8:09 C: What? Ekarika. Ekarika.
8:22 A: Ekarika. Yes. I've not heard about that before. No, I'm not asking of you. Not your name. I mean the name of the person.
8:34 C: Oh, okay, okay, okay, okay. Like Um, no, I don't think it's that. I don't think that one is just- that one is encrypted.
8:56 A: Yeah, the consensus algorithm is Casper FFG now. It's Casper-friendly Finality gadgets. That's what I thought about the-
9:12 C: Sir, please, can you, can you come again with that name?
9:16 A: Casper FFG.
9:20 C: Oh wow, that's nice.
9:27 A: Casper the Friendly Finality Gadgets. Yeah,
9:31 C: yeah, I think I've heard that name once. So like, how, like, how exactly does it work?
9:36 A: How it works? And you've said it now, you said how it works.
9:40 C: Okay, the 2/3, reaching 2/3 of the total supply. Exactly. Oh wow.
9:48 A: You know that, uh, you know we have validator pools, right? So validator pools are before you can become a validator, you need to have some- you need to have the execution client. Yes, um, the full node. And also, you also have staked 32 ETH, right?
10:14 C: Yes.
10:16 A: So then, you know, there's the round robin algorithm that is going to randomly select Yes,
10:25 C: yes, randomly select
10:26 A: nodes. Yeah, yeah. So those people that are selected, you know, he's going to choose a leader among them, and the leader is going to look into the mempool and he's going to pick transactions.
10:38 C: He's going to pick a block.
10:39 A: Yes, he's going to create a block and pick transactions from the mempool. So then the transactions will then be you know, it's going to be broadcast to the other validators and they are going to verify the transactions. And, you know, the 2/3, like that, like that, that's where the penalty gadget comes in. So that's how blocks are produced on layer 1. So in the layer 2, on StarkNet, So we use what we call the what, uh, sequencers. So the sequencers, they are responsible for receiving transactions. So we already know that what the gateways- from here we already know that the gateways, that's, that's what is serving as our main pools, right? So when the sequencer receives transactions, then it's going to, um, it's going to order those transactions Then it's going to produce a block. So it operates similarly to the validators on Ethereum. After that, the prover- so we now, you know, when you've executed that, it now sends the transaction, you know, it's going to now send it to the prover. So the prover starts generating proofs for the created blocks and transactions. So it uses the Kyros virtual machine to run proving programs. thereby creating execution traces necessary for generating stack proofs. So which means that it is the prover that now, you know, the transaction normally it has, it has passed. So the prover will now generate the proof for those transactions. Then on the layer 1, which is Ethereum, it hosts a smart contract that is capable of verifying these stack proofs. The proofs are valid. the state- the StarkNet state root on layer 1 is updated. So StarkNet state is a comprehensive snapshot maintained through Merkle trees, much like in Ethereum. This summarizes the architecture of the Validity Rollup and the roles of each component. So for a more in-depth look at each component, we have to read on. So let's look more on the sequencers. So they are the backbone of StarkNet network. They are like the Ethereum validators, they usher transactions into the system. So validator rollups excel at offloading some network calls like bundling and processing transactions to specialized players. This setup is somewhat like how Ethereum and Bitcoin delegate security to miners. Sequencing, like mining, demands hefty resources. So for networks like Stacknet and other platforms utilizing Byzantine rollups, a similar parallel is drawn. These networks outsource transaction processing to specialized entities and then verify their work. These specialized entities in the context of Byzantine rollups are called sequencers. So instead of providing security as miners do, sequencers provide transaction capacity. So they order multiple transactions into a single batch. Execute them, and produce a block that will later be proved by the prover and submitted to the layer 1 as a single compact proof known as a rollup. In other words, just as validators in Ethereum and miners in Bitcoin are specialized actors securing the network, sequencers in BFT rollup-based networks are specialized actors that provide transaction capacity. So the mechanism allows Validity Rollup to handle a higher volume of transactions while maintaining the security of the underlying Ethereum network. So if we look at this now, we already know that- so if we look at this now, we already know that the You know, the TPS on Ethereum is around 15 transactions per second. So the sequencers on StarkNet, it's what makes StarkNet be able to, you know, um, take in as much as over 1,000 transactions per second. So when it takes in those transactions, a lot of them, and it executes them, it's orders them through this block, execute them. Then it's now going to take the block, it will, you know, it's going to send it to the prover. The prover runs a Cairo virtual machine which generates the proof, the stack proof, on those transactions. And the stack proof is then sent to the Layer 1, right? So sequencers must be reliable and highly available. So you see that sequencing, it collects transactions from users and orders them. Executing- so these are the things that a sequencer does. Sequencing, sequencer- so which means sequencer, it's what it sequences. So sequencing means ordering of transaction. Executing means processing of transactions. Bashing means grouping of transactions, and block production is, you know, all the transactions that it has bashed together is going to produce a block for them. So sequencers must be reliable and highly available. So what's the meaning of reliability? So when you say that something is reliable, it means it is Consistent. It is consistently good in quality or performance.
16:39 D: Yeah, it does not fail.
16:41 A: It does not-
16:43 D: It does not fail.
16:46 A: It does not fail. Um, is that it? Reliable is just about- reliability is just about, um, like, just- yes, you can count
17:01 E: on it.
17:01 A: You can count on it. Thank you very much. You can count on it. So it is very dependable. So then availability also, you know, it has to be available. So as their role is critical to the network's smooth functioning, so they need powerful and well-connected machines to perform their role effectively, as they must process transactions rapidly and continuously. So the current roadmap for StarkNet includes decentralizing the sequencer role. So which means that Currently, the sequencer- we have just one sequencer, which makes it centralized. It is currently centralized. So shifting towards decentralized, we allow more participants to become sequencers, contribute to the robustness of the network. So when you say that a network is robust, it means that, uh, it is, it is strong and good condition. and it's able to withstand adversity. That's the meaning of robustness. So do we all understand what is meant by what sequencers do?
18:12 F: Can you hear me?
18:18 A: Yes.
18:22 F: Okay, so you just said StarkNet is centralized. Uh, can you explain?
18:29 A: Okay, so like sequencers, the sequencers on StarkNet, they are currently centralized. So centralization is just, you know, when you have just one thing that is doing it, that's just the meaning of centralization. when you have one, if one entity is doing something, that's, that means it is centralized. So which means that if that particular net- that entity fails, if it fails, then you know the network has failed. Do you get that? So decentralized, decentralization means a lot of entities are doing it. a lot of entities are like, nobody has the control, so everyone keeps their control. So, and whenever we have a decentralized system like that, then there has to be a consensus, um, mechanism. So which means there has to be a source of truth. There has to be a source of truth. Like, how do you know if like 3 people are doing something. So there is possibility for disputes, or, you know, one of them can be a bad actor. So how do you, um, how do you resolve conflicts? That's where consensus mechanism comes in.
19:55 F: Okay, so, uh, I want to see sequencers as nodes in layer 1. So they are like nodes, right?
20:06 A: Sequencers, they are not- they are like validators. Do you get? They are like validators on layer 1. They are like the validators. So we said that these sequencers, they do 4 things. Number 1, they sequence transactions. They do what? They sequence transactions. What does that mean? It means that they order transactions. Just like validators, you know, when you have validators, when you have validators, there has to be a leader amongst them, right? And it's the leader that is going to take up the transactions from the mempool. And when it takes up the transactions from the mempool, it's going to broadcast this to other ones, then they are going to verify it, and the Casper finality- friendly finality gadget comes into play. So in this case too, so the sequencer, so it's going to order, order the transactions, then it's also going to execute those transactions. Then after that, it's going to batch, that is group those transactions together, and it's also going to produce block. So it's the sequencer that is, that is, uh, that is doing all of this work, producing block. So currently, sequencer-
21:34 C: So what then does the prover just do? It just checks the transaction that the sequencer is bringing in?
21:42 A: What did you say?
21:45 C: I said the prover, what then is that work? Is it like they just check the transactions that the Sequencer is bringing in-
21:55 A: The prover is going to take in that block and it's going to generate the execution trace for it. Generate the execution trace. You know, there is a difference between execution and the execution trace. The sequencer, it executes the transaction. The prover generates the execution trace. The execution trace is used to generate the proof, which is sent to the layer 1. So the layer 1 is going to verify- in the layer 1, you have a smart contract that verifies, uh, the proof, and if it is true, it updates the state of StarkNet on layer 1. Is there something still confusing? Is there anything still confusing?
23:04 C: No, no, it's fine. I think I'll just check more, but then I was still trying to get the gaps. the sequencer and stuff. But then I think I get the idea. I get the whole idea with sequencer being like validators and then the approvers checking the- it's just a little perplexing, but I don't draw the class back. That's why I'm just not wanting to.
23:30 A: What did you say?
23:31 C: Like, I'm not really getting the whole scope of the sequencer. Like, so like, I was just like trying to fit it in, but since you said it's like, um, a validator on the Ethereum network, so I'm just trying to like, okay, equate them together. But then that is at the- the- I'm just trying to relate where the, the, the proof of work now comes in. Like, is it like they take the transaction and they start hashing there and stuff like that? Like, it's just- I'm just- it's just playing around in my head.
24:05 A: Okay, okay, um, let's, let's do it small, small, right? Uh, sequencer, it has just 4 functions, right? Number 1, it's going to take, you know, it's going to receive plasmid transfer which we- which is equivalent to mempool. Now it will now sequence. Sequence means it will order the transactions, then it's going to execute. So when you say that something- when you say that you are executing something, right, executing is just to- when you execute a transaction, you know, there's going to be a state change. Like if you execute a particular function now.
25:01 C: Yes, yes, yes, yes.
25:04 A: So you know if it is, uh, if it is, uh, if it runs successfully or not, and the, you know, all the differences that it should bring about. So that one is execution. Now execution is different from execution trace. Execution trace is You're looking at step by step, like the step by step of, um, execution is- execution trace is about like showing workings. It's just like you're in a math class and, uh, your teacher asks you that x squared minus 5x plus 6 equals 0, that you should solve it. So as you Executing the solution will tell you that what, x equals to 3 and y equals, um, like x equals to 3 or 2. Let's say that x equals to 3 or 2. Now execution trace is going to be that you say, uh, you know, subtract those, uh, subtract this from both sides, half the square of half of, uh, coefficient of b to both sides. find the square root of both sides, subtract this from both sides like that. So that's like execution trace. So the execution trace is needed to generate the proof. So that proof is what is now sent to layer 1. So the proof is what tells us that what the exact sequence is. Correct. So which means that you don't have to be running everything that the sequencer has already run. You don't have to be running it on the layer 1. It just validates that, okay, the proof is correct and it updates the states.
27:00 C: Makes sense, makes sense. Yeah, I'm getting it.
27:07 A: All right, thank God. So then we now have the prover. Where is the sequencer? Okay, the prover. So the prover serves as the second line of verification in the StarkNet network. So their main task is to validate the work of this. Do you see that? Their main task is to what? Validate the work of the sequencers when they receive the block produced by the sequencer. and to generate proofs that these processes were correctly performed. That's- so what they do is they validate work of the sequencer and generate proof. Now, the duties of a prover include receiving blocks. Hey, you people are sleeping. Sequencers receive what? Transactions. Transactions. Provers receive what?
28:13 B: Blocks.
28:17 A: Blocks. Thank you. So they receive blocks. So block- provers obtain blocks of processed transactions on sequencers. Now, processing. So provers process this block a second time, ensuring that all transactions within the block have been correctly handled. Then proof generation. After processing, provers generate a proof of correct transaction processing. Sending proof to Ethereum. Finally, the proof is sent to the Ethereum network validation. If the proof is correct, the Ethereum network accepts the block of transactions. So provers need even more computational power than sequencers because they have to calculate and generate proofs. They have to calculate and generate proofs. So, you know, if you look at using that as an example again, x squared minus 5x plus 6 equals 0. So I squared minus- it is possible that you can, if they ask you to solve it, for it is easier for you to like to solve that, uh, you can solve it than to prove that you solve it correctly. So that's the difference between the sequencer. So the sequencer will just solve it and get the final answer, but the prover it's going to make sure that, okay, what the sequencer did is correct. Then it will now generate a proof of execution. Proof of execution. So the design of StarkNet relies on these 2 types of actors, sequencers and provers, working in tandem to ensure efficient processing and secure verification of transactions. So Then talking about optimizing sequencers and provers, debugging common mistakes. So the relationship between sequencer and provers in blockchain technology often sparks debate. The common misunderstanding suggests that either the prover or the sequencer is the main bottleneck. To set the record straight, let's discuss the optimization of both components. So StarkNet, utilizing the Cairo programming language, currently supports only sequential transactions. So plans are in place to introduce parallel transactions in the future. However, as of now, the sequencer operates one transaction at a time, making it the bottleneck in the system. In contrast, provers operate asynchronously and can execute multiple tasks in parallel. The use of proof recursion allows for task distribution across multiple machines making scalability less of an issue for provers. So since the asynchronous and scalable nature of provers, focus in StarkNet has shifted to enhancing the sequencer's efficiency. So this explains why current development efforts are primarily aimed at the sequencing side of the equation. So if you hear tomorrow or next tomorrow that Uh, StarkNet, in the- if you see in the roadmap of StarkNet that there is something called transaction parallelization, do you understand what it means now? Do you understand what it means? Yes, yes, parallelization. So which means that currently on StarkNet The sequencers undo or they execute the transactions one after the other, like one transaction at a time. So, but this, uh, but the, the, what's it called, the prover. So the prover, because it has recursive proof, because it has recursive proof, so it means it can, you know, it can distribute its tasks and asynchronously through a particular block. Then we have nodes. When it comes to defining what nodes do in Bitcoin or Ethereum, people often misinterpret their role as keeping track of every transaction within the network. This is not entirely accurate. Nodes serve as auditors of the network, maintaining the state of the network, such as how much Bitcoin each person owns or the current state from a specific smart contract. So they accomplish this by processing transactions and preserving a record of all transactions, but that's a means to an end, not the end itself. So in validity rollups, and specifically within StarkNet, this idea is somewhat reversed. Nodes don't necessarily have to process transactions to get the state. In contrast to Ethereum or Bitcoin, StarkNet nodes aren't required to process all transactions to maintain the state of the network. So there are 2 main ways to access network state data via an API gateway or using the RPC protocol to communicate with the node. So operating your own node is significantly faster than using a shared architecture like a gateway. Over time, StarHub plans to deprecate APIs and replace them with the JSON-RPC standard, making it even more beneficial to operate your own node. So it's, um, worth noting that Equally, more people to run nodes increase the resilience of the network and prevent server flooding, which has been an issue in networks in other layers. So currently there are primarily 3 methods for a node to keep track of the network state, and you can have nodes implementing them. Number 1, replaying old transactions. Number 2, relying on L2 consensus. And number 3, checking for validation on L1. So each type of node setup comes with its own set of hardware requirements and trust assumptions. So nodes that replay transactions- nodes that replay transactions require powerful machines to track and execute all transactions. So these nodes don't have trust assumptions. They rely solely on the transactions they execute, guaranteeing that the state at any given point is valid. So these ones, they require- they don't have trust as option, so they rely solely on transactions to be executed. So that's for the first one, they have to complete transactions. So nodes that rely on L2 consensus- so nodes relying on L2 require less computational power. They need sufficient storage to keep the state but don't need to process a lot of transactions. So the trade-off here is a trust assumption. Currently, Stakeway revolves around one sequencer, so these nodes are trusting Stakeway not to disrupt the network. Trust me, bro. However, once the consensus mechanism and ledger election are most sequenced, these nodes will only need to trust that a sequencer Next question. Those that only update their states based on proof validation require the least hardware, so they have the same requirement as an Ethereum node. And once Ethereum Lite nodes become a reality, maintaining such a node will be as simple as using a smartphone. So the only trade-off is latency. Proofs are not sent to Ethereum every block, but intermittently, so resulting in delayed state updates. Plans are in place to produce proofs more frequently, even if they are not sent to Ethereum immediately, allowing these nodes to reduce their latency. However, this development is still a way off in the StarkNet ecosystem. So, conclusion. Through this chapter, you delve into the StarkNet structure, uncovering the importance of sequencer, prover, and nodes. So, and each has its own unique role to play. So, and as we venture further into the StackFlow universe, our next stop will be exploration of transaction lifecycle before we delve into actor-coding. So do we have questions based on these points?
36:53 C: Yes, sir. Does, um, does Kygo use blobs, or does Tacnet, sorry, use blobs? What? Does Tacnet use blobs?
37:13 A: Sorry, I didn't get it.
37:16 C: Does StarkNet, do they use blobs? Like, do they use blobs?
37:19 A: Oh, okay, okay. Yes, they use blobs.
37:24 C: So if they use blobs, then I see- I'm still trying to understand. I understand that the, the prover receives the block and does a kind of calculation to ensure that all the transactions in the block Uh, I've been properly well documented or well checked.
37:46 A: Sorry, sorry, can you ask the first question?
37:50 C: Imagine if StarkNet use blob.
37:54 A: Blob.
37:54 C: Blob.
37:55 A: Yes, yes,
37:59 C: yes. So like, I'm trying to understand if StarkNet use blob, um, blob, I mean, and then like blob, B-L-O-B. Yes. So if StarkNet uses block, meaning that each transaction is coming in or will be sent to, to, um, to the layer 1 as, as a block. So like, is it like it is when it is before the prover checks through the block of transactions or confirms the transaction, um, that it is now converted to a block, or before it gets to the pool. At what point, like, does it convert it to a blob before it finally goes on the L1?
38:41 A: So thank you very much for that question. Um, it shows that you very much understand what's happening. So firstly, uh, let's understand what a blob is. Um, you know, we have Normally, the normal way of transacting is- so you can make use of what we call the call data. We all know what call data are, right?
39:08 C: Yes, sir. Yes, sir.
39:11 A: So when you now say blob, blob, uh, blob is much more different. So in fact, the first time that, you know, blob is like- it's blob you can send image you get. It's like, uh, it's like the data format in which images are even sent, and you know how big that can be. So now let's, let's just run through the StarkNet architecture again, you know, and let us think if there is a plugin in StarkNet, where can it, where can it be? So we know that You know, there is gateway, which is like the mempool where the transactions are sent. So, and the sequencer sequences them and executes them and, you know, produce block. And the sequencer produces block and this block is now sent to the prover. Do we get? Now the prover that gets the blob, that gets the block, now that block is now re-executed and the, you know, the execution trace is used to generate proof. Now the proof is now sent to layer 1. Before? Before the- is it decorum or is Is it Dencom? Yeah, I think it's Dencom fork. Before the Dencom fork, so the only way to interact on the layer 1 is by using what is what we call the core data, right? So, uh, during the Dencom fork with the EIP-4844, so that's where we have the introduction of the block So with the blob, with the blob, uh, you know, layer 2s can now send their proofs, their proofs to layer 1 using blob. So which separates their own gas fee competition from the, uh, from the normal users. And that greatly reduced the fee that for most of the chains on Layer 1. And that's the reason on StarkNet currently, the transactions are very, very as low as a cent for running transactions on StarkNet. And that's because of the Demcom fork or the introduction of EIP-1559. call it OPFOR, which allows the use of blobs in sending, in communicating with the L1. So you can already see that it is the prover that is going to be sending its own proofs as blobs to the Layer 1.
42:18 C: Yeah, yeah, yeah, it makes sense. So that means that how does the Layer 1 now confirm that what the prover attests to is correct. And I understand that the prover have done- like, this is my question now. Now, before the Dencom fork, now the, um, um, the, the layer 1 has their way of interacting with layer 2s, and they just do that to get transactions. Or probably let's leave it at layer 2 paywall. They get the transactions and then go through the, um, verify the transaction and and all this stuff. And now instead of transactions, they're now getting blobs, they're not getting proofs. Like, since the proof- I have proof trace. So do the layer 1 also have their own proof trace to be able to follow up and check the-
43:10 A: Do the layer 1 also have their own?
43:14 C: Like, do they have a kind of like proof trace to be able to ascertain what- yeah, to to be able to ascertain the proof that the, that, um, the Layer 2 is sending to them? Or how, like, how exactly does the Layer 1 confirm this transaction? You know, before, the Layer 1 have their checkers, they have their checkers, their validators that validate these transactions and stuff like that. But now they are receiving proofs, they are receiving proof. So how do they confirm all the transactions that have been proven? What if Layer 2 is a kind of thief that is trying to manipulate something and sending it to Layer 1, something like that.
43:56 A: So that is where ZK proof comes in. That's where ZK proof comes into play. So let me- I'm going to try to be slow. I think I've been slow actually. But what I just want to say is, if I'm going to be saying some things, if you don't understand, just continue to be asking questions. I believe it's going to be a net positive, um, effect or learning experience for everyone. Uh, so yeah, when we talk about, you know, the reason we have StarkNet and other layer 2s is so that we can solve a particular problem. So there is a problem that we have with, um, decentralized systems, which is that number one, we have what we call the blockchain trilemma. The blockchain trilemma, which is that a blockchain cannot be decentralized, secured, and scalable, right? So So it cannot do all of those things. Now the number- uh, we now have Ethereum, which is decentralized and it has a very big security, but it has 15 transactions per second as what- as the, um, as the TPS, as its throughput. So we now have different ways in which, you know, you can scale Ethereum. So there are different ways. We now have what we call what the rollups as one of the ways in which you can scale Ethereum. We now have 2 types of rollups. We have what we call the optimistic rollup and what we call what the validity rollup. So when you say that something is optimistic, you are optimistic that, you know, you are just optimistic. Optimistic is like you have an inherent good behavior unless you prove it otherwise. So what this means is that if I want to- if I'm giving you money, right, you are optimistic that the money that I gave you is what? Is original, right? Unless there is a- unless someone tells you that what this money is, what is fake. That's when you can now start saying that, oh, because there's no way someone will just give you money and you're like, ah, this one is fake or something, unless you are, you know, you are first optimistic that, oh, you don't even check most of the money that you collect. You collect the money, so it's when you now realize that someone tells you that, ah, this one is fake, you now start going back to, you know, there's going to be a contesting. So for optimistic proof systems, for optimistic rollups, they usually have a contesting period which is that when a transaction goes on, you know, you have a particular period for you to contest that this transaction is, um, is right or wrong, or, uh, there is a fraud case. So, and it's going to be- well, when you now say that something is what, validity, it means as you are sending the transaction, you are also sending the proof that this transaction is what? Valid. correct, right? So for validity rollup, just like I've mentioned, the prover is going to send the proof that the transaction is correct. It's going to send it to a contract on layer 1, and that contract is going to verify that it is true. So if it is true, it's going to update states of the- of StarkNet on the layer 1 contract. is going to- so if it is not true, it will not, it will not, uh, you know, you might be thinking about how, how is it that, uh, how will it be able to generate proof and all of those questions. If you have specific questions-
47:59 C: Yes,
48:00 A: yes, yes, that one is, is a lot of, it's a lot of mathematics.
48:04 C: Because, because you just mentioned that it isn't zero knowledge, that means it does not know what is coming Or it does not know this, but yet it's able to verify.
48:13 A: So when we say zero knowledge, it means that zero knowledge there means that it doesn't reveal any other information apart from the fact that this thing is what is correct. It doesn't- zero knowledge means that it doesn't take in any information about, about it. The only information that you can only derive from it is the fact that this is correct. In fact, when you say Cairo, you know, I think I mentioned it when I started taking the Cairo class. Cairo is, uh, you know, this one is- we say proof of correct execution. That's what you do with Cairo, proof of correct. And Cairo is a- is a provable programming language, which means that when you write a program on Cairo, if someone executes that program, they can generate proof of correct execution. In fact, they can generate proof of execution for that program. They can generate proof of execution for that program. So when they generate proof of execution for the program, the next person don't need to, you know, re-execute it You just need to make sure that, okay, the crew- you just need to check that the proof is what is correct. If you want to understand how everything goes Can I hope everyone can hear me, sir?
50:02 C: Yeah, we can hear you
50:04 A: now. Yeah, so someone was raising his hand before. Okay, okay.
50:12 G: Yes, um, it means that with Cairo programming language there's no need to learn ZKPs now, the technology of, um, the Zero-knowledge proofs.
50:24 A: Yeah, so this, you know, about building on Ethereum, you know, you can build on Ethereum at the application layer, or you can build on Ethereum at the protocol layer. So at the application layer, you just learn about Solidity and how to write Solidity. At the protocol layer, how do you even build the Solidity itself? How do you build the architectures and all of those stuff like that? So that one is different. Those are 2 different things. So when you talk about, um, Cairo, yes, Cairo- with Cairo, you can write provable programs. With Cairo, you can write provable programs. So it's just like you are the, uh, you are the consuming end of it. Because if you now want to understand what happens in Cairo, if you want to understand what happens in Cairo, then you need to, you need to learn a lot of things. Number one, uh, you need, you need to learn a lot of things. The Cairo itself, what does it do? Cairo means CPU Algebraic Intermediate Representation. So which means that when you write, the way Cairo works is different from the way normal programming languages work. When you run normal programming language, when you run Solidity, for example, Solidity runs on the Ethereum Virtual Machine, which is like, which is more like, uh, a virtual machine like the normal, uh, which is more like the normal, normal way computer programs run in binary. It's in binary. But for Cairo, it's different. In Cairo, it is, uh, when you have Cairo, you are going to convert the Cairo towards- to Sierra. Sierra means Safe Intermediate Representation. So the safe intermediate representation, what it does is that it makes sure- so it's actually in Cairo 1 that you now have the introduction of safe intermediate representation, which means that with safe intermediate representation, you can- when you write a program in Cairo, it cannot fail. There's nothing like panic or anything. It cannot- the program cannot fail. That's why when you write your smart contract and you build it, you have- it's going to produce the what? The car, um, this Sierra and then the Kazim. So those ones, they cannot fail. They cannot fail. So when you have those ones that cannot fail like that, that's like the starting point of, of, um, of your transactions. Now in the Cairo Virtual, in the verifier also there are some things that it's also looking at. So actually, if you want to understand most of those things, you need to take the Cairo white paper and read the Cairo white paper. When you read the Cairo white paper, you are going to understand a lot of things about the architecture. It uses the read-only model. So like, you know, normal In the normal computer, you'll be able to like read and write, but this one you can only read. So instead of- how do you now write it another way? So you understand the meaning of int, you understand the meaning of, uh, you have int, you have, uh, what again? Yeah, uh, we have int, we have Oh, I've forgotten the name of that one. But if you read the Kaggle white paper, if you want to understand what happens behind the hood, like the proof that is generated, how does it generate it, how does it, you know, do all of those stuff, then you need to go deep into the Kaggle white paper for you to understand all of those ones. But right now, what you need to understand is that the programs that you write, uh, all the programs that you write, they are represented as what? Safe intermediate representation and can be proved. So when you run a particular program, it generates- it's going to run it and generate the execution trace. And that execution trace is now used what? To generate the proof, which is sent to a contract that verifies it. So the way it verifies is that when you send In fact, the, the things that are verified there, we have- it's going to take the PC, like the program counter, uh, the PC at the beginning, the initial state, you know, all of those, all of those stuff like that. So yeah, someone is raising- yeah. You can- someone is raising hand. You can call.
55:35 C: Okay, so like now, now this is like a, a little deviation out of the talk. Now I swear that I was trying to write- I was trying to just start to probably maybe write a simple smart- a simple smart contract using Cairo. And now it's, it's now dawned on me that one, I don't have a VS Code extension telling me when I'm wrong and stuff like that. I know that one, there will be an extension. So I don't want to use time to ask if I can get- if you can suggest an extension that can be checking my code for me, like, while I'm writing that. But that's by the way. The major question I want to ask is this: is there something like Remix for Cairo that you can use to check your contract, compile it, and then deploy it and be able to check out the function? Because right now, as I'm writing the contract, I'm just realizing- it's dawning on me that I have to write the tests too in, in order to be able to test the, the contract. So like, is there a way out, or that's just the way it has to be for now? Like, I have to just write the contract and then write the test for it, then, then please Back to question 1, please don't forget the extension that would help mark out all those ones that show red lines when you're writing nonsense, because I'm expecting my whole project to have a lot of red lines.
56:58 A: I did not get the last question.
57:02 C: No, like, I'm saying don't forget my question on that you should help suggest an extension that one can use in VS Code that will show all those red lines when you're writing nonsense. nonsense. Because my
57:17 A: code now is showing a lot of extension.
57:21 C: I'm using Cairo 1, but it does not show any red lines.
57:25 A: The reason it's not showing the extension is most likely because you have not set it up yet, most likely. So either, you know, it's just like Rust also. In Rust, if the code that you are writing, if it's not connected to the main, uh, to the main crate, to the main this thing, it's not going to show you if it is, uh, it is wrong or right. So which means that whatever code-
58:00 C: So how do I add that bit?
58:01 A: So let's say, if, let's say, um, okay, let me Let me try to stop presenting. So let's say I am So, so let's say I create the, uh, what's it called, scab new, um, let's call this stack, stack app. Okay,
59:41 C: does it matter that I'm using SM4 instead of CAP?
59:44 A: It doesn't matter. So you see this, lib.chiro here. This is like the main entry point of the contract. So if I am writing a contract, if you are writing a contract inside this place, it should tell you if what you are writing is strong or not, unless if the extension is-
60:10 C: I'm not seeing the lib.chiro, sir.
60:17 A: This lib.py, or you don't have lib.py there?
60:24 C: I do have lib.py, like I'm not seeing where your arrow is going, that's what I'm saying. But, um, like the thing is I'm not writing exactly inside lib.py, like inside my lib.py I just wrote mode, then the name of the file that I'm writing inside. So I created a new file and I'm writing inside that file, but the lib.py is like
60:44 A: If you have another- so let's say that you have something here, um, you have, let's say, contracts, huh? So if you have contracts here and inside this place you now have, um, let's say it's in this place that you have ALC20, ALC.style. Right, so you know that normally in this place now you are supposed to have a lib. How does the directory structure work here? So, and in this place, what's the name?
61:27 C: Yeah, so your screen is paused too.
61:30 A: What?
61:32 C: Your screen is paused. It's on Node.js. Starter pack API. It's your starter pack API.
61:44 A: I don't get
61:46 C: what you're doing. Your screen is-
61:48 D: what
61:49 C: you're seeing is,
61:50 A: uh, oh sorry, let me check. It's like it does the obvious sometimes. What are you guys seeing now?
62:09 C: Infinity mirror.
62:13 G: Infinity mirror.
62:17 A: How about now?
62:19 G: I see some-
62:21 C: yeah, we can see your- we can see the lib.kyro now.
62:24 A: Okay. So you need to have that contract in this. You have to have it scoped here.
62:44 F: Alex, please, your font is tiny.
62:53 A: Thank you. In this main here, that's where if you now- if you are not writing a function here, now start, uh, That's why it's not going to start. I don't even know if- let me check if Cairo extension carries- do that Cairo one also. At times it doesn't really show something. Okay, it is installed, so it's going to- it's going to start showing error. where necessary, or just use, uh, what's it called, CapBuild.
63:58 C: Okay, so even if I use, um, SMForge to create the, the project, I can use CapBuild to-
64:04 A: I use SMForge, just follow their own, um, instruction also. Just follow their instruction. So this one now, module not found. Does it work this way? So I think this thing is supposed to- hey, so Yeah, okay. Yeah, you're supposed to have functions.
66:20 C: Our secret will be moderc.kairo, like the complete name of the, of the file. I don't know, just-
66:32 A: .kairo is not supposed to be there.
66:34 C: Oh, okay.
66:50 A: But it should be something around this. Actually, I'm going to recheck it soon to see also. Okay, okay, so leave this guy open. It keeps clicking. I can't figure this out. The reason most likely it doesn't show is, is if it's not in scope. So if that contract is not in scope, just find a way to bring it in scope and, and everyone will be fine. Okay, so, um, So let's look at the transaction versions. Yeah, so understanding transaction- StarkNet transaction types is essential to mastering its architecture and capabilities. So each transaction type serves a unique purpose, and getting a grip on their differences is crucial for proficient StarkNet usage. So StarkNet POS The backbone. So central to StarkNet's functionality is the StarkNet operating system, a carrier program that powers the network. So this OS orchestrates key activities including: 1, deploying contracts; 2, executing transactions; facilitating L1/L2 message exchanges. So in StarkNet terminology, protocol level alludes to the applications in the foundational StarkNet Cairo program, ensuring a steadfast process. So we have transaction types. Declare transactions, so unique in their ability to introduce new classes leading to potential new smart contracts. We have invoke transactions, so they call upon an action but can't introduce new ones. Deploy account transactions. So designed for setting up smart wallet contracts. So declare transactions. So these are- so the transactions are the sole mechanism for introducing new smart contracts to StarkNet. So if you want to, you want to deploy a smart contract on StarkNet, then you have to firstly declare the transaction. So when you declare it, it's going to give you the, um, class hash. Then you can now use that to deploy, uh, the contract. So you see that the core programming in C++, before employing a variable or function, it's first declared, signaling to the compiler its existence and type. Only then can you define or use it. Declare transactions and start operation. Operates on similar principle. They announce the new operation, prepping it for future. So we have version 0 suited for Cairo 0, version 1 tailored for Cairo 0 with nonce, and we have version 2 optimized for Cairo contracts, modern Cairo contract. So here is a key distinction to understand the difference between the Cairo versions. With Cairo Zero, developers sent Cairo assembly code directly to the sequencer, but with the contemporary Cairo version, they send Sierra code to the sequencer. So breaking it down, Cairo Zero compiles straight to Kasm, while the current Cairo version compiles to Sierra, which subsequently compiles to Kasm. The crucial difference is that Sierra executions are infallible and always provable, whereas in Cairo Zero, transaction could fail if they did- non-provable. The latest Cairo iteration ensures all code compares to Sierra, making every transaction reliable. Do we understand that? I believe I have explained it previously, right? Yes, we did it. So no question, right? When declaring a contract with the latest version, developers are essentially announcing Sierra code, not just raw Kasm. Examining the parameters of the V2 transaction reviews measures that ensure the class hash corresponds to the the serial code being dispatched. Class hash incorporates the hash of the Cairo assembly code, but since developers send serial code, it's imperative to ensure that the dispatched code aligns with the indicated class hash. So in essence, in essence, using the most recent Cairo version implies the utilization of the latest declared transaction version. So The invoke transaction. Unlike declare transaction, invoke transaction doesn't add new functions. They ask the network to carry out actions such as executing or deploying contracts. This method contrasts with Ethereum, where a contract can either be deployed by sending a distinct transaction or by having another smart contract factory to deploy it. StarkNet uses only 2- only the second method. So the universal deployer contract is StarkNet illustrates this idea. So utility helps to deploy contracts. This mirrors how in C++ a declared function is used to perform tasks. So in computer science, think of how functions operate on C++. After declaring the functional object, you invoke it to take action. StarkNet invoke transaction works similarly, activating pre-declared contracts or functions. So every invoke transaction in StarkNet undergoes validate and execute stage. What do you- am I clear? Yes,
75:17 F: sir. Yes, um, this class hash, right? Is it the hash of the, uh, the module?
75:30 A: Is it
75:30 F: the hash of the module? Because I'm trying to understand what's the hash to get the class hash.
75:36 A: Okay, so when you declare a transaction, I mean, when you, when you want to deploy a contract, right? So you are going to declare the contract. So the class hash, the hash is the hash of the contract. You know, the contract, the way the contract is, you hash it, you now get the hash of the contract is what is called the class hash in this case. And there's actually a reason, um, StarkNet is also using, um, Last hash in that case also. If you read the Cairo whitepaper, you understand it.
76:25 F: Okay, so when you say the hash of the contract, is it that the whole code was hashed? Yes. The whole Cairo code? Yes.
76:40 G: Just like that, it's already
76:42 A: done. So which means that if you should change, which means that you have to, uh, you cannot deploy the same contract twice. You cannot declare, not deploy, you cannot declare the same contract twice. So if you've declared a particular contract before, uh, and you now declare that contract again, it should give you the same class hash and tell you that, oh, it has been declared before. So if you see an already declared contract, even if you are not the one that can still deploy it. So which makes sense, it's that on StarkNet, if you want to verify a contract, you just have to verify the declared Sierra. So when you verify that, just, just that one, you know, it applies to, applies to everything. Though on Ethereum it makes sense too that when you, you know, when you verify one contract, if it's a factory contract, it's going to automatically verify other ones also. But this one is still- it still makes more sense. And when you, um, when you read the Cairo whitepaper also, you know the reason why it's using the class hash. It uses that class hash to load, uh, to load the particular contract. You want to call the contract, you just use the class hash to load that contract.
78:08 F: Okay, so in terms of my address, my account on Bravo Sergeant wallet that I deploy, right, to Is there a code that has been, um, set already? Yes, these addresses.
78:30 A: Yes, so that's the- now if you now look at this, is that deploy account? Wait, every- look at this- every invoked transaction in StarkNet undergoes validate and what execute stages. Do you get that?
78:50 F: Uh, where are you reading?
78:54 A: Uh, she's not sleeping. Every invoke transaction, she knows it.
79:03 F: Can you highlight it?
79:06 A: This is it. Can you see it?
79:12 F: Yeah, thank you.
79:15 A: You cannot see that.
79:16 F: No, I can see it now.
79:19 A: This one,
79:20 F: okay, just covered everything. Oh, I can see.
79:25 A: Okay, so you know we've talked about declare already, right? You saw that there are 3 types of transactions: declare, invoke, and what? Deploy. Have you now?
79:41 F: Yes, yes.
79:41 A: It's like you people are already sleeping. No, we are
79:50 F: here.
79:50 A: So the second one is now the invoke. So they are telling us that every invoke transaction in StarkNet undergoes what? Validate and what? Execute stages. The validate step checks the transaction's correctness, similar to a syntax or logic check. After validation, the execute phase processes the transaction. Under that, this 2-step process focusing on utilizing existing functionality highlights StarkNet's distinct transaction strategy. You know, if you want to If you want to put, uh, invoke a particular transaction on StarkNet, but this one it passes through validator and execute. Now on Ethereum, if you want to call a particular contract, you just call it directly. But in StarkNet, it uses what we call the native account abstraction. What does that mean? It means there's no difference. There is no- there's nothing called externally owned accounts and something, something, something. So which means everything on StarkNet is what? Is a smart contract account. Which means that your wallet, the wallet that you are making use of on StarkNet, is a smart contract. So, and for smart contracts, for account contracts, they usually have what we call- they usually have this validate, uh, this execute, this execute function. They usually have it. So which is that execute function? When you want to invoke a particular transaction, it's like you are invoking- you are- what you are calling, you are calling the execute in your own smart contract, your smart contract account. It's not your smart contract account that will now call the contracts for you. So it is your smart contract that will now call that account for you. Do you get? So yeah, um, that's how things work in StarkNet. So deploy account transactions. Look at this. The challenge arises, how do you set up accounts without having one already? Because, you know, we've already said it here that you have to validate and what- and execute. When creating your first smart wallet contract, deployment fees arise. How do you cover these without a smart wallet? So the solution is deploy account transactions. Uniquely in StarkNet, addresses can accept funds even without an associated smart wallet. So this trait is private during deployment. Before an account is formally created, the validate function checks the proposed deployment address even if it lacks a smart wallet observation fund. If present, the constructor proceeds, resulting in account deployment. So the method guarantees the new account legitimacy and financial record. So which is that when you want to do I want to create a new account. The first thing you do is you already have an address, even though it is not deployed yet. You already have an address, so you have to send funds into the address first before you can now deploy it. So conclusion, it's vital to understand each transaction type, declare transaction standard Please, do you have questions as regards the transactions?
83:48 C: Yes, sir.
83:51 A: We are-
83:52 C: so, um, just like we have in Solidity where we can get ABI once we Once we compiled the contract, this class hash, is it possible to get it? Probably, maybe, well, let's say we compile the contract through a script and we compile the contract through a script and we deploy the contract through a script rather. Is there a place we can get the class hash? Yes. Yes. Under what section? Like, when will we declare? Under what section is it?
84:37 A: So actually, when you declare a contract, yeah, when you declare a contract, you come out and you- when you declare a contract The, uh, when you declare a contract, you already see the, the ABI is already part of the information that you see on. Um, you can just go to Agents, you can just go to Voyager and you get your ABI for that contract from. So then Uh, what was it again? Then yes, there is actually another distance. There is a- there is something that you can press. There is a distance there, you can check it, but there is a CLI command that you can get and the ABI. Do you get?
85:51 C: Yes, sir. Yes, sir. Although I was talking about- when I'm talking about contract, I was talking about probably maybe say not like a wallet owner, it's just say maybe a random contract that I write on my own. Like if we are- if if I deploy it, like, is it possible to retrieve the class hash, something like that? That's what I was-
86:15 A: Yes, it will give you the class hash when you declare it. When you declare it, go and check the- when you go, go to the network to check it, you see API also.
86:27 C: Okay, because why am I seeing this like this is because
86:33 A: You can use the Stack Metal PC Builder. Let me- okay, okay.
86:45 C: There was a, there was a course that just wrote a script and they just did npm run deploy direct and using that script, and they did not probably maybe Inside the script, maybe they declared it and everything.
87:02 A: Declare and deploy. There is declare and deploy if you are using scripts. If you are using, uh, um, JavaScript, no, StackNet.js, there is declare and deploy there also.
87:20 C: Okay, because, because inside the script, probably maybe they declared and then deployed. inside the script, but the, the command they used for deploying was just npm run deploy, um, npm run deploy, something like that. Can't really remember, but npm something. So like, well, like where I'm going to is if say I'm able to write such a script and deploy the contract, where can I go? Like under which file or something, something, something can I go that I will get the Plasma?
87:49 A: You can get class, um, getClass. Is it this stacknet? This, um, getClassAt. So if you should send this request, okay, this one is answered. Let me go to So you see that if you want to get-
88:20 C: So what we are seeing is transaction lifestyle, transaction lifecycle.
88:24 A: Oh, sorry. Okay, so this one now you can see it gives you the Sierra program. This is Sierra program and it also gives you the API. See, this is the API, the API of the Okay, contracts. So, any other question?
89:41 B: Yes, sir. Okay, my- I have a question. I don't know if you can hear me.
89:50 A: Yeah, I can
89:54 B: hear you. Okay, let's say for deploying an account on StarkNet, Is it that we have to deploy for every network we're using? Let's say I want to work on mainnet, I have to deploy that particular account on mainnet. I want to work on, let's say, Sepolia, I have to deploy that account on Sepolia, or I just deploy it once, it's deployed?
90:19 A: You have to deploy it where you want to work on.
90:26 B: Right, right. Thank you.
90:28 A: You're welcome. Okay, so no other question, so we move to transaction lifecycle. I think we've already talked about the- right, so starting a transaction starts by being sent to a gateway, a node which acts as the mempool. A sequencer, currently a single service, first validates and then executes the Transaction in order. If validated successfully, the status becomes received. If not, the status becomes rejected. Successfully executed transactions are applied to state and marked as accepted on L2. Failed during this phase are reverted. So then, um, in the prover So in the prover stage, the system operates on the new block, completes its proof, and sends it to L1. So the following image shows the transaction flow. So we have the mempool, you know, if the validation- if the transaction is received, marked as valid, in the validation phase it is injected. So from here, it's either accepted on L2 or reverted. Then here it's either accepted on L1 or reverted. Then before exploring each step in depth, let's clarify the different status. So it has 2 primary status types. So you have the finality status and the execution status. So in the finality status, you have, uh, received, This has actually passed mempool validation but hasn't included in block. Accepted on L2 and accepted- was added to block on L2 and L1. So execution status, we have rejected, reverted, or succeeded. So we know rejected, rejected from, uh, what's it called, mempool. Reverted at the execution side. Succeeded, succeeded. So to obtain this information, query the transaction receipt Turn-takings node. Refer to the tooling chapter in the StarkNet book for methods like the transaction receipt command in Stark Client or the fetchTransactionReceipt method in the StarkNet Py library. We will use these tools throughout this chapter. All right, so nonsense in- not nonsense, nonsense. What are nonce? Nonce. What are nonce?
94:04 C: Like identifiable digits, like a digit to identify a transaction.
94:14 A: In on Ethereum, nonce can mean two things. What are what?
94:23 C: It determines the order with which the transaction is being executed, I think. And also used to- what's that word now? Let me let the other person just try.
94:46 A: In relation to proof of work, what are nodes? No, it doesn't automatically deploy. Once you fund it, you still have to, still have to deploy it. No, when you send funds to the address, what you want to say is when you, you know, you've sent funds to it, you cannot send funds out of it. So when you send funds, when you try to send funds out of it, it will force to deploy it first. before it will now send it. Maybe that was where you- maybe that was what you meant, but you have to deploy first before. Okay, um, nonce. So in relation to proof of nonce, can be, you know, the nonce in your wallet The nonce in your wallet, the nonce that is included into your transaction, is going to be the number of transactions that you've performed with that particular wallet. It's added and it's used to order transactions. Nonce in relation to proof of work, uh, you know, for proof of work you need to find the block difficulty, right? And the block difficulty is just solving for the hash of the transaction or the block to have a certain number of- for the hash to have a particular number of zeros either at the beginning or at the end. And in order for you to do that, you vary the nonce value. So you vary the nonce value for you to be able to get that. So nonce in StarkNet- initially StarkNet did not incorporate nonces. This omission meant that The same transaction could be sent multiple times with an identical nonce, leading to duplicate hashes- a problem. In Ethereum, nonces not only sequence transactions but also ensure each has a unique hash. Similarly, StarkNet employs nonces to assign a distinct hash to every transaction. StarkNet's current plans on nonces mandate that they may be sequential. In other words, entering a transaction from your account Its nonce must precisely follow the previous transaction's nonce, although nonce abstraction would allow developers to manage this logic at the smart contract level. Sparknode is reviewing this feature; however, its integration is not deemed a priority. Transaction creation: Let us start with its preparation. The sender queries their account nonce which has a unique identifier for the transaction, signs the transaction, sends it to their node. So the node, analogous to a post office, receives the transaction and broadcasts it to the StarkNet network, primarily to the sequencer. As the network evolves, the transaction will be broadcasted to multiple sequencers. That's when the, uh, what's it called, when the transaction is coming through. The gateway performs the validation step so that checking the maximum fee exists, exists a minimum fee, and the account balance is greater than the maximum fee. The transaction will be saved in storage if the validation function passes. If not, rejected. The sequencer's role- Does it like we are repeating the same thing? So if at the end of this class you don't become a StarkNet Marxist, like, there should be nothing in StarkNet that you don't know about. On receiving the transaction, the sequencer acknowledges it, you see it, but hasn't processed it yet, similar to zero-input state. So you see the transaction validates, executes, updates it. So remember, standard transaction, the nonce won't change until the sequencer closes the transaction. This can complicate backend application development, potentially causing errors if sending multiple transactions consecutively. Then we have accepted on layer 2. So finality status accepted on layer 2. Execution status succeeded. So you can see the difference between finality and execution status. So accepted at layer 1. Transaction finality in StarkNet. So transaction finality refers to the point at which a transaction is considered irreversible and is no longer susceptible to being reversed or undone. It's the assurance that once the transaction is committed, it can't be altered or rolled back, hence securing the integrity of the transaction and the system as a whole. Let's dive into the transaction finality in both StarkNet and Ethereum and how they compare. So Ethereum transaction finality. Ethereum operates on a proof-of-stake consensus mechanism. It essentially has the finality status So it is part of the block that can't change without a significant amount of ETH getting burned. The number of blocks required to ensure that a transaction will be rolled back is called blocks to finality, and the time to create blocks is called time to finality. It is considered to be an average of 6 blocks to reach the finality status, given that a new block is validated each 12 seconds. The average time for finality For a transaction is 75 seconds. So StarkNet transaction finality. StarkNet, a layer 2 solution on Ethereum, has a 2-step transaction finality. The first step is when it gets accepted on layer 2, and second on layer 1. Accepted on layer 2 by the When a validator includes a block on StarkNet, it chooses finality. However, the finality relies on the L2 consensus and comes with a slight risk of pollution amongst the validators due to transaction reversal. Accepted on Layer 1. The absolute finality comes when the block containing the transaction gets a proof generated. The proof is validated by the verifier contract on Ethereum and the state is updated on Ethereum. At this point, the transaction is as secure as Ethereum's proof-of-stake consensus can provide, meaning it becomes computationally infeasible to alter or reverse it. Comparison. The main difference between Ethereum and StarkNet's transaction finality lies in the stages of finality and their reliance on consensus mechanisms. Ethereums transaction finality becomes increasingly unlikely to be reversed as more blocks are added. Starknets finality process is twofold. The initial finality L2 we speak about relies on L2 consensus and carries a small risk of pollution. The ultimate finality is slower as it involves generation and validation of proofs and updates on Ethereum. However, Unswitched, it provides the same level of security as an Ethereum transaction. So rejected transaction. So rejected- when a transaction finds validation in the mempool but fails during the sequence, it's rejected. So finality status received, execution status rejected. So we can see the difference between finality and execution status. So handling of reverted transaction. A transaction can be reverted due to failed execution. The transaction will still be included in a block. And the account will be charged for the resource consumed, received, reverted. So transaction lifecycle. So we have the mempool, we have the mempool. So if it is valid, it is received. If it is not valid, it is not received. Then if it is valid in the sticker side, it is received. It is received but rejected. So then here it is succeeded, here it is reverted. Succeeded, it succeeded there, it succeeded there. So any question? Any question? Any question?
104:49 D: Okay, sir. Um, I have a question. I don't know whether it's really related to what you just, you know, explained. Now, um, some codebase I see gas estimation on their, you know, on their tests before their test scripts. Like, what is actually, you know, that gas estimation doing there?
105:09 A: What?
105:15 D: Hello, sir, can you hear me?
105:16 A: Yeah, I can hear you.
105:19 D: Okay, I'm asking, in some scripts, like in some, um, Pyro scripts, um, some find, uh, gas, estimated gas, you know, like I want to ask, um, why do they do that actually?
105:42 A: What? Sorry, I did not get.
105:43 D: I mean, I, I'm asking them, some test scripts on Cairo, they define gas estimation, like estimated gas.
105:55 A: Okay.
105:57 D: Yeah, I want to ask, like, why, why use it? Like, why do they do that? Because normally, even without the gas estimation, it will still, you know, the test will still run.
106:08 A: All of those things are compiler-related. Yeah. So, and I think in some, in the latest Most of these labels, these things, they are not- Yeah, so someone, someone is answering me on the- So, so he said that. So, understand this term built-in. Yeah, what I was looking for then, I talked about, uh, ints. So we also have built-in. So built-in, these are predefined operations in your codes, simplify common tasks for calculation. So we have the following built-ins: Cairo steps, Peterson matches, range checks, signature verification. B indicates the severity or course of an operation, showing how resource intensive an action is. So components and limits: Cairo steps, pillar synergies, signature verification, gain check. Data availability. Data availability. So data availability is key in blockchain networks. Especially in Layer 2 solutions like StarkNet. So rollups, acting as a bridge between Ethereum and off-chain computation, enables transactions off-chain while maintaining Ethereum's security and access system. The focus often lies on scaling computation and execution, but it's just part of the challenge. Both computation and data transfer are vital for effective blockchain scaling. The growing use of rollups, which facilitate more off-chain execution, intensifies for efficient data availability solutions. This must arise from the necessity to store, access, and verify data from off-chain transactions. Robust data availability solutions are critical for rollups success. Without effective data handling, the scalability and performance advantages of rollups could be undermined. Base layer blockchains such as Ethereum are evolving towards becoming data availability layers. A prime example of this evolution is They have spearheaded this movement by developing layer one blockchain with a deep AI-centric approach. In parallel, Ethereum is undergoing a significant transition. Historically, an execution-focused blockchain, Ethereum is now incorporating new EIPs to shift its focus towards data availability. So data availability in Starknet: state transition process in Starknet as the most blockchain network The system transitions from state n to state n plus one by executing a series of transactions within a block. In the standard case, this is done with the current language. I require state information to know the current state n of network. There are two primary sources: the sequencer or the full node. The liveness problem arises from this concern. What happens if Both the secondary and the full node become unresponsive. This will be due to the priority of these necessary and stable failure or external attacks. If for some reasons both the secondary and the layer 2 full node stop responding, there will be no way to ascertain the current state of end of the network. Third scenario: while transactions could still be received, the network will be unable to switch over to state N+1 due to the lack of information about the state N. Consequently, the network would essentially become stuck. Although this scenario is highly unlikely, its potential impact is significant. It would halt the progress of the network, preventing any state transition and effectively freezing operations. State difference: Pangolin addresses the liveness problem through the transmission of validators and state difference to Layer 1. This process is Critical to ensuring that the network remains operational and the state can be verified independently of the sequencer and layer 2 full nodes. So validity proof to layer 1. After computing the validity proof, StarkNet sends it to layer 1. State difference as code data. So along with the validity proof, StarkNet also sends what's known as the state difference. State event represents the change in the L2 state since the last validity proof was sent. So this includes updates and modifications made to the network state. So if you look at the way StarkNet sends it, apart from the validity proof, it proved that the transaction is correct. So it also sends the state difference. So, uh, after state difference along with the event, StackNet also sends the- so it also sends the state difference. So which is going to be You know, the difference there, if there are smart contracts that they are storing and all those things have changed, all those. So it's going to send those state difference also. And data availability and state changes in transaction. So transmitting changes, not balance. So what's happening since layer 1 for data availability are the changes in states, not the new balances. This involves capturing how each transaction within a validity proof alters the state. To consider a simple scenario with 3 participants, Jimmy, Rose, and Nick. Transaction sequence: Jimmy sends 1 ETH to Rose, then Rose sends half an ETH to Nick. State changes sent to layer 1: The data sent to layer 1 would reflect that Jimmy has 1 ETH less. Rose has half an ETH more, and Nick also gains half an ETH. The net changes are what matter. For instance, if Jimmy and Rose send ETH back and forth, but the end result is Jimmy having half an ETH more, only these net changes are sent to Layer 1. Why? So this one sends this one to this one. So what it's going to do is what Jimmy is going to, you know, Jimmy- so this is it. Jimmy sends 1 to this one. This one now sends half to this one. So which means Jimmy has -1, which means that he sent -1 out. Rose received- because Rose has already sent 0.5 to another person, so you just count as Rose received 0.5 and Nick received 0.5. So that's the mean of state difference. If this one is still sending- ah, so this one again, if this one sends 1 to this, this one sends 1, 2 to this, and this one sends 0.5 to this, you see that this one that sends 1 to this received 2 and then sent 0.5 out. So 1 minus- I mean, minus 1 plus 2, that's 1, minus 0.5. So which means that this one is going to be minus, uh, this one is going to be plus 0.5. But this one, it received 1, so we have 1 minus 2, that's minus 1, plus 0.5, that's minus 0.5. That's what we have here. So this is the meaning of what state difference. This approach means that even with multiple transactions, the actual data sent for data availability can be less if the net state changes are minimal. In cases where transaction parties nullify each other, so no change in the state occurs, nothing is sent to layer 1 for data availability, making it the cheapest form of transaction since the cost of sending data to to Ethereum as code data constitutes about 90% of Layer 2 transaction costs. Reducing the amount of data sent can significantly impact overall transaction costs. Projects on StarkNet often use strategies to minimize state changes in their transactions, thereby reducing the data sent to Layer 1 and lowering transaction costs. So reducing data availability cost in StarkNet. So 2 main mechanisms to reduce data availability costs are currently under implementation. So we have the EIP-4844 and the Volition. So the 4844 is the blob data, while the Volition is the flexibility in data storage. You can You can see that, okay, my own data, I'm not posting it on Ethereum. I should do it on Starknet. When you, when you make something like that, that's called pollution. When you start saying, okay, my own data should remain on Starknet, I don't want to post it on Ethereum, and that's going to reduce the cost of your transaction. I hope that is clear. I hope that is clear. So EIP-484 incorporates a new change in how data availability information is sent to Layer 1 instead of using core data. The information will be sent to blobs, significantly reducing the bandwidth required and the current method used by stacknets for posting data to Ethereum. Consequently, it would make layer 2 transactions more affordable. So a notable downside of this approach is the limited lifetime of blob data. Once posted to Ethereum, this data will only be available for one month before being deleted by layer 1. So Volition introduces the concept of choosing where to store data for transaction liveness. Users can opt to post data either to Ethereum or off-chain alternatives. Data availability committee systems like Celestia or EigenDA. The cost of using Volition is based on the chosen storage option. Off-chain options are referred to be cheaper than using EIP-4844. So the timeline for enabling Volition on Circle is not yet defined, but it's starting to follow the support of EIP-4844. EIP-4844 is already Emulation offers a unique advantage for StarkNet by providing more flexibility in data storage and potentially lowering costs. Emulation requires having a virtual machine that is not limited by the audience to emulate Ethereum, so a custom virtual machine like Cardano is required. So, recreating StarkNet state. This is a contingency plan for extreme scenarios where the space at Layer 2 may become unavailable. So StarkNet, like any blockchain network, started with an empty state and a genesis block. Over time, it has produced multiple blocks, leading to changes in its state. Verifying signs sends a validity proof to L1. So along with the validity proof, so as StarkNet continues to produce more blocks, the process repeats. So by applying the state defines in order as they are sent to L1, possible to reconstruct the layer 2 state. So which means that if you want to reconstruct the state in layer- in StackNet, you just have to go through all the, you know, just add all the state difference and you're going to get the L2 state. The StackNet OS, the StackNet OS, the last step inside the stack, inside the sequencer, plays a crucial role in determining Why the state depends on the output of the SHARP and how it interacts with the- so this one is StackNet Shared Sequencer, I think. I know that this SHARP is the name of the book. So the StackNet is based on Kyrgyzstan, another version of them. So the StackNet receives 4 main inputs: the current state, the new block, the class hashes resulting- compiled class hashes resulting from transactions. So the stack method takes the current state, appends the new transaction block, evaluates what changes occur in the system. So here we have stack methods: current state, new blocks, class hashes, compiled class hashes. So this one gives you current state and the new blocks, gives you the state difference. Class hashes, class hashes, compare class hashes, compare class hashes. So the sequencer executes numerous transactions and creates blocks. When enough blocks accumulate, they trigger the creation of a block. These blocks are passed to the stack network. To calculate the state difference, class hashes and vampire value gives the information that the prover is tasked with proving. The output from the blockchain writer therefore includes the state elements, state-dependent elements. This output is what gets sent to the memory pages, smart contract, etc. So the blockchain writer module, contrary to the direct interaction between the prover and the Ethereum worker, there is an intermediary known as SHA-256. Prover and stacknet currently is stone prover is focused solely on proving the execution of the target programs internally. Sharp utilizes an externally owned account specifically for interacting with Ethereum. This account is responsible for conducting transactions on Ethereum network, so handling validity proofs and state difference. So the actual module within Sharp. That sends the price proof as indicators to the memory pages on Ethereum is known as blockchain writer. So this module bridges the gap between the internal workings of StarkNet and Ethereum blockchain. So direct interaction with Ethereum- the output of the proof of work is directed to the blockchain writer. It is this blockchain writer that interacts with Ethereum, sending data to the final step in data transmission. So the proving data from StarkNet internal application is transmitted to Ethereum for storage verification. So this is the Ethereum address of the blockchain writer, which is itself an EOA coding resources. So see, sharp. These are ready. I guess it has transmitted to this, most likely. So there's no- there's nothing again. There's nothing inside this one again. So you can see that it's no longer- so it has transferred to this almost like- so I think this is the new shop. So 2 hours ago, easy. Contract verifier. So data availability modes. Rollup mode definition again. Data for is posted directly on the rollup mode. It's posted directly on Ethereum. Advantage: the primary balances are enhanced. Liveliness, cost optimization. So Validium- for Validium, data is off-chain. The primary advantage is cost-effectiveness, liveliness guarantee, trade-off for reduced cost. So StarkEx uses this. Then Volition Mode, upcoming. You have the ability to To see wherever you want to put it. So do we have questions about that? No question.
126:12 B: There's no question, sir.
126:13 A: All right, okay, sequencers. So we've talked about sequencers, right? So before diving in, make sure to check the architecture. So 3 main layers exist in blockchain: data availability, ordering, and execution. Sequencers have have evolved within this evolving modular architecture. So mostly around blockchain like Ethereum and do all these tasks. Initially, blockchain itself as distributed version has been focused on organizing and executing transactions. Even though rollups running on Ethereum today often centralize sequencing, ordering, and execution while relying on Ethereum for data availability. So this is the concept of Stark Network, which uses Ethereum for data availability and centralized sequencer. For ordering and execution. However, it's possible to decentralize sequencing and execution as Stackwise is doing. So each of these layers plays a crucial role in achieving consensus. First, the data must be available. Second, it needs to be put in a specific order. That's the main job of a sequencer, whether run by a single They've been sequenced. The final step done by the sequencer tool determines the system's current state and keeps all connected clients on the same page. Okay, so introduction to sequence. I mean, the advent of layer 2 solutions like rollups has altered the blockchain landscape, improving scalability and efficiency. However, transaction order- is this managed by the base layer? This is an external system. So in essence, it has 2 quarters: sequencing and executing. So first, other transactions determine the canonical sequence of blocks, then new blocks to the sequence. So to clarify, we see sequencing as the act of taking a group of another transactions and producing another block. So sequencers on StarkNet. So we have Madara and Kraken, 2 high-performance StarkNet sequencers. So a sequencer must at least do 2 things: order and execute. So Madara handles the sequencing process, supporting methods from simple FCFS and PGA to complex ones like Narwhal and Bosha, a data structure that holds unconfirmed transactions. So developers can choose the consensus protocol through Madara's use of Substrate, which offers multiple built-in options. So Madara lets you choose between 2 execution crates, Blockfire and Starknet in Rust, both with the LVM for their framework. So we also have the Kraken as an option. Ordering, it employs novel and bootstrap combinatorial methods. It can choose from multiple consensus methods. So execution, it runs on StarkNet mainnet and can be deployed to either Cairo Native or Cairo VM. So these ones are Conclusion. So this is how to get started with Madara. Okay, you can come back to this and Read it very well. Then we have the provers. So the sharp is shared prover. Yes, I got it. So generated proof, stack verifier program, cargo job prover, new proof generated, decrease process triggered, reached solidity verifier. Conclusion. So we've talked about nodes and the different ways in which they can be- so the Pathfinder node, Juno, Papyrus, I think all of them are developed by Nethermind. Implementing a Pathfinder node. 32 gig, 1 terabyte, gigabyte Ethernet. To these out to run with. Oh, there are 3. And appchains. So appchains let you create blockchain designed precisely for your application's needs. So this specified blockchain allows for smart contracts, such as hash functions and consensus algorithms. Moreover, they inherit the security features of Layer 1 and Layer 2. So Layer 3 blockchains can exist on top of Layer 2 blockchains. You can even build additional Layer 3 on top of Layer 3 for more complex So a sample layout is shown below. So you can see we have Ethereum, we have the public StarkNet. So on top of the public StarkNet, you can build a privacy StarkNet, you can build other StarkNets that now has a layer 4 privacy StarkNet, can build an app-specific StarkNet, can build StackX, the Validium, StackX, the rollup. So examples of an environment with a Layer 3 and Layer 4. In this example, there are 3 options include the public StarkNet, which is a general Layer 3 StarkNet optimized for cost-sensitive application, customized L3 StarkNet, StarkX systems used by platforms like dYdX and Solana, some privacy Benefits of Layer 3. Layer 3 appchains with Madara as an app sequencer or other option offer a variety of advantages due to its modularity and flexibility. Here's an overview of the key benefits. So quick iterations. Appchains enable rapid protocol changes, freeing you from constraints of the public Layer 2 roadmap. For example, you could rapidly deploy Governance independence. You maintain complete control over feature development and improvements, avoiding the need for centralized governance consensus. This enables, for example, quick invention of user-suggested features. So cost efficiency. So Layer 3 offers substantial cost reductions potentially up to 1 million times compared to Layer 1, making it economically feasible to run more complex applications. So we have security and other ones. So Madara is a framework for Layer 3. It's a framework that simplifies development of modular chain. So with Madara, you can leverage the StarkNet stack scalability and security while tailoring a chain to the specific requirements of your dApp. So key benefits of developing with Madara congressive control. With vanilla, you can customize essential components such as your program compiler version, reduce congestion, your off-chain, your DApp exclusively, granting predictable performance. And so you have the kind of also work as a service. Solidity verifier. Before explaining this chapter, I read the starting. So quick overview, Sharp and SharpJobs. So SHARP is the shared prover. So that aggregates various private programs for distinct- from distinct users. These programs, each with unique logic, run together producing a common proof for all, optimized cost and efficiency. Thank you. Furthermore, SHARP supports combining multiple pools into one, enhancing its efficiency by allowing parallel pools to process verification. SHARP verifies non-starknet transactions like transfers, trading, and also confirms smart contract execution. When you use SHARP, think of commuting by bus. The bus driver transports passengers to the correct programs. The driver checks only the tickets of the passengers alighting at the upcoming stop. Much like SHARP, the program forms a single proof for all Cairo programs in batch, but verifies only the proof of programs contained in the succeeding block. So SHARP jobs, known as SHARP overjobs, let multiple users present their Cairo programs for combined execution. Sorry. Okay, so Solidity Verifier. The Solidity Verifier is a layer 1 smart contract crafted in Solidity designed to validate Stark proofs from Sharp. So Sharp Verifier contract map. It's not- it's not- yes. So, you know, there is, there is this new, uh, what's it called? There's this new prover that StarkNet is building. Is there anyone that knows it? No. So how many of you have heard about CircleStack? CircleStack, you know, they released the paper recently. So the paper that's on CircleStack So, and with that, they are building, um, the STWO approval. STWO approval. So that's going to be much faster than this one. It's going to be much faster than this one. So you can see that the, the, the chain with the innovation is actually the StarkNet, and it's- you just have to like deep dive into the ecosystem and And also build on it. All right, all right. So you can see the decentralization is still under construction. It's not decentralized yet. I, I know that the person that asked me the question, like, uh, is centralized here, like, ah, how is StarkNet centralized? Is, is too bad to hear or what? Yeah, I think The sequencer is still currently centralized, and that's not a problem for a layer 2 since, you know, the security is on Ethereum. So it is- there is- there are plans to decentralize it. So smart contracts, you all know what smart contracts are, right? I do not.
139:37 F: Yes, sir.
139:38 A: So deployment and interaction. So, um, what's the time? We have just 30 minutes left. So I would have said that we should do some- a little, a little bit of front-end integration to it too. Yeah, I can't ask questions. So do you have any question? Do you have any question?
140:54 F: I think no one has a question.
140:55 A: Please, I'm not saying you're- this thing, if you have a question, just talk. Okay, nobody has question. That's nice. That can mean 2 things. It's either you all perfectly understood everything that I said, or the opposite. So which of the 2?
141:35 D: Let's say, it's just a matter of time actually, it will sink.
141:40 A: Actually, So the only way it's going to sink is, you know, practice makes what? Perfect. No, it cannot be perfect. Now, how is that possible? So practice makes improvement, right? So as you are reading and reading and reading and reading, but at least, uh, from what we actually did today, there should be nothing in StackBlitz that you don't understand. Let's, let's be truthful to ourselves. Let's be truthful to ourselves. So this is what we are going to do because- so I'm just going to allow you the next, um, 10 minutes to ask any question. Can I just ask any question actually? So we are going to use the next 10 minutes for you to ask any question. Then, um, we are now going to do an introduction to, um, to Only Dust and how you can, how you can start, you know, contributing and all of those things like that. If you have So if you have any question, you can just, you can just ask right now. As regards most things, I don't want to say anything at first because the kind of question that you're asking, I don't see anything said. It's almost If you have any question, you can ask. No questions still. Should I be going? If there is no question, I'm not No, I'm not, I'm not proceeding. It's like,
143:56 D: okay, sir, um, I don't know whether, I don't know whether my question is relating to what we did today, but I'm just like-
144:03 A: Yes.
144:04 D: Yeah, like, I'm, I feel like I, I want to ask actually, like, what does it take for someone to actually, you know, say, let's say, spin up a node on, on StarkNet?
144:21 A: Yeah, I think everything was. You can come back to this. Where is it? That part that we skipped. You can see that they even put the cost of those hardware and this thing there. So where is it? Notes. Yes, you can just come back to this note and start and read it. So you can run the Juno node, the Juno by MetaMask. I see the hardware requirements, the estimated cost. So it's not even fancy. And yeah, you're good to go. Is that the only question?
145:19 D: From my end, that's all.
145:27 A: Okay. No, Dr. Shah. No question. Okay, then, um, so maybe there's going to be most likely another- Hello, sir.
146:29 F: Yeah, yeah. I don't know if this is going to be our last class.
146:32 A: You don't know if-
146:36 F: Do you know if this is going to be our last class?
146:40 A: Yeah, there's most likely going to be another for the front end, another for the front end, and that's going to be the last class. This normally supposed to Yeah, okay. So we just find a time and we communicate it. So for us to, to do the frontend part, and that would be all. So yeah, a piece of advice, or Yeah, why am I even here? Just,
147:24 B: uh, you'll be bored.
147:25 A: Oh yeah, so just, you know, just try to like, um, put yourself out there. And the best way for you to put yourself out is by contributing, you know. And the StarkNet is still like the best framework, the best, you know, is the most rewarding currently that you can contribute to. So you should try to explore the StarkNet ecosystem, everything about it, and you'd see, okay, what are those things that you can improve in it. If you don't, if you don't use it, there's no way you'll be able to say that, okay, there's this problem somewhere that I need to improve that, or I can improve. So all the things that you've learned throughout the, um, throughout the start of the bootcamp, just apply them. And one thing that you actually need to know is that, see, it is only if you don't- it is only if you don't, uh, need the help, that's when Uh, that's when you are not going to see anything. So on StarkNet, even if you don't have a job, in fact, you might even be better off not having a job than having- it's just that job gives you this security and peace of mind. So, but if you have that builder mindset, yeah, StarkNet is like the most rewarding, uh, place that you can ever be. So, and yes, you should also, you know, go on- what's this platform? Um, OnlyDust. You know, it's like there is StarkNet and then there is the OnlyDust platform. But you just go to OnlyDust, sign up. For when you sign up, you're going to see different projects there. So, you know, of course, before you can start doing your thing. And you don't even have to be genius for you to start contributing there. You just have to have, number one, the curiosity and the willingness to do. That's all. So, so far as you have the curiosity and the willingness to do, go to OnlyDust, look for any program, look for any, uh, what's it called, look for any Look for any, uh, any project that you can contribute to and look for any issue there. Tell them that they should assign it to you. And one thing about it is that when you, when you do that, everything like the resources that you need for you to be able to do it, they are going to provide it for you. So you just have to And if you have problem while executing it, you can reach out to them, you can reach out to your friends and all. So those are the ways in which you, you know, you are going to become- you are going to become known. So right now, you know, I know most of you just finished the Web3 class and now you are just finishing the- you're just finishing the, uh, what's it called? They're just finishing the masterclass also. So you should just, um, what's it called, I'm going to stop the recording soon so that I can say some other things. So you should just make sure that go to OnlyDust and start contributing there, and you're going to be rewarded for every issue that That you are contributing to. Okay, someone has a question. What's that?
151:20 F: I think I'll just say it after you are done, so you stop recording.
More from this hub
- Web3Bridge Weekly Update Vlog 3
- Web3Bridge Weekly Update Vlog 2 1
- Web3Bridge Weekly Update Vlog 1
- Web3Bridge Experience Uche
- Web3Bridge Experience Vicentia
- Web3Bridge Experience Tosin
- Web3Bridge Student Experience
- Web3Bridge Experience Mitchell
- Web3Bridge Experience Abiodun
- Web3Bridge Live Stream
- Web3 Lagos Conference 2022
- Web3Bridge 3rd anniversary Documentary
- Meet The Students of Web3bridge Cohort 09 - Part I
- Meet The Students of Web3bridge Cohort 09 - Part II
- Cohort 09 Week 01 Students' Report
- Cohort 09 Week 02 Students' Report
- Question & Answer Session With Vitalik Buterin
- Pushing the boundaries of Web3 UX - Richa Joshi
- Implications of the National Policy of Blockchain in Nigeria on the growth of the Web3 ecosystem
- Cohort 09 Week 03 Students' Report
- Cohort 09 Web3bridgers in Class
- Understanding Blockchain For Beginners - Hezekiah Suleman
- Exciting Insights: Students Reflect on Their Week 04 Learnings!
- Taking a Breather: Our Students Stepped Away from Classes for Conference and Workshop Week 05
- The Students Share Their Eviction Test Experience Week 06
- The Students Spent The Whole Week Building Projects Week 07
- An Introduction to Web3 Frontend: Students Sharing Their Experiences Week 08
- The Students Talk About The Dapps They Built Week 09
- Web3bridge Odyssey: Documentary Telling The Story of Web3bridge
- Exploring Foundry: Students Share Their Learning Journey Week 10
- Students Explain Diamond Standard (EIP-2535) | Week 11
- Smart Contract Code Review: The Students Share Their Experience Week 12
- Students Share Their Experience With Smart Contract Security Class Week 13
- Starting & Building a Career in Blockchain - Michael Jerry
- Web3: Community & Protocol - Ayodele Aransiola
- Understanding & Contributing to DAOs - Odebunmi Fiyinfoluwa
- Hacking distribution for web3 startups - Olatinwo Barakat Anuoluwa
- How crypto can regenerate the world - Kevin Owocki
- The Future of Work in a Decentralized World - Emmanuel Tope
- Blockchain for Africa: Why we should care - Amarachi Amaechi
- Web3bridge Cohort X Onsite Arrival Footage
- Meet The Faces of Cohort X: Introducing The Students of Cohort X - Part I
- Meet The Faces of Cohort X: Introducing The Students of Cohort X - Part II
- Meet The Faces of Cohort X: Introducing The Students of Cohort X - Part III
- Centralized vs Decentralized Networks: Insights from The Msg Senders
- Team ZK Shares Their Knowledge Concerning Smart Contract and It's Advantages
- Happy International Women's Day From Web3bridge
- Our Students Share Insight to What Consensus Mechanism is on Blockchain
- Utilizing JSON RPC as a Communication Protocol for Blockchain
- The Life of a Web3bridger in The Cohort: Abigael Irene Nyangasi from kenya
- The Life of a Web3bridger in The Cohort: Mary Gathoni Wangui from kenya
- Team MsgSender Shares Their Insight on Dapps, What They Learned, and Built
- Team Zero Knowledge Shares Their Insight on Dapps, and What They Learned
- Team Alpha.Eth || Solidity
- Exploring Smart Contracts || Cohort X Shares Insight
- Our Students Break Down Multisig Wallet || Cohort X
- Our Students Explain Mainnet Forking: Mirroring The Live Blockchain || Cohort X
- Exploring Smart Contract Interaction || Cohort X
- A Weekly Recap: What Cohort X Learned at Web3Bridge
- Interacting with Web3: Frontend Development in Cohort X
- Project Week: Cohort X Shares Insights and Emotions on Eviction Test
- Watch Our Students Break Down the Diamond Standard in Blockchain || Cohort X
- Starknet Fundamentals
- Cairo Programming Language I
- Cairo Programming Language II
- Writing Cairo Smart Contract on Starknet I
- Writing Cairo Smart Contract on Starknet II
- Testing
- Check out what our ZK masterclass students said about their experiences in the program.
- Frontend Interaction With Cairo Smart Contract on Starknet
- Quick Review: Understanding Account Abstraction in Blockchain
- Quick Review: EIP-4844 Proto-Danksharding on Ethereum
- Quick Review: Blockchain Layer Two Solutions Explained
- Quick Review: Oracles in Blockchain Technology
- Beyond Web3Bridge: Ayomide Adebara’s Success Story
- Beyond Web3Bridge: Casweeney Ojukwu’s Success Story
- Beyond Web3Bridge: Etim Paul’s Success Story
- Beyond Web3Bridge: Faith Robert’s Success Story
- Beyond Web3Bridge: Emmanuel Glory Praise’s Success Story
- Beyond Web3Bridge: Chinonso Idogwu’s Success Story
- Beyond Web3Bridge: Ginika Chinonso’s Success Story
- Beyond Web3Bridge: Mayowa Obisesan's Success Story
- Beyond Web3Bridge: Mitong Dapal's Success Story
- Beyond Web3Bridge: Musa Abdulkareem's Success Story
- Meet The Faces of Cohort XI: Introducing The Students of Cohort XI - Part I
- Meet The Faces of Cohort XI: Introducing The Students of Cohort XI - Part II
- Meet The Faces of Cohort XI: Introducing The Students of Cohort XI - Part III
- Meet The Faces of Cohort XI: Introducing The Students of Cohort XI - Part IV
- Meet The Faces of Cohort XI: Introducing The Students of Cohort XI - Part V
- Web3 Lagos Conference 2024: Innovation, Networking & Game-Changing Insights - Day 1 & 2 Highlights!
- Web3 Lagos Conference 2024 Recap: Innovation, Hackathons, and Blockchain Breakthroughs!
- Supercharging user onboarding; Building with social logins and smart wallet - Ayomitan Pamilerin
- Web3bridge Journey; A look into the Future - Ayodeji Awosika
- Mental Model for Building Smart Contracts on Bitcoin - Abimbola Adebayo
- Beyond DX; Building World Class Developer Documentation for Web3 - Owanate Amachree
- DAOs and Onchain Governance - Fiyin Odebunmi
- Build In Public; The Web3 Advantage - Kevin Chibuoyim
- Building Scalable Dapps - Israel Rex
- Web3bridge Students (cohort 11) Share What They’ve Learned: What is blockchain?
- Web3bridge Students (cohort 11) Share What They’ve Learned: Understanding Ethereum
- Web3bridge Students (cohort 11) Share What They’ve Learned: Nodes and Clients
- Web3bridge Students (cohort 11) Share What They’ve Learned: Consensus mechanism.
- The Future of Data in Web3 - Ivy Elebesunu
- Empowering Underserved Markets Onchain An Exposition to Real World Assets RWAs - Oluwole Kayode
- Introduction to Blockchain - Hezekiah Suleman
- Real World Assets Fluke or For real - Emmanuel Tope
- Science on the blockchain - Introduction to Decentralized Science - Scott Itepu
- Product Roadmaps and Team Management in a Decentralized World - Adedoyinsolami Adeyeye
- The Role of Social Media in Building Web3 Communities Best Practices and Pitfalls - Amara Achusi
- Working as a writer in Web3; How to build their brand - Toluwalope Ajetunmobi
- A DePIN protocol for unlocking Africa's solar energy potential and solving Energ - Ifeanyi Christwin
- Introduction to Arbitrum - Oluwafemi Samuel
- Web3 UX from a Wallet point of view - John Odey
- How to write content that connects with Target audience - Victor Fawole
- The Role of User Experience in Web3 Adoption - Favour Ohanekwu
- Building a Career in Web3 - Purity Ogheneochuko
- Scroll Technical Workshop - Wisdom Ogwu
- Web3 Documentation Best Practices - Lessons from Rootstock - Wisdom Nwokocha
- Interchain applications Cosmos and the IBC - Peter Anyaogu
- Developers guide to building on Solana - Alex
- Future of Wallet and Custody - Peter Olawuyi
- Field Notes from the Trenches - Ukeme David Eseme
- Web3bridge Students (cohort 11) Share What They’ve Learned: An Account
- Web3bridge Students (cohort 11) Share What They’ve Learned: The EVM
- Web3bridge Students (cohort 11) Share What They’ve Learned: Public and Private Keys
- Web3bridge Students (cohort 11) Share What They’ve Learned: Transaction
- Web3bridge at 5 Full Documentary | Ayodeji Awosika on the Web3 Journey and Growth
- Invariants Testing for Smart Contracts in the World of Medusa - Joshua Adesanya
- Improving web3 User experience through chain abstraction - Collins Enebeli
- The Future of Technical Communication in Web3 - Victoria Adedayo
- CoreDAO workshop
- Build On Bitcoin Leveraging Rootstock - Chekwube Peters
- Building Scalable Web3 Applications - Amani Kanu
- The Future of Social Media for Blockchain Startups - Motolani Omotuyi
- Buidling Decentralized App quickly - KC Pele
- Building the Future Decentralized Computing Infrastructure for Web 3.0 - Uchechukwu Azubuko
- Understanding the Lisk Protocol - Lisk Workshop
- ZK Workshop - PSE team
- From Ancestors to Algorithms Harmonizing Trust Based Cultures - Abidemi Adenle
- DeSci Web3 and the Future of Scientific Collaboration - Daniel Anomfueme
- Exploring Career Paths in Web3 An Introductory Guide for Beginners - Glory Praise
- Building beyond the Hype - Titus Adenugba
- The Future of Digital Trust Leveraging Ceramic for Global Trust System - Kenechukwu Orjiene
- Building a Global Web3 Community - The SuperTeam Case Study
- Meet Push Notification - Push Ambassador
- Introduction to DEXPAY
- Understanding the East African Ecosystem - David Lumala
- Web3bridge Students (cohort 11) Share What They’ve Learned: Building Function Modifiers
- Web3bridge Students (cohort 11) Share What They’ve Learned: EVM Explained
- Web3bridge Students (cohort 11) Share What They’ve Learned: Account
- Web3bridge Students (cohort 11) Share What They’ve Learned: Wallet
- Web3bridge Students (cohort 11) Share What They’ve Learned :Contract structure
- Web3bridge Students (cohort 11) Share What They’ve Learned: Function Visibility
- Web3bridge Students (cohort 11) Share What They’ve Learned: DApps
- Web3bridge Students (cohort 11) Share What They’ve Learned: Deploying a Smart-Contract
- Cohort 11 Student Shares How Our Training Facility Fuels Success: Meet Akinwunmi Akinrimisi.
- OFFICIAL PARTNERSHIP ANNOUNCEMENT
- Cohort XI - Eviction Week
- Web3bridge Students (Cohort XI) Share What They’ve Learned: Interface, Interaction & Mainnet forking
- Web3bridge Students (Cohort XI) Share What They’ve Learned: Multisig Wallet
- Web3bridge Students (Cohort XI) Share What They’ve Learned: NFT Gated Event Contract
- Web3bridge Students (Cohort XI) Share What They’ve Learned: NFT Gated Event Contract
- Web3bridge Students (Cohort XI) Share What They’ve Learned: ABI
- Web3bridge Students (Cohort XI) Share What They’ve Learned: Intro to REACT
- Web3Bridge Journey: A Ugandan Student's Path to Blockchain Excellence
- Web3bridge Students (Cohort XI) Share What They’ve Learned: JSON RPC and Ethereum JSON RPC
- Web3bridge Students (Cohort XI) Share What They’ve Learned: Wallet, Providers and Signers
- Web3bridge Students (Cohort XI) Share What They’ve Learned: Advanced DApps
- Web3bridge Students (Cohort XI) Share What They’ve Learned: IPFS & IPNS
- Web3bridge Students (Cohort XI) Share What They’ve Learned: MetaMask & MetaMask SDK
- Web3bridge Students (Cohort XI) Share What They’ve Learned: Multicall
- Web3bridge Students (Cohort XI) Share What They’ve Learned: Subgraph
- Web3bridge Students (Cohort XI) Share What They’ve Learned: Calls
- Web3bridge Students (Cohort XI) Share What They’ve Learned: Diamond Standard
- Web3bridge Students (Cohort XI) Share What They’ve Learned: EIP 2535 Diamond Standard
- Web3bridge Students (Cohort XI) Share What They’ve Learned: Upgradeable Smart Contract
- Meet The Faces of Cohort XII: Introducing The Students of Cohort XII - Part I
- Meet The Faces of Cohort XII: Introducing The Students of Cohort XII - Part II
- Meet The Faces of Cohort XII: Introducing The Students of Cohort XII - Part III
- Meet The Faces of Cohort XII: Introducing The Students of Cohort XII - Part IV
- Web3bridge Students (Cohort XII) Share What They’ve Learned: Cryptography, Ethereum, and Wallets.
- Web3bridge Students (Cohort XII) Share What They’ve Learned: Solidity, Functions, and Data Locations
- Scroll Meets Web3Bridge: Exclusive Talk with the Founder!
- The Visit!
- Web3bridge Students Share What They’ve Learned: Blockchain, Distributed Ledger & Consensus Mechanism
- Lisk & CVVC Labs Visit Web3Bridge: Power Moves in African Web3
- Alumni Spotlight: Wilfred, Co-Founder of Audioblocks
- Alumni Spotlight: Michael, Co-Founder of Coinsafe
- This Man's Determination Will Leave You Speechless - Alumni Spotlight EP3: Casweeney Ojukwu
- Breaking Into Tech as a Woman - Alumni Spotlight EP4: Glory Praise Emmanuel
- From Machines to Code | Switched Gears into Tech - Alumni Spotlight EP5: Olorunsogo Banwo
- Web3: Get Rich Quick or Game Changer? – Alumni Spotlight EP6: Ayomitan Pamilerin
- Web3 Lagos Conference 4.0 Is Coming! Africa’s Biggest #web3 Event
- Introducing the Web3Bridge Cohort Xiii students
- DeFi Diaries: Building Wealth Community and Resilience in Web3
- The Future of Privacy - Olayinka Oshidipe
- The Future of Payments: From Card Swipes to Stablecoins - Iyanu Faleye
- Blockchain-Enabled AI for Smart Grid Optimization in Africa - Nnamdi Onuigbo
- Introduction to Arbitrum and the Arbitrum Technologies - Olatunji Samuel
- Data-driven Community Building: Metrics that Matter in Web3 - Mfonobong Umondia
- Panel Session VI: How Stablecoins are Powering the New Pan-African Economy.
- From ChatGPT to ChainGPT: Shipping Autonomous Agents on Ethereum - Opeyemi Stephen
- Understanding and building on Polkadot - Bekka
- Panel Session IV: Onchain data or Community-led Models: Which works Better for Today's Market?
- Panel Session II: From Grants to Growth Capital: The Evolving Web3 Playbook For Web3 African Founder
- Designing for Web3: Crafting Useful Products, Beyond DAOs, DeFis, and Wallets - Mercy Kolapo
- Understanding Qubic - Israel Qubic
- Developer Experience Done Right: Proven DX Strategies to Onboard and Retain More Developers - Joshua
- Dexpay Showcase
- Bridging Traditional Fintech with Decentralized Finance - Motunrayo Koyejo
- Composable Yields - Peter Anyaogu
- A Guide to Crypto Data Analytics. Building Your First Dashboard With Dune - Oladayo Oladipupo
- The Vaults Economy: Supercharging Crypto Market Money with ERC-4626 - Olaoluwa Oluwatunmise
- Creating Public Goods: The Missing Link in Your Developer Marketing - John Fawole
- Web3Bridge Turns 6! 🎉
- 6th Anniversary Appreciation
- RWA Tokenization - Ginger Eke-Daniel
- Stop Yapping, Start Building: Real African Contributions to Web3 - Chukwuemeka Uche
- Starknet: Opportunities and how to get started - Faith Roberts
- Stellar and it's Ecosystem - Levai Agbara
- Content Marketing For Onchain Products: A playbook for Builders and Marketers. - Joy Joe
- Beyond Audits: Securing Web3 in the Age of Lazarus - Gracious Igwe
- The State of Onchain UX. Why Crypto Still Feels Broken (How We Fix It) - Nnamdi Ernest
- Inclusive by Design, Compliance by Default. The Blueprint for Web3 Success - Deborah Enyone Oni
- Why Storytelling Matters in Web3 - Gloria Echendu
- Harnessing The Ripple Effects as African Creators - The Content Chef
- Panel Session: Finding the right path to protocol development and growth as a Web3 Developer
- Panel session I: The rise of builder hubs in Nigeria, lessons & opportunity
- The Future of Payments: Spend Crypto like Cash - Amarachi Agwu
- Pathway to Continuous Growth as a Developer || Mayowa Tudonu || Alumni Retreat
- Enterprise Blockchain: What You Should Know and Prepare For || Adebayo Fabamise || Alumni Retreat
- Crypto and Tax in Nigeria: A Practical Guide to the New Rules || Mitong Dapal || Alumni Retreat
- What to Expect from Web3bridge in 2026
- Web3Bridge Cohort XIV Arrival Day Highlight
- Web3Bridge: Not a Shortcut, But a Launchpad
- Meet the new builders of Web3bridge Cohort XIV || PART 1
- Meet the new builders of Web3bridge Cohort XIV || PART 2
- COHORT XIV INTRODUCTION PART 3
- COHORT XIV INTRODUCTION PART 4
- COHORT XIV INTRODUCTION PART 5
- Web3 Lagos Conference 2026 FINALE
- Web3 Lagos Conference 2026
- WAs for African Money Markets and SMEs | Abidemi Ademola @Web3LagosCon
- The Hard Truth: Why Most Nigerian Startups Never Raise Venture Capital | Adeola Adesina
- Why Every Blockchain Needs an Intelligence Layer | Christian Obi @Web3LagosCon
- AI-Powered Infrastructure:Building More with Fewer Servers & Nodes | KC Pele @Web3LagosCon
- Scaling Your Web3 Startup to Mainstream Adoption | Oluwasanmi Timilehin @Web3LagosCon
- Onchain Lending for Productive Assets | Kayode Oluwole @Web3LagosCon
- The Trust Layer for a Trillion Agents: Blockchain, AI & the Next Internet | Ukeme David
- Trust Machines: What Crypto Actually Does for Credit in Africa | Favour Aniogor @Web3LagosCon
- Stablecoins as a Tool for Financial Inclusion | Ajayi Matthew (OnyxFi) @Web3LagosCon
- Tokenization: The Future of Ownership | Solomon Amaechi @Web3LagosCon
- DePIN & Decentralised AI | Panel Session @Web3LagosCon
- The Missing Layer in AI: Incentives, Trust & Accountability | Aishat Suleiman @Web3LagosCon
- Money in Crypto, Life in Fiat | Francis Codex @Web3LagosCon
- Optimizing for AI Agents: Why Founders Must Build for AI, Not Human Eyes | Adugbo Victory
- Decentralization Across Borders | Adetola Ogunsanya @Web3LagosCon
- Stablecoins & the Future of Digital Payments in Africa | Panel Session @Web3LagosCon 5.0
- AI Is Reshaping the Cybersecurity Landscape but How? | Damilola Abiona @Web3LagosCon 5.0
- Scaling Web3 in Africa: Growth Strategies & Adoption | Growth Panel @Web3LagosCon 5.0
- Building Pan-African Payment Rails with Stablecoins | Suleiman Suleiman @Web3LagosCon 5.0
- The Global Builder Pathway: Where Ethereum's Next Applications Come From | Pablo EAG @Web3LagosCon
- Why Every Fintech Is Rebuilding the Same Stablecoin Liquidity Stack | Amadi Chibuotu @Web3LagosCon
- Legal & Compliance in Web3: Navigating Blockchain Regulations | Panel Session @Web3LagosCon
- The Creator Economy with Stablecoins | Ike Orizu @Web3LagosCon 5.0
- Stablecoins Beyond the Hype: Building Africa's Cross-Border Payment Infrastructure | Mercy Emmanuel
- Venture Capital & Startup Funding in Africa | VC/Funding Panel @Web3LagosCon 5.0
Something wrong, or a video you want off this page? Write to wethem.xyz@gmail.com and it is fixed or taken down within 48 hours.
