3land_sdk 1.0.1 → 1.0.2

package/dist/library/implementation/storeImplementation.js

@@ -0,0 +1,308 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { BN } from "bn.js";
+import { Store } from "../Store";
+import { Keypair, PublicKey, SendTransactionError } from "@solana/web3.js";
+import { Creator, CurrencyType, FeeType, PriceRule, SaleType, } from "../../types/types";
+import { Wallet } from "@project-serum/anchor";
+import * as fs2 from "fs";
+import path from "path";
+import { bs58 } from "@project-serum/anchor/dist/cjs/utils/bytes";
+function initializeSDKAndWallet(options) {
+    const sdk = new Store();
+    let walletKeypair;
+    if (options.privateKey) {
+        if (typeof options.privateKey === "string") {
+            // Decode base58 string to Uint8Array
+            try {
+                const decoded = bs58.decode(options.privateKey);
+                walletKeypair = Keypair.fromSecretKey(decoded);
+            }
+            catch (error) {
+                throw new Error(`Invalid base58 private key: ${error}`);
+            }
+        }
+        else if (Array.isArray(options.privateKey)) {
+            // Handle array of numbers
+            walletKeypair = Keypair.fromSecretKey(Uint8Array.from(options.privateKey));
+        }
+        else {
+            // Handle Uint8Array directly
+            walletKeypair = Keypair.fromSecretKey(options.privateKey);
+        }
+    }
+    else if (options.walletPath) {
+        // Existing file-based initialization
+        const secretKey = JSON.parse(fs2.readFileSync(options.walletPath, "utf-8"));
+        walletKeypair = Keypair.fromSecretKey(Uint8Array.from(secretKey));
+    }
+    else {
+        throw new Error("Either walletPath or privateKey must be provided");
+    }
+    const payer = new Wallet(walletKeypair);
+    return { sdk, walletKeypair, payer };
+}
+function createStoreImp(options, storeSetup) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { sdk, walletKeypair, payer } = initializeSDKAndWallet(options);
+        try {
+            const storeConfig = {
+                fee: new BN(1000000),
+                feePercentage: storeSetup.storeFee,
+                feeType: new FeeType.AllMints(),
+                trust: payer.publicKey,
+                rules: [],
+                toJSON: function () {
+                    throw new Error("Function not implemented.");
+                },
+                toEncodable: function () {
+                    throw new Error("Function not implemented.");
+                },
+            };
+            const createStoreTxId = yield sdk.createStore(walletKeypair, storeSetup.storeName, storeConfig);
+            return {
+                transactionId: createStoreTxId,
+                payerPublicKey: payer.publicKey.toString(),
+            };
+        }
+        catch (error) {
+            handleError(error);
+            throw error;
+        }
+    });
+}
+function createCollectionImp(options, collectionOpts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { sdk, walletKeypair, payer } = initializeSDKAndWallet(options);
+        const collectionDetails = { __kind: "V1", size: 0 };
+        const creator = new Creator({
+            address: payer.publicKey,
+            verified: false,
+            share: 100,
+        });
+        const metadata = {
+            symbol: collectionOpts.collectionSymbol, //max 10 chars
+            name: collectionOpts.collectionName, //max 32 chars
+            uri: "",
+            sellerFeeBasisPoints: new BN(5),
+            creators: [creator],
+            collection: null,
+            uses: null,
+        };
+        const imageBuffer = fs2.readFileSync(path.join(process.cwd(), "assets", "ds.jpeg")).buffer;
+        const coverBuffer = fs2.readFileSync(path.join(process.cwd(), "assets", "3land_rebrand.gif")).buffer;
+        const optionsCollection = {
+            symbol: metadata.symbol,
+            metadata: {
+                name: metadata.name,
+                description: collectionOpts.collectionDescription,
+                files: {
+                    file: {
+                        arrayBuffer() {
+                            return imageBuffer;
+                        },
+                        type: "image/gif",
+                    },
+                    cover: {
+                        arrayBuffer() {
+                            return coverBuffer;
+                        },
+                        type: "image/gif",
+                    },
+                },
+            },
+            creators: metadata.creators,
+            traits: [],
+            sellerFeeBasisPoints: metadata.sellerFeeBasisPoints,
+        };
+        try {
+            const collectionTx = yield sdk.createCollection(walletKeypair, collectionDetails, metadata, {
+                options: optionsCollection,
+            });
+            console.log("create collection tx: ", collectionTx);
+            return collectionTx;
+        }
+        catch (error) {
+            handleError(error);
+            return { success: false, error: error };
+        }
+    });
+}
+function createSingleImp(options, storeAccount, collectionAccount, createOptions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { sdk, walletKeypair, payer } = initializeSDKAndWallet(options);
+        try {
+            const creator = new Creator({
+                address: payer.publicKey,
+                verified: false,
+                share: 100,
+            });
+            const metadata = {
+                name: createOptions.itemName,
+                uri: "",
+                uriType: 1,
+                sellerFeeBasisPoints: createOptions.sellerFee,
+                collection: new PublicKey(collectionAccount),
+                creators: [creator],
+                toJSON: function () {
+                    throw new Error("Function not implemented.");
+                },
+                toEncodable: function () {
+                    throw new Error("Function not implemented.");
+                },
+            };
+            /*
+              For MP4
+              const videoBuffer = await fs2.promises.readFile(
+                path.join(process.cwd(), "assets", "video.mp4")
+              );
+        
+              For MP3
+              const audioBuffer = await fs2.promises.readFile(
+                path.join(process.cwd(), "assets", "audio.mp3")
+              );
+        
+              For WebP
+              const webpBuffer = await fs2.promises.readFile(
+                path.join(process.cwd(), "assets", "image.webp")
+              );
+        
+              For GLB
+              const glbBuffer = await fs2.promises.readFile(
+                path.join(process.cwd(), "assets", "model.glb")
+        );
+            */
+            let options;
+            if (createOptions.mainImageUrl) {
+                // Create base metadata files object
+                let baseMetadataFiles = {
+                    file: {
+                        url: createOptions.mainImageUrl,
+                    },
+                };
+                // Add cover if present
+                if (createOptions.coverImageUrl) {
+                    baseMetadataFiles.cover = {
+                        url: createOptions.coverImageUrl,
+                    };
+                }
+                options = {
+                    symbol: createOptions.itemSymbol,
+                    metadata: {
+                        name: metadata.name,
+                        description: createOptions.itemDescription,
+                        files: baseMetadataFiles,
+                    },
+                    creators: metadata.creators,
+                    traits: createOptions.traits,
+                    sellerFeeBasisPoints: metadata.sellerFeeBasisPoints,
+                };
+            }
+            else {
+                const imageBuffer = yield fs2.promises.readFile(path.join(process.cwd(), "assets", "og.png"));
+                if (!imageBuffer || imageBuffer.byteLength === 0) {
+                    throw new Error("Failed to read main image file");
+                }
+                const coverBuffer = yield fs2.promises.readFile(path.join(process.cwd(), "assets", "niicl.gif"));
+                if (!coverBuffer) {
+                    throw new Error("Failed to read cover file");
+                }
+                options = {
+                    symbol: createOptions.itemSymbol,
+                    metadata: {
+                        name: metadata.name,
+                        description: createOptions.itemDescription,
+                        files: {
+                            file: {
+                                arrayBuffer: () => imageBuffer,
+                                type: "image/png",
+                                name: "og.png",
+                                size: imageBuffer.length,
+                            },
+                            cover: {
+                                arrayBuffer: () => coverBuffer,
+                                type: "image/gif",
+                                name: "niicl.gif",
+                                size: coverBuffer.length,
+                            },
+                        },
+                    },
+                    creators: metadata.creators,
+                    traits: createOptions.traits,
+                    sellerFeeBasisPoints: metadata.sellerFeeBasisPoints,
+                };
+            }
+            console.log("cover options: ", options);
+            const saleConfig = {
+                prices: [
+                    {
+                        amount: new BN(createOptions.price),
+                        priceType: new CurrencyType.Native(),
+                        toJSON: function () {
+                            throw new Error("Function not implemented.");
+                        },
+                        toEncodable: function () {
+                            throw new Error("Function not implemented.");
+                        },
+                    },
+                ],
+                priceType: new PriceRule.None(),
+                rules: [],
+                sendToVault: 0,
+                saleType: new SaleType.Normal(),
+                toJSON: function () {
+                    throw new Error("Function not implemented.");
+                },
+                toEncodable: function () {
+                    throw new Error("Function not implemented.");
+                },
+            };
+            const createSingleEditionTxId = yield sdk.createSingleEdition(walletKeypair, new PublicKey(storeAccount), 100, metadata, saleConfig, [1, 0, 0], [1, 0], 0, 12345, new PublicKey(collectionAccount), {
+                options: options,
+            });
+            return {
+                transactionId: createSingleEditionTxId,
+                payerPublicKey: payer.publicKey.toString(),
+            };
+        }
+        catch (error) {
+            handleError(error);
+            throw error;
+        }
+    });
+}
+function buySingleImp(options, item) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { sdk, walletKeypair, payer } = initializeSDKAndWallet(options);
+        try {
+            const owner = payer;
+            const buySingleEditionTxId = yield sdk.buySingleEdition(walletKeypair, [0, 0, 0, 0, 0, 0], new PublicKey(item));
+            console.log("** buy single tx: ", buySingleEditionTxId);
+            return {
+                transactionId: buySingleEditionTxId,
+                ownerPublicKey: owner.publicKey.toString(),
+            };
+        }
+        catch (error) {
+            handleError(error);
+            throw error;
+        }
+    });
+}
+function handleError(error) {
+    if (error instanceof SendTransactionError) {
+        console.error("Transaction failed. Error message:", error.message);
+        console.error("Transaction logs:", error.logs);
+    }
+    else {
+        console.error("An unexpected error occurred:", error);
+    }
+}
+export { createStoreImp, createCollectionImp, createSingleImp, buySingleImp, handleError, };

