Upcoming Solana NFT Projects – Moonly



Upcoming Solana NFT Projects — Moonly

Good day, good people! After a short break from sharing my progress update for Automatio, I’m back with a new project. Meanwhile, I married and became a father, (minted) a beautiful girl called Mila.

As you may know already, I devote time to building a no-code web automation tool called Automatio (a powerful web scraper and bot builder). But I also dived into Solana NFT blockchain development a couple of months ago. And despite the challenges, it’s been an exciting ride.



But Quickly, What’s an NFT?

NFT stands for non-fungible token. An NFT can be any physical item made available for sale digitally. This can be a painting, music, or any other sellable. And by non-fungible, it means an NFT isn’t replaceable, even with any other similar item. It’s essentially unique and tagged to the maker’s identity. In essence, no two same NFTs can exist at the same time. Each NFT item is identified in a blockchain using a unique token generated at the point of minting. And that’s why they call them non-fungible tokens, which means they’re non-replicable as each of them possesses a unique certificate.

Minting, however, means creating an NFT item on a digital platform such as Solana to put it out for sale. NFTs exist on blockchains and are available for sales in cryptocurrencies. When you sell an NFT as the author, you invest in a lifetime passive income as the unique token trails your creation. So even whenever buyers resell your item, you get a certain percentage, called a royalty (determined by you), on each sale.



Moonly

So, friends, I present to you, for the first time, **Moonly**, the Solana blockchain project that has captured my time and passion. With a regularly updated database of trending NFT projects, it helps you recommend the best upcoming NFT projects worth investing in on Solana.

I’ve been on to NFT for some years now, and I know how difficult it can be to decide what NFT project is worth the time and investment. This problem and other salient ones are what I vision Moonly to solve. It’s currently a prototype version. But with the current development metrics, I’m optimistic that it will be a handy NFT project companion, dishing out the best timely ideas to its users when it finally launches. Moonly not only recommends the best NFT project available on Solana but goes ahead to help you decide which one is worth minting at a particular time.



So what’s Moonly, and how does it work?

It’s an NFT recommender built on the Solana NFT blockchain. Since engagement determines, to a great extent, the potential worth of an NFT project, Moonly uses data analysis and detailed visualizations to give insights on metrics, such as the engagement pattern of NFT projects on Solana. Using these stats, it then tells you the most promising upcoming project with high potential to bring you passive income.

The recommender relies heavily on several NFT data points sourced from several APIs. And we also scrape some using **Automatio** in real-time. This is also a way to interlink my products and build a robust infrastructural framework.

However, Moonly will recognize possible blue-chip NFT projects by analyzing over 18 different factors like social stats, engagement, validation of followers, growth rate, doxxed founders, roadmap, Discord community, etc. It will offer a set of tools to help you monitor existing NFT projects and better decide on trading factors like Floor Price, Volume, Listing count, historical data, undercut opportunities, and more.

However, regardless of your experience with NFTs, the purpose of Moonly is to take you to the moon! It ensures that you invest only in solid NFT projects with high ROI (return on investment) potential.

Having been a part of the Solana community for a while now, it became my first choice for blockchain technology. Indeed, it’s one of the fastest decentralized systems. It also offers a lower cost per transaction, and it’s more eco-friendly than most alternatives out there. Plus, it’s a friendly community. That’s why it’s popular among NFT creators and investors.

Below, you can find the top 30 Solana NFT projects of all time, sorted by volume. Clicking on any of them redirects you to Moonly, where you can find more information about them. Nonetheless, note that what you currently see is just a prototype. A fully rebuilt version is coming soon, with more data for each project.

Boryoku Dragonz

Solana Monkey Business

Shadowy Super Coder DAO

Degen Coin Flip

Degen Ape Academy

Thugbirdz

Mindfolk

Monkey Kingdom

Taiyo Robotics

Portals

Stoned Ape Crew

Aurory

SolSocks

SolStein

OG Flowers

Zillaz

Baby Ape Social Club

The Catalina Whale Mixer

Turtles

Nyan Heroes

Playground Waves

Zero G Labs: Solanauts

Fine Fillies

Galactic Geckos

Solsteads Surreal Estate

Pesky Penguins

Solpunks

Famous Fox Federation

Solana Monkette Business

