3land_sdk 1.0.0 → 1.0.2

package/dist/utility/PdaManager.js

@@ -0,0 +1,160 @@
+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 { BUBBLEGUM_PROGRAM_ID, PROGRAM_ID, SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID, TOKEN_METADATA_PROGRAM_ID, TOKEN_PROGRAM_ID, } from "../types/programId";
+import { PublicKey } from "@solana/web3.js";
+export const METADATA_PREFIX = "metadata";
+export function holderPDA({ creator, slot }) {
+    if (!slot)
+        slot = 0;
+    creator = toPublicKey(creator);
+    return PublicKey.findProgramAddress([
+        Buffer.from("holder"),
+        creator.toBytes(),
+        new BN(slot).toArrayLike(Buffer, "le", 8),
+    ], toPublicKey(PROGRAM_ID));
+}
+export function holderAccountPDA({ creator, slot }) {
+    if (!slot)
+        slot = 0;
+    creator = toPublicKey(creator);
+    return PublicKey.findProgramAddress([
+        Buffer.from("holder_account"),
+        creator.toBytes(),
+        new BN(slot).toArrayLike(Buffer, "le", 8),
+    ], toPublicKey(PROGRAM_ID));
+}
+export function storePDA({ storeId, creator, holder }) {
+    holder = toPublicKey(holder);
+    creator = toPublicKey(creator);
+    if (!(storeId === null || storeId === void 0 ? void 0 : storeId.toNumber))
+        storeId = new BN(storeId);
+    return PublicKey.findProgramAddress([
+        Buffer.from("store"),
+        holder.toBytes(),
+        creator.toBytes(),
+        storeId.toArrayLike(Buffer, "le", 2),
+    ], toPublicKey(PROGRAM_ID));
+}
+export function creatorAuthorityPDA({ creator, store }) {
+    store = toPublicKey(store);
+    creator = toPublicKey(creator);
+    return PublicKey.findProgramAddress([Buffer.from("creator_authority"), store.toBytes(), creator.toBytes()], toPublicKey(PROGRAM_ID));
+}
+export function itemAccountPDA({ creator, store, identifier }) {
+    store = toPublicKey(store);
+    creator = toPublicKey(creator);
+    return PublicKey.findProgramAddress([
+        Buffer.from("item_account"),
+        store.toBytes(),
+        creator.toBytes(),
+        identifier.toArrayLike(Buffer, "le", 8),
+    ], toPublicKey(PROGRAM_ID));
+}
+export function itemReserveListPDA({ item }) {
+    item = toPublicKey(item);
+    return PublicKey.findProgramAddress([Buffer.from("item_reserve_list"), item.toBytes()], toPublicKey(PROGRAM_ID));
+}
+export const toPublicKey = (key) => {
+    if (typeof key !== "string")
+        return key;
+    const PubKeysInternedMap = new Map();
+    let result = PubKeysInternedMap.get(key);
+    if (!result) {
+        result = new PublicKey(key);
+        PubKeysInternedMap.set(key, result);
+    }
+    return result;
+};
+export const getMetadataPDA = (mint) => __awaiter(void 0, void 0, void 0, function* () {
+    const [publicKey] = yield PublicKey.findProgramAddress([
+        Buffer.from("metadata"),
+        TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+        mint.toBuffer(),
+    ], TOKEN_METADATA_PROGRAM_ID //PROGRAM_ID
+    );
+    return publicKey;
+});
+export const getEditionPDA = (mint, full) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield PublicKey.findProgramAddress([
+        Buffer.from(METADATA_PREFIX),
+        toPublicKey(TOKEN_METADATA_PROGRAM_ID).toBuffer(),
+        mint.toBuffer(),
+        Buffer.from("edition"),
+    ], toPublicKey(TOKEN_METADATA_PROGRAM_ID));
+});
+export const collectionAuthorityRecord = (_a) => __awaiter(void 0, [_a], void 0, function* ({ mint, new_authority, }) {
+    mint = toPublicKey(mint);
+    new_authority = toPublicKey(new_authority);
+    return PublicKey.findProgramAddress([
+        Buffer.from("metadata"),
+        TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+        mint.toBuffer(),
+        Buffer.from("collection_authority"),
+        new_authority.toBuffer(),
+    ], TOKEN_METADATA_PROGRAM_ID);
+});
+export const creatorRegistryPDA = ({ user, currency, store }) => {
+    user = toPublicKey(user);
+    currency = toPublicKey(currency);
+    store = toPublicKey(store);
+    return PublicKey.findProgramAddress([
+        Buffer.from("creator_registry"),
+        currency.toBytes(),
+        user.toBytes(),
+        store.toBytes(),
+    ], toPublicKey(PROGRAM_ID));
+};
+export const userActivityPDA = (_a) => __awaiter(void 0, [_a], void 0, function* ({ user, store }) {
+    user = toPublicKey(user);
+    store = toPublicKey(store);
+    return PublicKey.findProgramAddress([Buffer.from("user_activity_tracking"), user.toBytes(), store.toBytes()], toPublicKey(PROGRAM_ID));
+});
+export const collectorArtistRegistryPDA = (_a) => __awaiter(void 0, [_a], void 0, function* ({ user, artist, currency, store, }) {
+    user = toPublicKey(user);
+    currency = toPublicKey(currency);
+    artist = toPublicKey(artist);
+    store = toPublicKey(store);
+    return PublicKey.findProgramAddress([
+        Buffer.from("collectors_artist_registry"),
+        user.toBytes(),
+        currency.toBytes(),
+        artist.toBytes(),
+        store.toBytes(),
+    ], toPublicKey(PROGRAM_ID));
+});
+export const collectorGlobalRegistryPDA = ({ user, currency, store }) => {
+    user = toPublicKey(user);
+    currency = toPublicKey(currency);
+    store = toPublicKey(store);
+    return PublicKey.findProgramAddress([
+        Buffer.from("collectors_global_registry"),
+        user.toBytes(),
+        currency.toBytes(),
+        store.toBytes(),
+    ], toPublicKey(PROGRAM_ID));
+};
+export const buyPaymentPDA = ({ owner, itemAccount }) => {
+    owner = toPublicKey(owner);
+    itemAccount = toPublicKey(itemAccount);
+    return PublicKey.findProgramAddress([Buffer.from("buy_payment"), owner.toBytes(), itemAccount.toBytes()], toPublicKey(PROGRAM_ID));
+};
+export const treeAuthority = ({ tree }) => {
+    tree = toPublicKey(tree);
+    return PublicKey.findProgramAddressSync([tree.toBuffer()], toPublicKey(BUBBLEGUM_PROGRAM_ID));
+};
+export const getATAPDA = (_a) => __awaiter(void 0, [_a], void 0, function* ({ owner, mint }) {
+    const [publicKey] = yield PublicKey.findProgramAddress([
+        toPublicKey(owner).toBuffer(),
+        TOKEN_PROGRAM_ID.toBuffer(),
+        toPublicKey(mint).toBuffer(),
+    ], SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID);
+    return publicKey;
+});

