├── .gitignore
├── .prettierrc
├── README.md
├── ReadApi
    ├── WrapperConnection.ts
    └── types.ts
├── example.env
├── metaplex
    ├── fetchNFTsByGroup.ts
    ├── fetchNFTsByOwner.ts
    ├── mintToCollection.ts
    ├── simpleProofVerification.ts
    └── transferNFT.ts
├── package.json
├── scripts
    ├── changelog.ts
    ├── createAndMint.ts
    ├── fetchNFTsByCollection.ts
    ├── fetchNFTsByOwner.ts
    ├── mintToCollection.ts
    ├── transferNFT.ts
    ├── verboseCreateAndMint.ts
    └── verifyCreator.ts
├── tsconfig.json
├── utils
    ├── compression.ts
    └── helpers.ts
└── yarn.lock


/.gitignore:
--------------------------------------------------------------------------------
 1 | # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
 2 | 
 3 | # public/robots*
 4 | public/rss*
 5 | public/sitemap*
 6 | .contentlayer
 7 | 
 8 | # dependencies
 9 | /node_modules
10 | /.pnp
11 | .pnp.js
12 | test-ledger
13 | 
14 | # testing
15 | /coverage
16 | 
17 | # next.js
18 | /.next/
19 | /out/
20 | 
21 | # production
22 | /build
23 | 
24 | # misc
25 | .DS_Store
26 | *.pem
27 | 
28 | # debug
29 | npm-debug.log*
30 | yarn-debug.log*
31 | yarn-error.log*
32 | .pnpm-debug.log*
33 | # local env files and key files
34 | .env*
35 | .env*.local
36 | .local_keys
37 | .local_keys2
38 | 
39 | # vercel
40 | .vercel
41 | 
42 | pnpm-lock.yaml
43 | yarn.lock
44 | package-lock.json


--------------------------------------------------------------------------------
/.prettierrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "tabWidth": 2,
 3 |   "useTabs": false,
 4 |   "singleQuote": false,
 5 |   "printWidth": 100,
 6 |   "trailingComma": "all",
 7 |   "arrowParens": "avoid",
 8 |   "endOfLine": "auto",
 9 |   "proseWrap": "always"