Finally, I’d like to know, are you into the NFT games? If yes, what’s your chosen chain? Solana or Ethereum? And what NFT project are you holding? More importantly, I’d appreciate your honest feedback on the Moonly project itself.

Peace.


Source link

On-Chain SVG Generation – Part 1

As of recent, a lot of projects have requested for us to deploy their art on-chain. While this is cool, trendy way of keeping all of your NFT art on-chain, it comes with some limitations. The image (in bytes) that they want to store on-chain can only be so big without losing a ton of money to gas costs.

While this is not a new idea by any means (Cryptopunks is on-chain and they were one of the first), I found trouble finding a good tutorial on how to do it.

Thus, we will be covering how to generate the art on chain, and in part 2 we will explain how you go about actually handling randomness and pushing the correct metadata for the OS protocol.



First steps

You will need to deploy all of your assets onto IPFS (bear with me, we won’t be just referencing them in our metadata as the image). You will then need to build a json struct, here is an example I did for a “Mobsters” NFT:

{
    "Mobster":
    {
        "Shoes": [
            "Black": "https://gateway.pinata.cloud/ipfs/pinata_shoes_folder/Shoes/Black.png",
            "Brown": "https://gateway.pinata.cloud/ipfs/pinata_shoes_folder/Shoes/Brown.png",
            "Gold": "https://gateway.pinata.cloud/ipfs/pinata_shoes_folder/Shoes/Gold.png",
            "Red": "https://gateway.pinata.cloud/ipfs/pinata_shoes_folder/Shoes/Red.png",
            "White": "https://gateway.pinata.cloud/ipfs/pinata_shoes_folder/Shoes/White.png",
            "White & Blue": "https://gateway.pinata.cloud/ipfs/pinata_shoes_folder/Shoes/WhiteBlueSneakers.png",
        ],

        "Pants": [
            "Black": "https://gateway.pinata.cloud/ipfs/pinata_pants_folder/Pants/Black.png",
            "Gold": "https://gateway.pinata.cloud/ipfs/pinata_pants_folder/Pants/Gold.png",
            "Jeans": "https://gateway.pinata.cloud/ipfs/pinata_pants_folder/Pants/Jeans.png",
            "Pinstripe": "https://gateway.pinata.cloud/ipfs/pinata_pants_folder/Pants/Pinstripe.png",
            "Red": "https://gateway.pinata.cloud/ipfs/pinata_pants_folder/Pants/Red.png",
            "White": "https://gateway.pinata.cloud/ipfs/pinata_pants_folder/Pants/White.png"
        ],
   // ETC

Next, we are going to generate a file called Traits.sol (some parts cut for the sake of part 1s simplicity, which is where we are going to upload each of these assets as base64 encoded versions).

It will look something like this:

// SPDX-License-Identifier: MIT LICENSE

pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./interfaces/ITraits.sol";
import "./interfaces/IMnC.sol";

contract Traits is Ownable, ITraits {

  using Strings for uint256;

  // struct to store each trait's data for metadata and rendering
  struct Trait 
    string name;
    string png;
  

  // mapping from trait type (index) to its name
  string[8] private _traitTypes = [
      "Shoes",
      "Pants",
      "Shirt",
      "Eyes",
      "Head",
      "Hat",
      "Mouth Piece",
      "Accessories",  
  ];
  // storage of each traits name and base64 PNG data
  mapping(uint8 => mapping(uint8 => Trait)) public traitData;

  /**
   * administrative to upload the names and images associated with each trait
   * @param traitType the trait type to upload the traits for (see traitTypes for a mapping)
   * @param traits the names and base64 encoded PNGs for each trait
   */
  function uploadTraits(uint8 traitType, uint8[] calldata traitIds, Trait[] calldata traits) external onlyOwner 
    require(traitIds.length == traits.length, "Mismatched inputs");
    for (uint i = 0; i < traits.length; i++) 
      traitData[traitType][traitIds[i]] = Trait(
        traits[i].name,
        traits[i].png
      );
    
  

  /** RENDER */

  /**
   * generates an <image> element using base64 encoded PNGs
   * @param trait the trait storing the PNG data
   * @return the <image> element
   */
  function drawTrait(Trait memory trait) public pure returns (string memory) 
    return string(abi.encodePacked(
      '<image x="4" y="4" width="64" height="64" image-rendering="pixelated" preserveAspectRatio="xMidYMid" xlink:href="data:image/png;base64,',
      trait.png,
      '"/>'
    ));
  

  /**
   * generates an entire SVG by composing multiple <image> elements of PNGs
   * @param tokenId the ID of the token to generate an SVG for
   * @return a valid SVG of the Mobster
   */
  function drawSVG(uint256 tokenId) internal view returns (string memory) 
    IMnC.CopperMobster memory s = mncNFT.getTokenTraits(tokenId);

    string memory svgString = string(abi.encodePacked(
      drawTrait(traitData[0][s.shoes]),
      drawTrait(traitData[1][s.pants]),
      drawTrait(traitData[2[s.shirt]),
      drawTrait(traitData[3][s.eyes]),
      drawTrait(traitData[4][s.head]),
      drawTrait(traitData[5][s.hat]),
      drawTrait(traitData[6][s.mouthpiece]),
      drawTrait(traitData[7][s.accessories])
    ));

    return string(abi.encodePacked(
      '<svg id="NFT" width="100%" height="100%" version="1.1" viewBox="0 0 64 64" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">',
      svgString,
      "</svg>"
    ));
  

So, essentially all we are doing her is storing all the traits in a struct which will be stored in a mapping for later use by using the uploadTraits method. This will be the first thing you will want to knock out when starting this project. drawTrait will be used to actually wrap the base64 encoded png in an image tag so it can be rendered. Finally, drawSVG will allow us to grab the randomized trait (will be explained in the next tutorial, there are a lot of ways to do this, but to do it entirely on-chain, here used A.J. Walker’s Alias Algorithm for anyone wanting to jump ahead.



Script to upload one group of traits

Note, this can also be done in a loop to do everything at once, but for simplicity sake, here is a script of how to upload one group (we will be doing our mobsters shirts).

const  ethers  = require("hardhat");
require('dotenv').config(path: ".env")
const fs = require('fs');
const fetch = require("node-fetch");
const traitJson = JSON.parse(fs.readFileSync('scripts/traitMapping.json'));

async function main() 

  const [user1, user2]  = await ethers.getSigners();
  provider = ethers.getDefaultProvider()

  // Deploy our Traits.sol contract
  const Traits = await ethers.getContractFactory("Traits")
  t = await Traits.deploy()
  await t.deployed()
  console.log("Traits.sol deployed to", t.address)
  // Attach to the contract
  const tContract = await Traits.attach(t.address)
  let traitsToUpload = []
  console.log(traitJson["Mobster"]["Shirt"])
  for (let i=0; i < traitJson["Mobster"]["Shirt"].length; i++) 
    // Get name of the specific attribute
    let key = Object.keys(traitJson["Mobster"]["Shirt"][i]).toString();
    // Get IPFS URL for the asset
    let value = Object.values(traitJson["Mobster"]["Shirt"][i]).toString();
    // Encode in Base64 the png (this is where the magic happens)
    let imgB64 = await fetch(value).then(r => r.buffer()).then(buf => `data:image/png;base64,`+buf.toString('base64'));
    // Append the dictionary of the mapping fo the name to the base64 image
    traitsToUpload.push(name: key, png: imgB64)
  
  tx = await tContract.uploadTraits(2, [3, 3, 8, 1, 10, 10, 10, 11, 3, 11, 8, 10], traitsToUpload)
  // The first arg is the position of the trait in Traits.sol, the second array is for randomness
  // randomness which will be explained in part 2 of the tutorial, and finally the third arg is
  // our actual mappings we just generated
  console.log(tx)


main()
  .then(() => process.exit(0))
  .catch((error) => 
    console.error(error);
    process.exit(1);
  );

After doing this for each attribute, all of about assets are ready to be combined upon mint!



Script to make sure your assets combine correctly

If you’re curious how your assets stack up, you can do this off-chain to check that things are assembling correctly, once you have altered the script below, at the bottom of this webpage you can paste in your svg code to see a preview of what it will render as. Keep in mind these are SVG’s so you need to keep them small. SVG stands for Scalable Vector Graphics. Which means even if your SVG is very small (64x64px is probably the largest I would go for gas reasons it will scale as it is rendered on OpenSea or elsewhere.)

This is a very blunt script, to help explain in detail what exactly will happen on-chain to combine the assets. (It’s crucial you sync with your artist to make sure you are layering them in the correct order.)

const fetch = require("node-fetch");

async function main() 
    let shoesB64 = await fetch("https://gateway.pinata.cloud/ipfs/pinata_asset_folder/White-Blue-Sneakers.png").then(r => r.buffer()).then(buf => `data:image/png;base64,`+buf.toString('base64'));
    let pantsB64 = await fetch("https://gateway.pinata.cloud/ipfs/pinata_asset_folder/Jeans.png").then(r => r.buffer()).then(buf => `data:image/png;base64,`+buf.toString('base64'));
    let shirtB64 = await fetch("https://gateway.pinata.cloud/ipfs/pinata_asset_folder/Godfather.png").then(r => r.buffer()).then(buf => `data:image/png;base64,`+buf.toString('base64'));
    let eyesB64 = await fetch("https://gateway.pinata.cloud/ipfs/pinata_asset_folder/3D-Glasses.png").then(r => r.buffer()).then(buf => `data:image/png;base64,`+buf.toString('base64'));
    let headB64 = await fetch("https://gateway.pinata.cloud/ipfs/pinata_asset_folder/Boss.png").then(r => r.buffer()).then(buf => `data:image/png;base64,`+buf.toString('base64'));
    let hatB64 = await fetch("https://gateway.pinata.cloud/ipfs/pinata_asset_folder/White-Fedora.png").then(r => r.buffer()).then(buf => `data:image/png;base64,`+buf.toString('base64'));
    let mouthB64 = await fetch("https://gateway.pinata.cloud/ipfs/pinata_asset_folder/Cigar.png").then(r => r.buffer()).then(buf => `data:image/png;base64,`+buf.toString('base64'));
    let assessB64 = await fetch("https://gateway.pinata.cloud/ipfs/pinata_asset_folder/Tommy-Gun.png").then(r => r.buffer()).then(buf => `data:image/png;base64,`+buf.toString('base64'));


    base = '<image x="4" y="4" width="64" height="64" image-rendering="pixelated" preserveAspectRatio="xMidYMid" xlink:href="'
    end = '"/>'

    shoes = base + shoesB64 + end
    pants = base + pantsB64 + end
    shirt = base + shirtB64 + end
    eyes = base + eyesB64 + end
    head = base + headB64 + end
    hat = base + hatB64 + end
    mouth = base + mouthB64 + end
    access = base + assessB64 + end

    starter = '<svg id="NFT" width="100%" height="100%" version="1.1" viewBox="0 0 64 64" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">'
    finisher = "</svg>"

    console.log(starter+shoes+pants+shirt+eyes+head+hat+mouth+access+finisher)


main()
  .then(() => process.exit(0))
  .catch((error) => 
    console.error(error);
    process.exit(1);
  );

This should output a string you can paste in the link above to see if that specific NFT is rendering correctly.

I hope you found this tutorial helpful. If you have any comments or suggestions on how I could improve my process or how you did it more efficiently, I am all ears. Please feel free to leave something in the comments. Once the second part of the tutorial is complete, we will be open sourcing the entire repo.

If you found this tutorial helpful, please give me a follow on Twitter and follow my company, CrossChain Labs for any NFT/DeFi help you made need with your project or more helpful blog posts.



Stay tuned for part 2!!




Source link

Release an NFT drop on your own site without writing any code



Intro

Hello everyone! In this guide I will walk you step-by-step on how to create your own NFT drop without having to write a single line of code, no Solidity, no JavaScript, nothing.

In this example, we’ll create an NFT drop where people can claim a unique Pokémon NFT. The same process can be followed for other types of NFTs (audio, video) as well as “one of many” NFTs (e.g multiple copies of the same trading card).

No matter what your use case is, this web3 guide will explain everything step-by-step, no programming knowledge required.

You will notice as you perform many of the steps in this walkthrough, your wallet will prompt you to accept transactions. thirdweb is not charging you anything, it’s the gas costs of deploying the contracts from your own address, so you can own the contracts.



Set up a project

First, we need to create a project on thirdweb, which can be done on thirdweb dashboard.

For this project, we’re going to be deploying on Polygon Testnet Mumbai, but you can use a mainnet for it (Ethereum, Polygon, Avalanche, etc).

The name for this project is for internal use, so you can identify it later on the dashboard. The name and description used here are not public.



Set up the drop



Create a drop module

After we have created our own project, click on “Add Module” and select “Drop“.

Drop uses ERC-721, which means every NFT will be unique.

This is my Drop Module after I fill in the information:

Drop module creation

The drop I’m going to be deploying is a Pokémon-themed one, so we’re going to be uploading all the Pokémon from Gen 1 as NFTs, isn’t that exciting?!

So, what does every input do? Let’s use Bored Ape Yacht Club, a popular collection, as an example:

BAYC as an example

  • Image: Image of your collection (as a whole).
  • Name: Sets the name of your collection.
  • Description: Description of your collection.
  • Symbol: Etherscan symbol (BAYC on Bored Ape Yacht Club)
  • Primary Sale Recipient Address: The address that will receive both the money from the primary sales and the royalties.
  • Royalty: The % of money you’ll get from any secondary sales (For example any time your NFT gets sold on OpenSea after the mint).



Configure the drop

Next thing we’ll do, is configure the drop, these are my settings for this drop:

Drop settings

So let’s explain what each of these do!

  • Currency: The currency you want users to mint the NFT with. You can use any token available on the chain, even your own custom tokens!
  • Price per token: How much of that currency it’s going to cost (0 is free).
  • Maximum Mint Supply: How many NFTs are going to be available for minting, in my case, 152 (A pokeball and 151 Gen 1 Pokémon.)
  • Waittime (seconds): The amount of time people need to wait until they can mint again after they have minted once. (Click “Max” if you only want them to mint once).
  • Claim limit per transaction: The maximum number of NFTs you want them to be able to claim in one transaction (helps saving money on gas).



Set permissions

The next screen will allow us to set permissions. Here you can give admin capabilities to other wallets, if you want to do so. I’m going to leave it exactly as is for the moment:

All the permisions you can set



Bulk upload

We reached the fun part! Now we’re going to be uploading all our NFTs with all the metadata to our drop module so people can mint it.

I’ve prepared a folder with all the Gen 1 Pokémon and the metadata for you to try this guide, it’s available here.

Click “Bulk Create” at the top of your Drop Module.

Bulk Create button

It asks us to upload a folder.

So, what are the requirements for the folder?

  • Files must contain one .csv file with metadata. – Download example.csv
  • Assets must be named 0,1,2,3…n.extension
  • Images and videos can be used in combination. They both have to follow the asset naming convention above. (Example: 0.png and 0.mp4)

Our pokemon folder already complies with all these requirements, so we can go ahead and upload it.

After uploading, we’ll see this preview of all our NFTs with their description and properties:

Preview before uploading

As you can see, I added a “Generation” property, and I set it to “1”. If in the future I want to add more Pokémon, I can do it and set the “Generation” property differently, you can use this to add unique traits and rarity to your NFT drops – each column in the .csv represents a unique property.

Go ahead and click “Bulk Create X drops“.

This is what I see on the dashboard after they finish uploading:

Our dashboard with all the Pokémon

Important! Every single image that you just added, was also automatically uploaded and pinned to IPFS, which means your images now live in the blockchain, forever.

The metadata for the NFT also gets uploaded to IPFS.

So… now we have created our drop, wasn’t that easy? The next step will enable people to mint the NFTs.



Embed the drop

Click on the embed tab on the drop module.

Embed tab

thirdweb offers an easy copy and paste embed that you can add on any website that accepts HTML. People will be able to connect their wallet and mint their own NFTs.

This is the configuration that thirdweb offers:

Embed configuration

  • IPFS Gateway: This is where the embed is hosted. For your own production deployments, we recommend getting your own.
  • RPC Url: The RPC Url that is used, you can use Alchemy or Infura here, recommended for production deployments.
  • Relayer Url: Provide a relayer url to use for this embed. A relayer can be used to make the transaction gas-less for the end user. Learn more.

Next, at the bottom of the page, you’ll be able to see a preview of how it will appear. Once you claim an NFT, it will show on the inventory tab of the embed!

Our own embed!

After claiming one NFT



Add the embed to your website

For this example, I’m going to use Carrd, but you can use the embed on any page that accepts HTML (Webflow, Bubble, WordPress, etc.)

Carrd specifically needs a premium version to be able to add embeds, but remember you can add this HTML code to any HTML page for free.

I’m using this free template called Random Product, which is very simple but perfect for our needs.

Click the “+” button, and click “Embed“.

Click Embed on the + dropdown.

A drawer will open, you need to paste the embed code provided by thirdweb here:

Add embed code

Save the page on the top right and publish it.

This is how mine looks:

My carrd site



That’s it!

You are finished! You have done a lot, let’s recap:

  • You have created your own NFT drop and setup the conditions for people to claim.
  • All the images have been uploaded to IPFS, so they’ll live on the blockchain forever.
  • You have created your own website.
  • You have added an embed so people can mint your drop!

You’re now a blockchain expert! If you want to go ahead and mint some Pokémon from my site, here’s the link. Remember there’s only 151 available!

Also, if you want to check this collection on OpenSea, you can do it here.

I hope you have enjoyed this guide, if you create your own collection with this, please send it to me on Discord or on Twitter @nachoiacovino.

See you on the next one!

Article originally published at thirdweb.com.




Source link

Creating an NFT on Solana with Metaplex Candy Machine.



Guide Overiew

After what felt like walking through a mine field trying to figure out how to create my own NFT on Solana with the current guides, I decided to put together a guide myself in a very beginner friendly fashion.

I won’t be taking a deeper dive into the specifics of how everything works, but rather help people with zero knowledge of rust obtain a general understanding on how to create their very own NFT on Solana with the help of Metaplex candy machine and a web starter kit.

Note: I used Ubuntu 21.10 – Wayland for it. Some things may vary depending on the operating system you are running.



What is a Metaplex Candy Machine?

Metaplex is a command line tool that interacts with the candy-machine program. In this guide, we will use it to:

  1. Upload your images along with their metadata to arweave, then register them on the Solana blockchain.
  2. Verify that the state of your candy machine is valid and complete.
  3. Mint individual tokens.

Candy Machine is a system that manages fair mints.
• The minting process starts and finishes at the same time for everyone.
• It won’t accept your funds if there are no more NFTs to sell.



Prerequisites

  1. NodeJS (version 14.17.6)
  2. SolanaCLI
  3. Metaplex CLI
  4. Phantom Wallet

If you have a different version of Node installed on your system, you can use nvm which allows you to quickly install and use different versions of node via the command line.



Getting Started



Installing The SolanaCLI

Solana already has really well made guides on installing and using the Solana command line.
Install Solana Command Line Tools



Using Devnet

Devnet is really useful for developers to test out their programs and applications.

You can set your default Solana url to devnet using:
$ solana config set --url https://api.devnet.solana.com

Now, let’s create a devnet wallet:
$ solana-keygen new --outfile ~/.config/solana/devnet.json
Remember to store your seed phrase somewhere safe.

I highly recommend making devnet your default keypair
$ solana config set --keypair ~/.config/solana/devnet.json



Funding The Devnet Wallet

Firstly, let’s make sure that we’re on devnet by checking the configuration.

$ solana config get
//Output:
Config File: /Users/dev/.config/solana/cli/config.yml
RPC URL: https://api.devnet.solana.com
WebSocket URL: wss://api.devnet.solana.com/ (computed)
Keypair Path: /Users/dev/.config/solana/devnet.json
Commitment: confirmed

Now, let’s fund that wallet:
Firstly, We check the balance of our current wallet.

$ solana balance 
//Output:
0 SOL

Then we airdrop the amount of SOL to our wallet. Remember, the amount is capped to 5 SOL.

$ solana airdrop 4
//Output
Requesting airdrop of 4

Signature: Transaction Signature

4 SOL

Now, Let’s check our balance to confirm the airdrop was successful.

$ solana balance
//Output:
4 SOL //This can vary depending on the balance you initially had.

In case you’re confused by any of the above steps, you can check the manuals to get a better understanding by running:

$ solana help config
$ solana help balance
$ solana help airdrop



Configuring Phantom Wallet

After setting up your phantom wallet, we can link our newly created devnet wallet above to phantom.
To do so, first we need to open its settings, click on Change Network and select Devnet

Now, we need to obtain the devnet wallet private key. To obtain that, open your terminal and cat to view the contents of the keypair.json file

$ cat .config/solana/devnet.json
//Output:
[12,22,.....]

Now copy the output you received and open phantom wallet. Click on the top left navigation menu and click on Add/Connect Wallet and then click on Import Private Key and give it a suitable name and paste the contents we copied before in the Private Key field.

You should be able to see 4 SOL in your wallet.



Running Candy Machine CLI

Please ensure that you have node and yarn installed before proceeding.

Also install ts-node by running:
$ npm install -g ts-node

Now, let’s clone the metaplex project into the location of your choice.

$ git clone https://github.com/metaplex-foundation/metaplex.git
$ cd metaplex/js
$ yarn install && yarn bootstrap && yarn build

To run the command line utility,

$  ts-node metaplex/js/packages/cli/src/candy-machine-cli.ts help
Usage: candy-machine-cli [options] [command]

Options:
  -V, --version                          output the version number
  -h, --help                             display help for command

Commands:
  upload [options] <directory>
  verify [options]
  verify_price [options]
  create_candy_machine [options]
  update_candy_machine [options]
  mint_one_token [options]
  sign [options]
  sign_candy_machine_metadata [options]
  help [command]                         display help for command



Organizing & Uploading Your Assets

For this guide, we will be using pre-made assets which you can download by clicking here. courtesy of solana-candy-factory
Place this assets folder in a suitable location.
Here is how you should organize your NFT files to upload:

ls assets | sort -n
0.json
0.png
1.json
1.png
2.json
2.png
3.json
3.png
....

You can notice that these files come in numerical pairs, that is 1.png and 1.json are the two halves of the NFT. The png file is the art work and the json file contains the metadata.

The directory name assets does not matter. You can go with anything you like.



Validating Your Assets

This may feel tedious but it’s just as important. Checkout the the manual on carrying this out at
https://docs.metaplex.com/nft-standard



Uploading Your Project Assets

Now that we have the funds, assets all organized and vaidated, we can proceed with the fun stuff!

We will proceed with uploading our assets with the CLI. Remember, our assets are located at metaplexjspackagescliexample-assets

$ ts-node metaplex/js/packages/cli/src/candy-machine-cli.ts upload assets --env devnet --keypair ~/.config/solana/devnet.json

//Output
Processing file: 0
Processing file: 1
Processing file: 2
Processing file: 3
Done

By uploading, it sends the files to Arweave and also registers those files with your candy machine. Both Arweave and Solana are initialized after a successful run.



Validating Your Candy Machine

You can confirm the health and status of your on-chain assets using:

$ ts-node metaplex/js/packages/cli/src/candy-machine-cli.ts verify --env devnet --keypair ~/.config/solana/devnet.json
//Output:
Looking at key  0
Name redacted-name 0 with https://arweave.net/redacted-tx-id checked out
Looking at key  1
Name redacted-name 1 with https://arweave.net/redacted-tx-id checked out
Looking at key  2
Name redacted-name 2 with https://arweave.net/redacted-tx-id checked out
Looking at key  3
Name redacted-name 3 with https://arweave.net/redacted-tx-id checked out



Starting Your Candy Machine

After verifying that our assets are good to go, we can finally start the candy machine.
$ ts-node metaplex/js/packages/cli/src/candy-machine-cli.ts create_candy_machine --env devnet --keypair ~/.config/solana/devnet.json



Updating Your Candy Machine

We can modify our candy machine details to include a start date and/or price etc.

$ ts-node metaplex/js/packages/cli/src/candy-machine-cli.ts update_candy_machine --env devnet --keypair ~/.config/solana/devnet.json --price 1 --date "29 Oct 2021 00:12:00 GMT"



Minting Our NFT

To mint our NFT, we can use mint_one_token like so:

$ ts-node metaplex/js/packages/cli/src/candy-machine-cli.ts mint_one_token --env devnet --keypair ~/.config/solana/devnet.json

If all goes well, you can now open your phantom wallet, open the collectibles page (It’s beside the $ symbol on the bottom) and voila! Your newly minted NFT will be there!



Setting Up The Web Starter Kit

Now that we’ve successfully minted an NFT into our wallet, let’s make a web application to carry out the mint instead!
Note: This project is very new and could cause some issues, if it does then please report it on github.

The goal of the project is for you to be able to configure it and customize it to your liking.

Fork the project and then clone it to your desired location.
Link: https://github.com/exiled-apes/candy-machine-mint

Now we need to build the project,

cd candy-machine-mint
yarn install
yarn build

This is where things get a little bit complicated. When we uploaded our NFTs, a cache file was created in the same directory as our assets directory. However, this .cache folder is hidden! If you’re on ubuntu, use ctrl+h to display hidden files.

Once you have discovered that folder, open it and you’ll find devnet-temp file. Open it in your IDE and you’ll see the following


    "program": 
        "uuid": "Ch3ps8",
        "config": "Ch3ps8QDLUEa2C1VfbjVCGny86kU7fU2mMUU6r2VAY3c"
    ,
    "items": 
        "0": 
            "link": "https://arweave.net/_z2OeYH3Wom1y-MyRExVzejA2f1KQls9yV0hx8HeF6c",
            "name": "TEST",
            "onChain": true
        ,
        "1": 
            "link": "https://arweave.net/L1XD2LZmpLDYX8CQZbhlLpLUpq9zwa5UdAfnL1FnHVM",
            "name": "TEST",
            "onChain": true
        ,
        "2": 
            "link": "https://arweave.net/1Mf8jqdXDkqJXK-dis7Lo5mTWPcmY2XV4sBoTdrkwVY",
            "name": "TEST",
            "onChain": true
        ,
        "3": 
            "link": "https://arweave.net/g3FY_hre1WRzq2U7Yo7qy0bw6ko5lcjoOfnHuEsokDs",
            "name": "TEST",
            "onChain": true
        ,
        "4": 
            "link": "https://arweave.net/osvMsQGCbr4sQ6d_gsh67Hz59JNesngMicRlD4kMPzs",
            "name": "TEST",
            "onChain": true
        ,
        "5": 
            "link": "https://arweave.net/bKwtXFt05BMIw5tMuqi6Q9U0VOtIfIJH9xCRzvqYZlY",
            "name": "TEST",
            "onChain": true
        
    ,
    "env": "devnet",
    "cacheName": "temp",
    "authority": "9xJwcnBLEuH9uuM6dJ939oHpjGFwHUroVJyCherdHxGD",
    "candyMachineAddress": "3WmzqKPPhFrenFs9md7ZoSi96aWUeKtLFu18mtjPBht5",
    "startDate": 1632615120

We’re going to need all this data when we run our web application to mint.



Configuring Candy-Machine-Mint

Open up the candy-machine-mint folder, where you will find a file called .env.example
(The file is usually hidden, use ctrl+h to display hidden files)
Rename it to .env and then open it to edit the following details:

REACT_APP_CANDY_MACHINE_CONFIG=__PLACEHOLDER__

This is the program.config key from our .cache/devnet-temp file.

REACT_APP_CANDY_MACHINE_ID=__PLACEHOLDER__

This is the candyMachineAddress from our .cache/devnet-temp file.

REACT_APP_TREASURY_ADDRESS=__PLACEHOLDER__

This the Solana address that receives the funds gathered during the minting process. You can set this to your devnet wallet address.

REACT_APP_CANDY_START_DATE=__PLACEHOLDER__

This is the startDate key from our .cache/devnet-temp file.
Note: If you cannot find it, use update_candy_machine as mentioned above as you may have missed out on mentioning the date.

REACT_APP_SOLANA_NETWORK=devnet

This identifies the Solana network you want to connect to. Options are devnet, testnet, and mainnet.

REACT_APP_SOLANA_RPC_HOST=https://explorer-api.devnet.solana.com

This identifies the RPC server your web app will access the Solana network through.



Starting The Web Application

Open your terminal and navigate to the candy-machine-mint directory and start the react app by using yarn start

Once you see Compiled Successfully in your terminal, Open http://localhost:3000 to view it in the browser.

You can now proceed with connecting your wallet, and clicking on the mint button.

After clicking on the mint button, you can check the collectibles page on your phantom wallet and you’ll see your newly minted NFT!

That’s all I will be covering in this guide. If you encounter any issues, comment down below and I’ll try to help!



Other Resources

  1. https://hackmd.io/@levicook/HJcDneEWF
  2. https://docs.metaplex.com/
  3. Follow Anatoly and Raj Gokal for good vibes.




Source link

Print code on NFT – DEV Community

PRINTCODE - is collection base on star pattern
All item can run code on javascript language or NodeJS

Hi guys!
“This is first my collection on NFT”

Non-fungible tokens (NFT)
https://ethereum.org/en/nft/

I’m interested NFT for a while
I’m print code on NFT in website opensea on chain ethereum (ETH)
Update 18 item in collection PRINTCODE

Example code first item
PRINT CODE #0001
I’m use javascript language
CODE

You can support collection PRINTCODE
https://opensea.io/collection/printcode101


Source link