Prerequisites

• Yarn
• TypeScript
• NodeJS
• ~0.05 SOL to pay the required fee’s
• Solana RPC Endpoint

NFTs require their image and JSON metadata files to be hosted. We recommend using a decentralized storage provider such as Shadow Drive (UI for small-scale hosting). We will provide a couple of examples, but the following will be needed for your own unique NFTs:

• URI for the hosted collection image
• URI for the hosted NFT images
• URI containing the JSON metadata for the collection
• URI containing the JSON metadata for NFT
• Inside the exampleNftJson folder is an example of the NFTs JSON metadata we have hosted on Shadow Drive

How to mint Metaplex Compressed NFTs on Solana

On Solana, State Compression is the method of creating a “fingerprint” (or hash) of off-chain data and storing this fingerprint on-chain for secure verification. Effectively using the security of the Solana ledger to securely validate off-chain data, verifying it has not been tampered with.

This method of “compression” allows Solana programs and dApps to use cheap blockchain ledger space instead of the more expensive account space to store data securely.

This is accomplished by using a special binary tree structure, known as a concurrent Merkle tree, to create a hash of each piece of data (called a leaf), hashing those together, and only storing this final hash on-chain. This method of “compression” allows Solana programs and dApps to use cheap blockchain ledger space instead of the more expensive account space to store data securely.

With this technology, compressed NFTs can be created on-chain similarly to before, but for a fraction of the cost as before. As a frame of reference of on-chain cost reduction, take a 1 million NFT collection:
1 million NFTs ~= 12,000 SOL (traditional NFTs)
1 million NFTs ~= 5 SOL (compressed)
 — Solana State Compression Docs

This technical tutorial will guide you through minting compressed NFTs on the Solana blockchain using the Metaplex protocol. We will modify and run two scripts:

1. Creates a Merkle tree, and a collection
   createCollectionAndMerkleTree.ts
2. Mint compressed NFTs to TipLinks
   mintToTipLink.ts

This guide adapts a handful of resources on compressed NFTs published by Metaplex and Solana Foundation. We cloned the official Solana Developers GitHub repo and modified it to create TipLinks.

• Spotlight: State Compression by Solana
• Compressed NFTs Live Github Walkthrough with Nick Frostbutter

Cloning the Repo

We will clone an example repo to get the example up and running quickly. This GitHub repo is adapted from Solana Foundations Compression NFTs example, allowing you to mint directly into TipLink URL wallets.

1. Let’s start by cloning the repo. Run gh repo clone GoonTrades/compressed-nfts-TipLink-adapted in your CLI.
2. If you are using VSCode you can also click “Clone Git Repository” underneath “Start” and paste in this URL: https://github.com/GoonTrades/compressed-nfts-TipLink-adapted.git
3. Install the packages using yarn install
4. Run yarn demo ./scripts/createWallet.ts to initialize a wallet and store the private key in the .local_keys file
5. Send 0.05 SOL to the wallet to create the Merkle tree, and have some leftover SOL to fund the TipLinks
6. Rename the example.env file to .env (Make sure you do this, or you will publicly share your keys + the script will fail)
7. Set RPC_URL=”your_helius_api_key”
   You can get a free Helius API key here

The main folder we will work out of is the scripts folder. It utilizes the two files createCollectionAndMerkleTree.ts and mintToTipLinks.ts.

We will create the collection and Merkle tree via the first script. Then we will mint the NFTs into individual TipLinks, using the collection and Merkle tree we created.

Note: Run these scripts in order! The CreateCollectionAndMerkleTree.ts saves data to a .local_keys folder within this repo for use by the other scripts.

Creating the Collection and Merkle Tree

1. Open createCollectionAndMerkleTree.ts and view the size of your Merkle tree size.

Three values to configure your tree, each serving a very specific purpose:

1. maxDepth - used to determine how many NFTs we can have in the tree
2. maxBufferSize - used to determine how many updates to your tree are possible in the same block
3. canopyDepth - used to store a portion of the proof on the chain, and as such, is a large factor of cost and composability of your compressed NFT collection

To keep things simple and cheap, for this tutorial we have a maxDepth: 3, and a const canopyDepth = maxDepthSizePair.maxDepth - 3. This creates a Merkle tree for eight compressed NFTs.

The parameters below size your tree between 16,384 to 1,058,576 NFTs per tree. A great tool to help size your Merkle tree is Compressed.app. Feel free to read more about the details on State Compression, including how to size a tree and potential composability concerns.