10 | }
11 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # State Compression and Compressed NFTs
  2 | 
  3 | At a high level, state compression is a technique in which off-chain data is secured by the Solana
  4 | ledger, using a hashing algorithm to "fingerprint" the _off-chain_ data and storing it inside a
  5 | special _on-chain_ Merkle tree, called a Concurrent Merkle Tree.
  6 | 
  7 | With this technology, compressed NFTs can be created on-chain in a similar manner as before, but for
  8 | a fraction of the cost as before. As a frame of reference of on-chain cost reduction, take a 1
  9 | million NFT collection:
 10 | 
 11 | - traditional NFTs (aka non-compressed):
 12 |   - 1 million NFTs ~= 12,000 SOL
 13 | - compressed NFTs:
 14 |   - 1 million NFTs ~= 5 SOL
 15 | 
 16 | ## Quick links to learn more
 17 | 
 18 | - Solana Docs for [State Compression](https://docs.solana.com/learn/state-compression)
 19 | - written guide
 20 |   [minting compressed NFTs](https://solana.com/developers/guides/javascript/compressed-nfts) (which
 21 |   is based on this repo)
 22 | 
 23 | ## Tech stack of this repo
 24 | 
 25 | - uses TypeScript and NodeJS
 26 | - yarn (as the node package manager)
 27 | 
 28 | ## Setup locally
 29 | 
 30 | 1. Clone this repo to your local system
 31 | 2. Install the packages via `yarn install`
 32 | 3. Rename the `example.env` file to be named `.env`
 33 | 4. Update the `RPC_URL` variable to be the cluster URL of a supporting RPC provider
 34 | 
 35 | If you have the Solana CLI installed locally: update the `LOCAL_PAYER_JSON_ABSPATH` environment
 36 | variable to be the **_absolute path_** of your local testing wallet keypair JSON file.
 37 | 
 38 | ## Recommended flow to explore this repo
 39 | 
 40 | After setting up locally, I recommend exploring the code of the following files (in order):
 41 | 
 42 | 1. [`./scripts/verboseCreateAndMint.ts`](./scripts/verboseCreateAndMint.ts)
 43 | 2. [`./scripts/fetchNFTsByOwner.ts`](./scripts/fetchNFTsByOwner.ts)
 44 | 3. [`./scripts/transferNFT.ts`](./scripts/transferNFT.ts)
 45 | 
 46 | After reviewing the code, then running each of these scripts in the same order.
 47 | 
 48 | > **Note:** Running each of these scripts will save some bits of data to a `.local_keys` folder
 49 | > within this repo for use by the other scripts later in this ordered list. Therefore, running them
 50 | > in a different order will result in them not working as written. You have been warned :)
 51 | 
 52 | ### Running the included Scripts
 53 | 
 54 | Once you're setup locally, you will be able to run the scripts included within this repo:
 55 | 
 56 | ```
 57 | yarn demo ./scripts/<script>
 58 | ```
 59 | 
 60 | #### `scripts/createAndMint.ts`
 61 | 
 62 | Performs all the following actions:
 63 | 
 64 | - create a new Merkle tree on-chain
 65 | - create a new NFT collection
 66 | - mint two compressed NFTs (to different addresses)
 67 | 
 68 | #### `scripts/verboseCreateAndMint.ts`
 69 | 
 70 | Functionally the same as `scripts/createAndMint.ts`. This script adds extra console logging and
 71 | comments for explanation purposes.
 72 | 
 73 | #### `scripts/fetchNFTsByOwner.ts`
 74 | 
 75 | Uses the ReadApi `fetchAssetsByOwner` method to fetch the NFTs owners by the two addresses.
 76 | 
 77 | #### `scripts/fetchNFTsByCollection.ts`
 78 | 
 79 | Uses the ReadApi `fetchAssetsByGroup` method to fetch the NFTs belonging to the same collection,
 80 | compressed or otherwise.
 81 | 
 82 | #### `scripts/transferNFT.ts`
 83 | 
 84 | Performs the complete process to transfer compressed NFTs. Specifically:
 85 | 
 86 | - fetching the NFT asset data from the RPC
 87 | - fetching the asset's proof from the RPC
 88 | - verifying the RPC provided proof on the client side
 89 | - builds the compressed NFT transfer function
 90 | 
 91 | #### `scripts/mintToCollection.ts`
 92 | 
 93 | Mint additional compressed NFTs into an already existing collection and/or tree.
 94 | 
 95 | ## Metaplex sdk examples
 96 | 
 97 | This repo also contains code examples of how to use the
 98 | [`@metaplex-foundation/js`](https://www.npmjs.com/package/@metaplex-foundation/js) sdk to work with
 99 | compressed NFTs, including reading and transferring them.
100 | 
101 | After setting up locally, I recommend exploring the code of the following metaplex specific files
102 | (in order):
103 | 
104 | 1. [`./metaplex/mintToCollection.ts`](./metaplex/mintToCollection.ts)
105 | 2. [`./metaplex/transferNFT.ts`](./metaplex/transferNFT.ts)
106 | 3. [`./metaplex/fetchNFTsByOwner.ts`](./metaplex/fetchNFTsByOwner.ts)
107 | 4. [`./metaplex/simpleProofVerification.ts`](./metaplex/simpleProofVerification.ts)
108 | 
109 | #### `metaplex/mintToCollection.ts`
110 | 
111 | Mint a single compressed NFT to an existing tree and collection, using the metaplex sdk. This
112 | requires you to create your tree and collection ahead of time. See the
113 | [`./scripts/verboseCreateAndMint.ts`](./scripts/verboseCreateAndMint.ts) script for details on how
114 | to create a tree and collection.
115 | 
116 | #### `metaplex/transferNFT.ts`
117 | 
118 | Transfer a compressed NFT using the metaplex sdk. This method only requires you to know the
119 | `assetId` of the compressed NFT to transfer.
120 | 
121 | #### `metaplex/fetchNFTsByOwner.ts`
122 | 
123 | Uses the ReadApi `fetchAssetsByOwner` method to fetch the NFTs owned by a single address.
124 | 
125 | #### `metaplex/fetchNFTsByGroup.ts`
126 | 
127 | Uses the ReadApi `fetchAssetsByGroup` method to fetch the NFTs belonging to the same collection,
128 | compressed or otherwise.
129 | 
130 | #### `metaplex/simpleProofVerification.ts`
131 | 
132 | Mint additional compressed NFTs into an already existing collection and/or tree.
133 | 
134 | ## Resources on State Compression and Compressed NFTS
135 | 
136 | - Solana Docs:
137 |   - [State Compression](https://edge.docs.solana.com/learn/state-compression)
138 |   - [Guide for compressed NFTs](https://edge.docs.solana.com/developing/guides/compressed-nfts)
139 |     (which is based on this repo)
140 | - Account Compression SPL Program:
141 |   - Documentation - https://spl.solana.com/account-compression
142 |   - Repository -
143 |     https://github.com/solana-labs/solana-program-library/tree/master/account-compression
144 | - Metaplex Read API:
145 |   - open spec:
146 |     https://github.com/metaplex-foundation/api-specifications/tree/main/specifications/read_api
147 |   - Playground - https://metaplex-read-api.surge.sh/
148 | - Metaplex Compression examples:
149 |   - https://github.com/metaplex-foundation/compression-read-api-js-examples
150 |   - Bubblegum program - https://github.com/metaplex-foundation/mpl-bubblegum
151 | 


--------------------------------------------------------------------------------
/ReadApi/WrapperConnection.ts:
--------------------------------------------------------------------------------
  1 | import { Commitment, Connection, ConnectionConfig, PublicKey } from "@solana/web3.js";
  2 | import BN from "bn.js";
  3 | 
  4 | import { TokenStandard } from "@metaplex-foundation/mpl-token-metadata";
  5 | import { PROGRAM_ID as BUBBLEGUM_PROGRAM_ID } from "@metaplex-foundation/mpl-bubblegum";
  6 | 
  7 | // import from the `@metaplex-foundation/js`
  8 | import { MetaplexError, toBigNumber, Pda, amount } from "@metaplex-foundation/js";
  9 | import type { SplTokenCurrency, Metadata, Mint, NftOriginalEdition } from "@metaplex-foundation/js";
 10 | 
 11 | // local imports for the ReadApi types
 12 | import type {
 13 |   GetAssetProofRpcInput,
 14 |   GetAssetProofRpcResponse,
 15 |   GetAssetRpcInput,
 16 |   GetAssetsByOwnerRpcInput,
 17 |   GetAssetsByGroupRpcInput,
 18 |   ReadApiAsset,
 19 |   ReadApiAssetList,
 20 | } from "@/ReadApi/types";
 21 | 
 22 | type JsonRpcParams<ReadApiMethodParams> = {
 23 |   method: string;
 24 |   id?: string;
 25 |   params: ReadApiMethodParams;
 26 | };
 27 | 
 28 | type JsonRpcOutput<ReadApiJsonOutput> = {
 29 |   result: ReadApiJsonOutput;
 30 | };
 31 | 
 32 | /** @group Errors */
 33 | export class ReadApiError extends MetaplexError {
 34 |   readonly name: string = "ReadApiError";
 35 |   constructor(message: string, cause?: Error) {
 36 |     super(message, "rpc", undefined, cause);
 37 |   }
 38 | }
 39 | 
 40 | /**
 41 |  * Convert a ReadApi asset (e.g. compressed NFT) into an NftEdition
 42 |  */
 43 | export const toNftEditionFromReadApiAsset = (input: ReadApiAsset): NftOriginalEdition => {
 44 |   return {
 45 |     model: "nftEdition",
 46 |     isOriginal: true,
 47 |     address: new PublicKey(input.id),
 48 |     supply: toBigNumber(input.supply.print_current_supply),
 49 |     maxSupply: toBigNumber(input.supply.print_max_supply),
 50 |   };
 51 | };
 52 | 
 53 | /**
 54 |  * Convert a ReadApi asset (e.g. compressed NFT) into an NFT mint
 55 |  */
 56 | export const toMintFromReadApiAsset = (input: ReadApiAsset): Mint => {
 57 |   const currency: SplTokenCurrency = {
 58 |     symbol: "Token",
 59 |     decimals: 0,
 60 |     namespace: "spl-token",
 61 |   };
 62 | 
 63 |   return {
 64 |     model: "mint",
 65 |     address: new PublicKey(input.id),
 66 |     mintAuthorityAddress: new PublicKey(input.id),
 67 |     freezeAuthorityAddress: new PublicKey(input.id),
 68 |     decimals: 0,
 69 |     supply: amount(1, currency),
 70 |     isWrappedSol: false,
 71 |     currency,
 72 |   };
 73 | };
 74 | 
 75 | /**
 76 |  * Convert a ReadApi asset's data into standard Metaplex `Metadata`
 77 |  */
 78 | export const toMetadataFromReadApiAsset = (input: ReadApiAsset): Metadata => {
 79 |   const updateAuthority = input.authorities?.find(authority => authority.scopes.includes("full"));
 80 | 
 81 |   const collection = input.grouping.find(({ group_key }) => group_key === "collection");
 82 | 
 83 |   return {
 84 |     model: "metadata",
 85 |     /**
 86 |      * We technically don't have a metadata address anymore.
 87 |      * So we are using the asset's id as the address
 88 |      */
 89 |     address: Pda.find(BUBBLEGUM_PROGRAM_ID, [
 90 |       Buffer.from("asset", "utf-8"),
 91 |       new PublicKey(input.compression.tree).toBuffer(),
 92 |       Uint8Array.from(new BN(input.compression.leaf_id).toArray("le", 8)),
 93 |     ]),
 94 |     mintAddress: new PublicKey(input.id),
 95 |     updateAuthorityAddress: new PublicKey(updateAuthority!.address),
 96 | 
 97 |     name: input.content.metadata?.name ?? "",
 98 |     symbol: input.content.metadata?.symbol ?? "",
 99 | 
100 |     json: input.content.metadata,
101 |     jsonLoaded: true,
102 |     uri: input.content.json_uri,
103 |     isMutable: input.mutable,
104 | 
105 |     primarySaleHappened: input.royalty.primary_sale_happened,
106 |     sellerFeeBasisPoints: input.royalty.basis_points,
107 |     creators: input.creators,
108 | 
109 |     editionNonce: input.supply.edition_nonce,
110 |     tokenStandard: TokenStandard.NonFungible,
111 | 
112 |     collection: collection
113 |       ? { address: new PublicKey(collection.group_value), verified: false }
114 |       : null,
115 | 
116 |     // Current regular `Metadata` does not currently have a `compression` value
117 |     // @ts-ignore
118 |     compression: input.compression,
119 | 
120 |     // Read API doesn't return this info, yet
121 |     collectionDetails: null,
122 |     // Read API doesn't return this info, yet
123 |     uses: null,
124 |     // Read API doesn't return this info, yet
125 |     programmableConfig: null,
126 |   };
127 | };
128 | 
129 | /**
130 |  * Wrapper class to add additional methods on top the standard Connection from `@solana/web3.js`
131 |  * Specifically, adding the RPC methods used by the Digital Asset Standards (DAS) ReadApi
132 |  * for state compression and compressed NFTs
133 |  */
134 | export class WrapperConnection extends Connection {
135 |   constructor(endpoint: string, commitmentOrConfig?: Commitment | ConnectionConfig) {
136 |     super(endpoint, commitmentOrConfig);
137 |   }
138 | 
139 |   private callReadApi = async <ReadApiMethodParams, ReadApiJsonOutput>(
140 |     jsonRpcParams: JsonRpcParams<ReadApiMethodParams>,
141 |   ): Promise<JsonRpcOutput<ReadApiJsonOutput>> => {
142 |     const response = await fetch(this.rpcEndpoint, {
143 |       method: "POST",
144 |       headers: {
145 |         "Content-Type": "application/json",
146 |       },
147 |       body: JSON.stringify({
148 |         jsonrpc: "2.0",
149 |         method: jsonRpcParams.method,
150 |         id: jsonRpcParams.id ?? "rpd-op-123",
151 |         params: jsonRpcParams.params,
152 |       }),
153 |     });
154 | 
155 |     return await response.json();
156 |   };
157 | 
158 |   // Asset id can be calculated via Bubblegum#getLeafAssetId
159 |   // It is a PDA with the following seeds: ["asset", tree, leafIndex]
160 |   async getAsset(assetId: PublicKey): Promise<ReadApiAsset> {
161 |     const { result: asset } = await this.callReadApi<GetAssetRpcInput, ReadApiAsset>({
162 |       method: "getAsset",
163 |       params: {
164 |         id: assetId.toBase58(),
165 |       },
166 |     });
167 | 
168 |     if (!asset) throw new ReadApiError("No asset returned");
169 | 
170 |     return asset;
171 |   }
172 | 
173 |   // Asset id can be calculated via Bubblegum#getLeafAssetId
174 |   // It is a PDA with the following seeds: ["asset", tree, leafIndex]
175 |   async getAssetProof(assetId: PublicKey): Promise<GetAssetProofRpcResponse> {
176 |     const { result: proof } = await this.callReadApi<
177 |       GetAssetProofRpcInput,
178 |       GetAssetProofRpcResponse
179 |     >({
180 |       method: "getAssetProof",
181 |       params: {
182 |         id: assetId.toBase58(),
183 |       },
184 |     });
185 | 
186 |     if (!proof) throw new ReadApiError("No asset proof returned");
187 | 
188 |     return proof;
189 |   }
190 | 
191 |   //
192 |   async getAssetsByGroup({
193 |     groupKey,
194 |     groupValue,
195 |     page,
196 |     limit,
197 |     sortBy,
198 |     before,
199 |     after,
200 |   }: GetAssetsByGroupRpcInput): Promise<ReadApiAssetList> {
201 |     // `page` cannot be supplied with `before` or `after`
202 |     if (typeof page == "number" && (before || after))
203 |       throw new ReadApiError(
204 |         "Pagination Error. Only one pagination parameter supported per query.",
205 |       );
206 | 
207 |     // a pagination method MUST be selected, but we are defaulting to using `page=0`
208 | 
209 |     const { result } = await this.callReadApi<GetAssetsByGroupRpcInput, ReadApiAssetList>({
210 |       method: "getAssetsByGroup",
211 |       params: {
212 |         groupKey,
213 |         groupValue,
214 |         after: after ?? null,
215 |         before: before ?? null,
216 |         limit: limit ?? null,
217 |         page: page ?? 1,
218 |         sortBy: sortBy ?? null,
219 |       },
220 |     });
221 | 
222 |     if (!result) throw new ReadApiError("No results returned");
223 | 
224 |     return result;
225 |   }
226 | 
227 |   //
228 |   async getAssetsByOwner({
229 |     ownerAddress,
230 |     page,
231 |     limit,
232 |     sortBy,
233 |     before,
234 |     after,
235 |   }: GetAssetsByOwnerRpcInput): Promise<ReadApiAssetList> {
236 |     // `page` cannot be supplied with `before` or `after`
237 |     if (typeof page == "number" && (before || after))
238 |       throw new ReadApiError(
239 |         "Pagination Error. Only one pagination parameter supported per query.",
240 |       );
241 | 
242 |     // a pagination method MUST be selected, but we are defaulting to using `page=0`
243 | 
244 |     const { result } = await this.callReadApi<GetAssetsByOwnerRpcInput, ReadApiAssetList>({
245 |       method: "getAssetsByOwner",
246 |       params: {
247 |         ownerAddress,
248 |         after: after ?? null,
249 |         before: before ?? null,
250 |         limit: limit ?? null,
251 |         page: page ?? 1,
252 |         sortBy: sortBy ?? null,
253 |       },
254 |     });
255 | 
256 |     if (!result) throw new ReadApiError("No results returned");
257 | 
258 |     return result;
259 |   }
260 | }
261 | 


--------------------------------------------------------------------------------
/ReadApi/types.ts:
--------------------------------------------------------------------------------
  1 | /*
  2 |   Types specific to the ReadApi
  3 | */
  4 | 
  5 | import type { Metadata, Option } from "@metaplex-foundation/js";
  6 | import { ConcurrentMerkleTreeAccount } from "@solana/spl-account-compression";
  7 | 
  8 | export type ReadApiAssetInterface =
  9 |   | "V1_NFT"
 10 |   | "V1_PRINT"
 11 |   | "LEGACY_NFT"
 12 |   | "V2_NFT"
 13 |   | "FungibleAsset"
 14 |   | "Custom"
 15 |   | "Identity"
 16 |   | "Executable"
 17 |   | "ProgrammableNFT";
 18 | 
 19 | export type ReadApiPropGroupKey = "collection";
 20 | 
 21 | export type ReadApiPropSortBy = "created" | "updated" | "recent_action";
 22 | 
 23 | export type ReadApiPropSortDirection = "asc" | "desc";
 24 | 
 25 | export type TransferNftCompressionParam = {
 26 |   ownership?: ReadApiOwnershipMetadata;
 27 |   data?: ReadApiCompressionMetadata;
 28 |   assetProof?: GetAssetProofRpcResponse;
 29 |   merkleTree?: ConcurrentMerkleTreeAccount;
 30 | };
 31 | 
 32 | export type ReadApiParamAssetSortBy = {
 33 |   sortBy: ReadApiPropSortBy;
 34 |   sortDirection: ReadApiPropSortDirection;
 35 | };
 36 | 
 37 | export type ReadApiAssetContent = {
 38 |   json_uri: string;
 39 |   metadata: Metadata["json"];
 40 | };
 41 | 
 42 | export type ReadApiCompressionMetadata = {
 43 |   eligible: boolean;
 44 |   compressed: boolean;
 45 |   data_hash: string;
 46 |   creator_hash: string;
 47 |   asset_hash: string;
 48 |   tree: string;
 49 |   seq: number;
 50 |   leaf_id: number;
 51 | };
 52 | 
 53 | export type ReadApiOwnershipMetadata = {
 54 |   frozen: boolean;
 55 |   delegated: boolean;
 56 |   delegate: string | null;
 57 |   owner: string;
 58 |   ownership_model: "single" | "token";
 59 | };
 60 | 
 61 | export type ReadApiAssetSupplyMetadata = {
 62 |   edition_nonce: number;
 63 |   print_current_supply: number;
 64 |   print_max_supply: number;
 65 | };
 66 | 
 67 | export type ReadApiAssetRoyaltyMetadata = {
 68 |   primary_sale_happened: boolean;
 69 |   basis_points: number;
 70 | };
 71 | 
 72 | export type ReadApiAssetGrouping = {
 73 |   group_key: ReadApiPropGroupKey;
 74 |   group_value: string;
 75 | };
 76 | 
 77 | export type ReadApiAuthorityScope = "full";
 78 | 
 79 | export type ReadApiAssetAuthority = {
 80 |   address: string;
 81 |   scopes: ReadApiAuthorityScope[];
 82 | };
 83 | 
 84 | export type GetAssetRpcInput = {
 85 |   id: string;
 86 | };
 87 | 
 88 | export type GetAssetProofRpcInput = {
 89 |   id: string;
 90 | };
 91 | 
 92 | export type GetAssetProofRpcResponse = {
 93 |   root: string;
 94 |   proof: string[];
 95 |   node_index: number;
 96 |   leaf: string;
 97 |   tree_id: string;
 98 | };
 99 | 
100 | export type GetAssetsByGroupRpcInput = {
101 |   groupKey: ReadApiPropGroupKey;
102 |   groupValue: string;
103 |   page?: Option<number>;
104 |   limit?: Option<number>;
105 |   /* assetId to search before */
106 |   before?: Option<string>;
107 |   /* assetId to search after */
108 |   after?: Option<string>;
109 |   sortBy?: Option<ReadApiParamAssetSortBy>;
110 | };
111 | 
112 | export type GetAssetsByOwnerRpcInput = {
113 |   /**
114 |    * String of the owner's PublicKey address
115 |    */
116 |   ownerAddress: string;
117 |   page?: Option<number>;
118 |   limit?: Option<number>;
119 |   before?: Option<string>;
120 |   after?: Option<string>;
121 |   sortBy?: Option<ReadApiParamAssetSortBy>;
122 | };
123 | 
124 | export type ReadApiAsset = {
125 |   /**
126 |    * The asset Id
127 |    */
128 |   id: string;
129 |   interface: ReadApiAssetInterface;
130 |   ownership: ReadApiOwnershipMetadata;
131 |   mutable: boolean;
132 |   authorities: Array<ReadApiAssetAuthority>;
133 |   content: ReadApiAssetContent;
134 |   royalty: ReadApiAssetRoyaltyMetadata;
135 |   supply: ReadApiAssetSupplyMetadata;
136 |   creators: Metadata["creators"];
137 |   grouping: Array<ReadApiAssetGrouping>;
138 |   compression: ReadApiCompressionMetadata;
139 | };
140 | 
141 | export type ReadApiAssetList = {
142 |   total: number;
143 |   limit: number;
144 | 
145 |   /**
146 |    * listing of individual assets, and their associated metadata
147 |    */
148 |   items: Array<ReadApiAsset>;
149 | 
150 |   /**
151 |    * `page` is only provided when using page based pagination, as apposed
152 |    * to asset id before/after based pagination
153 |    */
154 |   page: Option<number>;
155 | 
156 |   /**
157 |    * asset Id searching before
158 |    */
159 |   before: Option<string>;
160 | 
161 |   /**
162 |    * asset Id searching after
163 |    */
164 |   after: Option<string>;
165 | 
166 |   /**
167 |    * listing of errors provided by the ReadApi RPC
168 |    */
169 |   errors: Option<ReadApiRpcResponseError[]>;
170 | };
171 | 
172 | export type ReadApiRpcResponseError = {
173 |   error: string;
174 |   id: string;
175 | };
176 | 


--------------------------------------------------------------------------------
/example.env:
--------------------------------------------------------------------------------
1 | # RPC endpoint (that supports the DAS ReadApi)
2 | # (e.g. Helius, Triton, Metaplex, GenesysGo, etc)
3 | # RPC_URL=
4 | 
5 | # absolute path for a local keypair file
6 | # LOCAL_PAYER_JSON_ABSPATH=
7 | 
8 | ## example of using an absolute path for a current filesystem keypair
9 | # LOCAL_PAYER_JSON_ABSPATH=/home/nick/.config/solana/id.json


--------------------------------------------------------------------------------
/metaplex/fetchNFTsByGroup.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Demonstrate the use of a few of the Metaplex Read API methods,
  3 |  * (needed to fetch compressed NFTs)
  4 |  * using the `@metaplex-foundation/js` sdk
  5 |  */
  6 | 
  7 | // import custom helpers for demos
  8 | import {
  9 |   loadPublicKeysFromFile,
 10 |   printConsoleSeparator,
 11 |   savePublicKeyToFile,
 12 | } from "@/utils/helpers";
 13 | 
 14 | // imports from other libraries
 15 | import dotenv from "dotenv";
 16 | import { Metaplex, MetaplexError, ReadApiAssetList } from "@metaplex-foundation/js";
 17 | import { ReadApiConnection } from "@metaplex-foundation/js";
 18 | import { PublicKey } from "@solana/web3.js";
 19 | 
 20 | // load the env variables and store the cluster RPC url
 21 | dotenv.config();
 22 | const CLUSTER_URL = process.env.RPC_URL ?? "";
 23 | 
 24 | (async () => {
 25 |   // load the stored PublicKeys for ease of use
 26 |   let keys = loadPublicKeysFromFile();
 27 | 
 28 |   // ensure the primary script was already run
 29 |   if (!keys?.collectionMint || !keys?.treeAddress)
 30 |     return console.warn("No local keys were found. Please run the `index` script");
 31 | 
 32 |   const treeAddress: PublicKey = keys.treeAddress;
 33 |   const treeAuthority: PublicKey = keys.treeAuthority;
 34 |   const collectionMint: PublicKey = keys.collectionMint;
 35 |   const userAddress: PublicKey = keys.userAddress;
 36 |   const testWallet: PublicKey = keys.testWallet;
 37 | 
 38 |   console.log("==== Local PublicKeys loaded ====");
 39 |   console.log("Tree address:", treeAddress.toBase58());
 40 |   console.log("Tree authority:", treeAuthority.toBase58());
 41 |   console.log("Collection mint:", collectionMint.toBase58());
 42 |   console.log("User address:", userAddress.toBase58());
 43 |   console.log("Test address:", testWallet.toBase58());
 44 | 
 45 |   //////////////////////////////////////////////////////////////////////////////
 46 |   //////////////////////////////////////////////////////////////////////////////
 47 | 
 48 |   // define the address we are actually going to check (in this case, our collection's mint)
 49 |   const checkAddress = collectionMint.toBase58();
 50 | 
 51 |   printConsoleSeparator(`getAssetsByGroup: ${checkAddress}`);
 52 | 
 53 |   const connection = new ReadApiConnection(CLUSTER_URL);
 54 |   const metaplex = Metaplex.make(connection);
 55 | 
 56 |   /**
 57 |    * Fetch a listing of NFT assets by an owner's address (via the ReadApi)
 58 |    * ---
 59 |    * NOTE: This will return both compressed NFTs AND traditional/uncompressed NFTS
 60 |    */
 61 |   const rpcAssets = await metaplex
 62 |     .rpc()
 63 |     .getAssetsByGroup({
 64 |       groupKey: "collection",
 65 |       groupValue: checkAddress,
 66 |       sortBy: {
 67 |         sortBy: "created",
 68 |         sortDirection: "asc",
 69 |       },
 70 |     })
 71 |     .then(res => {
 72 |       if ((res as MetaplexError)?.cause) throw res;
 73 |       else return res as ReadApiAssetList;
 74 |     });
 75 | 
 76 |   /**
 77 |    * Process the returned `rpcAssets` response
 78 |    */
 79 |   console.log("Total assets returned:", rpcAssets.total);
 80 | 
 81 |   // loop over each of the asset items in the collection
 82 |   rpcAssets.items.map(asset => {
 83 |     // only show compressed nft assets
 84 |     if (!asset.compression.compressed) return;
 85 | 
 86 |     // display a spacer between each of the assets
 87 |     console.log("\n===============================================");
 88 | 
 89 |     // locally save the addresses for the demo
 90 |     savePublicKeyToFile("assetIdTestAddress", new PublicKey(asset.id));
 91 | 
 92 |     // extra useful info
 93 |     console.log("assetId:", asset.id);
 94 | 
 95 |     // view the ownership info for the given asset
 96 |     console.log("ownership:", asset.ownership);
 97 | 
 98 |     // metadata json data (auto fetched thanks to the Metaplex Read API)
 99 |     // console.log("metadata:", asset.content.metadata);
100 | 
101 |     // view the compression specific data for the given asset
102 |     console.log("compression:", asset.compression);
103 | 
104 |     if (asset.compression.compressed) {
105 |       console.log("==> This NFT is compressed! <===");
106 |       console.log("\tleaf_id:", asset.compression.leaf_id);
107 |     } else console.log("==> NFT is NOT compressed! <===");
108 |   });
109 | })();
110 | 


--------------------------------------------------------------------------------
/metaplex/fetchNFTsByOwner.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Demonstrate the use of a few of the Metaplex Read API methods,
  3 |  * (needed to fetch compressed NFTs)
  4 |  * using the `@metaplex-foundation/js` sdk
  5 |  */
  6 | 
  7 | // import custom helpers for demos
  8 | import {
  9 |   loadPublicKeysFromFile,
 10 |   printConsoleSeparator,
 11 |   savePublicKeyToFile,
 12 | } from "@/utils/helpers";
 13 | 
 14 | // imports from other libraries
 15 | import dotenv from "dotenv";
 16 | import { Metaplex, MetaplexError, ReadApiAssetList } from "@metaplex-foundation/js";
 17 | import { ReadApiConnection } from "@metaplex-foundation/js";
 18 | import { PublicKey } from "@solana/web3.js";
 19 | 
 20 | // load the env variables and store the cluster RPC url
 21 | dotenv.config();
 22 | const CLUSTER_URL = process.env.RPC_URL ?? "";
 23 | 
 24 | (async () => {
 25 |   // load the stored PublicKeys for ease of use
 26 |   let keys = loadPublicKeysFromFile();
 27 | 
 28 |   // ensure the primary script was already run
 29 |   if (!keys?.collectionMint || !keys?.treeAddress)
 30 |     return console.warn("No local keys were found. Please run the `index` script");
 31 | 
 32 |   const treeAddress: PublicKey = keys.treeAddress;
 33 |   const treeAuthority: PublicKey = keys.treeAuthority;
 34 |   const collectionMint: PublicKey = keys.collectionMint;
 35 |   const userAddress: PublicKey = keys.userAddress;
 36 |   const testWallet: PublicKey = keys.testWallet;
 37 | 
 38 |   console.log("==== Local PublicKeys loaded ====");
 39 |   console.log("Tree address:", treeAddress.toBase58());
 40 |   console.log("Tree authority:", treeAuthority.toBase58());
 41 |   console.log("Collection mint:", collectionMint.toBase58());
 42 |   console.log("User address:", userAddress.toBase58());
 43 |   console.log("Test address:", testWallet.toBase58());
 44 | 
 45 |   // define the address we are actually going to check (in this case, either are user's address or test address)
 46 |   // const checkAddress = testWallet.toBase58();
 47 |   const checkAddress = userAddress.toBase58();
 48 | 
 49 |   //////////////////////////////////////////////////////////////////////////////
 50 |   //////////////////////////////////////////////////////////////////////////////
 51 | 
 52 |   printConsoleSeparator(`getAssetsByOwner: ${checkAddress}`);
 53 | 
 54 |   const connection = new ReadApiConnection(CLUSTER_URL);
 55 |   const metaplex = Metaplex.make(connection);
 56 | 
 57 |   /**
 58 |    * Fetch a listing of NFT assets by an owner's address (via the ReadApi)
 59 |    * ---
 60 |    * NOTE: This will return both compressed NFTs AND traditional/uncompressed NFTS
 61 |    */
 62 |   const rpcAssets = await metaplex
 63 |     .rpc()
 64 |     .getAssetsByOwner({
 65 |       ownerAddress: checkAddress,
 66 |     })
 67 |     .then(res => {
 68 |       if ((res as MetaplexError)?.cause) throw res;
 69 |       else return res as ReadApiAssetList;
 70 |     });
 71 | 
 72 |   /**
 73 |    * Process the returned `rpcAssets` response
 74 |    */
 75 |   console.log("Total assets returned:", rpcAssets.total);
 76 | 
 77 |   // loop over each of the asset items in the collection
 78 |   rpcAssets.items.map(asset => {
 79 |     // only show compressed nft assets
 80 |     if (!asset.compression.compressed) return;
 81 | 
 82 |     // display a spacer between each of the assets
 83 |     console.log("\n===============================================");
 84 | 
 85 |     // locally save the addresses for the demo
 86 |     savePublicKeyToFile("assetIdTestAddress", new PublicKey(asset.id));
 87 | 
 88 |     // extra useful info
 89 |     console.log("assetId:", asset.id);
 90 | 
 91 |     // view the ownership info for the given asset
 92 |     console.log("ownership:", asset.ownership);
 93 | 
 94 |     // metadata json data (auto fetched thanks to the Metaplex Read API)
 95 |     // console.log("metadata:", asset.content.metadata);
 96 | 
 97 |     // view the compression specific data for the given asset
 98 |     console.log("compression:", asset.compression);
 99 | 
100 |     if (asset.compression.compressed) {
101 |       console.log("==> This NFT is compressed! <===");
102 |       console.log("\tleaf_id:", asset.compression.leaf_id);
103 |     } else console.log("==> NFT is NOT compressed! <===");
104 |   });
105 | })();
106 | 


--------------------------------------------------------------------------------
/metaplex/mintToCollection.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * This script demonstrates how to mint an additional compressed NFT to an
  3 |  * existing tree and/or collection, using the `@metaplex-foundation/js` SDK
  4 |  * ---
  5 |  * NOTE: A collection can use multiple trees to store compressed NFTs, as desired.
  6 |  * This example uses the same tree for simplicity.
  7 |  */
  8 | 
  9 | // imports from other libraries
 10 | import dotenv from "dotenv";
 11 | import { Metaplex, ReadApiConnection, keypairIdentity } from "@metaplex-foundation/js";
 12 | import { PublicKey, clusterApiUrl } from "@solana/web3.js";
 13 | 
 14 | // import custom helpers for demos
 15 | import {
 16 |   loadPublicKeysFromFile,
 17 |   loadKeypairFromFile,
 18 |   loadOrGenerateKeypair,
 19 |   explorerURL,
 20 |   printConsoleSeparator,
 21 |   savePublicKeyToFile,
 22 | } from "@/utils/helpers";
 23 | import { getLeafAssetId, metadataArgsBeet } from "@metaplex-foundation/mpl-bubblegum";
 24 | import {
 25 |   changeLogEventV1Beet,
 26 |   deserializeApplicationDataEvent,
 27 |   deserializeChangeLogEventV1,
 28 | } from "@solana/spl-account-compression";
 29 | import { bs58 } from "@project-serum/anchor/dist/cjs/utils/bytes";
 30 | import { BN } from "@project-serum/anchor";
 31 | 
 32 | // load the env variables and store the cluster RPC url
 33 | dotenv.config();
 34 | const CLUSTER_URL = process.env.RPC_URL ?? clusterApiUrl("devnet");
 35 | 
 36 | // create a new rpc connection
 37 | // const connection = new Connection(CLUSTER_URL);
 38 | const connection = new ReadApiConnection(CLUSTER_URL);
 39 | 
 40 | (async () => {
 41 |   //////////////////////////////////////////////////////////////////////////////
 42 |   //////////////////////////////////////////////////////////////////////////////
 43 | 
 44 |   // generate a new Keypair for testing, named `testWallet`
 45 |   const testWallet = loadOrGenerateKeypair("testWallet");
 46 | 
 47 |   // generate a new keypair for use in this demo (or load it locally from the filesystem when available)
 48 |   const payer = process.env?.LOCAL_PAYER_JSON_ABSPATH
 49 |     ? loadKeypairFromFile(process.env?.LOCAL_PAYER_JSON_ABSPATH)
 50 |     : loadOrGenerateKeypair("payer");
 51 | 
 52 |   console.log("Payer address:", payer.publicKey.toBase58());
 53 |   console.log("Test wallet address:", testWallet.publicKey.toBase58());
 54 | 
 55 |   // load the stored PublicKeys for ease of use
 56 |   let keys = loadPublicKeysFromFile();
 57 | 
 58 |   // ensure the primary script was already run
 59 |   if (!keys?.collectionMint || !keys?.treeAddress)
 60 |     return console.warn("No local keys were found. Please run the `index` script");
 61 | 
 62 |   const treeAddress: PublicKey = keys.treeAddress;
 63 |   const collectionMint: PublicKey = keys.collectionMint;
 64 |   const collectionAuthority: PublicKey = keys.collectionAuthority;
 65 | 
 66 |   console.log("==== Local PublicKeys loaded ====");
 67 |   console.log("Tree address:", treeAddress.toBase58());
 68 |   console.log("Collection mint:", collectionMint.toBase58());
 69 |   console.log("User address:", payer.publicKey.toBase58());
 70 |   console.log("Test address:", testWallet.publicKey.toBase58());
 71 | 
 72 |   //////////////////////////////////////////////////////////////////////////////
 73 |   //////////////////////////////////////////////////////////////////////////////
 74 | 
 75 |   // initialize metaplex with our RPC connection, and the payer of the transactions
 76 |   const metaplex = Metaplex.make(connection).use(keypairIdentity(payer));
 77 |   // const metaplex = Metaplex.make(connection).use(keypairIdentity(testWallet));
 78 | 
 79 |   printConsoleSeparator("Mint a single compressed NFT into the collection:");
 80 | 
 81 |   /**
 82 |    * minting compressed NFTs with the metaplex sdk is very much identical to minting non-compressed nfts
 83 |    *
 84 |    * the difference is that when you want to mint a compressed nft into a collection,
 85 |    * you simply provide the `tree` address that will store the compressed nft.
 86 |    *
 87 |    * when `tree` is present, the metaplex sdk knows you want to mint a compressed nft and will handle the rest!
 88 |    */
 89 | 
 90 |   // mint a new compressed NFT into our existing collection
 91 |   const { response, nft } = await metaplex.nfts().create({
 92 |     uri: "https://supersweetcollection.notarealurl/token.json",
 93 |     name: "compressed with metaplex",
 94 |     sellerFeeBasisPoints: 500,
 95 |     collection: collectionMint,
 96 |     // note: the `payer` is also this collection's authority
 97 |     collectionAuthority: payer,
 98 | 
 99 |     // note: this merkle tree must have already been created
100 |     tree: treeAddress,
101 |   });
102 | 
103 |   // save the `assetId` of the new compressed NFT locally
104 |   savePublicKeyToFile("assetIdTestAddress", new PublicKey(nft.address));
105 | 
106 |   console.log("nft minted with metaplex sdk:", nft);
107 | 
108 |   printConsoleSeparator("View on explorer");
109 | 
110 |   console.log(explorerURL({ txSignature: response.signature }));
111 | })();
112 | 


--------------------------------------------------------------------------------
/metaplex/simpleProofVerification.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Demonstrate how to perform a simple client side proof verification, using
  3 |  * data provided from the `@metaplex-foundation/js` SDK
  4 |  */
  5 | 
  6 | // import custom helpers for demos
  7 | import { loadPublicKeysFromFile, printConsoleSeparator } from "@/utils/helpers";
  8 | 
  9 | import dotenv from "dotenv";
 10 | import { GetAssetProofRpcResponse, Metaplex, ReadApiConnection } from "@metaplex-foundation/js";
 11 | 
 12 | // imports from other libraries
 13 | import { PublicKey, clusterApiUrl } from "@solana/web3.js";
 14 | import {
 15 |   ConcurrentMerkleTreeAccount,
 16 |   MerkleTree,
 17 |   MerkleTreeProof,
 18 | } from "@solana/spl-account-compression";
 19 | 
 20 | // load the env variables and store the cluster RPC url
 21 | dotenv.config();
 22 | const CLUSTER_URL = process.env.RPC_URL ?? clusterApiUrl("devnet");
 23 | 
 24 | // create a new rpc connection
 25 | // const connection = new Connection(CLUSTER_URL);
 26 | const connection = new ReadApiConnection(CLUSTER_URL);
 27 | 
 28 | (async () => {
 29 |   //////////////////////////////////////////////////////////////////////////////
 30 |   //////////////////////////////////////////////////////////////////////////////
 31 | 
 32 |   // load the stored PublicKeys for ease of use
 33 |   let keys = loadPublicKeysFromFile();
 34 | 
 35 |   // ensure the primary script was already run
 36 |   if (!keys?.assetIdTestAddress)
 37 |     return console.warn(
 38 |       "No locally saved `assetIdTestAddress` was found, Please run a `fetchNFT` script",
 39 |     );
 40 | 
 41 |   const assetIdTestAddress: PublicKey = keys.assetIdTestAddress;
 42 |   const assetIdUserAddress: PublicKey = keys.assetIdUserAddress;
 43 | 
 44 |   console.log("==== Local PublicKeys loaded ====");
 45 |   console.log("Test Asset ID:", assetIdTestAddress.toBase58());
 46 |   console.log("User Asset ID:", assetIdUserAddress.toBase58());
 47 | 
 48 |   // set the asset to test with
 49 |   const assetId = assetIdTestAddress;
 50 |   // const assetId = assetIdUserAddress;
 51 | 
 52 |   const metaplex = Metaplex.make(connection);
 53 | 
 54 |   //////////////////////////////////////////////////////////////////////////////
 55 |   //////////////////////////////////////////////////////////////////////////////
 56 | 
 57 |   printConsoleSeparator("Get the compressed nft by its assetId:");
 58 | 
 59 |   /**
 60 |    * Fetch an asset from the ReadApi by its `assetId`
 61 |    */
 62 |   const nft = await metaplex.nfts().findByAssetId({ assetId });
 63 |   console.log(nft);
 64 | 
 65 |   printConsoleSeparator("Get the asset proof from the RPC:");
 66 | 
 67 |   /**
 68 |    * Perform client side verification of the proof that was provided by the RPC
 69 |    * ---
 70 |    * NOTE: This is not required to be performed, but may aid in catching errors
 71 |    * due to your RPC providing stale or incorrect data (often due to caching issues)
 72 |    * The actual proof validation is performed on-chain.
 73 |    * ---
 74 |    * NOTE: This client side validation is also handled by the Metaplex SDK when
 75 |    * transferring a compressed NFT. But it is also show here for convenience
 76 |    */
 77 | 
 78 |   // fetch an asset's proof from the ReadApi by its `assetId`
 79 |   const assetProof = (await metaplex.rpc().getAssetProof(assetId)) as GetAssetProofRpcResponse;
 80 |   console.log(assetProof);
 81 | 
 82 |   // construct a valid proof object to check against
 83 |   const merkleTreeProof: MerkleTreeProof = {
 84 |     leafIndex: nft.compression?.leaf_id || 0,
 85 |     leaf: new PublicKey(assetProof.leaf).toBuffer(),
 86 |     root: new PublicKey(assetProof.root).toBuffer(),
 87 |     proof: assetProof.proof.map((node: string) => new PublicKey(node).toBuffer()),
 88 |   };
 89 | 
 90 |   /**
 91 |    * note:
 92 |    * the `merkleTreeProof.proof` value is the COMPLETE list of all the "proof values".
 93 |    * The entire list of these "proof hashes" are required to be used when performing this
 94 |    * client side verification check. Since this client side check does not know/care about
 95 |    * the proof hashes that are stored on chain in the tree's canopy.
 96 |    *
 97 |    * warning:
 98 |    * This is different than when you are sending proof hashes inside of a compressed nft transfer instruction.
 99 |    * In that case, sending the "complete proof hash list" will result in a failed transaction.
100 |    * This is because the on-chain program will use ALL the proof hashes included in the transaction
101 |    * (via the `anchorRemainingAccounts` field) to compute the root hash on chain.
102 |    *
103 |    */
104 | 
105 |   printConsoleSeparator("Client side checks of the RPC provided proof");
106 | 
107 |   // get the actual merkle tree data from the Solana blockchain
108 |   const merkleTree = new PublicKey(assetProof.tree_id);
109 |   const treeAccount = await ConcurrentMerkleTreeAccount.fromAccountAddress(connection, merkleTree);
110 | 
111 |   const currentRoot = treeAccount.getCurrentRoot();
112 |   const rootFromRpc = new PublicKey(assetProof.root).toBuffer();
113 | 
114 |   console.log("Is RPC provided proof/root valid:", MerkleTree.verify(rootFromRpc, merkleTreeProof));
115 | 
116 |   /**
117 |    * note: the current on-chain root hash (`currentRoot`) does NOT have to match the
118 |    * RPC provided root hash (`rootFromRpc`). This is because a "secure changelog"
119 |    * of valid root hashes are stored on-chain via the trees on-chain buffer
120 |    * (set by your tree's `maxBufferSize` at tree creation)
121 |    *
122 |    * This check is show here purely for demonstration, and is not required to be performed
123 |    */
124 |   console.log(
125 |     "Does the current on-chain root match RPC provided root:",
126 |     new PublicKey(currentRoot).toBase58() === new PublicKey(rootFromRpc).toBase58(),
127 |   );
128 | })();
129 | 


--------------------------------------------------------------------------------
/metaplex/transferNFT.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Demonstrate how to transfer a compressed NFT from one owner to another,
  3 |  * using the `@metaplex-foundation/js` SDK
  4 |  */
  5 | 
  6 | // imports from other libraries
  7 | import dotenv from "dotenv";
  8 | import { Metaplex, ReadApiConnection, keypairIdentity } from "@metaplex-foundation/js";
  9 | import { PublicKey, clusterApiUrl } from "@solana/web3.js";
 10 | 
 11 | // import custom helpers for demos
 12 | import {
 13 |   loadPublicKeysFromFile,
 14 |   loadKeypairFromFile,
 15 |   loadOrGenerateKeypair,
 16 |   explorerURL,
 17 |   printConsoleSeparator,
 18 | } from "@/utils/helpers";
 19 | 
 20 | // load the env variables and store the cluster RPC url
 21 | dotenv.config();
 22 | const CLUSTER_URL = process.env.RPC_URL ?? clusterApiUrl("devnet");
 23 | 
 24 | // create a new rpc connection
 25 | // const connection = new Connection(CLUSTER_URL);
 26 | const connection = new ReadApiConnection(CLUSTER_URL);
 27 | 
 28 | (async () => {
 29 |   //////////////////////////////////////////////////////////////////////////////
 30 |   //////////////////////////////////////////////////////////////////////////////
 31 | 
 32 |   // generate a new Keypair for testing, named `testWallet`
 33 |   const testWallet = loadOrGenerateKeypair("testWallet");
 34 | 
 35 |   // generate a new keypair for use in this demo (or load it locally from the filesystem when available)
 36 |   const payer = process.env?.LOCAL_PAYER_JSON_ABSPATH
 37 |     ? loadKeypairFromFile(process.env?.LOCAL_PAYER_JSON_ABSPATH)
 38 |     : loadOrGenerateKeypair("payer");
 39 | 
 40 |   console.log("Payer address:", payer.publicKey.toBase58());
 41 |   console.log("Test wallet address:", testWallet.publicKey.toBase58());
 42 | 
 43 |   // load the stored PublicKeys for ease of use
 44 |   let keys = loadPublicKeysFromFile();
 45 | 
 46 |   // ensure the primary script was already run
 47 |   if (!keys?.assetIdTestAddress)
 48 |     return console.warn(
 49 |       "No locally saved `assetIdTestAddress` was found, Please run a `fetchNFT` script",
 50 |     );
 51 | 
 52 |   const assetIdTestAddress: PublicKey = keys.assetIdTestAddress;
 53 |   const assetIdUserAddress: PublicKey = keys.assetIdUserAddress;
 54 | 
 55 |   console.log("==== Local PublicKeys loaded ====");
 56 |   console.log("Test Asset ID:", assetIdTestAddress.toBase58());
 57 |   console.log("User Asset ID:", assetIdUserAddress.toBase58());
 58 | 
 59 |   // set the asset to test with
 60 |   const assetId = assetIdTestAddress;
 61 |   // const assetId = assetIdUserAddress;
 62 | 
 63 |   const metaplex = Metaplex.make(connection).use(keypairIdentity(payer));
 64 |   // const metaplex = Metaplex.make(connection).use(keypairIdentity(testWallet));
 65 | 
 66 |   //////////////////////////////////////////////////////////////////////////////
 67 |   //////////////////////////////////////////////////////////////////////////////
 68 | 
 69 |   printConsoleSeparator("Get the compressed nft by its assetId:");
 70 | 
 71 |   /**
 72 |    * Fetch an asset from the ReadApi by its `assetId`
 73 |    */
 74 |   const nft = await metaplex.nfts().findByAssetId({ assetId });
 75 |   console.log(nft);
 76 | 
 77 |   /**
 78 |    * Use the Metaplex SDK to perform the transfer of a compressed NFT
 79 |    * ---
 80 |    * NOTE: When your `nftOrSft` was already retrieved using the ReadApi
 81 |    * (via `metaplex.nfts().findByAssetId()`), the Metaplex SDK will
 82 |    * auto-magically handle the rest of the data fetching (including the
 83 |    * proof and merkle tree), * as well as perform some client side verification
 84 |    * that the RPC provided proof is valid to complete the transfer
 85 |    */
 86 | 
 87 |   printConsoleSeparator("Transfer the compressed nft:");
 88 | 
 89 |   await metaplex
 90 |     .nfts()
 91 |     .transfer({
 92 |       nftOrSft: nft,
 93 |       toOwner: payer.publicKey,
 94 |     })
 95 |     .then(res => {
 96 |       console.log("transfer complete:", res);
 97 | 
 98 |       console.log(explorerURL({ txSignature: res.response.signature }));
 99 |     })
100 |     .catch(err => {
101 |       console.log("==================");
102 |       console.log("  Transfer failed!");
103 |       console.log("==================");
104 |       console.error(err);
105 |     });
106 | })();
107 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@solana-developers/compressed-nfts",
 3 |   "version": "1.0.0",
 4 |   "license": "MIT",
 5 |   "extension": [
 6 |     "ts"
 7 |   ],
 8 |   "scripts": {
 9 |     "demo": "npx ts-node -r tsconfig-paths/register"
10 |   },
11 |   "dependencies": {
12 |     "@metaplex-foundation/js": "^0.19.4",
13 |     "@metaplex-foundation/mpl-bubblegum": "^0.7.0",
14 |     "@metaplex-foundation/mpl-token-metadata": "^2.12.0",
15 |     "@project-serum/anchor": "^0.26.0",
16 |     "@solana/spl-account-compression": "^0.1.8",
17 |     "@solana/spl-token": "^0.3.7",
18 |     "@solana/web3.js": "^1.73.3",
19 |     "dotenv": "^16.0.3"
20 |   },
21 |   "devDependencies": {
22 |     "eslint": "^8.35.0",
23 |     "ts-node": "^10.9.1",
24 |     "tsconfig-paths": "^4.1.2",
25 |     "typescript": "^4.8.4"
26 |   }
27 | }
28 | 


--------------------------------------------------------------------------------
/scripts/changelog.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Demonstrate the use of a few of the Metaplex Read API methods,
  3 |  * (needed to fetch compressed NFTs)
  4 |  */
  5 | 
  6 | // local import of the connection wrapper, to help with using the ReadApi
  7 | import { WrapperConnection } from "@/ReadApi/WrapperConnection";
  8 | 
  9 | // import custom helpers for demos
 10 | import {
 11 |   explorerURL,
 12 |   loadKeypairFromFile,
 13 |   loadOrGenerateKeypair,
 14 |   loadPublicKeysFromFile,
 15 |   printConsoleSeparator,
 16 | } from "@/utils/helpers";
 17 | import {
 18 |   TokenProgramVersion,
 19 |   TokenStandard,
 20 |   computeCreatorHash,
 21 |   computeDataHash,
 22 |   createVerifyCreatorInstruction,
 23 |   getLeafAssetId,
 24 | } from "@metaplex-foundation/mpl-bubblegum";
 25 | 
 26 | import {
 27 |   SPL_ACCOUNT_COMPRESSION_PROGRAM_ID,
 28 |   SPL_NOOP_PROGRAM_ID,
 29 |   ConcurrentMerkleTreeAccount,
 30 |   getAllChangeLogEventV1FromTransaction,
 31 | } from "@solana/spl-account-compression";
 32 | import {
 33 |   MetadataArgs,
 34 |   Creator,
 35 |   PROGRAM_ID as BUBBLEGUM_PROGRAM_ID,
 36 | } from "@metaplex-foundation/mpl-bubblegum";
 37 | import {
 38 |   AccountMeta,
 39 |   PublicKey,
 40 |   TransactionMessage,
 41 |   VersionedTransaction,
 42 |   clusterApiUrl,
 43 | } from "@solana/web3.js";
 44 | 
 45 | import dotenv from "dotenv";
 46 | import { BN } from "@project-serum/anchor";
 47 | dotenv.config();
 48 | 
 49 | (async () => {
 50 |   // generate a new Keypair for testing, named `wallet`
 51 |   const testWallet = loadOrGenerateKeypair("testWallet");
 52 | 
 53 |   // generate a new keypair for use in this demo (or load it locally from the filesystem when available)
 54 |   const payer = process.env?.LOCAL_PAYER_JSON_ABSPATH
 55 |     ? loadKeypairFromFile(process.env?.LOCAL_PAYER_JSON_ABSPATH)
 56 |     : loadOrGenerateKeypair("payer");
 57 | 
 58 |   console.log("Payer address:", payer.publicKey.toBase58());
 59 |   console.log("Test wallet address:", testWallet.publicKey.toBase58());
 60 | 
 61 |   //////////////////////////////////////////////////////////////////////////////
 62 |   //////////////////////////////////////////////////////////////////////////////
 63 | 
 64 |   //////////////////////////////////////////////////////////////////////////////
 65 |   //////////////////////////////////////////////////////////////////////////////
 66 | 
 67 |   // load the env variables and store the cluster RPC url
 68 |   const CLUSTER_URL = process.env.RPC_URL ?? clusterApiUrl("devnet");
 69 | 
 70 |   // create a new rpc connection, using the ReadApi wrapper
 71 |   const connection = new WrapperConnection(CLUSTER_URL);
 72 | 
 73 |   //////////////////////////////////////////////////////////////////////////////
 74 |   //////////////////////////////////////////////////////////////////////////////
 75 | 
 76 |   printConsoleSeparator("");
 77 | 
 78 |   // load the stored PublicKeys for ease of use
 79 | 
 80 |   // https://explorer.solana.com/tx/3V1pMta1aKzJdnYwttHR5qtrPVQfazwdUykvgM1YY5Xwb2x6hwttLj9R1hJi4ZjMA9KaXWGx9LxiNBAAoAHKsKdn?cluster=devnet
 81 |   const devnetSig =
 82 |     "3V1pMta1aKzJdnYwttHR5qtrPVQfazwdUykvgM1YY5Xwb2x6hwttLj9R1hJi4ZjMA9KaXWGx9LxiNBAAoAHKsKdn";
 83 | 
 84 |   const tx = await connection.getTransaction(devnetSig, {
 85 |     maxSupportedTransactionVersion: 0,
 86 |   });
 87 | 
 88 |   if (!tx) throw Error("Tx not found");
 89 | 
 90 |   printConsoleSeparator("Events:");
 91 | 
 92 |   const events = getAllChangeLogEventV1FromTransaction(tx);
 93 | 
 94 |   console.log(events);
 95 |   const leafIndex = events[0].index;
 96 | 
 97 |   const assetId = await getLeafAssetId(events[0].treeId, new BN(events[0].index));
 98 | 
 99 |   console.log("assetId:", assetId);
100 |   console.log("total events:", events.length);
101 | })();
102 | 


--------------------------------------------------------------------------------
/scripts/createAndMint.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |   Overall flow of this script
  3 |   - load or create two keypairs (named `payer` and `testWallet`)
  4 |   - create a new tree with enough space to mint all the nft's you want for the "collection"
  5 |   - create a new NFT Collection on chain (using the usual Metaplex methods)
  6 |   - mint a single compressed nft into the tree to the `payer`
  7 |   - mint a single compressed nft into the tree to the `testWallet`
  8 |   - display the overall cost to perform all these actions
  9 | 
 10 |   ---
 11 |   NOTE: this script is identical to the `scripts/verboseCreateAndMint.ts` file, except THIS file has
 12 |   less console logging and explanation of what is occurring
 13 | */
 14 | 
 15 | import { Keypair, LAMPORTS_PER_SOL, clusterApiUrl } from "@solana/web3.js";
 16 | import { ValidDepthSizePair } from "@solana/spl-account-compression";
 17 | import {
 18 |   MetadataArgs,
 19 |   TokenProgramVersion,
 20 |   TokenStandard,
 21 | } from "@metaplex-foundation/mpl-bubblegum";
 22 | import { CreateMetadataAccountArgsV3 } from "@metaplex-foundation/mpl-token-metadata";
 23 | 
 24 | // import custom helpers for demos
 25 | import { loadKeypairFromFile, loadOrGenerateKeypair, numberFormatter } from "@/utils/helpers";
 26 | 
 27 | // import custom helpers to mint compressed NFTs
 28 | import { createCollection, createTree, mintCompressedNFT } from "@/utils/compression";
 29 | 
 30 | // local import of the connection wrapper, to help with using the ReadApi
 31 | import { WrapperConnection } from "@/ReadApi/WrapperConnection";
 32 | 
 33 | import dotenv from "dotenv";
 34 | dotenv.config();
 35 | 
 36 | // define some reusable balance values for tracking
 37 | let initBalance: number, balance: number;
 38 | 
 39 | (async () => {
 40 |   //////////////////////////////////////////////////////////////////////////////
 41 |   //////////////////////////////////////////////////////////////////////////////
 42 | 
 43 |   // generate a new Keypair for testing, named `wallet`
 44 |   const testWallet = loadOrGenerateKeypair("testWallet");
 45 | 
 46 |   // generate a new keypair for use in this demo (or load it locally from the filesystem when available)
 47 |   const payer = process.env?.LOCAL_PAYER_JSON_ABSPATH
 48 |     ? loadKeypairFromFile(process.env?.LOCAL_PAYER_JSON_ABSPATH)
 49 |     : loadOrGenerateKeypair("payer");
 50 | 
 51 |   console.log("Payer address:", payer.publicKey.toBase58());
 52 |   console.log("Test wallet address:", testWallet.publicKey.toBase58());
 53 | 
 54 |   //////////////////////////////////////////////////////////////////////////////
 55 |   //////////////////////////////////////////////////////////////////////////////
 56 | 
 57 |   // load the env variables and store the cluster RPC url
 58 |   const CLUSTER_URL = process.env.RPC_URL ?? clusterApiUrl("devnet");
 59 | 
 60 |   // create a new rpc connection, using the ReadApi wrapper
 61 |   const connection = new WrapperConnection(CLUSTER_URL, "confirmed");
 62 | 
 63 |   // get the payer's starting balance (only used for demonstration purposes)
 64 |   initBalance = await connection.getBalance(payer.publicKey);
 65 | 
 66 |   //////////////////////////////////////////////////////////////////////////////
 67 |   //////////////////////////////////////////////////////////////////////////////
 68 | 
 69 |   /*
 70 |     Define our tree size parameters
 71 |   */
 72 |   const maxDepthSizePair: ValidDepthSizePair = {
 73 |     // max=16,384 nodes
 74 |     maxDepth: 14,
 75 |     maxBufferSize: 64,
 76 |   };
 77 |   const canopyDepth = maxDepthSizePair.maxDepth - 5;
 78 | 
 79 |   /*
 80 |     Actually allocate the tree on chain
 81 |   */
 82 | 
 83 |   // define the address the tree will live at
 84 |   const treeKeypair = Keypair.generate();
 85 | 
 86 |   // create and send the transaction to create the tree on chain
 87 |   const tree = await createTree(connection, payer, treeKeypair, maxDepthSizePair, canopyDepth);
 88 | 
 89 |   /*
 90 |     Create the actual NFT collection (using the normal Metaplex method)
 91 |     (nothing special about compression here)
 92 |   */
 93 | 
 94 |   // define the metadata to be used for creating the NFT collection
 95 |   const collectionMetadataV3: CreateMetadataAccountArgsV3 = {
 96 |     data: {
 97 |       name: "Super Sweet NFT Collection",
 98 |       symbol: "SSNC",
 99 |       // specific json metadata for the collection
100 |       uri: "https://supersweetcollection.notarealurl/collection.json",
101 |       sellerFeeBasisPoints: 100,
102 |       creators: [
103 |         {
104 |           address: payer.publicKey,
105 |           verified: false,
106 |           share: 100,
107 |         },
108 |       ],
109 |       collection: null,
110 |       uses: null,
111 |     },
112 |     isMutable: false,
113 |     collectionDetails: null,
114 |   };
115 | 
116 |   // create a full token mint and initialize the collection (with the `payer` as the authority)
117 |   const collection = await createCollection(connection, payer, collectionMetadataV3);
118 | 
119 |   /*
120 |     Mint a single compressed NFT
121 |   */
122 | 
123 |   const compressedNFTMetadata: MetadataArgs = {
124 |     name: "NFT Name",
125 |     symbol: collectionMetadataV3.data.symbol,
126 |     // specific json metadata for each NFT
127 |     uri: "https://supersweetcollection.notarealurl/token.json",
128 |     creators: [
129 |       {
130 |         address: payer.publicKey,
131 |         verified: false,
132 |         share: 100,
133 |       },
134 |       {
135 |         address: testWallet.publicKey,
136 |         verified: false,
137 |         share: 0,
138 |       },
139 |     ],
140 |     editionNonce: 0,
141 |     uses: null,
142 |     collection: null,
143 |     primarySaleHappened: false,
144 |     sellerFeeBasisPoints: 0,
145 |     isMutable: false,
146 |     // these values are taken from the Bubblegum package
147 |     tokenProgramVersion: TokenProgramVersion.Original,
148 |     tokenStandard: TokenStandard.NonFungible,
149 |   };
150 | 
151 |   // fully mint a single compressed NFT to the payer
152 |   console.log(`Minting a single compressed NFT to ${payer.publicKey.toBase58()}...`);
153 | 
154 |   await mintCompressedNFT(
155 |     connection,
156 |     payer,
157 |     treeKeypair.publicKey,
158 |     collection.mint,
159 |     collection.metadataAccount,
160 |     collection.masterEditionAccount,
161 |     compressedNFTMetadata,
162 |     // mint to this specific wallet (in this case, the tree owner aka `payer`)
163 |     payer.publicKey,
164 |   );
165 | 
166 |   // fully mint a single compressed NFT
167 |   console.log(`Minting a single compressed NFT to ${testWallet.publicKey.toBase58()}...`);
168 | 
169 |   await mintCompressedNFT(
170 |     connection,
171 |     payer,
172 |     treeKeypair.publicKey,
173 |     collection.mint,
174 |     collection.metadataAccount,
175 |     collection.masterEditionAccount,
176 |     compressedNFTMetadata,
177 |     // mint to this specific wallet (in this case, airdrop to `testWallet`)
178 |     testWallet.publicKey,
179 |   );
180 | 
181 |   //////////////////////////////////////////////////////////////////////////////
182 |   //////////////////////////////////////////////////////////////////////////////
183 | 
184 |   // fetch the payer's final balance
185 |   balance = await connection.getBalance(payer.publicKey);
186 | 
187 |   console.log(`===============================`);
188 |   console.log(
189 |     "Total cost:",
190 |     numberFormatter((initBalance - balance) / LAMPORTS_PER_SOL, true),
191 |     "SOL\n",
192 |   );
193 | })();
194 | 


--------------------------------------------------------------------------------
/scripts/fetchNFTsByCollection.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Demonstrate the use of a few of the Metaplex Read API methods,
 3 |  * (needed to fetch compressed NFTs)
 4 |  */
 5 | 
 6 | // local import of the connection wrapper, to help with using the ReadApi
 7 | import { WrapperConnection } from "@/ReadApi/WrapperConnection";
 8 | 
 9 | // import custom helpers for demos
10 | import { loadPublicKeysFromFile, printConsoleSeparator } from "@/utils/helpers";
11 | 
12 | // imports from other libraries
13 | import { PublicKey, clusterApiUrl } from "@solana/web3.js";
14 | 
15 | import dotenv from "dotenv";
16 | dotenv.config();
17 | 
18 | (async () => {
19 |   // load the stored PublicKeys for ease of use
20 |   let keys = loadPublicKeysFromFile();
21 | 
22 |   // ensure the primary script was already run
23 |   if (!keys?.collectionMint)
24 |     return console.warn("No local keys were found, specifically `collectionMint`");
25 | 
26 |   // convert the locally saved keys to PublicKeys
27 |   const collectionMint: PublicKey = keys.collectionMint;
28 | 
29 |   console.log("==== Local PublicKeys loaded ====");
30 |   console.log("Collection mint:", collectionMint.toBase58());
31 | 
32 |   //////////////////////////////////////////////////////////////////////////////
33 |   //////////////////////////////////////////////////////////////////////////////
34 | 
35 |   // load the env variables and store the cluster RPC url
36 |   const CLUSTER_URL = process.env.RPC_URL ?? clusterApiUrl("devnet");
37 | 
38 |   // create a new rpc connection, using the ReadApi wrapper
39 |   const connection = new WrapperConnection(CLUSTER_URL);
40 | 
41 |   printConsoleSeparator("Getting all assets by the 'collection' group...");
42 | 
43 |   await connection
44 |     .getAssetsByGroup({
45 |       groupKey: "collection",
46 |       groupValue: collectionMint.toBase58(),
47 |       sortBy: {
48 |         sortBy: "recent_action",
49 |         sortDirection: "asc",
50 |       },
51 |     })
52 |     .then(res => {
53 |       console.log("Total assets returned:", res.total);
54 | 
55 |       // loop over each of the asset items in the collection
56 |       res.items?.map(asset => {
57 |         // display a spacer between each of the assets
58 |         console.log("\n===============================================");
59 | 
60 |         // print the entire asset record to the console
61 |         // console.log(asset);
62 | 
63 |         // print some useful info
64 |         console.log("assetId:", asset.id);
65 |         console.log("ownership:", asset.ownership);
66 |         console.log("compression:", asset.compression);
67 |       });
68 |     });
69 | })();
70 | 


--------------------------------------------------------------------------------
/scripts/fetchNFTsByOwner.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Demonstrate the use of a few of the Metaplex Read API methods,
  3 |  * (needed to fetch compressed NFTs)
  4 |  */
  5 | 
  6 | // local import of the connection wrapper, to help with using the ReadApi
  7 | import { WrapperConnection } from "@/ReadApi/WrapperConnection";
  8 | 
  9 | // import custom helpers for demos
 10 | import {
 11 |   loadPublicKeysFromFile,
 12 |   printConsoleSeparator,
 13 |   savePublicKeyToFile,
 14 | } from "@/utils/helpers";
 15 | 
 16 | // imports from other libraries
 17 | import { PublicKey, clusterApiUrl } from "@solana/web3.js";
 18 | 
 19 | import dotenv from "dotenv";
 20 | dotenv.config();
 21 | 
 22 | (async () => {
 23 |   // load the stored PublicKeys for ease of use
 24 |   let keys = loadPublicKeysFromFile();
 25 | 
 26 |   // ensure the primary script was already run
 27 |   if (!keys?.testWallet) return console.warn("No local keys were found, specifically `testWallet`");
 28 | 
 29 |   // convert the locally saved keys to PublicKeys
 30 |   const treeAddress: PublicKey = keys.treeAddress;
 31 |   const testWallet: PublicKey = keys.testWallet;
 32 |   const userAddress: PublicKey = keys.userAddress;
 33 | 
 34 |   console.log("==== Local PublicKeys loaded ====");
 35 |   console.log("Test address:", testWallet.toBase58());
 36 |   console.log("User address:", userAddress.toBase58());
 37 | 
 38 |   //////////////////////////////////////////////////////////////////////////////
 39 |   //////////////////////////////////////////////////////////////////////////////
 40 | 
 41 |   // load the env variables and store the cluster RPC url
 42 |   const CLUSTER_URL = process.env.RPC_URL ?? clusterApiUrl("devnet");
 43 | 
 44 |   // create a new rpc connection, using the ReadApi wrapper
 45 |   const connection = new WrapperConnection(CLUSTER_URL);
 46 | 
 47 |   // get all the assets owned by the specific address
 48 |   printConsoleSeparator(`Getting all assets by owner ${testWallet.toBase58()}...`);
 49 | 
 50 |   await connection
 51 |     .getAssetsByOwner({
 52 |       ownerAddress: testWallet.toBase58(),
 53 |     })
 54 |     .then(res => {
 55 |       console.log("Total assets returned:", res.total);
 56 | 
 57 |       // loop over each of the asset items in the collection
 58 |       res.items?.map(asset => {
 59 |         // only show compressed nft assets
 60 |         if (!asset.compression.compressed) return;
 61 | 
 62 |         // display a spacer between each of the assets
 63 |         console.log("\n===============================================");
 64 | 
 65 |         // locally save the addresses for the demo
 66 |         savePublicKeyToFile("assetIdTestAddress", new PublicKey(asset.id));
 67 | 
 68 |         // extra useful info
 69 |         console.log("assetId:", asset.id);
 70 | 
 71 |         // view the ownership info for the given asset
 72 |         console.log("ownership:", asset.ownership);
 73 | 
 74 |         // metadata json data (auto fetched thanks to the Metaplex Read API)
 75 |         // console.log("metadata:", asset.content.metadata);
 76 | 
 77 |         // view the compression specific data for the given asset
 78 |         console.log("compression:", asset.compression);
 79 | 
 80 |         // if (asset.compression.compressed) {
 81 |         //   console.log("==> This NFT is compressed! <===");
 82 |         //   console.log("\tleaf_id:", asset.compression.leaf_id);
 83 |         // } else console.log("==> NFT is NOT compressed! <===");
 84 |       });
 85 |     });
 86 | 
 87 |   //////////////////////////////////////////////////////////////////////////////
 88 |   //////////////////////////////////////////////////////////////////////////////
 89 | 
 90 |   // get the latest NFT owned by the `userAddress`
 91 |   printConsoleSeparator(`Getting latest assets by owner ${userAddress.toBase58()}...`);
 92 | 
 93 |   await connection
 94 |     .getAssetsByOwner({
 95 |       ownerAddress: userAddress.toBase58(),
 96 |       sortBy: {
 97 |         sortBy: "recent_action",
 98 |         sortDirection: "asc",
 99 |       },
100 |     })
101 |     .then(res => {
102 |       console.log("Total assets returned:", res.total);
103 | 
104 |       // search for NFTs from the same tree
105 |       res.items
106 |         ?.filter(asset => asset.compression.tree === treeAddress.toBase58())
107 |         .map(asset => {
108 |           // display some info about the asset
109 |           console.log("assetId:", asset.id);
110 |           console.log("ownership:", asset.ownership);
111 |           console.log("compression:", asset.compression);
112 | 
113 |           // save the newest assetId locally for the demo
114 |           if (asset.compression.tree === treeAddress.toBase58())
115 |             savePublicKeyToFile("assetIdUserAddress", new PublicKey(asset.id));
116 |         });
117 |     });
118 | })();
119 | 


--------------------------------------------------------------------------------
/scripts/mintToCollection.ts:
--------------------------------------------------------------------------------
  1 | /*
  2 |   This script demonstrates how to mint an additional compressed NFT to an existing tree and/or collection
  3 |   ---
  4 |   NOTE: A collection can use multiple trees to store compressed NFTs, as desired. 
  5 |   This example uses the same tree for simplicity.
  6 | */
  7 | 
  8 | import { PublicKey, clusterApiUrl } from "@solana/web3.js";
  9 | import {
 10 |   MetadataArgs,
 11 |   TokenProgramVersion,
 12 |   TokenStandard,
 13 | } from "@metaplex-foundation/mpl-bubblegum";
 14 | 
 15 | // import custom helpers to mint compressed NFTs
 16 | import { WrapperConnection } from "@/ReadApi/WrapperConnection";
 17 | import { mintCompressedNFT } from "@/utils/compression";
 18 | import {
 19 |   loadKeypairFromFile,
 20 |   loadOrGenerateKeypair,
 21 |   loadPublicKeysFromFile,
 22 |   printConsoleSeparator,
 23 | } from "@/utils/helpers";
 24 | 
 25 | // load the env variables and store the cluster RPC url
 26 | import dotenv from "dotenv";
 27 | dotenv.config();
 28 | 
 29 | (async () => {
 30 |   //////////////////////////////////////////////////////////////////////////////
 31 |   //////////////////////////////////////////////////////////////////////////////
 32 | 
 33 |   // generate a new Keypair for testing, named `wallet`
 34 |   const testWallet = loadOrGenerateKeypair("testWallet");
 35 | 
 36 |   // generate a new keypair for use in this demo (or load it locally from the filesystem when available)
 37 |   const payer = process.env?.LOCAL_PAYER_JSON_ABSPATH
 38 |     ? loadKeypairFromFile(process.env?.LOCAL_PAYER_JSON_ABSPATH)
 39 |     : loadOrGenerateKeypair("payer");
 40 | 
 41 |   console.log("Payer address:", payer.publicKey.toBase58());
 42 |   console.log("Test wallet address:", testWallet.publicKey.toBase58());
 43 | 
 44 |   // load the stored PublicKeys for ease of use
 45 |   let keys = loadPublicKeysFromFile();
 46 | 
 47 |   // ensure the primary script was already run
 48 |   if (!keys?.collectionMint || !keys?.treeAddress)
 49 |     return console.warn("No local keys were found. Please run the `index` script");
 50 | 
 51 |   const treeAddress: PublicKey = keys.treeAddress;
 52 |   const treeAuthority: PublicKey = keys.treeAuthority;
 53 |   const collectionMint: PublicKey = keys.collectionMint;
 54 |   const collectionMetadataAccount: PublicKey = keys.collectionMetadataAccount;
 55 |   const collectionMasterEditionAccount: PublicKey = keys.collectionMasterEditionAccount;
 56 | 
 57 |   console.log("==== Local PublicKeys loaded ====");
 58 |   console.log("Tree address:", treeAddress.toBase58());
 59 |   console.log("Tree authority:", treeAuthority.toBase58());
 60 |   console.log("Collection mint:", collectionMint.toBase58());
 61 |   console.log("Collection metadata:", collectionMetadataAccount.toBase58());
 62 |   console.log("Collection master edition:", collectionMasterEditionAccount.toBase58());
 63 | 
 64 |   //////////////////////////////////////////////////////////////////////////////
 65 |   //////////////////////////////////////////////////////////////////////////////
 66 | 
 67 |   // load the env variables and store the cluster RPC url
 68 |   const CLUSTER_URL = process.env.RPC_URL ?? clusterApiUrl("devnet");
 69 | 
 70 |   // create a new rpc connection, using the ReadApi wrapper
 71 |   const connection = new WrapperConnection(CLUSTER_URL);
 72 | 
 73 |   //////////////////////////////////////////////////////////////////////////////
 74 |   //////////////////////////////////////////////////////////////////////////////
 75 | 
 76 |   printConsoleSeparator();
 77 | 
 78 |   /*
 79 |     Mint a single compressed NFT
 80 |   */
 81 | 
 82 |   const compressedNFTMetadata: MetadataArgs = {
 83 |     name: "NFT Name",
 84 |     symbol: "SSNC",
 85 |     // specific json metadata for each NFT
 86 |     uri: "https://supersweetcollection.notarealurl/token.json",
 87 |     sellerFeeBasisPoints: 100,
 88 |     creators: [
 89 |       {
 90 |         address: payer.publicKey,
 91 |         verified: false,
 92 |         share: 99,
 93 |         // share: 100,
 94 |       },
 95 |       {
 96 |         address: testWallet.publicKey,
 97 |         verified: false,
 98 |         share: 1,
 99 |         // share: 0,
100 |       },
101 |     ],
102 |     editionNonce: 0,
103 |     uses: null,
104 |     collection: null,
105 |     primarySaleHappened: false,
106 |     isMutable: true,
107 |     // values taken from the Bubblegum package
108 |     tokenProgramVersion: TokenProgramVersion.Original,
109 |     tokenStandard: TokenStandard.NonFungible,
110 |   };
111 | 
112 |   // fully mint a single compressed NFT to the payer
113 |   console.log(`Minting a single compressed NFT to ${payer.publicKey.toBase58()}...`);
114 | 
115 |   const mintToPayer = await mintCompressedNFT(
116 |     connection,
117 |     payer,
118 |     treeAddress,
119 |     collectionMint,
120 |     collectionMetadataAccount,
121 |     collectionMasterEditionAccount,
122 |     compressedNFTMetadata,
123 |     // mint to this specific wallet (in this case, the tree owner aka `payer`)
124 |     payer.publicKey,
125 |   );
126 | 
127 |   // fully mint a single compressed NFT
128 |   console.log(`Minting a single compressed NFT to ${testWallet.publicKey.toBase58()}...`);
129 | 
130 |   const mintToWallet = await mintCompressedNFT(
131 |     connection,
132 |     payer,
133 |     treeAddress,
134 |     collectionMint,
135 |     collectionMetadataAccount,
136 |     collectionMasterEditionAccount,
137 |     compressedNFTMetadata,
138 |     // mint to this specific wallet (in this case, airdrop to `testWallet`)
139 |     testWallet.publicKey,
140 |   );
141 | })();
142 | 


--------------------------------------------------------------------------------
/scripts/transferNFT.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Demonstrate how to transfer a compressed NFT from one account to another
  3 |  */
  4 | 
  5 | import {
  6 |   AccountMeta,
  7 |   PublicKey,
  8 |   Transaction,
  9 |   clusterApiUrl,
 10 |   sendAndConfirmTransaction,
 11 | } from "@solana/web3.js";
 12 | 
 13 | import {
 14 |   PROGRAM_ID as BUBBLEGUM_PROGRAM_ID,
 15 |   createTransferInstruction,
 16 | } from "@metaplex-foundation/mpl-bubblegum";
 17 | import {
 18 |   SPL_ACCOUNT_COMPRESSION_PROGRAM_ID,
 19 |   SPL_NOOP_PROGRAM_ID,
 20 |   ConcurrentMerkleTreeAccount,
 21 |   MerkleTree,
 22 |   MerkleTreeProof,
 23 | } from "@solana/spl-account-compression";
 24 | 
 25 | // import custom helpers for demos
 26 | import {
 27 |   loadPublicKeysFromFile,
 28 |   loadKeypairFromFile,
 29 |   loadOrGenerateKeypair,
 30 |   printConsoleSeparator,
 31 |   extractSignatureFromFailedTransaction,
 32 |   explorerURL,
 33 | } from "@/utils/helpers";
 34 | 
 35 | // local import of the connection wrapper, to help with using the ReadApi
 36 | import { WrapperConnection } from "@/ReadApi/WrapperConnection";
 37 | 
 38 | import dotenv from "dotenv";
 39 | dotenv.config();
 40 | 
 41 | (async () => {
 42 |   //////////////////////////////////////////////////////////////////////////////
 43 |   //////////////////////////////////////////////////////////////////////////////
 44 | 
 45 |   // load the env variables and store the cluster RPC url
 46 |   const CLUSTER_URL = process.env.RPC_URL ?? clusterApiUrl("devnet");
 47 | 
 48 |   // create a new rpc connection, using the ReadApi wrapper
 49 |   const connection = new WrapperConnection(CLUSTER_URL);
 50 | 
 51 |   //////////////////////////////////////////////////////////////////////////////
 52 |   //////////////////////////////////////////////////////////////////////////////
 53 | 
 54 |   // load or generate a new Keypair for testing, named `testWallet`
 55 |   const testWallet = loadOrGenerateKeypair("testWallet");
 56 | 
 57 |   // generate a new keypair for use in this demo (or load it locally from the filesystem when available)
 58 |   const payer = process.env?.LOCAL_PAYER_JSON_ABSPATH
 59 |     ? loadKeypairFromFile(process.env?.LOCAL_PAYER_JSON_ABSPATH)
 60 |     : loadOrGenerateKeypair("payer");
 61 | 
 62 |   console.log("Payer address:", payer.publicKey.toBase58());
 63 |   console.log("Test wallet address:", testWallet.publicKey.toBase58());
 64 | 
 65 |   // load the stored PublicKeys for ease of use
 66 |   let keys = loadPublicKeysFromFile();
 67 | 
 68 |   // ensure the primary script was already run
 69 |   if (!keys?.assetIdTestAddress)
 70 |     return console.warn("No locally saved `assetId` was found, Please run a `fetchNFT` script");
 71 | 
 72 |   const assetIdTestAddress: PublicKey = keys.assetIdTestAddress;
 73 |   const assetIdUserAddress: PublicKey = keys.assetIdUserAddress;
 74 | 
 75 |   console.log("==== Local PublicKeys loaded ====");
 76 |   console.log("Test Asset ID:", assetIdTestAddress.toBase58());
 77 |   console.log("User Asset ID:", assetIdUserAddress.toBase58());
 78 | 
 79 |   // set the asset to test with
 80 |   // const assetId = assetIdTestAddress;
 81 |   const assetId = assetIdUserAddress;
 82 | 
 83 |   //////////////////////////////////////////////////////////////////////////////
 84 |   //////////////////////////////////////////////////////////////////////////////
 85 | 
 86 |   /**
 87 |    * Get the asset details from the RPC
 88 |    */
 89 |   printConsoleSeparator("Get the asset details from the RPC");
 90 | 
 91 |   const asset = await connection.getAsset(assetId);
 92 | 
 93 |   console.log(asset);
 94 | 
 95 |   console.log("Is this a compressed NFT?", asset.compression.compressed);
 96 |   console.log("Current owner:", asset.ownership.owner);
 97 |   console.log("Current delegate:", asset.ownership.delegate);
 98 | 
 99 |   // ensure the current asset is actually a compressed NFT
100 |   if (!asset.compression.compressed)
101 |     return console.error(`The asset ${asset.id} is NOT a compressed NFT!`);
102 | 
103 |   //////////////////////////////////////////////////////////////////////////////
104 |   //////////////////////////////////////////////////////////////////////////////
105 | 
106 |   /**
107 |    * Get the asset's proof from the RPC
108 |    */
109 | 
110 |   printConsoleSeparator("Get the asset proof from the RPC");
111 | 
112 |   const assetProof = await connection.getAssetProof(assetId);
113 | 
114 |   console.log(assetProof);
115 | 
116 |   /**
117 |    * Get the tree's current on-chain account data
118 |    */
119 | 
120 |   // parse the tree's address from the `asset`
121 |   const treeAddress = new PublicKey(asset.compression.tree);
122 |   console.log("Tree address:", treeAddress.toBase58());
123 | 
124 |   // get the tree's account info from the cluster
125 |   const treeAccount = await ConcurrentMerkleTreeAccount.fromAccountAddress(connection, treeAddress);
126 | 
127 |   /**
128 |    * Perform client side verification of the proof that was provided by the RPC
129 |    * ---
130 |    * NOTE: This is not required to be performed, but may aid in catching errors
131 |    * due to your RPC providing stale or incorrect data (often due to caching issues)
132 |    * The actual proof validation is performed on-chain.
133 |    */
134 | 
135 |   printConsoleSeparator("Validate the RPC provided asset proof on the client side:");
136 | 
137 |   const merkleTreeProof: MerkleTreeProof = {
138 |     leafIndex: asset.compression.leaf_id,
139 |     leaf: new PublicKey(assetProof.leaf).toBuffer(),
140 |     root: new PublicKey(assetProof.root).toBuffer(),
141 |     proof: assetProof.proof.map((node: string) => new PublicKey(node).toBuffer()),
142 |   };
143 | 
144 |   const currentRoot = treeAccount.getCurrentRoot();
145 |   const rpcRoot = new PublicKey(assetProof.root).toBuffer();
146 | 
147 |   console.log(
148 |     "Is RPC provided proof/root valid:",
149 |     MerkleTree.verify(rpcRoot, merkleTreeProof, false),
150 |   );
151 | 
152 |   console.log(
153 |     "Does the current on-chain root match RPC provided root:",
154 |     new PublicKey(currentRoot).toBase58() === new PublicKey(rpcRoot).toBase58(),
155 |   );
156 | 
157 |   /**
158 |    * INFO:
159 |    * The current on-chain root value does NOT have to match this RPC provided
160 |    * root in order to perform the transfer. This is due to the on-chain
161 |    * "changelog" (set via the tree's `maxBufferSize` at creation) keeping track
162 |    * of valid roots and proofs. Thus allowing for the "concurrent" nature of
163 |    * these special "concurrent merkle trees".
164 |    */
165 | 
166 |   //////////////////////////////////////////////////////////////////////////////
167 |   //////////////////////////////////////////////////////////////////////////////
168 | 
169 |   /**
170 |    * Build the transfer instruction to transfer ownership of the compressed NFT
171 |    * ---
172 |    * By "transferring" ownership of a compressed NFT, the `leafOwner`
173 |    * value is updated to the new owner.
174 |    * ---
175 |    * NOTE: This will also remove the `leafDelegate`. If a new delegate is
176 |    * desired, then another instruction needs to be built (using the
177 |    * `createDelegateInstruction`) and added into the transaction.
178 |    */
179 | 
180 |   // set the new owner of the compressed NFT
181 |   const newLeafOwner = testWallet.publicKey;
182 | 
183 |   // set the current leafOwner (aka the current owner of the NFT)
184 |   const leafOwner = new PublicKey(asset.ownership.owner);
185 | 
186 |   // set the current leafDelegate
187 |   const leafDelegate = !!asset.ownership?.delegate
188 |     ? new PublicKey(asset.ownership.delegate)
189 |     : leafOwner;
190 | 
191 |   /**
192 |    * NOTE: When there is NOT a current `leafDelegate`,
193 |    * the current leafOwner` address should be used
194 |    */
195 | 
196 |   const treeAuthority = treeAccount.getAuthority();
197 |   const canopyDepth = treeAccount.getCanopyDepth();
198 | 
199 |   // parse the list of proof addresses into a valid AccountMeta[]
200 |   const proofPath: AccountMeta[] = assetProof.proof
201 |     .map((node: string) => ({
202 |       pubkey: new PublicKey(node),
203 |       isSigner: false,
204 |       isWritable: false,
205 |     }))
206 |     .slice(0, assetProof.proof.length - (!!canopyDepth ? canopyDepth : 0));
207 | 
208 |   //
209 |   // console.log(proofPath);
210 | 
211 |   // create the NFT transfer instruction (via the Bubblegum package)
212 |   const transferIx = createTransferInstruction(
213 |     {
214 |       merkleTree: treeAddress,
215 |       treeAuthority,
216 |       leafOwner,
217 |       leafDelegate,
218 |       newLeafOwner,
219 |       logWrapper: SPL_NOOP_PROGRAM_ID,
220 |       compressionProgram: SPL_ACCOUNT_COMPRESSION_PROGRAM_ID,
221 |       anchorRemainingAccounts: proofPath,
222 |     },
223 |     {
224 |       root: [...new PublicKey(assetProof.root.trim()).toBytes()],
225 |       dataHash: [...new PublicKey(asset.compression.data_hash.trim()).toBytes()],
226 |       creatorHash: [...new PublicKey(asset.compression.creator_hash.trim()).toBytes()],
227 |       nonce: asset.compression.leaf_id,
228 |       index: asset.compression.leaf_id,
229 |     },
230 |     BUBBLEGUM_PROGRAM_ID,
231 |   );
232 | 
233 |   // return;
234 | 
235 |   //////////////////////////////////////////////////////////////////////////////
236 |   //////////////////////////////////////////////////////////////////////////////
237 | 
238 |   printConsoleSeparator("Sending the transfer transaction...");
239 | 
240 |   try {
241 |     // create and send the transaction to transfer ownership of the NFT
242 |     const tx = new Transaction().add(transferIx);
243 |     tx.feePayer = payer.publicKey;
244 | 
245 |     // send the transaction
246 |     const txSignature = await sendAndConfirmTransaction(
247 |       connection,
248 |       tx,
249 |       // ensuring the feePayer signs the transaction
250 |       [payer],
251 |       {
252 |         commitment: "confirmed",
253 |         skipPreflight: true,
254 |       },
255 |     );
256 | 
257 |     console.log("\nTransfer successful!\n", explorerURL({ txSignature }));
258 | 
259 |     /**
260 |      * Re-fetch the asset from the RPC to see the new ownership
261 |      */
262 |     const newAsset = await connection.getAsset(assetId);
263 |     // console.log(newAsset);
264 | 
265 |     printConsoleSeparator();
266 | 
267 |     /**
268 |      * NOTE: Since part of the asset's data changed (i.e. the owner),
269 |      * the proof will have also changed
270 |      */
271 |     // const newAssetProof = await connection.getAssetProof(assetId);
272 |     // console.log(newAssetProof);
273 | 
274 |     // display the new and old ownership values
275 |     console.log("   Old owner:", asset.ownership.owner);
276 |     console.log("   Old delegate:", asset.ownership.delegate);
277 |     console.log("   New owner:", newAsset.ownership.owner);
278 |     console.log("   New delegate:", newAsset.ownership.delegate);
279 | 
280 |     // the end :)
281 |   } catch (err: any) {
282 |     console.error("\nFailed to create transfer nft:", err);
283 | 
284 |     console.log("\n=======================");
285 |     console.log("  Transfer failed!");
286 |     console.log("=======================");
287 | 
288 |     // log a block explorer link for the failed transaction
289 |     await extractSignatureFromFailedTransaction(connection, err);
290 | 
291 |     throw err;
292 |   }
293 | })();
294 | 


--------------------------------------------------------------------------------
/scripts/verboseCreateAndMint.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Compressed NFTs on Solana, using State Compression
  3 |   ---
  4 |   Overall flow of this script
  5 |   - load or create two keypairs (named `payer` and `testWallet`)
  6 |   - create a new tree with enough space to mint all the nft's you want for the "collection"
  7 |   - create a new NFT Collection on chain (using the usual Metaplex methods)
  8 |   - mint a single compressed nft into the tree to the `payer`
  9 |   - mint a single compressed nft into the tree to the `testWallet`
 10 |   - display the overall cost to perform all these actions
 11 | 
 12 |   ---
 13 |   NOTE: this script is identical to the `scripts/createAndMint.ts` file, except THIS file has
 14 |   additional explanation, comments, and console logging for demonstration purposes.
 15 | */
 16 | 
 17 | /**
 18 |  * General process of minting a compressed NFT:
 19 |  * - create a tree
 20 |  * - create a collection
 21 |  * - mint compressed NFTs to the tree
 22 |  */
 23 | 
 24 | import { Keypair, LAMPORTS_PER_SOL, clusterApiUrl } from "@solana/web3.js";
 25 | import {
 26 |   ValidDepthSizePair,
 27 |   getConcurrentMerkleTreeAccountSize,
 28 | } from "@solana/spl-account-compression";
 29 | import {
 30 |   MetadataArgs,
 31 |   TokenProgramVersion,
 32 |   TokenStandard,
 33 | } from "@metaplex-foundation/mpl-bubblegum";
 34 | import { CreateMetadataAccountArgsV3 } from "@metaplex-foundation/mpl-token-metadata";
 35 | 
 36 | // import custom helpers for demos
 37 | import {
 38 |   loadKeypairFromFile,
 39 |   loadOrGenerateKeypair,
 40 |   numberFormatter,
 41 |   printConsoleSeparator,
 42 |   savePublicKeyToFile,
 43 | } from "@/utils/helpers";
 44 | 
 45 | // import custom helpers to mint compressed NFTs
 46 | import { createCollection, createTree, mintCompressedNFT } from "@/utils/compression";
 47 | 
 48 | // local import of the connection wrapper, to help with using the ReadApi
 49 | import { WrapperConnection } from "@/ReadApi/WrapperConnection";
 50 | 
 51 | import dotenv from "dotenv";
 52 | dotenv.config();
 53 | 
 54 | // define some reusable balance values for tracking
 55 | let initBalance: number, balance: number;
 56 | 
 57 | (async () => {
 58 |   //////////////////////////////////////////////////////////////////////////////
 59 |   //////////////////////////////////////////////////////////////////////////////
 60 | 
 61 |   // generate a new Keypair for testing, named `wallet`
 62 |   const testWallet = loadOrGenerateKeypair("testWallet");
 63 | 
 64 |   // generate a new keypair for use in this demo (or load it locally from the filesystem when available)
 65 |   const payer = process.env?.LOCAL_PAYER_JSON_ABSPATH
 66 |     ? loadKeypairFromFile(process.env?.LOCAL_PAYER_JSON_ABSPATH)
 67 |     : loadOrGenerateKeypair("payer");
 68 | 
 69 |   console.log("Payer address:", payer.publicKey.toBase58());
 70 |   console.log("Test wallet address:", testWallet.publicKey.toBase58());
 71 | 
 72 |   // locally save the addresses for the demo
 73 |   savePublicKeyToFile("userAddress", payer.publicKey);
 74 |   savePublicKeyToFile("testWallet", testWallet.publicKey);
 75 | 
 76 |   //////////////////////////////////////////////////////////////////////////////
 77 |   //////////////////////////////////////////////////////////////////////////////
 78 | 
 79 |   // load the env variables and store the cluster RPC url
 80 |   const CLUSTER_URL = process.env.RPC_URL ?? clusterApiUrl("devnet");
 81 | 
 82 |   // create a new rpc connection, using the ReadApi wrapper
 83 |   const connection = new WrapperConnection(CLUSTER_URL, "confirmed");
 84 | 
 85 |   //////////////////////////////////////////////////////////////////////////////
 86 |   //////////////////////////////////////////////////////////////////////////////
 87 | 
 88 |   // get the payer's starting balance
 89 |   initBalance = await connection.getBalance(payer.publicKey);
 90 |   console.log(
 91 |     "Starting account balance:",
 92 |     numberFormatter(initBalance / LAMPORTS_PER_SOL),
 93 |     "SOL\n",
 94 |   );
 95 | 
 96 |   //////////////////////////////////////////////////////////////////////////////
 97 |   //////////////////////////////////////////////////////////////////////////////
 98 | 
 99 |   /*
100 |     Define our tree size parameters
101 |   */
102 |   const maxDepthSizePair: ValidDepthSizePair = {
103 |     // max=8 nodes
104 |     // maxDepth: 3,
105 |     // maxBufferSize: 8,
106 | 
107 |     // max=16,384 nodes
108 |     maxDepth: 14,
109 |     maxBufferSize: 64,
110 | 
111 |     // max=131,072 nodes
112 |     // maxDepth: 17,
113 |     // maxBufferSize: 64,
114 | 
115 |     // max=1,048,576 nodes
116 |     // maxDepth: 20,
117 |     // maxBufferSize: 256,
118 | 
119 |     // max=1,073,741,824 nodes
120 |     // maxDepth: 30,
121 |     // maxBufferSize: 2048,
122 |   };
123 |   const canopyDepth = maxDepthSizePair.maxDepth - 5;
124 | 
125 |   //////////////////////////////////////////////////////////////////////////////
126 |   //////////////////////////////////////////////////////////////////////////////
127 | 
128 |   /*
129 |     For demonstration purposes, we can compute how much space our tree will
130 |     need to allocate to store all the records. As well as the cost to allocate
131 |     this space (aka minimum balance to be rent exempt)
132 |     ---
133 |     NOTE: These are performed automatically when using the `createAllocTreeIx`
134 |     function to ensure enough space is allocated, and rent paid.
135 |   */
136 | 
137 |   // calculate the space available in the tree
138 |   const requiredSpace = getConcurrentMerkleTreeAccountSize(
139 |     maxDepthSizePair.maxDepth,
140 |     maxDepthSizePair.maxBufferSize,
141 |     canopyDepth,
142 |   );
143 | 
144 |   const storageCost = await connection.getMinimumBalanceForRentExemption(requiredSpace);
145 | 
146 |   // demonstrate data points for compressed NFTs
147 |   console.log("Space to allocate:", numberFormatter(requiredSpace), "bytes");
148 |   console.log("Estimated cost to allocate space:", numberFormatter(storageCost / LAMPORTS_PER_SOL));
149 |   console.log(
150 |     "Max compressed NFTs for tree:",
151 |     numberFormatter(Math.pow(2, maxDepthSizePair.maxDepth)),
152 |     "\n",
153 |   );
154 | 
155 |   // ensure the payer has enough balance to create the allocate the Merkle tree
156 |   if (initBalance < storageCost) return console.error("Not enough SOL to allocate the merkle tree");
157 |   printConsoleSeparator();
158 | 
159 |   //////////////////////////////////////////////////////////////////////////////
160 |   //////////////////////////////////////////////////////////////////////////////
161 | 
162 |   /*
163 |     Actually allocate the tree on chain
164 |   */
165 | 
166 |   // define the address the tree will live at
167 |   const treeKeypair = Keypair.generate();
168 | 
169 |   // create and send the transaction to create the tree on chain
170 |   const tree = await createTree(connection, payer, treeKeypair, maxDepthSizePair, canopyDepth);
171 | 
172 |   // locally save the addresses for the demo
173 |   savePublicKeyToFile("treeAddress", tree.treeAddress);
174 |   savePublicKeyToFile("treeAuthority", tree.treeAuthority);
175 | 
176 |   //////////////////////////////////////////////////////////////////////////////
177 |   //////////////////////////////////////////////////////////////////////////////
178 | 
179 |   /*
180 |     Create the actual NFT collection (using the normal Metaplex method)
181 |     (nothing special about compression here)
182 |   */
183 | 
184 |   // define the metadata to be used for creating the NFT collection
185 |   const collectionMetadataV3: CreateMetadataAccountArgsV3 = {
186 |     data: {
187 |       name: "Super Sweet NFT Collection",
188 |       symbol: "SSNC",
189 |       // specific json metadata for the collection
190 |       uri: "https://supersweetcollection.notarealurl/collection.json",
191 |       sellerFeeBasisPoints: 100,
192 |       creators: [
193 |         {
194 |           address: payer.publicKey,
195 |           verified: false,
196 |           share: 100,
197 |         },
198 |       ], // or set to `null`
199 |       collection: null,
200 |       uses: null,
201 |     },
202 |     isMutable: false,
203 |     collectionDetails: null,
204 |   };
205 | 
206 |   // create a full token mint and initialize the collection (with the `payer` as the authority)
207 |   const collection = await createCollection(connection, payer, collectionMetadataV3);
208 | 
209 |   // locally save the addresses for the demo
210 |   savePublicKeyToFile("collectionMint", collection.mint);
211 |   savePublicKeyToFile("collectionMetadataAccount", collection.metadataAccount);
212 |   savePublicKeyToFile("collectionMasterEditionAccount", collection.masterEditionAccount);
213 | 
214 |   /**
215 |    * INFO: NFT collection != tree
216 |    * ---
217 |    * NFTs collections can use multiple trees for their same collection.
218 |    * When minting any compressed NFT, simply pass the collection's addresses
219 |    * in the transaction using any valid tree the `payer` has authority over.
220 |    *
221 |    * These minted compressed NFTs should all still be apart of the same collection
222 |    * on marketplaces and wallets.
223 |    */
224 | 
225 |   //////////////////////////////////////////////////////////////////////////////
226 |   //////////////////////////////////////////////////////////////////////////////
227 | 
228 |   /*
229 |     Mint a single compressed NFT
230 |   */
231 | 
232 |   const compressedNFTMetadata: MetadataArgs = {
233 |     name: "NFT Name",
234 |     symbol: collectionMetadataV3.data.symbol,
235 |     // specific json metadata for each NFT
236 |     uri: "https://supersweetcollection.notarealurl/token.json",
237 |     creators: [
238 |       {
239 |         address: payer.publicKey,
240 |         verified: false,
241 |         share: 100,
242 |       },
243 |       {
244 |         address: testWallet.publicKey,
245 |         verified: false,
246 |         share: 0,
247 |       },
248 |     ], // or set to null
249 |     editionNonce: 0,
250 |     uses: null,
251 |     collection: null,
252 |     primarySaleHappened: false,
253 |     sellerFeeBasisPoints: 0,
254 |     isMutable: false,
255 |     // these values are taken from the Bubblegum package
256 |     tokenProgramVersion: TokenProgramVersion.Original,
257 |     tokenStandard: TokenStandard.NonFungible,
258 |   };
259 | 
260 |   // fully mint a single compressed NFT to the payer
261 |   console.log(`Minting a single compressed NFT to ${payer.publicKey.toBase58()}...`);
262 | 
263 |   await mintCompressedNFT(
264 |     connection,
265 |     payer,
266 |     treeKeypair.publicKey,
267 |     collection.mint,
268 |     collection.metadataAccount,
269 |     collection.masterEditionAccount,
270 |     compressedNFTMetadata,
271 |     // mint to this specific wallet (in this case, the tree owner aka `payer`)
272 |     payer.publicKey,
273 |   );
274 | 
275 |   // fully mint a single compressed NFT
276 |   console.log(`Minting a single compressed NFT to ${testWallet.publicKey.toBase58()}...`);
277 | 
278 |   await mintCompressedNFT(
279 |     connection,
280 |     payer,
281 |     treeKeypair.publicKey,
282 |     collection.mint,
283 |     collection.metadataAccount,
284 |     collection.masterEditionAccount,
285 |     compressedNFTMetadata,
286 |     // mint to this specific wallet (in this case, airdrop to `testWallet`)
287 |     testWallet.publicKey,
288 |   );
289 | 
290 |   //////////////////////////////////////////////////////////////////////////////
291 |   //////////////////////////////////////////////////////////////////////////////
292 | 
293 |   // fetch the payer's final balance
294 |   balance = await connection.getBalance(payer.publicKey);
295 | 
296 |   console.log(`===============================`);
297 |   console.log(
298 |     "Total cost:",
299 |     numberFormatter((initBalance - balance) / LAMPORTS_PER_SOL, true),
300 |     "SOL\n",
301 |   );
302 | })();
303 | 


--------------------------------------------------------------------------------
/scripts/verifyCreator.ts:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Demonstrate the use of a few of the Metaplex Read API methods,
  3 |  * (needed to fetch compressed NFTs)
  4 |  */
  5 | 
  6 | // local import of the connection wrapper, to help with using the ReadApi
  7 | import { WrapperConnection } from "@/ReadApi/WrapperConnection";
  8 | 
  9 | // import custom helpers for demos
 10 | import {
 11 |   explorerURL,
 12 |   loadKeypairFromFile,
 13 |   loadOrGenerateKeypair,
 14 |   loadPublicKeysFromFile,
 15 |   printConsoleSeparator,
 16 | } from "@/utils/helpers";
 17 | import {
 18 |   TokenProgramVersion,
 19 |   TokenStandard,
 20 |   computeCreatorHash,
 21 |   computeDataHash,
 22 |   createVerifyCreatorInstruction,
 23 | } from "@metaplex-foundation/mpl-bubblegum";
 24 | 
 25 | import {
 26 |   SPL_ACCOUNT_COMPRESSION_PROGRAM_ID,
 27 |   SPL_NOOP_PROGRAM_ID,
 28 |   ConcurrentMerkleTreeAccount,
 29 | } from "@solana/spl-account-compression";
 30 | import { MetadataArgs, Creator } from "@metaplex-foundation/mpl-bubblegum";
 31 | import {
 32 |   AccountMeta,
 33 |   PublicKey,
 34 |   TransactionMessage,
 35 |   VersionedTransaction,
 36 |   clusterApiUrl,
 37 | } from "@solana/web3.js";
 38 | 
 39 | import dotenv from "dotenv";
 40 | dotenv.config();
 41 | 
 42 | (async () => {
 43 |   // generate a new Keypair for testing, named `wallet`
 44 |   const testWallet = loadOrGenerateKeypair("testWallet");
 45 | 
 46 |   // generate a new keypair for use in this demo (or load it locally from the filesystem when available)
 47 |   const payer = process.env?.LOCAL_PAYER_JSON_ABSPATH
 48 |     ? loadKeypairFromFile(process.env?.LOCAL_PAYER_JSON_ABSPATH)
 49 |     : loadOrGenerateKeypair("payer");
 50 | 
 51 |   console.log("Payer address:", payer.publicKey.toBase58());
 52 |   console.log("Test wallet address:", testWallet.publicKey.toBase58());
 53 | 
 54 |   //////////////////////////////////////////////////////////////////////////////
 55 |   //////////////////////////////////////////////////////////////////////////////
 56 | 
 57 |   // load the stored PublicKeys for ease of use
 58 |   let keys = loadPublicKeysFromFile();
 59 | 
 60 |   // ensure the primary script was already run
 61 |   if (!keys?.collectionMint || !keys?.treeAddress)
 62 |     return console.warn("No local keys were found. Please run the `index` script");
 63 | 
 64 |   const treeAddress: PublicKey = keys.treeAddress;
 65 |   const treeAuthority: PublicKey = keys.treeAuthority;
 66 |   const collectionMint: PublicKey = keys.collectionMint;
 67 |   const collectionMetadata: PublicKey = keys.collectionMetadataAccount;
 68 |   const collectionMasterEdition: PublicKey = keys.collectionMasterEditionAccount;
 69 | 
 70 |   const assetIdTestAddress: PublicKey = keys.assetIdTestAddress;
 71 |   const assetIdUserAddress: PublicKey = keys.assetIdUserAddress;
 72 | 
 73 |   console.log("==== Local PublicKeys loaded ====");
 74 |   console.log("Tree address:", treeAddress.toBase58());
 75 |   console.log("Tree authority:", treeAuthority.toBase58());
 76 |   console.log("Collection mint:", collectionMint.toBase58());
 77 |   console.log("Collection metadata:", collectionMetadata.toBase58());
 78 |   console.log("Collection master edition:", collectionMasterEdition.toBase58());
 79 | 
 80 |   console.log("Test Asset ID:", assetIdTestAddress.toBase58());
 81 |   console.log("User Asset ID:", assetIdUserAddress.toBase58());
 82 | 
 83 |   // set the asset to test with
 84 |   // const assetId = assetIdTestAddress;
 85 |   const assetId = assetIdUserAddress;
 86 | 
 87 |   //////////////////////////////////////////////////////////////////////////////
 88 |   //////////////////////////////////////////////////////////////////////////////
 89 | 
 90 |   // load the env variables and store the cluster RPC url
 91 |   const CLUSTER_URL = process.env.RPC_URL ?? clusterApiUrl("devnet");
 92 | 
 93 |   // create a new rpc connection, using the ReadApi wrapper
 94 |   const connection = new WrapperConnection(CLUSTER_URL);
 95 | 
 96 |   //////////////////////////////////////////////////////////////////////////////
 97 |   //////////////////////////////////////////////////////////////////////////////
 98 | 
 99 |   printConsoleSeparator("Get the asset from the RPC");
100 | 
101 |   const asset = await connection.getAsset(assetId);
102 | 
103 |   console.log(asset);
104 | 
105 |   console.log("Is this a compressed NFT?", asset.compression.compressed);
106 |   console.log("Current owner:", asset.ownership.owner);
107 |   console.log("Current delegate:", asset.ownership.delegate);
108 | 
109 |   // ensure the current asset is actually a compressed NFT
110 |   if (!asset.compression.compressed)
111 |     return console.error(`The asset ${asset.id} is NOT a compressed NFT!`);
112 | 
113 |   //////////////////////////////////////////////////////////////////////////////
114 |   //////////////////////////////////////////////////////////////////////////////
115 | 
116 |   /**
117 |    * Get the asset's proof from the RPC
118 |    */
119 | 
120 |   printConsoleSeparator("Get the asset proof from the RPC");
121 | 
122 |   const assetProof = await connection.getAssetProof(assetId);
123 |   console.log(assetProof);
124 | 
125 |   //////////////////////////////////////////////////////////////////////////////
126 |   //////////////////////////////////////////////////////////////////////////////
127 | 
128 |   /**
129 |    * define the creator address we want to verify on the specific nft
130 |    * ---
131 |    * note: this creator address is required to sign the transaction
132 |    */
133 |   const creatorAddress = payer.publicKey;
134 | 
135 |   /**
136 |    * correctly format/type the list of `creators`
137 |    * ---
138 |    * note: the creator address you are going to verify should still be it's current `verified=false` value.
139 |    * if the specific creator has already been verified, the instruction will throw an error and fail to execute
140 |    */
141 |   const creators: Creator[] = asset.creators.map(creator => {
142 |     return {
143 |       address: new PublicKey(creator.address),
144 |       verified: creator.verified,
145 |       share: creator.share,
146 |     };
147 |   });
148 | 
149 |   console.log("creators:", creators);
150 | 
151 |   /**
152 |    * create a correctly formatted `metadataArgs` data object that will be used
153 |    * for the on-chain hash verification
154 |    * ---
155 |    * note: this data object should be the correct, CURRENT data that is already
156 |    * hashed and stored on-chain. if this data is incorrect, the on-chain hash
157 |    * verification will throw and error and the instruction will fail
158 |    */
159 |   const metadataArgs: MetadataArgs = {
160 |     name: asset.content.metadata?.name || "",
161 |     symbol: asset.content.metadata?.symbol || "",
162 |     uri: asset.content.json_uri,
163 | 
164 |     sellerFeeBasisPoints: asset.royalty.basis_points,
165 | 
166 |     creators: creators,
167 |     collection: {
168 |       key: new PublicKey(asset.grouping[0].group_value),
169 |       // note: when a compressed nft is minted to a collection, the nft's collection value is auto verified
170 |       verified: true,
171 |     },
172 |     editionNonce: asset.supply.edition_nonce,
173 |     primarySaleHappened: asset.royalty.primary_sale_happened,
174 |     isMutable: asset.mutable,
175 |     uses: null,
176 | 
177 |     // values taken from the Bubblegum package
178 |     tokenProgramVersion: TokenProgramVersion.Original,
179 |     tokenStandard: TokenStandard.NonFungible,
180 |   };
181 | 
182 |   // console.log("metadataArgs:", metadataArgs, "\n\n");
183 | 
184 |   //////////////////////////////////////////////////////////////////////////////
185 |   //////////////////////////////////////////////////////////////////////////////
186 | 
187 |   printConsoleSeparator("Data hash and creator hash check");
188 | 
189 |   const currentDataHash = asset.compression.data_hash.trim();
190 |   console.log("currentDataHash:", currentDataHash);
191 |   const computedDataHash = new PublicKey(computeDataHash(metadataArgs)).toBase58();
192 |   console.log("computedDataHash:", computedDataHash);
193 |   console.log("Do they match:", computedDataHash == currentDataHash);
194 | 
195 |   const currentCreatorHash = asset.compression.creator_hash.trim();
196 |   console.log("currentCreatorHash:", currentCreatorHash);
197 |   const computedCreatorHash = new PublicKey(computeCreatorHash(creators)).toBase58();
198 |   console.log("computedCreatorHash:", computedCreatorHash);
199 |   console.log("Do they match:", currentCreatorHash == computedCreatorHash);
200 | 
201 |   //////////////////////////////////////////////////////////////////////////////
202 |   //////////////////////////////////////////////////////////////////////////////
203 | 
204 |   /**
205 |    * Get the tree's canopy depth to correctly slice the proof to send in the instruction
206 |    */
207 |   const treeAccount = await ConcurrentMerkleTreeAccount.fromAccountAddress(connection, treeAddress);
208 |   const canopyDepth = treeAccount.getCanopyDepth();
209 |   const slicedProof: AccountMeta[] = assetProof.proof
210 |     .map((node: string) => ({
211 |       pubkey: new PublicKey(node),
212 |       isSigner: false,
213 |       isWritable: false,
214 |     }))
215 |     .slice(0, assetProof.proof.length - (!!canopyDepth ? canopyDepth : 0));
216 | 
217 |   //////////////////////////////////////////////////////////////////////////////
218 |   //////////////////////////////////////////////////////////////////////////////
219 | 
220 |   printConsoleSeparator("Build and send the transaction/instruction");
221 | 
222 |   // create an instruction to verify
223 |   const verifyCreatorIx = createVerifyCreatorInstruction(
224 |     {
225 |       treeAuthority,
226 |       leafOwner: new PublicKey(asset.ownership.owner),
227 |       leafDelegate: new PublicKey(asset.ownership.delegate || asset.ownership.owner),
228 |       merkleTree: treeAddress,
229 |       payer: payer.publicKey,
230 | 
231 |       logWrapper: SPL_NOOP_PROGRAM_ID,
232 |       compressionProgram: SPL_ACCOUNT_COMPRESSION_PROGRAM_ID,
233 |       creator: creatorAddress,
234 | 
235 |       // provide the sliced proof
236 |       anchorRemainingAccounts: slicedProof,
237 |     },
238 |     {
239 |       // use the current root provided via the `getAssetProof`
240 |       root: [...new PublicKey(assetProof.root.trim()).toBytes()],
241 |       // compute the creator hash from the creators array
242 |       creatorHash: [...computeCreatorHash(creators)],
243 |       // compute the data hash from the metadata
244 |       dataHash: [...computeDataHash(metadataArgs)],
245 |       nonce: asset.compression.leaf_id,
246 |       index: asset.compression.leaf_id,
247 | 
248 |       // provide the full `metadataArgs` value for on-chain hash verification
249 |       message: metadataArgs,
250 |     },
251 |   );
252 | 
253 |   // build the transaction
254 |   let blockhash = await connection.getLatestBlockhash().then(res => res.blockhash);
255 | 
256 |   const messageV0 = new TransactionMessage({
257 |     payerKey: payer.publicKey,
258 |     recentBlockhash: blockhash,
259 |     instructions: [verifyCreatorIx],
260 |   }).compileToV0Message();
261 | 
262 |   const tx = new VersionedTransaction(messageV0);
263 | 
264 |   // sign with the fee payer and the authority addresses
265 |   tx.sign([payer]);
266 | 
267 |   const sig = await connection.sendTransaction(tx);
268 | 
269 |   console.log(explorerURL({ txSignature: sig }));
270 | 
271 |   //////////////////////////////////////////////////////////////////////////////
272 |   //////////////////////////////////////////////////////////////////////////////
273 | 
274 |   /**
275 |    * note: based on the speed of indexing updates to compressed nfts,
276 |    * this might not result in the updated asset data immediately after updating
277 |    */
278 | 
279 |   printConsoleSeparator("Get the new asset data");
280 | 
281 |   const newAsset = await connection.getAsset(assetId);
282 | 
283 |   console.log(newAsset);
284 | })();
285 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "esnext",
 4 |     "module": "commonjs",
 5 |     "strict": true,
 6 |     "preserveConstEnums": true,
 7 |     "noEmit": true,
 8 |     "sourceMap": false,
 9 |     "moduleResolution": "node",
10 |     "esModuleInterop": true,
11 |     "skipLibCheck": true,
12 |     "forceConsistentCasingInFileNames": true,
13 |     "allowJs": true,
14 |     "resolveJsonModule": true,
15 |     "isolatedModules": true,
16 |     "incremental": true,
17 |     "baseUrl": ".",
18 |     "paths": {
19 |       "@/*": ["./*"]
20 |     }
21 |   },
22 |   "include": ["**/*.ts", "**/**.ts", "**/*.tsx"],
23 |   "exclude": ["node_modules", ".vscode"]
24 | }
25 | 