package/dist/library/instructions/store/buySingleEdition.d.ts

@@ -0,0 +1,16 @@
+import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+export declare let lutAccount: any;
+export declare let merkleTree: any;
+export declare let merkleOptions: {
+    merkleTree: any;
+    lutAccount: any;
+    mainnet: {
+        merkleTree: string;
+        lutAccount: string;
+    };
+    devnet: {
+        merkleTree: string;
+        lutAccount: string;
+    };
+};
+export declare function buySingleEditionInstruction(paymentAccount: PublicKey, itemAccount: PublicKey, packAccount: PublicKey, burnDeposit: PublicKey, poolVault: PublicKey, holderAccount: PublicKey, owner: PublicKey, payer: PublicKey, distributionBumps: number[], data: any, storeAccount: PublicKey, globalStoreAccount: PublicKey, identifier: number, extraAccounts: any[], creator: PublicKey, collectionAddress: PublicKey, connectionInstance: Connection): Promise<TransactionInstruction[]>;

package/dist/library/instructions/store/buySingleEdition.js

@@ -0,0 +1,161 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { PublicKey, SystemProgram, } from "@solana/web3.js";
+import { PROGRAM_ID, BUBBLEGUM_PROGRAM_ID, SPL_NOOP_PROGRAM_ID, TOKEN_METADATA_PROGRAM_ID, SPL_ACCOUNT_COMPRESSION_PROGRAM_ID, PROGRAM_CNFT, } from "../../../types/programId";
+import { buyPay, printSingle } from "../../../types/instructions";
+import { creatorAuthorityPDA, getEditionPDA, getMetadataPDA, itemAccountPDA, storePDA, toPublicKey, collectionAuthorityRecord, } from "../../../utility/PdaManager";
+import { bytesToU32, cyrb53 } from "../../../utility/utils";
+import { BN } from "bn.js";
+import { ExtraParameter } from "../../../types/types";
+import { BorshCoder } from "@project-serum/anchor";
+import { idl } from "./idl";
+export let lutAccount = toPublicKey("EJbrXVgac2wEL2H7FJr38vD7LQpEujWZiSPHSYZ3htCa");
+export let merkleTree = toPublicKey("4GQ32bJ6F6hGnASo836rVbpxWRaeGzj3xkP3pmHnRwiz");
+export let merkleOptions = {
+    merkleTree,
+    lutAccount,
+    mainnet: {
+        merkleTree: "Ccw1HJ6U4uVHbmXWogUGA3YCtwQEoeb5ta9zF3o1QJBM",
+        lutAccount: "5keha7sPVfoK1A7kpBUaAox11xHBCremixsUmQ1ZDAiG",
+    },
+    devnet: {
+        merkleTree: "2t66TFv7rV69puPqPjU7T9wCwmCGRPnSJy7mbcrrZ5KU",
+        lutAccount: "Bpp4MKTVrtr1RajivpbMrEbqbYu8KEFbt1LzW8xAJqkE",
+    },
+};
+const logWrapper = SPL_NOOP_PROGRAM_ID;
+const bubblegumProgram = BUBBLEGUM_PROGRAM_ID;
+const tokenMetadataProgram = TOKEN_METADATA_PROGRAM_ID;
+const compressionProgram = SPL_ACCOUNT_COMPRESSION_PROGRAM_ID;
+let connection;
+export function buySingleEditionInstruction(paymentAccount, itemAccount, packAccount, burnDeposit, poolVault, holderAccount, owner, payer, distributionBumps, data, storeAccount, globalStoreAccount, identifier, extraAccounts, creator, collectionAddress, connectionInstance) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const systemProgram = SystemProgram.programId;
+        connection = connectionInstance;
+        const endpoint = connection.rpcEndpoint.toLocaleLowerCase();
+        const pay = buyPay({ distributionBumps }, {
+            paymentAccount,
+            itemAccount,
+            packAccount,
+            burnDeposit,
+            poolVault,
+            holderAccount,
+            owner,
+            payer,
+            systemProgram,
+        }, extraAccounts, PROGRAM_ID);
+        let itemCreator = creator;
+        const currency = toPublicKey(((_a = data === null || data === void 0 ? void 0 : data.track) === null || _a === void 0 ? void 0 : _a.currency) || PROGRAM_ID);
+        const bubblegumSigner = toPublicKey("4ewWZC5gT6TGpm5LZNDs9wVonfUT2q5PP5sc9kVbwMAK");
+        const useGlobal = false;
+        const merkle = useGlobal
+            ? merkleOptions === null || merkleOptions === void 0 ? void 0 : merkleOptions.merkleTree
+            : endpoint.includes("mainnet")
+                ? toPublicKey((_b = merkleOptions === null || merkleOptions === void 0 ? void 0 : merkleOptions.mainnet) === null || _b === void 0 ? void 0 : _b.merkleTree)
+                : toPublicKey((_c = merkleOptions === null || merkleOptions === void 0 ? void 0 : merkleOptions.devnet) === null || _c === void 0 ? void 0 : _c.merkleTree);
+        const [treeAuthority, _bump] = PublicKey.findProgramAddressSync([merkle.toBuffer()], BUBBLEGUM_PROGRAM_ID);
+        const seeds = [Buffer.from("tree"), merkle.toBuffer()];
+        if (useGlobal) {
+            seeds.pop();
+        }
+        const [merkleManager, treeBump] = PublicKey.findProgramAddressSync(seeds, PROGRAM_CNFT);
+        const collectionMint = collectionAddress;
+        const [creatorAuthority, creatorAuthBump] = yield creatorAuthorityPDA({
+            creator: itemCreator,
+            store: storeAccount,
+        });
+        let [collectionAuthorityRecordPda] = yield collectionAuthorityRecord({
+            mint: collectionMint,
+            new_authority: creatorAuthority,
+        });
+        const collectionMetadata = yield getMetadataPDA(collectionMint);
+        const [editionAccount] = yield getEditionPDA(collectionMint, false);
+        const joint_bytes = [...itemCreator.toBytes(), ...currency.toBytes()];
+        const proof = {
+            proofHash: new BN(cyrb53(joint_bytes, 1)),
+            amount: new BN(1000000),
+            currencyVerifier: new BN(bytesToU32(currency.toBytes().slice(0, 4))),
+            artistVerifier: new BN(bytesToU32(itemCreator.toBytes().slice(0, 4))),
+        };
+        if (!data.storeBump) {
+            const storedata = yield connection.getAccountInfo(toPublicKey(globalStoreAccount));
+            if (!storedata) {
+                throw new Error("-- No Store data store bump");
+            }
+            const [_, storeBump] = yield storePDA({
+                storeId: 1,
+                creator: itemCreator,
+                holder: holderAccount,
+            });
+            data.storeBump = storeBump;
+        }
+        if (!data.itemBump) {
+            // const storedata = await connection.getAccountInfo(itemAccount);
+            // if (!storedata) {
+            //   throw new Error("-- No Store data item bump");
+            // }
+            // const tipo = "Single";
+            // const tipofn = "itemAccountPDA";
+            const identifierdt = new BN(identifier);
+            const [_, itemBump] = yield itemAccountPDA({
+                creator: itemCreator,
+                store: storeAccount,
+                identifier: identifierdt,
+            });
+            data.itemBump = itemBump;
+        }
+        if (!data)
+            data = {};
+        if (!(data === null || data === void 0 ? void 0 : data.pre))
+            data.pre = [];
+        if (!(data === null || data === void 0 ? void 0 : data.post))
+            data.post = [];
+        const coder = new BorshCoder(idl);
+        const storedata = yield connection.getAccountInfo(toPublicKey(storeAccount));
+        if (!storedata) {
+            throw new Error("no store data in print single");
+        }
+        const store_decoded = coder.accounts.decode("Store", storedata.data);
+        const [_, storeBump] = yield storePDA(Object.assign({}, store_decoded));
+        data.storeBump = storeBump;
+        const single = printSingle({
+            proof,
+            storeBump: data.storeBump,
+            creatorAuthBump,
+            itemBump: data.itemBump,
+            treeBump,
+            extra: new ExtraParameter.None(),
+        }, {
+            owner,
+            itemAccount,
+            treeAuthority,
+            storeAccount,
+            creatorAuthority,
+            paymentAccount,
+            merkleTree: merkle,
+            merkleManager,
+            collectionAuthorityRecordPda,
+            editionAccount,
+            collectionMetadata,
+            collectionMint,
+            bubblegumSigner,
+            buytrackAccount: PROGRAM_CNFT,
+            revealForMe: PROGRAM_CNFT,
+            payer,
+            logWrapper,
+            bubblegumProgram,
+            compressionProgram,
+            tokenMetadataProgram,
+            systemProgram,
+        }, PROGRAM_ID);
+        return [pay, single];
+    });
+}