const maxDepthSizePair: ValidDepthSizePair = {
     // max=8 nodes
     maxDepth: 3,
     maxBufferSize: 8,
 
     // max=16,384 nodes
     // maxDepth: 14,
     // maxBufferSize: 64,
 
     // max=131,072 nodes
     // maxDepth: 17,
     // maxBufferSize: 64,
 
     // max=1,048,576 nodes
     // maxDepth: 20,
     // maxBufferSize: 256,
 
     // max=1,073,741,824 nodes
     // maxDepth: 30,
     // maxBufferSize: 2048,
   };
   const canopyDepth = maxDepthSizePair.maxDepth - 3;

1. Inside createCollectionAndMerkleTree.ts find the collectionMetadataV3 constant and pass your NFT collection details. Specifically the name, symbol, and metadata uri.
2. We have placeholder data here, so if you just want to run the example, there is no need to change anything.

// define the metadata to be used for creating the NFT collection
const collectionMetadataV3: CreateMetadataAccountArgsV3 = {
 data: {
   name: "Testing Compression",
   symbol: "TESTooor",
   // specific json metadata for the collection
   uri: "<https://shdw-drive.genesysgo.net/91uEGv2pFyc3nZPgya6L41FKaoD6GoTcGDHqhokHe7Hw/metaURI.json>",
   sellerFeeBasisPoints: 100,
   creators: [
     {
       address: payer.publicKey,
       verified: false,
       share: 100,
     },
   ], // or set to `null`
   collection: null,
   uses: null,
 },
 isMutable: false,
 collectionDetails: null,
};chat

Then go ahead and run the Script!

yarn demo ./scripts/createCollectionAndMerkleTree.ts

You have created a new Merkle tree and collection. As mentioned, the script saved the relevant data from creating the collection and tree to a .local_keys file. This data will be used in the mintToTipLinks.ts script, where we will continue this tutorial and mint the compressed NFTs into TipLinks.

{
 "userAddress":"BminWtwak7FjdAbKiDGe151GvXcAM8oApMeNf6PiM79F",
 "treeAddress":"9BA2PaYCZi2KeapK7MycnbS8CMTpm95xJ4bdWoceQws3",
 "treeAuthority":"4kxKUtrAhfHAYmXggVgA4cCBt7yvT4cwG5d8G3SfvSnH",
 "collectionMint":"5PBzz2WRv6w756uy9TeXCB7gGSKsyn11qw9ZUcNvGVrB",
 "collectionMetadataAccount":"9pigtefJdPF3E85p3P3YAfpTz3nexbGX9AXC8TrP7R5f",
 "collectionMasterEditionAccount":"2KpicaKU4K1YSWyu4bLZ3kCrgeoHk6dNMJDiYLMWGTXL"
}

Mint Compressed NFTs to TipLink URL Wallets

Now we can move to the second script. This creates a TipLink, funds it with some SOL, and mints a compressed NFT into the wallet.

This is where having your JSON metadata URIs is key. To use different art or traits, you must generate this JSON data and host it somewhere, such as Shadow Drive or IPFS. For brevity, we will just be using placeholder NFT metadata.

1. Navigate to the onChainNftMetadata folder and the onChainNFTs.ts file. This is where we will input metadata for the individual NFT to be minted.

The key pieces of our NFT’s metadata to note are:

• name - this is the actual name of our NFT that will be displayed in wallets and on explorers
• symbol - the shorthand symbol that represents the asset
• uri - this is the JSON metadata that defines the NFT based on the Metaplex Token Metadata program

We have populated the onChainNFTs.ts file with two example NFTs, including the hosted JSON metadata in the uri field - so there is no need to modify this until you want to mint your own NFTs.

