Transcripts
1. Welcome to this course!: Hello guys and welcome
to this course on creating your own
NFP collection. My name is Alex and I'm
a software engineer, but I have always been passionate
about cryptocurrencies. And when NFP is came out, I really owned in
three-beat a lot of them, mainly on open sea. Now this class will
be structured in a two lessons that
contain practical steps for you to take in
order to create an NFT collection and
deploy it on Open. See, I will show you how you
can programatically combine different layers
and generate with code a huge collection
of unique pieces, each with a different
documented rarity. If you are interested
in METs and also want to create
your own collection. Or at least want to see
what these processes like. Consider this course for you. There are no other requirements then an Internet connection. As for the project
of this class, it will be extremely practical and it will
involve you to follow the steps presented in the
course so you can start on your journey of creating
your own MFT collection. We told the set, I think we are ready. See you in the first lesson.
2. Smart contracts: Hello guys and welcome to
this course about greeting Dewar own NFP collection and then being
able to launch it. And in this first lecture we're going to talk about
smart contracts. At this point, you might wonder, what is the exact
connection in-between smart contracts and launching
your own NFT collection. What you need to firstly,
understand East debt. You are going to have a grip on some theoretical knowledge
before you will be able to launch your empty collection as some coding is involved and the use of some new concepts
to you will be needed. So we did before
word being said, we can go ahead and
define a smart contract. You can think of
a smart contract as self executing
digital contract, and it is stored under the centralized
blockchain network. What these smart contract contains is an agreement between the buyer and the seller that is made up
of lines of code. Their purpose of
these smart contracts is to automate the execution
of these agreement. Debt is made in those lines of code and the transaction
that it causes are trackable like
everything else on the blockchain and
also is irreversible. Unfortunately, you
might have heard of different schemes
and that people that scammed are actually
able to run off with the money because the
transactions are irreversible. So the people that these
being scammed cannot ever get their money back unless this camera wants
to give them back. And of course, the Dont mixed scalable is the creator of
the smart contracts. And he defined them as computerized transactions
protocols that executes terms of a contract. His vision for these
smart contracts was to replicate the
functionality of a POS, meaning a point of sale. You know, the one where
you put your card at the supermarket when you are
trying to buy something. He wanted to replicate these functionality
into the digital real. Another fair that
may help you put the pieces together
better is that vending machines
are mentioned as the oldest technology equivalent to smart contract
implementation. Now, you may wonder, why are these smart contracts
important in the context of NFP and the creation of
a collection of our own. After all, why are we
talking about them? Well, intuitively enough, these contracts are central
to the functioning of LFTs because they make
it possible to have permanently identification
information on these unique and LFTs. Also, it is useful when
minting an NFT to have these action executed if predetermined
conditions are met. Here we can talk either by a hype collection that only
lets the owner mean to a limited number of
LFTs or the price of the NFP being paid accurately
by the buyer and so on. In the context of NFV, these smart contracts
are created when a person is actually
minting and NFP. That is because at the point of maintaining that
specific NFT from the collection gets created according to its
underlying smart contract. Specific rarity based on different eventual
properties is given to it. Now, don't worry about this much amount of
theoretical knowledge, as in just a few lecture, you will be able to get your
hands on a specific type of deployment of a smart
contract in order to get you closer to sell your own. And if the collection. Now, the way in which smart contracts prevent
counterfeiting is that a token gets issued
to you when you buy an NFT token has within it all the details regarding
the smart contract. Those get registered
on the blockchain. With this information public, even if you are NFP
picture gets copied, which can of course happened. You might have seen those people that screenshot
entities out of Google. You can still prove that you are the owner of the original. Because the blockchain
registration that gets forever
publicly stored, there is going to be
multiple prove it. We tell if these being
non-fungible tokens, meaning not exchangeable because each of them is unique and
have a different reality. It is going to be
crucial for you if you buy an NFT to show that it is the original and its smart contracts are going to be able to
do that for you. Also do not get fooled
into thinking that NFP only have applications
in transactions. They can also be
used as tickets for different events or proof of ownership on different goods. This was about it for the first theoretical
lecture of this course. In the next one, we're going to check different token standards, including the token
debt we're going to use for creating our own LFTs, which is the ERC seventh 21. So if that sounds
interesting to you, I look forward to
see you guys there. And I thank you very
much for sticking with me up to the end
of this lecture.
3. Digital tokens: Hello guys and welcome
back to the scores, where we will learn how we can launch our own
NSD collection. In this lecture, we are
going to discuss beat, the token standards that
exist at this point in time. And also which one is
going to be the best for us in order to
implement our LFTs on. In the following lectures, we are going to get our hands on a much more practical
approach where we will see how we can actually deploy our LFTs on open sea, which is going to be
the end of this course. But for now, let's look at the three token
standards that exist. And these are the ERC-20, the ERC 721, and the ERC 1155. You can think of these
in broad terms, S2, the ERC 20 being used for
normal fungible tokens. Fungible means tradable. Then the ERC 721 that are used for antibodies
which are non-fungible, so non-tradable in-between them. As we already know, NFPA have different recipes and our unique silty cannot
be treated for one another. That couldn't be done without losing value
out of one of them. And then the ERC 1155 standard is one that is a mixed
in-between these and we're not really going
to talk about it as the ERC 721 is the one we
will use for our LFTs. But the ERC 20 easily beat important as EPs used
for cryptocurrencies. And we can say a few
words about it just for your own common knowledge cell. She said before the
ERC-20 token standard is used for normal
fungible tokens. Fungible tokens is the same
thing is fungible assets. And these tokens, as
I have mentioned, can be exchanged by
one and neither. You can think here that in our world we have money, right? And you can exchange a bill for another bill as they have
the same exact value. And also it goes four coins and objects
of the same value. Like a PS5, you can exchange
TPS 5s as long as they are the same and no party
will lose, fail you. And they will pretty much both agree of the
exchange being fair. Now, this only happens
because the objects that we exchange are the
exact same from one another. In terms of the crypto space, we can think about o of the cryptocurrencies as being
normal fungible tokens. Because they work the same as money or objects with
the same value work. You can think of
Ethereum, Bitcoin, and so on as fungible assets. These tokens, it can be
created actually from scratch, and it is very easy to do so. And in a future lecture, I will also show you
how you can do that. You will also be able to deploy
token that is ERC-20 and VPs used for deploying actual fungible assets
like cryptocurrencies. But that would be enough for
the ERC-20 tokens standard. And we're going to move
on to the ERC 721, which is the most important and relevant for the
scores as it is used for NFV is in their
deployment is we will see when we get to that
step in our course, these standard is used for
non-fungible tokens like LFTs. These tokens are non-fungible
because the art unique. They differ in properties. First of all, some of
them have more traits. And this may cause a difference in value
because they will cost more than others that
have more common properties. You can think here of
a specific NFT from a bigger collection
that is unique and has its own value
and properties. So for example, there are multiple NFP
collections out there that have a rainbow eyesight. So from the eyes
of the character, it goes straightforward,
rainbow. And that is considered
a very rare trait. So if you are NFT
has that treat, it will automatically
pump up its value, which is pretty
self-explanatory. And it is very in my opinion, now given these property, they are not mutually
interchangeable, like it was the case with the fungible tokens that
we just talked about. They cannot be valued
is another unit of the same collection if
they are rare and scores, these are given usually
by the demand caused, hence, of their very
rare properties. They can be very highly valued
by different collectors. Given examples, you can think about collectibles
that are physical. So to draw parallel
and maybe get a more practical image
of what happens here with the rear NFV
is, for example, you can think about collection
of watches that are very, very limited and that scar CP in their production and also their huge demand makes
them very wanted EPC, exactly the same
thing with any of these only b's are digital, but their uniqueness is
also the same and it can more easily be verified using the
blockchain as we discussed. When NFP is made on each
cryptocurrency blockchain in the form of a token that is not interchangeable
with one another. It is cryptographically unique. Usually these, any of these
have some intrinsic value stored within them other
than just the looks of it, even though that is hugely
important for some collectors, I am not denying that. Here we can think
about passive income. So for example, there was a collection of any fees that
was dropped later in 2021, which was called sloppy. And their promise for
the functionality of their LFTs was that you could have made passive
income out of the casinos that the team that developed
the nFET is partnered width, which is a very, very nice functionality
on your MAP, would most certainly
increase in value. Mixed deer are a
huge amount of NETs then makes available to you once you buy them a
skin in the game. Here you can think about crypto champions or
my pet hooligans, which will be a very huge game at the moment that
I'm recording these, the game has not
been yet dropped, but the collection has been. And once you have an
NFT in that collection, you can also be
able to later on, when the game is
actually launched, to use that specific NFT of yours as the
character in that game. Which can also be very nice. And they're rarely be, also increases with
the functionality that you get out of using them. Because you can
think that you use more rare character and
that is going to be nice. Also, there are also tickets to events greeted by the
owners of debt collection. So for example, if a group of
entrepreneurs that are very successful decided to
make an NFT collection of functionality for them might be that they are going to give
talks in different CPS. And if you have
one of their LFTs, you can enter for free at the
stocks and talk with them. Which idea has been
already implemented? Now as a conclusion here on these ERC 721 standard tokens, the ERCC1 21 standard
is an open set of rules that describes
the way in which you can build an NFT on
the EPM blockchain. Open sapling actually
has a class that has different methods and
fields implemented for ERC 721 that you
can use when making your own NFP or token by
deriving your class from it. We will go through this
process in detail during a future lecture in the few deep not understand
what they said. It is because it is more of a programmatically view of
things, but don't worry, when we get there, I
will make sure that you understand regardless of
your coding experience. There are also ease
these metaphors pyramid, which at the bottom of it has
the infrastructure layer. And there we have the
Ethereum polygon and so on, which are the Web three
dot o protocol layer. Then on top of that
we had the ERC-20, which is the standard for fungible tokens that
we talked about. And here we think about the tokens like cryptocurrencies
that can be changed. And again here, some
of these entities have their own coins made for them
and they can have utility. Their main purpose
should be to incentivize owners in the direction of participation in
an eventual game. We're buying power
within that game. Also maybe early adoption. So these entities have some coins that have
specific uses for them. And it differs a lot
from project to project. It could be a bit
difficult for me to give a broader views for them other than what I
have just mentioned. Now, on top of the ERC
20 layer is the ERC 721. And here it is the
actual land layer, which are the tokenized lens and the sinful and, and so on. And also the nFET is on top
of debt are the actual MFT is the collection that you are going to make would
be at these very step. And on top of that is you, of course the owner of it. The thing to keep in mind that this lecture is
that when you will open next time and
a collection of 10 thousand MFT is trapping. These are ERC tokens. This was about it
for this lecture. And in the next few
lectures we're going to take a much more practical
approach to things. And we will see how we can exactly deploy our
first smart contract. How we can create
our own the ERC-20 token and transfer it to
our mathematics Wallet, how we can make an
NFT smart contract. And then furthermore, generate our own MFT collection with
the exact MFT is deployed. And at the end, we will have the whole collection
on open CDS promised. And you will also
understand how you can do the pre reveal, reveal stage, how to
set the price for it, royalties, and so on. That sounds interesting to you. I look forward to see you
guys in the next lectures. And I thank you very
much for sticking with me up to the end of this one.
4. Creating a smart contract: Hello guys and welcome back
to this course where we learn how we can create
our own NFP collection. In this lecture, we
are going to deploy our first smart contract on the Ethereum blockchain
using the remix EPM IDE that is available
for free online. If you remember, in one
of the last lectures, we talked about smart contracts and what exactly they are. And we understood how they are exactly q small in
the context of MFT. Now, we're going to deploy
one on a local test network. So you do not have to worry
because it will not cost you anything to deploy it on a test network
that is locally. And you can play with
it as you would with a one that would be deployed on the main net
with the real deal. Now, first step is to do, as you see on the screen
VC, the remix website. The link to this website
is the remix dot dot ORG. Once you are on the website, you can create a
new dot SOL file. You can write your script in it. And how you're going to do that. You are going to go in
the top left screen on this page that is
available right here. And you can click
on it and you can see here that a new file, these being made available
for you to enter its name. And we're going to give
our smart contract name. You also need to
write its extension, which is going to be that SOL. So next you are going
to have to write this code into your SOL file. And this one just
specifies at the line to the version of the
ESP edX license of MIT is not such a big deal. Every smart contract, we'll have that pragmas solidity up there
with a specific version. But next you can
see that we define the contract with
the name of counter. Then we define the integral, which is the count
of the contract. Then we define a method which
can increment the counter. And increment means basically
add one to its value. And we also have a method
which will return to us the number of
the count value. Now, these smart contract
that is written there, we need to deploy it, right? And how we can do this? Well, we can go in the left menu bar to the
solidity compiler first of all, then we're going to
compile our gut SOL file. You can see that it
compiled very quickly. Next, to basically see
inside your smart contract, you're going to go one tab lower to deploy and
run transaction. And if you click on Deploy
without the published to IPFS, the interplanetary file system. You are going to see
that basically it will deploy it locally right here
on the diploid contracts. And you can see information
about each one of its fields. And also you can see the
logs of the transaction is displayed in the bottom
part of the screen. If you click on increments, you can see the log
debt transaction, first of all, to counter that
increments the spending. And then that transaction
actually happened. As you can see from
these green tick displayed right here. And you can see that the
count went from two to three. And when we click on getCount, it is three as well. Now again, if we increment
it and get count, it is for the account
gets a B24 again, but only once we hit it. So you can see that all of the fields that we
wrote basically work. Also the way in
which you can see if you are conflict is actually deployed on the desk
network is from the current environment
of JavaScript VM, which is displayed right here. If we had the injected
web dot three, it would actually deploy directly into the
Ethereum blockchain. And you could be able to make a transaction from it to
your mathematics wallet. You can see basically how a smart contract works and
what is the code behind it. Again, this is a very
simple smart contract that only has three fields. If you go and check
on ether scan, a contract that you want to meet or just check its fields, you are going to see
that it actually has quite a lot of fields. And we will also see this when we are going
to deploy here, our collection of
n if T is because that collection will actually have quite a lot of fields here, including the price of NFP, the maximum amount of MFT that are able to be
limited by a wallet, a pre reveal default image to be shown before the review of the actual LFTs and
so on and so forth. If that sounds
interesting to you, I look forward to see you
guys in the next lectures. And I thank you very
much for sticking with me up to the
end of this one.
5. Installing the prerequisites: Hello guys and welcome back to this course where we'll learn how you can make your
own empty collection. In this video, we
are going to begin the whole practical
process of creating your own NFP collection. And for that, we
are first of all going to need some
prerequisites. More exactly. We are going to need
two things to be installed on the machine where you will do the deployment
of these entities from. You are going to need NodeJS, which is a JavaScript framework. And JavaScript is a programming language in case you did not know and don't be scared
by these meanings. And three, discouraged
if you have never written code
before in your life. Because it is going to
be very easy, trust me, and I'm going to guide you
through each step and I will explain to you what
to write in each field. After all, it's
just text writing, so it will not be
complicated, I promise. Now, after running NodeJS, which we are going to
need in order to run a script that we are going
to get from public space, we're also going to need a
text editor for our code. So a place or an IDE, which is also the meaning of it, Where we are going to be able to modify our code
that will help us deploy our collection
of NHD is getting started with installing the
Node.JS JavaScript framework. If you are on a Mac like I am, you can simply write this command that you
see on my terminal, which is the second line. I will highlight it for you just so you can
see it more clear. But if you are on Windows, you can also search on
Google for Node.js. And you can see that it
will appear at Node js.org. And you can go ahead and click on Download and
then furthermore, select the exact distribution and operating system
that you are owned. So if you are on Windows, you can choose the
windows recommended for most users version and then go ahead and download
leap and furthermore, install it, as I said, now going back to Mac, if you are going to install
NodeJS from your terminal, you are first of all going
to need to install Homebrew, which is going to make your life much easier and will also help you do install
NodeJS much more easily. And actually that's what this instruction on
the second line is. For. Once you enter it
in your terminal, you will be prompted to write your password for pseudo
axis so it can install it. And then it will go ahead
and install freaking much. Now, if you want to see
if Homebrew is actually installed on your machine issue just brew and then
dash v from version. And you should see the Homebrew and then
the version of it. And pay attention that you
also need to add to path, the Homebrew in order to, for it to work and actually give your version to
you when you write root dash v. And now
the second step here, which is to actually install
NodeJS using Homebrew, which we just installed, is to write brew install Node. Now, as you can see, it will go ahead and
install NodeJS for us. As far as Windows goes, you can just go ahead and download the installer
in the ingest, install it with the UI. If that's easier for you, you can do the same
thing on MacOS. But from terminal with homebrew, I just find it easier. However, you prefer to
do these processes fine. If you choose to install
NodeJS be determiner. Again, you can just write after it is installed
Node and then densely to check if it has actually been installed
and check its version. That was it for the
Node.JS installing. And now we should just
take a look at our IDE, which is going to be
Visual Studio Code. We are choosing here Visual Studio code as
it is very lightweight. And it will be much
easier for us to run the code that we
need to run with NodeJS using Visual Studio Code. And also if you don't
have the latest machine, not a problem because Visual
Studio Code is much more versatile and it does not demand such high
System Requirements. So you can go on the download button
from Visual Studio Code. And again, depending on
your operating system, you should install it from here, it is going to be
pretty straightforward. But after you've done
these two steps, you will be able to go ahead and get to the next lecture
where we're going to see exactly where we
can get the public code for creating our own an empty
collection from scratch. Then we are coming to actually deployed on the test
net of open C. And though the pre-review and
reveal stages so you will be able to sell your
prepaid NFP collection. If all of that
sounds interesting, I really look forward to see you guys in the
next lectures and I thank you very much
for sticking with me up to the end of this one.
6. Structuring and storing our NFTs: Hello guys and welcome back
to this course where we learn how we can create
our own NFP collection. In this lecture, we
are going to take a look at the method
data standards that open see imposes on
our collection of NFP is in order for
us to respect them and have a collection that can be seen and also
solved on open sea, which we already know, is the biggest NFT marketplace
out there at this moment. So it's important for us
to have our collection here because all the
big collections are getting sold on open sea and serious buyers and also the
majority of buyers know about open sea and
also treated with respect and do the majority of their transactions
I don't open. See, this is a pretty
important point in our journey of creating
the NFP collection. And you can see here
that the link of ducts that opens you that i o slash doc slash metadata standards. We can see that the
exact documentation for our ERC 721 tokens, which of course are
our NFP tokens. From a programming perspective, you can think that there are already implemented
classes that represent the ERC-20 and ERC
seventh 21 tokens. And you can use the programming
language of JavaScript. And furthermore
derived your own token that she went to deploy
on the main net on Open. See, using these two classes, depending on which
you actually want. If you make a currency for
ERC-20 or NFP for ERC 721. Now if you remember, we discussed already about
these tokens and furthermore, what each of them do. Erc-20 is like a currency, but the main difference
between ERC-20, Bitcoin, for example, is that ERC-20 is actually a currency that is
deployed on a blockchain. When Bitcoin has
its own Blockchain, then the ERC seventh
21 token is used for non-fungible assets that
cannot be exchanged within each other
because each of them is unique and they
had different value. Just like NFP is R. And this is exactly why we
are going to implement your C7 2100 tokens
for our collection of ENFPs to these classes of
ERC-20 and ERCC1 one-to-one, we can add our own
particular fields, like the name symbol, the maximum amount that
can meet at launch, the pre-review date,
the review date. A picture that should take
the place of the nFET is when the collection is in the pre-review stage and so on. By scrolling on the
metadata standards here, we can see different
things that our collection should have and also
they are transposed. So you better understand
what each field of the code actually do in our
actual collection. We're going to
have the pictures, but we are also going
to have metadata that will be closely
related to it. And each of these
images will have a CEB, which is a content identifier. And these pictures of our
LFTs we will upload to IPFS. We are going to see
that in just a moment. So let me not get
ahead of myself. But it's important
for now for you to understand that our images
will have two parts. One which will be
the actual JPEG and also a JSON file which
will hold the metadata. There. It will have the CIP, which will be content
identifier you can think of as an unique ID that will recognize that picture
scrolling even more. Here is the metadata
structure and here it is being talked about each attributes
that you can give, different traits, like dates
and so on and so forth. But the really
important part here is the IPFS and are we
view our eyes section. Here, you can see
that the open sea supports the metadata
storage for any fees. In foreign networks
that are decentralized, they can be modified
by a central party. A de-centralized pile network, which can be modified
by a central party. And the most popular
nowadays is called IPFS. And why is it useful for us
to be more decentralized? You might ask, well, that's just because it is actually just like
the blockchain is. It is a distributed
cloud storage and anyone can have a node here. And now it is basically a point where you store your stuff. And here is the site
for it, IPFS.io. And it is just as you see, a hypermedia protocol
design to preserve and growth humanity's knowledge
by making the wave upgraded, more resilient and more open. So in the crypto space is this whole notion
of Web three dot o. And this is basically
an upgrade to the web, to data, which is the
Internet as we know it today. But let's not get
into that stuff. And let's just continue
reading the documentation. So if you use IPFS to
host your metadata, which were the JSON
files associated with each of our JPEG
from our NFT collection, you are URL should be in the format of IPFS
and then a hash, for example, IPFS
and then a hash. And this hash will actually be the content identifier which
I talked to you about. And this gets updated
with the file. So it will help immutability and persistence of your data. The persistence of your data is actually destroying
part of it. And you see that the
structure is very, very important and
it needs to have the CIP and the metadata, if you are wondering, is just the way in
which marketplaces will get the information
about our NFP. And when we talk about
information about our LFTs, you can think from
the places where our images will be stored and we will store
them in the Cloud. So not on our local computer, but somewhere on a server where the open sea would be able to retrieve the
data so the image from. And for that we're
going to use pinata, just like you see that opened CEs advising us
to do right here. But other than the
specific images, who are our LFTs, we are also going to
see that the rarity is the different properties
of an NFP and how rare it is, the royalties which is
going to be a percent. So after you seal any of
these from your collection, each time an additional
NFP will be sold, you can configure percent out of their transaction to again
come to you, the creator. And that can be
specified again in the metadata of the NFP. Now, you can see that if
you plan to store on IPFS, we Richmond, Indiana for
easily storing data. And Indiana is just
a Cloud space. So they offer cloud space, space on a server
where you can store your actual LFTs and
they will be online and publicly available
for open S3 treat them went trying to show you our entities on their homepage. You can see that they say that you can privatize any file
if you upload with Kenyatta, hiding it from the
IPFS public network. And you can control who can access files and for how long. This is, of course,
using the appropriate. But they have a free plan
that we are going to use, which is just storing and
managing our NFT media. And this again means the actual JPEGs and
demand that data. So we are going to be able
to store them here for free. And then furthermore, make them available to the open sea
collection of our own. And people can actually
treat them there with, of course, the help of
linear and also IPFS. In the next lecture, we're going to see where
we can publicly get the code for creating
our own NFP collection. We're going to see how
different layers can work in order to make our huge
collection of any piece. Because you might have seen that nFET is on OBC have
different attributes. And depending on what attributes
a specific entity has, it has a specific query. We're going to see how we can programatically
configure the layers and then actually create
programmatically. So not by hand because
it would be very hard to make 10 thousand
entities by hand, each of them at a time, but all of them at once
using those layers with Node.JS JavaScript framework in the Visual Studio Code ID. If that sounds
interesting to you, I look forward to
see you guys there. I thank you very much
for sticking with me up to the end
of this lecture.
7. Creating our NFTs: Hello guys and welcome back to the scores where we
learn how we can create and sell our own NFP collection made up of a lot of items
with different verities. In this lecture, we are actually going to
start the process of programmatically creating these MAPs from our collection. When I say programmatically, I mean, using code. You might have reckoned
before when you saw those 10 thousand
collections on open sea, you might have thought that
a person did not actually digitally draw each of those NFT is because that
would take a huge while. Instead, what these
artists do and the best practice is to draw different properties
of these LFTs, which are considered
layers in the picture. So only a part of the NFT and then combining
them together to get an actual NFT with a total rarity that will furthermore determine
its final price. So with that out of the way, the past that we are going
to take in creating these. Any of these is a free
tool that is using Node.JS to be using some
code, these entities. And the code for
it is open source, meaning it's free and it
is available on GitHub, as you can see on the screen. The link is github.com slash hash lips slash hash
slips art engine. If you go on this link, you can find the repository
that contains the code. Repository is basically
just the place where you store the codec. I'm sorry if I will also
explain for people that are not actually programmers
in real life so they can better understand
all the words that I'm using. Now, once you get here, you are going to have
to download the code. And how you're going to
do that is first of all, check in the right
part of the release is in here are the
latest releases, meaning the latest version
of code for this repository. And we can go ahead and click on Version one that wanted to, which as you can see, it's written here in green, that it is the latest. Once we click it,
we are going to see that we have here
the source code for it, and we can click
on it and it will furthermore download
archive for us. Back here, you can see down the line that they actually had the whole documentation
on how to use these repository and
the code within it. I already did research
this and used it. So if you want to further more, going check this documentation
out, be my guest. But I really think that it's
CTR just listening to me and watching what I do then
starting to read this. So going back to our
process after you are going to finish the
download of your archive. It will be shown in your downloads so you
can right-click on it. And furthermore, opening it
with your archive utility, if you are on Windows, you might have some wind seep
or 7-Zip available to use. So you can extract
the files that are in this archive
in an actual folder. What we're going
to do now is drag the folder that we get out of
this in Visual Studio Code. I have an external screen here. So as you can see, it's just opened up and drag. Now we have the
whole code from debt public GitHub
repository opened in our own code editor that we downloaded
in the last lecture. And as I've already said, the NFP is that we'll, we'll get with these
scripts that are written in this repository
are going to be created based on combining one of each of the layers
that are made available. You might ask yourself, where can you find these layers? Well, you have a subfolder
here which is called layers. And you can see here we
have a sub folder for each property that
our NHD can have. So we have some
default ones here, but if you are going to
create your own collection, you can basically change the
properties of your NSAIDs. And then here you can see
that we have some PNGs, which is the format for an image with a
transparent background. And if we click on one of it, you can see that it has different colors and basically
different properties. One more important observation here is that the way in which you should name these properties is its name and then hashtag, and then the percent of rarity that you want this
property to have. For example, if one of our METs is going to be
an eye color of green, only 1% of these entities
will have this green color. Now, again, the
bottom lead here, you can see that 40%, we'll have the middle one. 40% will have a lower, 120% will have a higher one. This is going to be
the more rare one. But again, all these layers are going to combine
each other when we execute this code in order
to create a whole NFP. And not just one but
a collection of Tim, each one being unique and
different from all the others. With that being said, you will need to go ahead
or who are own collection to replace these images with different
layers of your own. You can feed dogs, cats, apes and so on, whatever you think of and are able to nicely digitally draw. You might get an iPad forties or hire someone from Fiverr
to do it for you. But these actual design
is a required part of it. I am going to furthermore, use these default images that are provided in
order to show you, once you get that digitally art, how you can compile these different layers
into the actual NMT is. And then furthermore,
drop them in a collection on Open see in the config js file
that you can find here in the SRC sub folder. You can see that we have the layer configurations
constant at line 25. And you are going
to need to replace the name of the
folders at line 25. If you want to
change them, also, you need to keep
the order the same. So you can see that here we
have the layers or there. And this basically is an object and here
are its properties. Now the field of growth
addition size two is the amount of media images you want to create for
your collection. If you want a collection
of 10 thousand DFTs, you will write 10 thousand
here and instead of five. But what you need to
keep in mind here is that for a collection debt
big of 10 thousand rupees, you actually need quite a few
layers because otherwise, a lot of the properties
will be repeating. The diversity of your collection will go drastically down. Now, you can see that if I
tried to generate a 150 to 200 and FTEs out of just those
few layers that you saw, we will get basically
very, very, very similar. And if d is even odd,
even duplicates. Next, we actually need to add some dependencies from
the terminal in order for this project work and
for us to actually compile it and have
our NFP is here. So first of all,
you are going to need to open the terminal. If you are on Mac, you need to have the keyboard shortcut of
Control and then the hyphen, what I wrote here, control that and then hyphen, this is the keyboard
shortcut for opening the terminal on Mac
and on Windows, I think it's control and then T, and then you are terminale will open up just like mine did here. And here. We can go ahead and check if we have no JS installed on this machine in
order to be able to run the project
and create those NFV, these out of the
layers that we have. To do that we need to write node and then dash v. In this, you can see we have installed on this machine the
version 14, that 18.2. If node was not installed
on this machine, the thing that would have been returned here would have been something like node is
not unknown command. Next, let's do the
same thing for npm. The Node Package Manager is we will need that as
well to install some dependencies
that are found in the package.json and
packaged dish loc dot JSON. This project. To do that again, we do
npm and then the Ashby. And you can see that
I have installed the version eight
dot three dot o. It's important to have both of these things installed before going ahead and trying to install the dependencies
and run the project. Another very
important thing to be noted here is that if for some reason when you will try to build the project
and creating FFTs, you get an error. You can reference back to this video and check
your note version. Because it might be that the node version that you have installed on your machine will not be compatible
with the version of the hash lips aren't
engine for me to working. And I have the hash lips aren't
engine one, that one too. And the node version
of 14 that 1892. If you receive an
error and you have a different version
of Node installed, you might need to uninstall it and then install
another version for it. But with that out of the way, we can go ahead and
install the dependencies that are specified
in these two files. And to do that, we're going
to write npm install. And what this will
do, as I said, it will basically
read these two files and download all of
these dependencies. And it will put them, as you can see at the path of node modules and then some
other folders created. Before running npm install, you will not have
these node modules folder present in your
project structure. But after it, it
might take some time to network each normal. And it is only one time thing that you should do
on your project. It will create this
node modules folder, and it will install all the dependencies in order
for this project to run. Next, after we install
the dependencies as well, We are ready at this point Q, build the project and create the ENFPs out of those layers. We're going to do that is
right node and then index.js. If we press Enter, you can see that five images out of those
layers were created, each one of them with
specific content identifier. Now index.js is
referring of course, to this file that is specifying two other functions to
be called from main.js. And this is the way in which
the process is starting. If you ever took
programming courses, you can think of peace index.js, the int main that you had in the basic C plus plus scripts. So we created five METs, but where are they? Well, you can see that a new build folder was
created in our project. And if we open it, we have two sub folders here, images and then JSON. We created five of each
because each image should have the metadata in
corresponding JSON folder. And also the reason
that it created five LFTs is the
growth addition size two filled in the layer
configuration object that specifies the number
of any teach to be created. And if we look through these, you can see that
we have five eyes. Each one of them unique and with different
characteristics. And for each of them we have an additional corresponding
JSON file that specifies quite a
few things about this image and
what it specifies. First of all, it's its name, then the description which
will need to replace here. Then the IPFS URL that we already talked about
in the last lecture. Then DNA, which is going to
be the seed of the image. The addition, meaning the
number out of the total, that is NFP is, is the date. And then each attributes which are going to
be the properties. Here we have the
background black, eyeball light and so on. So out of this, the total rarity will be
calculated in different ways. These metric data
that is stored for each of the images in this JSON is crucial for
marketplaces that need to reference the data
when displaying it. We already seen the
OpenCV documentation that needed a new URL
for every image and also the metadata
for it in order to actually take these attributes output somewhere and
display them here. Because as you might
have seen on Open see, there are the properties listed and they need to
be taken from somewhere. So this is that somewhere. But we told the said this is about the way in
which you can create programatically a big
collection of n if T is out of different layers
that you already have. Now in the next
lectures we are going to upload this
collection that we have just created to a Cloud service that is coming to store
not just the images, but also the metadata
for them for open C. And then we are also
going to create and deploy these LFTs using the remix IDE that we have already seen when we created
this smart contract. I really hope you guys got
something out of this lecture and I look forward to
see you in the next one.
8. Uploading our NFTs: Hello guys and welcome back
to this tutorial where we learn how we can create
our own NFP collection. In this lecture, we are
going to understand how we can upload on Cloud. So on a remote server, our NHD pictures and metadata that we have just
created programmatically in the last lecture for debt as open since suggested
to us into documentation. If you remember, we are going
to use a combination of IPFS with the pinata
dotCloud website. And if you see here, this is their website
that you can head on. It's called pinata dotCloud. Again, it has two plants. One is for free and one
is the pro version. So paid one. In our case, we are going to get away
with the free one as we do not need that much storage
space in the first-place, the propane includes
some additional stuff. So you have unlimited storage, but we're not going
to beat one gig of storage for these
small collection. And other than that, it has some additional bandwidth and a dedicated IPFS gateways. But other than that, you can also sign up for the
individual plan that again, with unlimited storage
is only $0.15. So that's pretty good also. But if you are planning on
releasing a huge project, you might opt for the propane in case your needs
are that advanced. But I have already
created my account here. You can click on try it for
fee and then log in yourself. But when you are going to login, you will see this
page right here. And we will start with uploading the files that
we have just created. So we can upload an entire folder and then select the folder
we want to upload. In my case, it is
the images folder. So what we can upload it. And we can give it a
name which is going to be our NFP collection. The main reason you
use a Miata is to have the IPFS link
needed by open. See, this is the CID, the countered identifier that
we talked about earlier. We will upload these
images to be in the ACA, as you can see here. And it will give us a seed
and we need to replace the seed in the image field of the metadata so we can
reference them from IPFS. As you can see, each one of
them have different seed. If we click on this one, you can see that this is the axial seed that is
before the one dot PNG. As I've said, we need to replace the seed in the metadata
adjacent fast from our Visual Studio code before uploading the
metadata as well. The CID dash in
his name dot PNG, as you can see here, is going to take us to that specific
anything median in each. That as you can see, it's now available
openly on the web because it is stored on
Cloud on Kenyatta server. Once we get the
CID from Kenyatta, we can replace it in the config that JS in the base URI field. We can go ahead and copy
this field and then go to Visual Studio Code
in the config dot js. And here we have the base URI, which is going to be this one, and then replace it. Once we did that to
automatically update all the images fields for all the entities we need to run. Degenerate metadata
js from the folder. We can go ahead
and save this one. And you can see here that
we have the tails folder and then we have the
upbeat dash info that JS. And also degenerate
this metadata JS, which will run using node, and then it will update all the URIs here
in the image field. So you can see now in all the JSON's we have new
URI to replace. And after we run
this script E here, you should have the
new seed that we replaced in the config
dot js base URI. We can go ahead now in the
terminal and right node. Node because we are
running kit with NodeJS and chaos because it
is in the folder. And then there's the name of the script which is
generate metadata. And now when we click Enter, you can see that the
metadata was created. And now if we go on adjacent, you can see it at your
actual link here is changed. And for each of
them, it is changed. Now, only ones of the metadata JSON files are updated with the actual seed
image in the image field. Can we go ahead and upload
this folder to pin as well so we can go on to Kenyatta and upload
another folder. Then we will select folder which is going to be in the build and
the MAD is going to be the JSON folder and
upload it as well. We can say our and then md for metadata and we can
upload it as well. And as you can see, now, the media for our LFTs is available openly online
on being at a server. And furthermore,
hoping she will be able to see all of
these images by looking first into
the metadata and then seeing the links of
where the images are at. And also if you
remember, the charities, because they are also available in the JSON, as you can see. After this, the open sea, we'll go ahead and go to
this link in order to get the NFT image to display it
and also its properties. So I really hope you guys got something out
of this lecture in one step closer to
creating your NFT collection. In the next lecture, we
are going to look at how we can create and then deploy the smart contracts
for these LFTs so we are ready to
launch our collection. That sounds interesting to you. I really look forward to see you guys in the next lecture.
9. Deploying our NFTs: Hello guys and welcome back
to this course where we learn how we can create our
own NFT collection. In this lecture, we are going to see how we can create
the smart contract on the Ethereum blockchain
for the NFP collection that we programmatically created
in the last lecture. With that being said, the first thing we
need to do is to head over to the hash lips Git repository that we
also use to get that open source code for us
to create those entities. And we need to enter into the solidity dash smart
contracts repository. Then we need to go to contract. And if d and then NFP dot SOL, once we get here, this is going to be
a text file that we need to copy using
pitch two squares here. We need to go ahead to
the remix Ethereum IDE. Here we need to create a new file using these
new file button. Then write its name here. I'm not going to
do that because I have already made
the file for myself, but it also needs to have
the extension of SOL. This name is not very important regarding
to your collection. But some of the things
that you will need to change into this text file is, so you can see that this
is an ERC 721 token here. And we talked about these
kinds of tokens that are used to deploy any of these. First of all, you need
to check the pragma. So EVP here, the compiler needs to be
in-between these two values. In our case, it is alright, because the compiler version is 087 and we have
070 and then 090. So that's alright. Scrolling more in this file, we can see that we can play with different attributes
of these empty collection. First of all, here
we have the cost of an NFP in our collection
and VPs in ether. Of course, you can give whatever the price you want for one item of your collection. I would recommend 0
dot 05 to 0 dot t2. If you are doing a really high-quality project where a lot of people
are part of it. Now, the next field is
the max supply field. And here we are going to write the total amount of any
thes of our collection. If you remember
last time when we created those NSGs
programmatic clean and uploaded their media images and also their
metadata on pinata. I only made five of them. So for the purpose of this demo, I am going to write
five as well. But you can write a 1010 thousand or
however much you are. And if the collection is, then the max amount
is specifying the amount of NETs that quality is able
to meet at launch. And then I'm going to
leave this to one. And depending on how hyped
up, easier collection, you might want to drop
this down because of diversifying the owners
of your fifties. And next this Boolean is specifying where they're making
process is paused or not. By default, EPS set to pause. But you might want to set
it up to two if you want the main thing to be paused at the moment of
deploying smart contract. And this is advice to
be done because again, if it is and hyped
up project and a lot of people are looking to meet when you deploy
the smart contract. Some people might try to mean they might be able to do that if you do not
say these posts to true. And then we have a
constructor here. And if we scroll down a
bit here online, 126, you can see that
these code that I am right now highlighting is a function that will make a 5% cut to hash leaves
as a royalty fee. Each time one item of your
collection gets sold. The royalty fee was
again upper strand. That goes somewhere. Each time an item of your
collection gets sold. In this collection, 5% will
go to hash leaps because they provided these open
source code and helped you launch your collection. Again, if you do not
want to give them 5%, you can just do this. I do not advise you to do that. I won't do that, but you might just can't if you want to
maximize your profit. I'm just presenting that as an option and not the
right thing to do. Once you modify it, all of these items
to your liking, you can go ahead and compile
this smart contract by heading on here to the
solidity compiler. And then compile these files. Now you can see by the green
tick here that it compiled. And what do we need
to do is go a step lower to deploy and
run transactions. The next pin I am going to talk about here is that
you're going to need a mathematic wallet
in order to process these transactions and also
start your image to join me. But just in case you do
not know what that is, I'm going to spend a few
minutes talking about it. Mathematically is a Chrome
browser that is going to be added just like your
ad blocker might be here in the top-right corner. Here, you will have
an account that you can find with your EPI rhythm. This is the way in which
all the transactions on the Ethereum blockchain and regarding game FTEs
are being made. Of course there are other
wallets and other ways, but mathematics is
the most used one and most easy to use. You can go ahead and go
to maximize that i o and download it and it will
install it on your Chrome. Then by default, you will have a password for eight each
time you open Chrome up, you can fund it with purity PBM. And this is the way in which
you can pay to buy any fees. And also with deuterium being the Proof of Work
network that it is, you are going to need to also pay guest fees
on each transaction. So that is going to
be useful for you. Now, once you have the negative viewer
mathematics here, of course, you're going to be on
the Ethereum main net, which is the net where actual transactions
with deuterium happen. But With this being a demo, and I'm just going to deploy this collection on
a test network. I'm not going to actually
launch it by Q will be. So I just chose the
Rob's TEN test network. And here I have 0
that three Ethereum. So with that out of the way, now that you also have a
mathematic account here, the very important thing to select on deploying
drench in section, since the environment
by default, you are going to be on a
JavaScript virtual machine, either the London or Berlin
one in you're going to need to switch to inject
IT web dot three. And you're going to connect your MetaMask wallet
to this website. And if it is not connected, you can go ahead
and click on it. And then on these three
dots connected sites. And then if it wouldn't
have been connected, there would've been a
button here that we'd say manually connect
to this website. That's how you connect. And if you do,
you're going to see the network being shown here. We are unwraps then, but you are going to be on maintenance when
deploying this. And you can also see
the account linked and the sum of Ethereum
that we have. Now other than this, we do not have to change
anything on the gas limit. But on the contract we need to select our contract
before the learning. We're going to need to
change a few things here. And these things are from the constructor
as you see on line 32, from this text file that
is written in solidity. And these three things are
going to be of course, regarding our NHD collection. First of all, we need to write the name
of our collection, which in my case is
going to be crazy eyes. The symbol is going to be c0. Next, what you're
going to write in the image to base your eye is, as you remember from the, it opens the documentation. We need to write the IPFS URL. And then after the IPFS, you are going to write the
CID of the metadata that you have stored on Piazza server for your
immunity collection. We can go ahead and write IPFS, two dots, forward
slash, forward slash. Then we need to go ahead and pineapple and copy that
CID for our metadata, which is going to be this one. We're going to edit
after these IPFS link. And then we also need
a forward slash. After this, we can
basically transact, as you can see also that it says contract
deployment here. We can now click on firm. Here in the bottom of the screen you can see
that the creation of NFP is pending and we should get
a successful message next. So you can see that the
actual MAP collection is now live because we have
applied contexts here. So we can scroll and see that
we also can mean to them. We can pause it, we can remove waitlist. And there are basically
a lot of functions here that let us play
with this collection. So we can whitelist user and
then here as the parameter, we can add the
address of the user. And this user is going to
have the waitlist privilege, meaning that he will be
able to meet earlier. We also have the
cost-based your eye and so on and so forth. We can also meant MFT. We can go ahead and put
our interests here. Also. Let us say that we
want to meet one and then transact. Here. You can see that we have the mint message and
also a guess fee, and we can confirm this. Right now he'd be spending that is how you would mean connectivity of your collection. And also, you can see another success message here in the log section of
the Linux VM ID. You can see here guys, on designates that open sheet that I owe given the
fact that, I mean, these NFP is out
of a test network, they are going to be available
when you connect with your wallet on test net
that open, see that i o. But when you
actually create URM, if P collection on
the TVM main net, you're going to see
it on Open Data and AI right now mentee
down the tree and if t, so that's why we only
see three on screen. But also it might
take a while up until the point when you see
all of them in your wallet, it takes some time to
load them up basically. But as you can see, me now reached our final
goal of actually having our MFT collection deployed
on Open see, right now, you will be capable to do design your own NFP collection
of thousands of units and then put it
on sale on open sea though I really
hope you guys got something out of this tutorial. If you have any questions
of any kind or you get stuck at any point
in this tutorial, feel free to message me here. I am available to
you and I will do my best to respond in the
quickest manner possible. But again, thank you very
much guys for sticking with me up to the end
of this tutorial. And I look forward to see
you guys in future ones.