package/dist/utility/config.d.ts

@@ -0,0 +1,11 @@
+export declare enum NetworkType {
+    DEVNET = "devnet",
+    MAINNET = "mainnet-beta"
+}
+export interface NetworkConfig {
+    endpoint: string;
+    programId: string;
+    tokenProgramId: string;
+    metadataProgramId: string;
+}
+export declare const NETWORK_CONFIGS: Record<NetworkType, NetworkConfig>;

package/dist/utility/config.js

@@ -0,0 +1,20 @@
+import { PROGRAM_CNFT, TOKEN_METADATA_PROGRAM_ID, TOKEN_PROGRAM_ID, } from "../types/programId";
+export var NetworkType;
+(function (NetworkType) {
+    NetworkType["DEVNET"] = "devnet";
+    NetworkType["MAINNET"] = "mainnet-beta";
+})(NetworkType || (NetworkType = {}));
+export const NETWORK_CONFIGS = {
+    [NetworkType.DEVNET]: {
+        endpoint: "https://api.devnet.solana.com",
+        programId: PROGRAM_CNFT,
+        tokenProgramId: TOKEN_PROGRAM_ID,
+        metadataProgramId: TOKEN_METADATA_PROGRAM_ID,
+    },
+    [NetworkType.MAINNET]: {
+        endpoint: "https://api.mainnet-beta.solana.com",
+        programId: PROGRAM_CNFT,
+        tokenProgramId: TOKEN_PROGRAM_ID,
+        metadataProgramId: TOKEN_METADATA_PROGRAM_ID,
+    },
+};