export const nftMetadatas: NFTMetadata[] = [
  {
    name: "Compressed NFT 1",
    //This is example JSON metadata for the NFTs
    uri: "<https://shdw-drive.genesysgo.net/91uEGv2pFyc3nZPgya6L41FKaoD6GoTcGDHqhokHe7Hw/Frame%205%20(3).png>",
    symbol: "Testy Test"
  },

Finally, we will install and import the TipLink API and add the function to create the TipLink inside mintToTipLink.ts.

1. Install the package by running the following command on the command line:

yarn add @tiplink/api

2. Then, at the top of the mintToTipLink.ts file, add:

import { TipLink } from "@tiplink/api";

3. Add the function to create a TipLink inside the body of the pre-definedcreateAndFundTiplink function:

const tipLink = await TipLink.create();

4. Update the value of tipLinkPubKey as follows, and log the link afterward:

const tipLinkPubKey = tipLink.keypair.publicKey;
console.log(`Here is one of your TipLinks: ${tipLink.url.href}`);

The function should look like this when you’re done:

const createAndFundTiplink = async (
  connection: WrapperConnection,
  payer: Keypair,
  treeAddress: PublicKey,
  collectionMint: PublicKey,
  collectionMetadataAccount: PublicKey,
  collectionMasterEditionAccount: PublicKey,
  nftMetadata: NFTMetadata
) => {  
	//add the TipLink.create function and assign it to tipLink
	const tipLink = await TipLink.create();

        //then using tipLink.keypair.publicKey we can pass the address into transaction  
        const tipLinkPubKey = tipLink.keypair.publicKey;

        //this logs out the URL for the TipLink wallet
        console.log(` Here is one of your TipLinks: ${tipLink.url.href}`);

Now we can run the script to mint the two NFTs into TipLinks. The TipLink URLs will be stored in outputTipLink.csv.

yarn demo ./scripts/mintToTipLink.ts

Conclusion

This tutorial has demonstrated how to mint compressed NFTs on Solana using the Metaplex protocol. The purpose of this guide is to serve as a stepping stone to distributing NFTs at scale.

Some key pieces need to be included, such as generating the NFT images and metadata, storing the TipLink URLs, and creating multiple Merkle trees per collection. In this guide, we only minted one tree, but it is important to note that an NFT collection can have multiple Merkle trees.

Feel free to contact us in Discord if you have questions or need help minting compressed NFTs into a TipLink. Special shoutout to all the people who worked on compression. Specifically the Metaplex team, Solana Foundation, and Helius.

We are excited to see what this tech enables at scale!

TLDR: We raised $6m, launched our API to send crypto + NFTs with a link, and we are hiring!

We are thrilled to announce that we have raised $6m in seed funding led by Sequoia Capital and Multicoin Capital. TipLink allows users to send crypto or NFTs with just a link. The kicker is… the link is a wallet! We are building one of the most important distribution mechanisms in crypto, and this capital will help us bring TipLink to the masses.

Meet our other fantastic investors

Aside from Sequoia and Multicoin Capital, we couldn’t be more excited by the rest of our backers. This includes: Asymmetric, Big Brain Ventures, Circle Ventures, Karatage, Monke Ventures, Paxos, and Solana Ventures. We also are backed by well-known angels Vinny Lingham, Liu Jiang, and Sarah Guo.

There is a gap in crypto payments

If we take a step back from the crypto world and consider the larger world of payments, there are several challenges consumers are facing today. As an example, if Alice wants to send Bob $10 on the internet, there are several challenges she will run into.

1. She needs a coincidence of technologies, meaning that Alice and Bob both need the same application, like PayPal for example.
2. If they both use PayPal, Alice still needs to ask Bob for his information.
3. Even in crypto, Alice needs to ask Bob if he has a wallet and, if he does, have a back-and-forth exchange to get his public key.

The only version where people don’t need to worry about the above 3 is cash. When Alice hands Bob cash, she doesn’t have to worry whether they use the same apps or ask for each other’s usernames; she just hands over the cash. There should be a way to digitally move around assets like cash, but for the internet.

Introducing TipLink

With TipLink, users can send crypto or NFTs with just a link. The link itself is the wallet, meaning the user receiving doesn’t need to know anything about crypto. The user can then withdraw the assets to

1. A wallet they already have.
2. Over time directly to financial institutions they are familiar with.
3. If they’ve never set up a crypto wallet, they can log in with Google and have a lightweight non-custodial wallet in seconds.

The implications for this new distribution mechanism are massive. Instead of sending digital assets to only people in the small crypto ecosystem, you can now send assets to anyone on the planet with an internet connection.

Today, you can send crypto and NFTs to anyone with just a link. Want to send someone without a wallet crypto or NFTs? Use TipLink. Want to do a giveaway and give crypto without asking for people’s public keys? Just send a TipLink. Want to give out tokens at an event with just a QR code people need to scan? TipLink. Want to send money around the world with just a link? Send USDC with a TipLink. Blast out crypto/NFTs to an entire email distro; use TipLink. Almost every day, we hear about new ways people use our product. Sending digital assets should be easy, and people/companies should focus on what they send, not how it works.

The TipLink API!

We want to make sending TipLinks super simple for developers. Our API allows developers to create TipLinks for free and add any asset. This allows for setting up automated processes to send out digital assets and integrating creating/sending links directly into applications. Like Stripe helped create billion-dollar e-commerce businesses, TipLink can help create billion-dollar crypto companies. Now that TipLink exists, the early adopters in figuring out new use cases across IRL, social, marketing, payments, etc., will be rewarded.

Here is a quick example of how easy it is to make TipLinks with our API:

import { Tiplink } from '@tiplink/api';

Tiplink.create().then(tiplink => {
 console.log("link: ", tiplink.url.toString());
 console.log("publicKey: ", tiplink.keypair.publicKey.toBase58());
 return tiplink;
});

We are hiring!

If you’re interested in helping build the most important distribution mechanism in crypto, please apply here: https://jobs.lever.co/TipLink

Founders of TipLink,

Ian (@ArbVision) & Aashiq (@aashiq)