--------------------------------------------------------------------------------
/utils/compression.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 |   Keypair,
  3 |   PublicKey,
  4 |   Connection,
  5 |   Transaction,
  6 |   sendAndConfirmTransaction,
  7 |   TransactionInstruction,
  8 | } from "@solana/web3.js";
  9 | import { createAccount, createMint, mintTo, TOKEN_PROGRAM_ID } from "@solana/spl-token";
 10 | import {
 11 |   SPL_ACCOUNT_COMPRESSION_PROGRAM_ID,
 12 |   createAllocTreeIx,
 13 |   ValidDepthSizePair,
 14 |   SPL_NOOP_PROGRAM_ID,
 15 | } from "@solana/spl-account-compression";
 16 | import {
 17 |   PROGRAM_ID as BUBBLEGUM_PROGRAM_ID,
 18 |   MetadataArgs,
 19 |   computeCreatorHash,
 20 |   computeDataHash,
 21 |   createCreateTreeInstruction,
 22 |   createMintToCollectionV1Instruction,
 23 | } from "@metaplex-foundation/mpl-bubblegum";
 24 | import {
 25 |   PROGRAM_ID as TOKEN_METADATA_PROGRAM_ID,
 26 |   CreateMetadataAccountArgsV3,
 27 |   createCreateMetadataAccountV3Instruction,
 28 |   createCreateMasterEditionV3Instruction,
 29 |   createSetCollectionSizeInstruction,
 30 | } from "@metaplex-foundation/mpl-token-metadata";
 31 | 
 32 | // import local helper functions
 33 | import { explorerURL, extractSignatureFromFailedTransaction } from "@/utils/helpers";
 34 | 
 35 | /*
 36 |   Helper function to create a merkle tree on chain, including allocating 
 37 |   all the space required to store all the nodes
 38 | */
 39 | export async function createTree(
 40 |   connection: Connection,
 41 |   payer: Keypair,
 42 |   treeKeypair: Keypair,
 43 |   maxDepthSizePair: ValidDepthSizePair,
 44 |   canopyDepth: number = 0,
 45 | ) {
 46 |   console.log("Creating a new Merkle tree...");
 47 |   console.log("treeAddress:", treeKeypair.publicKey.toBase58());
 48 | 
 49 |   // derive the tree's authority (PDA), owned by Bubblegum
 50 |   const [treeAuthority, _bump] = PublicKey.findProgramAddressSync(
 51 |     [treeKeypair.publicKey.toBuffer()],
 52 |     BUBBLEGUM_PROGRAM_ID,
 53 |   );
 54 |   console.log("treeAuthority:", treeAuthority.toBase58());
 55 | 
 56 |   // allocate the tree's account on chain with the `space`
 57 |   // NOTE: this will compute the space needed to store the tree on chain (and the lamports required to store it)
 58 |   const allocTreeIx = await createAllocTreeIx(
 59 |     connection,
 60 |     treeKeypair.publicKey,
 61 |     payer.publicKey,
 62 |     maxDepthSizePair,
 63 |     canopyDepth,
 64 |   );
 65 | 
 66 |   // create the instruction to actually create the tree
 67 |   const createTreeIx = createCreateTreeInstruction(
 68 |     {
 69 |       payer: payer.publicKey,
 70 |       treeCreator: payer.publicKey,
 71 |       treeAuthority,
 72 |       merkleTree: treeKeypair.publicKey,
 73 |       compressionProgram: SPL_ACCOUNT_COMPRESSION_PROGRAM_ID,
 74 |       // NOTE: this is used for some on chain logging
 75 |       logWrapper: SPL_NOOP_PROGRAM_ID,
 76 |     },
 77 |     {
 78 |       maxBufferSize: maxDepthSizePair.maxBufferSize,
 79 |       maxDepth: maxDepthSizePair.maxDepth,
 80 |       public: false,
 81 |     },
 82 |     BUBBLEGUM_PROGRAM_ID,
 83 |   );
 84 | 
 85 |   try {
 86 |     // create and send the transaction to initialize the tree
 87 |     const tx = new Transaction().add(allocTreeIx).add(createTreeIx);
 88 |     tx.feePayer = payer.publicKey;
 89 | 
 90 |     // send the transaction
 91 |     const txSignature = await sendAndConfirmTransaction(
 92 |       connection,
 93 |       tx,
 94 |       // ensuring the `treeKeypair` PDA and the `payer` are BOTH signers
 95 |       [treeKeypair, payer],
 96 |       {
 97 |         commitment: "confirmed",
 98 |         skipPreflight: true,
 99 |       },
100 |     );
101 | 
102 |     console.log("\nMerkle tree created successfully!");
103 |     console.log(explorerURL({ txSignature }));
104 | 
105 |     // return useful info
106 |     return { treeAuthority, treeAddress: treeKeypair.publicKey };
107 |   } catch (err: any) {
108 |     console.error("\nFailed to create merkle tree:", err);
109 | 
110 |     // log a block explorer link for the failed transaction
111 |     await extractSignatureFromFailedTransaction(connection, err);
112 | 
113 |     throw err;
114 |   }
115 | }
116 | 
117 | /**
118 |  * Create an NFT collection on-chain, using the regular Metaplex standards
119 |  * with the `payer` as the authority
120 |  */
121 | export async function createCollection(
122 |   connection: Connection,
123 |   payer: Keypair,
124 |   metadataV3: CreateMetadataAccountArgsV3,
125 | ) {
126 |   // create and initialize the SPL token mint
127 |   console.log("Creating the collection's mint...");
128 |   const mint = await createMint(
129 |     connection,
130 |     payer,
131 |     // mint authority
132 |     payer.publicKey,
133 |     // freeze authority
134 |     payer.publicKey,
135 |     // decimals - use `0` for NFTs since they are non-fungible
136 |     0,
137 |   );
138 |   console.log("Mint address:", mint.toBase58());
139 | 
140 |   // create the token account
141 |   console.log("Creating a token account...");
142 |   const tokenAccount = await createAccount(
143 |     connection,
144 |     payer,
145 |     mint,
146 |     payer.publicKey,
147 |     // undefined, undefined,
148 |   );
149 |   console.log("Token account:", tokenAccount.toBase58());
150 | 
151 |   // mint 1 token ()
152 |   console.log("Minting 1 token for the collection...");
153 |   const mintSig = await mintTo(
154 |     connection,
155 |     payer,
156 |     mint,
157 |     tokenAccount,
158 |     payer,
159 |     // mint exactly 1 token
160 |     1,
161 |     // no `multiSigners`
162 |     [],
163 |     undefined,
164 |     TOKEN_PROGRAM_ID,
165 |   );
166 |   // console.log(explorerURL({ txSignature: mintSig }));
167 | 
168 |   // derive the PDA for the metadata account
169 |   const [metadataAccount, _bump] = PublicKey.findProgramAddressSync(
170 |     [Buffer.from("metadata", "utf8"), TOKEN_METADATA_PROGRAM_ID.toBuffer(), mint.toBuffer()],
171 |     TOKEN_METADATA_PROGRAM_ID,
172 |   );
173 |   console.log("Metadata account:", metadataAccount.toBase58());
174 | 
175 |   // create an instruction to create the metadata account
176 |   const createMetadataIx = createCreateMetadataAccountV3Instruction(
177 |     {
178 |       metadata: metadataAccount,
179 |       mint: mint,
180 |       mintAuthority: payer.publicKey,
181 |       payer: payer.publicKey,
182 |       updateAuthority: payer.publicKey,
183 |     },
184 |     {
185 |       createMetadataAccountArgsV3: metadataV3,
186 |     },
187 |   );
188 | 
189 |   // derive the PDA for the metadata account
190 |   const [masterEditionAccount, _bump2] = PublicKey.findProgramAddressSync(
191 |     [
192 |       Buffer.from("metadata", "utf8"),
193 |       TOKEN_METADATA_PROGRAM_ID.toBuffer(),
194 |       mint.toBuffer(),
195 |       Buffer.from("edition", "utf8"),
196 |     ],
197 |     TOKEN_METADATA_PROGRAM_ID,
198 |   );
199 |   console.log("Master edition account:", masterEditionAccount.toBase58());
200 | 
201 |   // create an instruction to create the metadata account
202 |   const createMasterEditionIx = createCreateMasterEditionV3Instruction(
203 |     {
204 |       edition: masterEditionAccount,
205 |       mint: mint,
206 |       mintAuthority: payer.publicKey,
207 |       payer: payer.publicKey,
208 |       updateAuthority: payer.publicKey,
209 |       metadata: metadataAccount,
210 |     },
211 |     {
212 |       createMasterEditionArgs: {
213 |         maxSupply: 0,
214 |       },
215 |     },
216 |   );
217 | 
218 |   // create the collection size instruction
219 |   const collectionSizeIX = createSetCollectionSizeInstruction(
220 |     {
221 |       collectionMetadata: metadataAccount,
222 |       collectionAuthority: payer.publicKey,
223 |       collectionMint: mint,
224 |     },
225 |     {
226 |       setCollectionSizeArgs: { size: 50 },
227 |     },
228 |   );
229 | 
230 |   try {
231 |     // construct the transaction with our instructions, making the `payer` the `feePayer`
232 |     const tx = new Transaction()
233 |       .add(createMetadataIx)
234 |       .add(createMasterEditionIx)
235 |       .add(collectionSizeIX);
236 |     tx.feePayer = payer.publicKey;
237 | 
238 |     // send the transaction to the cluster
239 |     const txSignature = await sendAndConfirmTransaction(connection, tx, [payer], {
240 |       commitment: "confirmed",
241 |       skipPreflight: true,
242 |     });
243 | 
244 |     console.log("\nCollection successfully created!");
245 |     console.log(explorerURL({ txSignature }));
246 |   } catch (err) {
247 |     console.error("\nFailed to create collection:", err);
248 | 
249 |     // log a block explorer link for the failed transaction
250 |     await extractSignatureFromFailedTransaction(connection, err);
251 | 
252 |     throw err;
253 |   }
254 | 
255 |   // return all the accounts
256 |   return { mint, tokenAccount, metadataAccount, masterEditionAccount };
257 | }
258 | 
259 | /**
260 |  * Mint a single compressed NFTs to any address
261 |  */
262 | export async function mintCompressedNFT(
263 |   connection: Connection,
264 |   payer: Keypair,
265 |   treeAddress: PublicKey,
266 |   collectionMint: PublicKey,
267 |   collectionMetadata: PublicKey,
268 |   collectionMasterEditionAccount: PublicKey,
269 |   compressedNFTMetadata: MetadataArgs,
270 |   receiverAddress?: PublicKey,
271 | ) {
272 |   // derive the tree's authority (PDA), owned by Bubblegum
273 |   const [treeAuthority, _bump] = PublicKey.findProgramAddressSync(
274 |     [treeAddress.toBuffer()],
275 |     BUBBLEGUM_PROGRAM_ID,
276 |   );
277 | 
278 |   // derive a PDA (owned by Bubblegum) to act as the signer of the compressed minting
279 |   const [bubblegumSigner, _bump2] = PublicKey.findProgramAddressSync(
280 |     // `collection_cpi` is a custom prefix required by the Bubblegum program
281 |     [Buffer.from("collection_cpi", "utf8")],
282 |     BUBBLEGUM_PROGRAM_ID,
283 |   );
284 | 
285 |   // create an array of instruction, to mint multiple compressed NFTs at once
286 |   const mintIxs: TransactionInstruction[] = [];
287 | 
288 |   /**
289 |    * correctly format the metadata args for the nft to mint
290 |    * ---
291 |    * note: minting an nft into a collection (via `createMintToCollectionV1Instruction`)
292 |    * will auto verify the collection. But, the `collection.verified` value inside the
293 |    * `metadataArgs` must be set to `false` in order for the instruction to succeed
294 |    */
295 |   const metadataArgs = Object.assign(compressedNFTMetadata, {
296 |     collection: { key: collectionMint, verified: false },
297 |   });
298 | 
299 |   /**
300 |    * compute the data and creator hash for display in the console
301 |    *
302 |    * note: this is not required to do in order to mint new compressed nfts
303 |    * (since it is performed on chain via the Bubblegum program)
304 |    * this is only for demonstration
305 |    */
306 |   const computedDataHash = new PublicKey(computeDataHash(metadataArgs)).toBase58();
307 |   const computedCreatorHash = new PublicKey(computeCreatorHash(metadataArgs.creators)).toBase58();
308 |   console.log("computedDataHash:", computedDataHash);
309 |   console.log("computedCreatorHash:", computedCreatorHash);
310 | 
311 |   /*
312 |     Add a single mint to collection instruction 
313 |     ---
314 |     But you could all multiple in the same transaction, as long as your 
315 |     transaction is still within the byte size limits
316 |   */
317 |   mintIxs.push(
318 |     createMintToCollectionV1Instruction(
319 |       {
320 |         payer: payer.publicKey,
321 | 
322 |         merkleTree: treeAddress,
323 |         treeAuthority,
324 |         treeDelegate: payer.publicKey,
325 | 
326 |         // set the receiver of the NFT
327 |         leafOwner: receiverAddress || payer.publicKey,
328 |         // set a delegated authority over this NFT
329 |         leafDelegate: payer.publicKey,
330 | 
331 |         /*
332 |             You can set any delegate address at mint, otherwise should 
333 |             normally be the same as `leafOwner`
334 |             NOTE: the delegate will be auto cleared upon NFT transfer
335 |             ---
336 |             in this case, we are setting the payer as the delegate
337 |           */
338 | 
339 |         // collection details
340 |         collectionAuthority: payer.publicKey,
341 |         collectionAuthorityRecordPda: BUBBLEGUM_PROGRAM_ID,
342 |         collectionMint: collectionMint,
343 |         collectionMetadata: collectionMetadata,
344 |         editionAccount: collectionMasterEditionAccount,
345 | 
346 |         // other accounts
347 |         compressionProgram: SPL_ACCOUNT_COMPRESSION_PROGRAM_ID,
348 |         logWrapper: SPL_NOOP_PROGRAM_ID,
349 |         bubblegumSigner: bubblegumSigner,
350 |         tokenMetadataProgram: TOKEN_METADATA_PROGRAM_ID,
351 |       },
352 |       {
353 |         metadataArgs,
354 |       },
355 |     ),
356 |   );
357 | 
358 |   try {
359 |     // construct the transaction with our instructions, making the `payer` the `feePayer`
360 |     const tx = new Transaction().add(...mintIxs);
361 |     tx.feePayer = payer.publicKey;
362 | 
363 |     // send the transaction to the cluster
364 |     const txSignature = await sendAndConfirmTransaction(connection, tx, [payer], {
365 |       commitment: "confirmed",
366 |       skipPreflight: true,
367 |     });
368 | 
369 |     console.log("\nSuccessfully minted the compressed NFT!");
370 |     console.log(explorerURL({ txSignature }));
371 | 
372 |     return txSignature;
373 |   } catch (err) {
374 |     console.error("\nFailed to mint compressed NFT:", err);
375 | 
376 |     // log a block explorer link for the failed transaction
377 |     await extractSignatureFromFailedTransaction(connection, err);
378 | 
379 |     throw err;
380 |   }
381 | }
382 | 