package/dist/utility/utils.d.ts

@@ -0,0 +1,13 @@
+import { FileData } from "../library/instructions/store/uploadFilesIryis";
+export declare function bytesToU32(slice: any): number;
+export declare const cyrb53: (str: any, seed?: number) => number;
+export declare const sleep: (t: any) => Promise<unknown>;
+export declare const nowS: () => number;
+export declare const validateSolAddress: (address: any) => any;
+export declare const checkFileType: (file: any) => "audio" | "image/png" | "image/gif" | "image/jpeg" | "image/webp" | "video/mp4" | "model/gltf-binary" | "video/webp" | null;
+export declare const checkCategory: (file: any) => "audio" | "image" | "video" | "vr" | null;
+export declare function normalizeFileData(fileData: any): Promise<FileData>;
+export declare function getFileType(file: any): string | null;
+export declare function validateFileType(type: string): void;
+export declare function getFileCategory(file: any): string | null;
+export declare function isAnimatable(type: string): boolean;

package/dist/utility/utils.js

@@ -0,0 +1,196 @@
+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 } from "@solana/web3.js";
+export function bytesToU32(slice) {
+    let result = 0;
+    for (let i = slice.length - 1; i >= 0; i--) {
+        result = (result << 8) | slice[i];
+    }
+    return result >>> 0;
+}
+export const cyrb53 = (str, seed = 0) => {
+    let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
+    let arr = null;
+    if (typeof str != "string") {
+        if (Array.isArray(str)) {
+            arr = str;
+        }
+        else {
+            str = str + "";
+        }
+    }
+    if (arr) {
+        for (const ch of arr) {
+            h1 = Math.imul(h1 ^ ch, 2654435761);
+            h2 = Math.imul(h2 ^ ch, 1597334677);
+        }
+    }
+    else {
+        for (let i = 0, ch; i < str.length; i++) {
+            ch = str.charCodeAt(i);
+            h1 = Math.imul(h1 ^ ch, 2654435761);
+            h2 = Math.imul(h2 ^ ch, 1597334677);
+        }
+    }
+    h1 =
+        Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^
+            Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+    h2 =
+        Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^
+            Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+    return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+};
+export const sleep = (t) => {
+    return new Promise((res) => {
+        setTimeout(res, t);
+    });
+};
+export const nowS = () => Date.now() / 1000;
+export const validateSolAddress = (address) => {
+    try {
+        let pubkey = new PublicKey(address);
+        return PublicKey.isOnCurve(pubkey.toBuffer());
+    }
+    catch (error) {
+        return false;
+    }
+};
+export const checkFileType = (file) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    return ((_a = file === null || file === void 0 ? void 0 : file.type) === null || _a === void 0 ? void 0 : _a.includes("video/webp"))
+        ? "video/webp"
+        : ((_b = file === null || file === void 0 ? void 0 : file.type) === null || _b === void 0 ? void 0 : _b.includes("image/webp"))
+            ? "image/webp"
+            : ((_c = file === null || file === void 0 ? void 0 : file.type) === null || _c === void 0 ? void 0 : _c.includes("jpeg")) || ((_d = file === null || file === void 0 ? void 0 : file.type) === null || _d === void 0 ? void 0 : _d.includes("jpg"))
+                ? "image/jpeg"
+                : ((_e = file === null || file === void 0 ? void 0 : file.type) === null || _e === void 0 ? void 0 : _e.includes("gif"))
+                    ? "image/gif"
+                    : ((_f = file === null || file === void 0 ? void 0 : file.type) === null || _f === void 0 ? void 0 : _f.includes("png"))
+                        ? "image/png"
+                        : ((_g = file === null || file === void 0 ? void 0 : file.type) === null || _g === void 0 ? void 0 : _g.includes("audio"))
+                            ? "audio"
+                            : ((_h = file === null || file === void 0 ? void 0 : file.type) === null || _h === void 0 ? void 0 : _h.includes("mp4"))
+                                ? "video/mp4"
+                                : ((_j = file === null || file === void 0 ? void 0 : file.name) === null || _j === void 0 ? void 0 : _j.includes("glb")) || ((_k = file === null || file === void 0 ? void 0 : file.type) === null || _k === void 0 ? void 0 : _k.includes("model"))
+                                    ? "model/gltf-binary"
+                                    : null;
+};
+export const checkCategory = (file) => {
+    var _a, _b, _c, _d, _e;
+    return ((_a = file === null || file === void 0 ? void 0 : file.type) === null || _a === void 0 ? void 0 : _a.includes("image"))
+        ? "image"
+        : ((_b = file === null || file === void 0 ? void 0 : file.type) === null || _b === void 0 ? void 0 : _b.includes("audio"))
+            ? "audio"
+            : ((_c = file === null || file === void 0 ? void 0 : file.type) === null || _c === void 0 ? void 0 : _c.includes("video"))
+                ? "video"
+                : ((_d = file === null || file === void 0 ? void 0 : file.name) === null || _d === void 0 ? void 0 : _d.includes("glb")) || ((_e = file === null || file === void 0 ? void 0 : file.type) === null || _e === void 0 ? void 0 : _e.includes("model"))
+                    ? "vr"
+                    : null;
+};
+export function normalizeFileData(fileData) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const buffer = yield (fileData.arrayBuffer instanceof Function
+                ? fileData.arrayBuffer()
+                : Promise.resolve(fileData.arrayBuffer));
+            const type = fileData.type || getMimeTypeFromBuffer(buffer);
+            return {
+                arrayBuffer: () => buffer,
+                type,
+                size: buffer.byteLength,
+                name: fileData.name,
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to normalize file data: ${error}`);
+        }
+    });
+}
+function getMimeTypeFromBuffer(buffer) {
+    const arr = new Uint8Array(buffer).subarray(0, 12);
+    const header = Array.from(arr)
+        .map((byte) => byte.toString(16))
+        .join("");
+    if (header.startsWith("89504e47"))
+        return "image/png";
+    if (header.startsWith("474946"))
+        return "image/gif";
+    if (header.startsWith("ffd8ff"))
+        return "image/jpeg";
+    if (header.startsWith("52494646") && header.includes("57454250"))
+        return "image/webp";
+    if (header.startsWith("494433") || header.startsWith("fffb"))
+        return "audio/mp3";
+    if (header.startsWith("000000") &&
+        (header.includes("66747970") || header.includes("6d6f6f76")))
+        return "video/mp4";
+    if (header.startsWith("676c5446"))
+        return "model/gltf-binary";
+    return "application/octet-stream";
+}
+export function getFileType(file) {
+    var _a;
+    if (!file)
+        return null;
+    const type = ((_a = file.type) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || "";
+    const name = (file.name || "").toLowerCase();
+    if (type.includes("video/webp"))
+        return "video/webp";
+    if (type.includes("image/webp"))
+        return "image/webp";
+    if (type.includes("jpeg") || type.includes("jpg"))
+        return "image/jpeg";
+    if (type.includes("gif"))
+        return "image/gif";
+    if (type.includes("png"))
+        return "image/png";
+    if (type.includes("mp3") || type.includes("audio/mp3"))
+        return "audio/mp3";
+    if (type.includes("mp4"))
+        return "video/mp4";
+    if (type.includes("glb") || name.endsWith(".glb"))
+        return "model/gltf-binary";
+    return type || null;
+}
+export function validateFileType(type) {
+    const allowedTypes = [
+        "image/png",
+        "image/jpeg",
+        "image/gif",
+        "image/webp",
+        "video/mp4",
+        "audio/mp3",
+        "model/gltf-binary",
+        "application/octet-stream",
+    ];
+    if (!allowedTypes.includes(type)) {
+        throw new Error(`Unsupported file type: ${type}`);
+    }
+}
+export function getFileCategory(file) {
+    if (!file)
+        return null;
+    const type = (file.type || "").toLowerCase();
+    const name = (file.name || "").toLowerCase();
+    if (type.includes("image"))
+        return "image";
+    if (type.includes("audio"))
+        return "audio";
+    if (type.includes("video"))
+        return "video";
+    if (type.includes("model") || name.endsWith(".glb"))
+        return "vr";
+    return null;
+}
+export function isAnimatable(type) {
+    return ((type === null || type === void 0 ? void 0 : type.includes("video/")) ||
+        (type === null || type === void 0 ? void 0 : type.includes("audio/")) ||
+        type === "model/gltf-binary");
+}

package/dist/utility/validation.d.ts

@@ -0,0 +1,12 @@
+import { PublicKey, Signer } from "@solana/web3.js";
+import { StoreConfig, SaleConfig, ShortMetadataArgs } from "../types/types";
+export declare class ValidationError extends Error {
+    constructor(message: string);
+}
+export declare function validateStoreConfig(config: StoreConfig): void;
+export declare function validateMetadata(metadata: ShortMetadataArgs): void;
+export declare function validateSaleConfig(config: SaleConfig): void;
+export declare function validateSupply(supply: number): void;
+export declare function validateIdentifier(identifier: number): void;
+export declare function validateCollectionArgs(collectionDetails: any, supply: number, metadata: any, irysData: any): void;
+export declare function validateBuySingleArgs(payer: Signer, packAccount: PublicKey, burnProgress: PublicKey, owner: PublicKey, distributionBumps: number[], globalStoreAccount: PublicKey, extraAccounts: any[], collectionAddress?: PublicKey, storeAccount?: PublicKey, creator?: PublicKey): void;

package/dist/utility/validation.js

@@ -0,0 +1,149 @@
+import { PublicKey } from "@solana/web3.js";
+import { BN } from "bn.js";
+export class ValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ValidationError";
+    }
+}
+export function validateStoreConfig(config) {
+    if (!config.fee || !(config.fee instanceof BN)) {
+        throw new ValidationError("Store fee must be a valid BN instance");
+    }
+    if (typeof config.feePercentage !== "number" ||
+        config.feePercentage < 0 ||
+        config.feePercentage > 100) {
+        throw new ValidationError("Fee percentage must be a number between 0 and 100");
+    }
+    if (!config.trust || !(config.trust instanceof PublicKey)) {
+        throw new ValidationError("Trust must be a valid PublicKey");
+    }
+}
+export function validateMetadata(metadata) {
+    if (!metadata.name || metadata.name.length > 32) {
+        throw new ValidationError("Metadata name is required and must be <= 32 characters");
+    }
+    if (metadata.uriType !== 0 && metadata.uriType !== 1) {
+        throw new ValidationError("Invalid URI type");
+    }
+    if (!metadata.creators || !metadata.creators.length) {
+        throw new ValidationError("At least one creator is required");
+    }
+    const totalShares = metadata.creators.reduce((sum, creator) => sum + creator.share, 0);
+    if (totalShares !== 100) {
+        throw new ValidationError("Creator shares must sum to 100");
+    }
+}
+export function validateSaleConfig(config) {
+    if (!config.prices || !config.prices.length) {
+        throw new ValidationError("At least one price configuration is required");
+    }
+    config.prices.forEach((price) => {
+        if (!price.amount || !(price.amount instanceof BN)) {
+            throw new ValidationError("Each price amount must be a valid BN instance");
+        }
+    });
+    if (config.sendToVault < 0) {
+        throw new ValidationError("sendToVault must be non-negative");
+    }
+}
+export function validateSupply(supply) {
+    if (typeof supply !== "number" || supply < 0) {
+        throw new ValidationError("Supply must be a non-negative number");
+    }
+}
+export function validateIdentifier(identifier) {
+    if (typeof identifier !== "number" || identifier < 0) {
+        throw new ValidationError("Identifier must be a non-negative number");
+    }
+}
+export function validateCollectionArgs(collectionDetails, supply, metadata, irysData) {
+    if (!collectionDetails || typeof collectionDetails.__kind !== "string") {
+        throw new ValidationError("Invalid collection details format");
+    }
+    if (typeof supply !== "number" || supply < 0) {
+        throw new ValidationError("Supply must be a non-negative number");
+    }
+    if (!metadata) {
+        throw new ValidationError("Metadata is required");
+    }
+    // Validate metadata fields
+    if (!metadata.symbol || metadata.symbol.length > 10) {
+        throw new ValidationError("Symbol is required and must be <= 10 characters");
+    }
+    if (!metadata.name || metadata.name.length > 32) {
+        throw new ValidationError("Name is required and must be <= 32 characters");
+    }
+    if (!metadata.creators || !Array.isArray(metadata.creators)) {
+        throw new ValidationError("Creators array is required");
+    }
+    const totalShares = metadata.creators.reduce((sum, creator) => sum + creator.share, 0);
+    if (totalShares !== 100) {
+        throw new ValidationError("Creator shares must sum to 100");
+    }
+    // Validate Irys data
+    if (!irysData || !irysData.options || !irysData.options.metadata) {
+        throw new ValidationError("Invalid Irys data format");
+    }
+    if (!irysData.options.metadata.files ||
+        !irysData.options.metadata.files.file) {
+        throw new ValidationError("Collection image file is required");
+    }
+}
+export function validateBuySingleArgs(payer, packAccount, burnProgress, owner, distributionBumps, globalStoreAccount, extraAccounts, collectionAddress, storeAccount, creator) {
+    if (!payer || !payer.publicKey) {
+        throw new ValidationError("Invalid payer");
+    }
+    if (!PublicKey.isOnCurve(packAccount)) {
+        throw new ValidationError("Invalid pack account public key");
+    }
+    if (!PublicKey.isOnCurve(burnProgress)) {
+        throw new ValidationError("Invalid burn progress public key");
+    }
+    if (!PublicKey.isOnCurve(owner)) {
+        throw new ValidationError("Invalid owner public key");
+    }
+    if (!Array.isArray(distributionBumps) || distributionBumps.length !== 6) {
+        throw new ValidationError("Distribution bumps must be an array of length 6");
+    }
+    distributionBumps.forEach((bump, index) => {
+        if (typeof bump !== "number" || bump < 0 || bump > 255) {
+            throw new ValidationError(`Invalid distribution bump at index ${index}`);
+        }
+    });
+    if (!storeAccount) {
+        throw new ValidationError("Store account missing");
+    }
+    if (PublicKey.isOnCurve(storeAccount)) {
+        throw new ValidationError("Invalid store account public key");
+    }
+    if (PublicKey.isOnCurve(globalStoreAccount)) {
+        throw new ValidationError("Invalid global store account public key");
+    }
+    if (!collectionAddress) {
+        throw new ValidationError("Collection address missing");
+    }
+    if (!PublicKey.isOnCurve(collectionAddress)) {
+        throw new ValidationError("Invalid collection address public key");
+    }
+    if (!creator) {
+        throw new ValidationError("Creator public key missing");
+    }
+    if (!PublicKey.isOnCurve(creator)) {
+        throw new ValidationError("Invalid creator public key");
+    }
+    if (!Array.isArray(extraAccounts)) {
+        throw new ValidationError("Extra accounts must be an array");
+    }
+    extraAccounts.forEach((account, index) => {
+        if (!account.pubkey || PublicKey.isOnCurve(account.pubkey)) {
+            throw new ValidationError(`Invalid public key in extra accounts at index ${index}`);
+        }
+        if (typeof account.isSigner !== "boolean") {
+            throw new ValidationError(`Invalid isSigner flag in extra accounts at index ${index}`);
+        }
+        if (typeof account.isWritable !== "boolean") {
+            throw new ValidationError(`Invalid isWritable flag in extra accounts at index ${index}`);
+        }
+    });
+}

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "3land_sdk",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "sdk for interacting with 3land's solana program",
   "main": "./src/library/implementation/storeImplementation.ts",
-  "type": "module",
   "scripts": {
     "test": "npx tsx ./src/index.ts"
   },

package/src/index.ts

@@ -18,8 +18,7 @@ async function main() {
   //   };
 
   const optionsWithBase58: StoreInitOptions = {
-    privateKey:
-      "2ixmpz6W9aAE7HDqCJYy1tsqQcAHhkuP54jTPGnTyqvYHJearwT16DzmkkaQLARB9TshZvoS3WE5dQg183wryVCC",
+    privateKey: "", //your private key
   };
 
   const storeSetup: CreateStoreParams = {
@@ -56,7 +55,7 @@ async function main() {
     const landStoreMainnet = "AmQNs2kgw4LvS9sm6yE9JJ4Hs3JpVu65eyx9pxMG2xA";
     const landStoreDevnet = "GyPCu89S63P9NcCQAtuSJesiefhhgpGWrNVJs4bF2cSK";
     // Create Collection
-    // const collection = await createCollectionTest(
+    // const collection = await createCollectionImp(
     //   optionsWithBase58,
     //   collectionOpts
     // );

package/src/library/implementation/storeImplementation.ts

@@ -97,7 +97,7 @@ async function createStoreImp(
   }
 }
 
-async function createCollectionTest(
+async function createCollectionImp(
   options: StoreInitOptions,
   collectionOpts: CreateCollectionOptions
 ) {
@@ -165,6 +165,7 @@ async function createCollectionTest(
     return collectionTx;
   } catch (error) {
     handleError(error);
+    return { success: false, error: error };
   }
 }
 
@@ -382,4 +383,10 @@ function handleError(error: unknown) {
   }
 }
 
-export { createStoreImp, createSingleImp, buySingleImp, handleError };
+export {
+  createStoreImp,
+  createCollectionImp,
+  createSingleImp,
+  buySingleImp,
+  handleError,
+};

package/src/library/instructions/store/buySingleEdition.ts

@@ -181,6 +181,7 @@ export async function buySingleEditionInstruction(
   if (!data?.post) data.post = [];
 
   const coder = new BorshCoder(idl);
+
   const storedata = await connection.getAccountInfo(toPublicKey(storeAccount));
   if (!storedata) {
     throw new Error("no store data in print single");

package/tsconfig.json

@@ -1,12 +1,29 @@
 {
   "compilerOptions": {
-    "target": "es6",
+    "target": "es2020",
     "module": "commonjs",
+    "lib": ["es2020", "dom"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
     "strict": true,
+    "noImplicitAny": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "useUnknownInCatchVariables": true,
+    "alwaysStrict": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
     "esModuleInterop": true,
-    "outDir": "./dist",
-    "declaration": true
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
   },
-  "include": ["src"],
-  "exclude": ["node_modules"]
-}
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}