3land_sdk 1.0.0

package/src/library/implementation/storeImplementation.ts

@@ -0,0 +1,385 @@
+import { BN } from "bn.js";
+import { StoreConfig, SaleConfig, Store } from "../Store";
+import { Keypair, PublicKey, SendTransactionError } from "@solana/web3.js";
+import {
+  Creator,
+  CurrencyType,
+  FeeType,
+  PriceJSON,
+  PriceRule,
+  SaleConfigJSON,
+  SaleType,
+  ShortMetadataArgs,
+  ShortMetadataArgsJSON,
+  StoreConfigJSON,
+} from "../../types/types";
+import { Wallet } from "@project-serum/anchor";
+import * as fs2 from "fs";
+import { PROGRAM_CNFT, SOLANA_ENDPOINT } from "../../types/programId";
+import path from "path";
+import { arrayBuffer } from "stream/consumers";
+import { bs58 } from "@project-serum/anchor/dist/cjs/utils/bytes";
+import {
+  CreateCollectionOptions,
+  CreateSingleOptions,
+  CreateStoreParams,
+  StoreInitOptions,
+} from "../../types/implementation/implementationTypes";
+
+function initializeSDKAndWallet(options: StoreInitOptions) {
+  const sdk = new Store();
+  let walletKeypair: Keypair;
+
+  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 };
+}
+
+async function createStoreImp(
+  options: StoreInitOptions,
+  storeSetup: CreateStoreParams
+) {
+  const { sdk, walletKeypair, payer } = initializeSDKAndWallet(options);
+
+  try {
+    const storeConfig: StoreConfig = {
+      fee: new BN(1000000),
+      feePercentage: storeSetup.storeFee,
+      feeType: new FeeType.AllMints(),
+      trust: payer.publicKey,
+      rules: [],
+      toJSON: function (): StoreConfigJSON {
+        throw new Error("Function not implemented.");
+      },
+      toEncodable: function () {
+        throw new Error("Function not implemented.");
+      },
+    };
+
+    const createStoreTxId = await sdk.createStore(
+      walletKeypair,
+      storeSetup.storeName,
+      storeConfig
+    );
+
+    return {
+      transactionId: createStoreTxId,
+      payerPublicKey: payer.publicKey.toString(),
+    };
+  } catch (error) {
+    handleError(error);
+    throw error;
+  }
+}
+
+async function createCollectionTest(
+  options: StoreInitOptions,
+  collectionOpts: CreateCollectionOptions
+) {
+  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 = await sdk.createCollection(
+      walletKeypair,
+      collectionDetails,
+      metadata,
+      {
+        options: optionsCollection,
+      }
+    );
+    console.log("create collection tx: ", collectionTx);
+    return collectionTx;
+  } catch (error) {
+    handleError(error);
+  }
+}
+
+async function createSingleImp(
+  options: StoreInitOptions,
+  storeAccount: string,
+  collectionAccount: string,
+  createOptions: CreateSingleOptions
+) {
+  const { sdk, walletKeypair, payer } = initializeSDKAndWallet(options);
+
+  try {
+    const creator = new Creator({
+      address: payer.publicKey,
+      verified: false,
+      share: 100,
+    });
+
+    const metadata: ShortMetadataArgs = {
+      name: createOptions.itemName,
+      uri: "",
+      uriType: 1,
+      sellerFeeBasisPoints: createOptions.sellerFee,
+      collection: new PublicKey(collectionAccount),
+      creators: [creator],
+      toJSON: function (): ShortMetadataArgsJSON {
+        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) {
+      // Define the type for metadata files
+      interface MetadataFiles {
+        file: {
+          url: string;
+        };
+        cover?: {
+          url: string;
+        };
+      }
+
+      // Create base metadata files object
+      let baseMetadataFiles: MetadataFiles = {
+        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 = await 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 = await 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: SaleConfig = {
+      prices: [
+        {
+          amount: new BN(createOptions.price),
+          priceType: new CurrencyType.Native(),
+          toJSON: function (): PriceJSON {
+            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 (): SaleConfigJSON {
+        throw new Error("Function not implemented.");
+      },
+      toEncodable: function () {
+        throw new Error("Function not implemented.");
+      },
+    };
+
+    const createSingleEditionTxId = await 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;
+  }
+}
+
+async function buySingleImp(options: StoreInitOptions, item: string) {
+  const { sdk, walletKeypair, payer } = initializeSDKAndWallet(options);
+
+  try {
+    const owner = payer;
+
+    const buySingleEditionTxId = await 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: unknown) {
+  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, createSingleImp, buySingleImp, handleError };

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

@@ -0,0 +1,227 @@
+import {
+  Connection,
+  PublicKey,
+  SystemProgram,
+  TransactionInstruction,
+} 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: Connection;
+
+export async 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[]> {
+  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(data?.track?.currency || PROGRAM_ID);
+
+  const bubblegumSigner = toPublicKey(
+    "4ewWZC5gT6TGpm5LZNDs9wVonfUT2q5PP5sc9kVbwMAK"
+  );
+
+  const useGlobal = false;
+  const merkle = useGlobal
+    ? merkleOptions?.merkleTree
+    : endpoint.includes("mainnet")
+    ? toPublicKey(merkleOptions?.mainnet?.merkleTree)
+    : toPublicKey(merkleOptions?.devnet?.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] = await creatorAuthorityPDA({
+    creator: itemCreator,
+    store: storeAccount,
+  });
+
+  let [collectionAuthorityRecordPda] = await collectionAuthorityRecord({
+    mint: collectionMint,
+    new_authority: creatorAuthority,
+  });
+
+  const collectionMetadata = await getMetadataPDA(collectionMint);
+  const [editionAccount] = await 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 = await connection.getAccountInfo(
+      toPublicKey(globalStoreAccount)
+    );
+    if (!storedata) {
+      throw new Error("-- No Store data store bump");
+    }
+
+    const [_, storeBump] = await 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] = await itemAccountPDA({
+      creator: itemCreator,
+      store: storeAccount,
+      identifier: identifierdt,
+    });
+    data.itemBump = itemBump;
+  }
+
+  if (!data) data = {};
+  if (!data?.pre) data.pre = [];
+  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");
+  }
+  const store_decoded = coder.accounts.decode("Store", storedata.data);
+  const [_, storeBump] = await storePDA({ ...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/src/library/instructions/store/createSingleEdition.ts

@@ -0,0 +1,49 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { PROGRAM_ID } from "../../../types/programId";
+import {
+  MetadataArgs,
+  SaleConfig,
+  ShortMetadataArgs,
+} from "../../../types/types";
+import { createSingle } from "../../../types/instructions";
+import BN from "bn.js";
+
+export 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 {
+  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/src/library/instructions/store/createStore.ts

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