--------------------------------------------------------------------------------
/utils/helpers.ts:
--------------------------------------------------------------------------------
  1 | import fs from "fs";
  2 | import path from "path";
  3 | import { Connection, Keypair, LAMPORTS_PER_SOL, PublicKey } from "@solana/web3.js";
  4 | 
  5 | // define some default locations
  6 | const DEFAULT_KEY_DIR_NAME = ".local_keys";
  7 | const DEFAULT_PUBLIC_KEY_FILE = "keys.json";
  8 | const DEFAULT_DEMO_DATA_FILE = "demo.json";
  9 | 
 10 | /*
 11 |   Load locally stored PublicKey addresses
 12 | */
 13 | export function loadPublicKeysFromFile(
 14 |   absPath: string = `${DEFAULT_KEY_DIR_NAME}/${DEFAULT_PUBLIC_KEY_FILE}`,
 15 | ) {
 16 |   try {
 17 |     if (!absPath) throw Error("No path provided");
 18 |     if (!fs.existsSync(absPath)) throw Error("File does not exist.");
 19 | 
 20 |     // load the public keys from the file
 21 |     const data = JSON.parse(fs.readFileSync(absPath, { encoding: "utf-8" })) || {};
 22 | 
 23 |     // convert all loaded keyed values into valid public keys
 24 |     for (const [key, value] of Object.entries(data)) {
 25 |       data[key] = new PublicKey(value as string) ?? "";
 26 |     }
 27 | 
 28 |     return data;
 29 |   } catch (err) {
 30 |     // console.warn("Unable to load local file");
 31 |   }
 32 |   // always return an object
 33 |   return {};
 34 | }
 35 | 
 36 | /*
 37 |   Locally save demo data to the filesystem for later retrieval
 38 | */
 39 | export function saveDemoDataToFile(
 40 |   name: string,
 41 |   newData: any,
 42 |   absPath: string = `${DEFAULT_KEY_DIR_NAME}/${DEFAULT_DEMO_DATA_FILE}`,
 43 | ) {
 44 |   try {
 45 |     let data: object = {};
 46 | 
 47 |     // fetch all the current values, when the storage file exists
 48 |     if (fs.existsSync(absPath))
 49 |       data = JSON.parse(fs.readFileSync(absPath, { encoding: "utf-8" })) || {};
 50 | 
 51 |     data = { ...data, [name]: newData };
 52 | 
 53 |     // actually save the data to the file
 54 |     fs.writeFileSync(absPath, JSON.stringify(data), {
 55 |       encoding: "utf-8",
 56 |     });
 57 | 
 58 |     return data;
 59 |   } catch (err) {
 60 |     console.warn("Unable to save to file");
 61 |     // console.warn(err);
 62 |   }
 63 | 
 64 |   // always return an object
 65 |   return {};
 66 | }
 67 | 
 68 | /*
 69 |   Locally save PublicKey addresses to the filesystem for later retrieval
 70 | */
 71 | export function savePublicKeyToFile(
 72 |   name: string,
 73 |   publicKey: PublicKey,
 74 |   absPath: string = `${DEFAULT_KEY_DIR_NAME}/${DEFAULT_PUBLIC_KEY_FILE}`,
 75 | ) {
 76 |   try {
 77 |     // if (!absPath) throw Error("No path provided");
 78 |     // if (!fs.existsSync(absPath)) throw Error("File does not exist.");
 79 | 
 80 |     // fetch all the current values
 81 |     let data: any = loadPublicKeysFromFile(absPath);
 82 | 
 83 |     // convert all loaded keyed values from PublicKeys to strings
 84 |     for (const [key, value] of Object.entries(data)) {
 85 |       data[key as any] = (value as PublicKey).toBase58();
 86 |     }
 87 |     data = { ...data, [name]: publicKey.toBase58() };
 88 | 
 89 |     // actually save the data to the file
 90 |     fs.writeFileSync(absPath, JSON.stringify(data), {
 91 |       encoding: "utf-8",
 92 |     });
 93 | 
 94 |     // reload the keys for sanity
 95 |     data = loadPublicKeysFromFile(absPath);
 96 | 
 97 |     return data;
 98 |   } catch (err) {
 99 |     console.warn("Unable to save to file");
100 |   }
101 |   // always return an object
102 |   return {};
103 | }
104 | 
105 | /*
106 |   Load a locally stored JSON keypair file and convert it to a valid Keypair
107 | */
108 | export function loadKeypairFromFile(absPath: string) {
109 |   try {
110 |     if (!absPath) throw Error("No path provided");
111 |     if (!fs.existsSync(absPath)) throw Error("File does not exist.");
112 | 
113 |     // load the keypair from the file
114 |     const keyfileBytes = JSON.parse(fs.readFileSync(absPath, { encoding: "utf-8" }));
115 |     // parse the loaded secretKey into a valid keypair
116 |     const keypair = Keypair.fromSecretKey(new Uint8Array(keyfileBytes));
117 |     return keypair;
118 |   } catch (err) {
119 |     // return false;
120 |     throw err;
121 |   }
122 | }
123 | 
124 | /*
125 |   Save a locally stored JSON keypair file for later importing
126 | */
127 | export function saveKeypairToFile(
128 |   keypair: Keypair,
129 |   fileName: string,
130 |   dirName: string = DEFAULT_KEY_DIR_NAME,
131 | ) {
132 |   fileName = path.join(dirName, `${fileName}.json`);
133 | 
134 |   // create the `dirName` directory, if it does not exist
135 |   if (!fs.existsSync(`./${dirName}/`)) fs.mkdirSync(`./${dirName}/`);
136 | 
137 |   // remove the current file, if it already exists
138 |   if (fs.existsSync(fileName)) fs.unlinkSync(fileName);
139 | 
140 |   // write the `secretKey` value as a string
141 |   fs.writeFileSync(fileName, `[${keypair.secretKey.toString()}]`, {
142 |     encoding: "utf-8",
143 |   });
144 | 
145 |   return fileName;
146 | }
147 | 
148 | /*
149 |   Attempt to load a keypair from the filesystem, or generate and save a new one
150 | */
151 | export function loadOrGenerateKeypair(fileName: string, dirName: string = DEFAULT_KEY_DIR_NAME) {
152 |   try {
153 |     // compute the path to locate the file
154 |     const searchPath = path.join(dirName, `${fileName}.json`);
155 |     let keypair = Keypair.generate();
156 | 
157 |     // attempt to load the keypair from the file
158 |     if (fs.existsSync(searchPath)) keypair = loadKeypairFromFile(searchPath);
159 |     // when unable to locate the keypair, save the new one
160 |     else saveKeypairToFile(keypair, fileName, dirName);
161 | 
162 |     return keypair;
163 |   } catch (err) {
164 |     console.error("loadOrGenerateKeypair:", err);
165 |     throw err;
166 |   }
167 | }
168 | 
169 | /*
170 |   Compute the Solana explorer address for the various sets of data
171 | */
172 | export function explorerURL({
173 |   address,
174 |   txSignature,
175 |   cluster,
176 | }: {
177 |   address?: string;
178 |   txSignature?: string;
179 |   cluster?: "devnet" | "testnet" | "mainnet" | "mainnet-beta";
180 | }) {
181 |   let baseUrl: string;
182 |   //
183 |   if (address) baseUrl = `https://explorer.solana.com/address/${address}`;
184 |   else if (txSignature) baseUrl = `https://explorer.solana.com/tx/${txSignature}`;
185 |   else return "[unknown]";
186 | 
187 |   // auto append the desired search params
188 |   const url = new URL(baseUrl);
189 |   url.searchParams.append("cluster", cluster || "devnet");
190 |   return url.toString() + "\n";
191 | }
192 | 
193 | /**
194 |  * Auto airdrop the given wallet of of a balance of < 0.5 SOL
195 |  */
196 | export async function airdropOnLowBalance(
197 |   connection: Connection,
198 |   keypair: Keypair,
199 |   forceAirdrop: boolean = false,
200 | ) {
201 |   // get the current balance
202 |   let balance = await connection.getBalance(keypair.publicKey);
203 | 
204 |   // define the low balance threshold before airdrop
205 |   const MIN_BALANCE_TO_AIRDROP = LAMPORTS_PER_SOL / 2; // current: 0.5 SOL
206 | 
207 |   // check the balance of the two accounts, airdrop when low
208 |   if (forceAirdrop === true || balance < MIN_BALANCE_TO_AIRDROP) {
209 |     console.log(`Requesting airdrop of 1 SOL to ${keypair.publicKey.toBase58()}...`);
210 |     await connection.requestAirdrop(keypair.publicKey, LAMPORTS_PER_SOL).then(sig => {
211 |       console.log("Tx signature:", sig);
212 |       // balance = balance + LAMPORTS_PER_SOL;
213 |     });
214 | 
215 |     // fetch the new balance
216 |     // const newBalance = await connection.getBalance(keypair.publicKey);
217 |     // return newBalance;
218 |   }
219 |   // else console.log("Balance of:", balance / LAMPORTS_PER_SOL, "SOL");
220 | 
221 |   return balance;
222 | }
223 | 
224 | /*
225 |   Helper function to extract a transaction signature from a failed transaction's error message
226 | */
227 | export async function extractSignatureFromFailedTransaction(
228 |   connection: Connection,
229 |   err: any,
230 |   fetchLogs?: boolean,
231 | ) {
232 |   if (err?.signature) return err.signature;
233 | 
234 |   // extract the failed transaction's signature
235 |   const failedSig = new RegExp(/^((.*)?Error: )?(Transaction|Signature) ([A-Z0-9]{32,}) /gim).exec(
236 |     err?.message?.toString(),
237 |   )?.[4];
238 | 
239 |   // ensure a signature was found
240 |   if (failedSig) {
241 |     // when desired, attempt to fetch the program logs from the cluster
242 |     if (fetchLogs)
243 |       await connection
244 |         .getTransaction(failedSig, {
245 |           maxSupportedTransactionVersion: 0,
246 |         })
247 |         .then(tx => {
248 |           console.log(`\n==== Transaction logs for ${failedSig} ====`);
249 |           console.log(explorerURL({ txSignature: failedSig }), "");
250 |           console.log(tx?.meta?.logMessages ?? "No log messages provided by RPC");
251 |           console.log(`==== END LOGS ====\n`);
252 |         });
253 |     else {
254 |       console.log("\n========================================");
255 |       console.log(explorerURL({ txSignature: failedSig }));
256 |       console.log("========================================\n");
257 |     }
258 |   }
259 | 
260 |   // always return the failed signature value
261 |   return failedSig;
262 | }
263 | 
264 | /*
265 |   Standard number formatter
266 | */
267 | export function numberFormatter(num: number, forceDecimals = false) {
268 |   // set the significant figures
269 |   const minimumFractionDigits = num < 1 || forceDecimals ? 10 : 2;
270 | 
271 |   // do the formatting
272 |   return new Intl.NumberFormat(undefined, {
273 |     minimumFractionDigits,
274 |   }).format(num);
275 | }
276 | 
277 | /*
278 |   Display a separator in the console, with our without a message
279 | */
280 | export function printConsoleSeparator(message?: string) {
281 |   console.log("\n===============================================");
282 |   console.log("===============================================\n");
283 |   if (message) console.log(message);
284 | }
285 | 


--------------------------------------------------------------------------------