3land_sdk 1.0.0

package/src/utility/Connection.ts

@@ -0,0 +1,9 @@
+import { Connection, Keypair, PublicKey } from "@solana/web3.js";
+
+export function getConnection(endpoint: string): Connection {
+  return new Connection(endpoint);
+}
+
+export function createKeypairFromSecretKey(secretKey: Uint8Array): Keypair {
+  return Keypair.fromSecretKey(secretKey);
+}

package/src/utility/Holders.ts

@@ -0,0 +1,8 @@
+export const devnetHolder = {
+  creator: "7fmpv3iEP1EYVgbnbvfrv8r99hdqpvGAPmtkpqGXztAv",
+  slot: 26,
+};
+export const mainnetHolder = {
+  creator: "6xzPPWsWjV2bvAufWHJHdfNrNqgbeS46yVPPofEQuJPL",
+  slot: 69,
+};

package/src/utility/PdaManager.ts

@@ -0,0 +1,230 @@
+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 }: any) {
+  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 }: any) {
+  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 }: any) {
+  holder = toPublicKey(holder);
+  creator = toPublicKey(creator);
+  if (!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 }: any) {
+  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 }: any) {
+  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 }: any) {
+  item = toPublicKey(item);
+  return PublicKey.findProgramAddress(
+    [Buffer.from("item_reserve_list"), item.toBytes()],
+    toPublicKey(PROGRAM_ID)
+  );
+}
+
+export const toPublicKey = (key: string | PublicKey | boolean) => {
+  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 = async (mint: any) => {
+  const [publicKey] = await PublicKey.findProgramAddress(
+    [
+      Buffer.from("metadata"),
+      TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+      mint.toBuffer(),
+    ],
+    TOKEN_METADATA_PROGRAM_ID //PROGRAM_ID
+  );
+  return publicKey;
+};
+
+export const getEditionPDA = async (mint: any, full: any) => {
+  return await 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 = async ({
+  mint,
+  new_authority,
+}: any) => {
+  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 }: any) => {
+  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 = async ({ user, store }: any) => {
+  user = toPublicKey(user);
+
+  store = toPublicKey(store);
+  return PublicKey.findProgramAddress(
+    [Buffer.from("user_activity_tracking"), user.toBytes(), store.toBytes()],
+    toPublicKey(PROGRAM_ID)
+  );
+};
+
+export const collectorArtistRegistryPDA = async ({
+  user,
+  artist,
+  currency,
+  store,
+}: any) => {
+  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 }: any) => {
+  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 }: any) => {
+  owner = toPublicKey(owner);
+  itemAccount = toPublicKey(itemAccount);
+  return PublicKey.findProgramAddress(
+    [Buffer.from("buy_payment"), owner.toBytes(), itemAccount.toBytes()],
+    toPublicKey(PROGRAM_ID)
+  );
+};
+
+export const treeAuthority = ({ tree }: any) => {
+  tree = toPublicKey(tree);
+
+  return PublicKey.findProgramAddressSync(
+    [tree.toBuffer()],
+    toPublicKey(BUBBLEGUM_PROGRAM_ID)
+  );
+};
+
+export const getATAPDA = async ({ owner, mint }: any) => {
+  const [publicKey] = await PublicKey.findProgramAddress(
+    [
+      toPublicKey(owner).toBuffer(),
+      TOKEN_PROGRAM_ID.toBuffer(),
+      toPublicKey(mint).toBuffer(),
+    ],
+    SPL_ASSOCIATED_TOKEN_ACCOUNT_PROGRAM_ID
+  );
+  return publicKey;
+};

package/src/utility/config.ts