package/dist/library/instructions/store/createSingleEdition.d.ts

@@ -0,0 +1,3 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { SaleConfig, ShortMetadataArgs } from "../../../types/types";
+export declare function createSingleEditionInstruction(storeAccount: PublicKey, itemAccount: PublicKey, creatorAuthority: PublicKey, itemReserveList: PublicKey, creator: PublicKey, payer: PublicKey, supply: number, shortMetadata: ShortMetadataArgs, saleConfig: SaleConfig, identifier: number, category: number[], superCategory: number[], eventCategory: number, hashTraits: number): TransactionInstruction;

package/dist/library/instructions/store/createSingleEdition.js

@@ -0,0 +1,24 @@
+import { PublicKey } from "@solana/web3.js";
+import { PROGRAM_ID } from "../../../types/programId";
+import { createSingle } from "../../../types/instructions";
+import BN from "bn.js";
+export function createSingleEditionInstruction(storeAccount, itemAccount, creatorAuthority, itemReserveList, creator, payer, supply, shortMetadata, saleConfig, identifier, category, superCategory, eventCategory, hashTraits) {
+    return createSingle({
+        supply: new BN(supply),
+        shortMetadata,
+        saleConfig,
+        identifier: new BN(identifier),
+        category,
+        superCategory,
+        eventCategory,
+        hashTraits: new BN(hashTraits),
+    }, {
+        storeAccount,
+        itemAccount,
+        creatorAuthority,
+        itemReserveList,
+        creator,
+        payer,
+        systemProgram: PublicKey.default,
+    }, PROGRAM_ID);
+}

package/dist/library/instructions/store/createStore.d.ts

@@ -0,0 +1,3 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { StoreConfig } from "../../../types/types";
+export declare function createStoreInstruction(holderAccount: PublicKey, storeAccount: PublicKey, creator: PublicKey, name: string, storeConfig: StoreConfig, storeId: number): TransactionInstruction;

package/dist/library/instructions/store/createStore.js

@@ -0,0 +1,6 @@
+import { PublicKey } from "@solana/web3.js";
+import { PROGRAM_ID } from "../../../types/programId";
+import { createStore } from "../../../types/instructions";
+export function createStoreInstruction(holderAccount, storeAccount, creator, name, storeConfig, storeId) {
+    return createStore({ name, storeConfig, storeId }, { holderAccount, storeAccount, creator, systemProgram: PublicKey.default }, PROGRAM_ID);
+}