@@ -0,0 +1,32 @@
+import {
+  PROGRAM_CNFT,
+  TOKEN_METADATA_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+} from "../types/programId";
+
+export enum NetworkType {
+  DEVNET = "devnet",
+  MAINNET = "mainnet-beta",
+}
+
+export interface NetworkConfig {
+  endpoint: string;
+  programId: string;
+  tokenProgramId: string;
+  metadataProgramId: string;
+}
+
+export const NETWORK_CONFIGS: Record<NetworkType, NetworkConfig> = {
+  [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/src/utility/utils.ts

@@ -0,0 +1,191 @@
+import { PublicKey } from "@solana/web3.js";
+import { FileData } from "../library/instructions/store/uploadFilesIryis";
+
+export function bytesToU32(slice: any) {
+  let result = 0;
+  for (let i = slice.length - 1; i >= 0; i--) {
+    result = (result << 8) | slice[i];
+  }
+  return result >>> 0;
+}
+
+export const cyrb53 = (str: any, 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: any) => {
+  return new Promise((res) => {
+    setTimeout(res, t);
+  });
+};
+
+export const nowS = () => Date.now() / 1000;
+
+export const validateSolAddress = (address: any) => {
+  try {
+    let pubkey = new PublicKey(address);
+    return PublicKey.isOnCurve(pubkey.toBuffer());
+  } catch (error) {
+    return false;
+  }
+};
+
+export const checkFileType = (file: any) => {
+  return file?.type?.includes("video/webp")
+    ? "video/webp"
+    : file?.type?.includes("image/webp")
+    ? "image/webp"
+    : file?.type?.includes("jpeg") || file?.type?.includes("jpg")
+    ? "image/jpeg"
+    : file?.type?.includes("gif")
+    ? "image/gif"
+    : file?.type?.includes("png")
+    ? "image/png"
+    : file?.type?.includes("audio")
+    ? "audio"
+    : file?.type?.includes("mp4")
+    ? "video/mp4"
+    : file?.name?.includes("glb") || file?.type?.includes("model")
+    ? "model/gltf-binary"
+    : null;
+};
+
+export const checkCategory = (file: any) => {
+  return file?.type?.includes("image")
+    ? "image"
+    : file?.type?.includes("audio")
+    ? "audio"
+    : file?.type?.includes("video")
+    ? "video"
+    : file?.name?.includes("glb") || file?.type?.includes("model")
+    ? "vr"
+    : null;
+};
+
+export async function normalizeFileData(fileData: any): Promise<FileData> {
+  try {
+    const buffer = await (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: ArrayBuffer): string {
+  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: any): string | null {
+  if (!file) return null;
+
+  const type = file.type?.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: string): void {
+  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: any): string | null {
+  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: string): boolean {
+  return (
+    type?.includes("video/") ||
+    type?.includes("audio/") ||
+    type === "model/gltf-binary"
+  );
+}

package/src/utility/validation.ts

@@ -0,0 +1,229 @@
+import { PublicKey, Signer } from "@solana/web3.js";
+import { StoreConfig, SaleConfig, ShortMetadataArgs } from "../types/types";
+import { BN } from "bn.js";
+
+export class ValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ValidationError";
+  }
+}
+
+export function validateStoreConfig(config: StoreConfig) {
+  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: ShortMetadataArgs) {
+  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: SaleConfig) {
+  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: number) {
+  if (typeof supply !== "number" || supply < 0) {
+    throw new ValidationError("Supply must be a non-negative number");
+  }
+}
+
+export function validateIdentifier(identifier: number) {
+  if (typeof identifier !== "number" || identifier < 0) {
+    throw new ValidationError("Identifier must be a non-negative number");
+  }
+}
+
+export function validateCollectionArgs(
+  collectionDetails: any,
+  supply: number,
+  metadata: any,
+  irysData: any
+) {
+  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: number, creator: any) => 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: Signer,
+  packAccount: PublicKey,
+  burnProgress: PublicKey,
+  owner: PublicKey,
+  distributionBumps: number[],
+  globalStoreAccount: PublicKey,
+  extraAccounts: any[],
+  collectionAddress?: PublicKey,
+  storeAccount?: PublicKey,
+  creator?: PublicKey
+) {
+  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/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true,
+    "outDir": "./dist",
+    "declaration": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules"]
+}