3land_sdk 1.0.1 → 1.0.2

package/dist/cjs/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/index.js

@@ -0,0 +1,74 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const storeImplementation_1 = require("./library/implementation/storeImplementation");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        //   const options: StoreInitOptions = {
+        //     walletPath: "", //route to keypair.json generated from the solana cli
+        //   };
+        const optionsWithBase58 = {
+            privateKey: "2ixmpz6W9aAE7HDqCJYy1tsqQcAHhkuP54jTPGnTyqvYHJearwT16DzmkkaQLARB9TshZvoS3WE5dQg183wryVCC", //your private key
+        };
+        const storeSetup = {
+            storeName: "Super cool store",
+            storeFee: 5,
+        };
+        const collectionOpts = {
+            collectionName: "Super awesome Collection",
+            collectionSymbol: "SAC",
+            collectionDescription: "This is a collection for the cool guys",
+        };
+        const createItemOptions = {
+            itemName: "supercoolitem7",
+            sellerFee: 500,
+            itemSymbol: "SCI7",
+            itemDescription: "implementing link imgs",
+            traits: [
+                { trait_type: "type", value: "cool" },
+                { trait_type: "creator", value: "me" },
+            ],
+            price: 100000000, //100000000 == 0.1 sol
+            mainImageUrl: "https://arweave.net/FMkKYYsheEImBfejYaPPoJbI3CxJxunwvErD9VYzxOY?ext=jpeg",
+        };
+        try {
+            //image url: https://arweave.net/FMkKYYsheEImBfejYaPPoJbI3CxJxunwvErD9VYzxOY?ext=jpeg
+            //image aI:  https://oaidalleapiprodscus.blob.core.windows.net/private/org-gqKriRsgW5z3sjYXrQv0vXPk/user-dhUswyb2oCg8NHc1yhPldLys/img-vX5am1Oagbimd9uSWnrSlUPb.png?st=2024-12-29T02%3A12%3A51Z&se=2024-12-29T04%3A12%3A51Z&sp=r&sv=2024-08-04&sr=b&rscd=inline&rsct=image/png&skoid=d505667d-d6c1-4a0a-bac7-5c84a87759f8&sktid=a48cca56-e6da-484e-a814-9c849652bcb3&skt=2024-12-28T21%3A04%3A53Z&ske=2024-12-29T21%3A04%3A53Z&sks=b&skv=2024-08-04&sig=ltGieu7AXXJUhIF7hyTPXmnnFVKTu5BwmifIB3kLqAY%3D
+            // Create store
+            //const storeResult = await createStoreTest(optionsWithBase58, storeSetup);
+            //console.log("Store created. Transaction ID:", storeResult.transactionId);
+            const landStoreMainnet = "AmQNs2kgw4LvS9sm6yE9JJ4Hs3JpVu65eyx9pxMG2xA";
+            const landStoreDevnet = "GyPCu89S63P9NcCQAtuSJesiefhhgpGWrNVJs4bF2cSK";
+            // Create Collection
+            // const collection = await createCollectionImp(
+            //   optionsWithBase58,
+            //   collectionOpts
+            // );
+            // console.log("collection mint: ", collection);
+            // Create single edition
+            // const storeAccount = "3MwBR619SgJ35ek7vDLxxE5QvBaNq1fmmEZSXKW2X3Lf"; //"P1c4bboejX24NbY3vMw8EncKVmvcGEryznWLs4PGp9j"; //current store created for testing
+            const collectionAccount = "Fpm8XgXEuNxxjmqUQuqEFkGusiSsKM6astUGPs5U9x6v"; //"2rQq34FJG1613i7H8cDfxuGCtEjJmFAUNbAPJqK699oD";
+            const singleEditionResult = yield (0, storeImplementation_1.createSingleImp)(optionsWithBase58, landStoreDevnet, collectionAccount, createItemOptions);
+            console.log("Single edition created. Transaction ID:", singleEditionResult.transactionId);
+            // Buy single edition
+            // const itemAccount = "8iUHPXuZWQdSGTV9X8hPdUgxSLfdXX7YjZYMck2TALBc"; //"7BhKXmc5obiwn5hhrUhErVBrAT7TErYcTpRYE8ggfjKV"; //current item created for testing
+            // const buyResult = await buySingleTest(options, itemAccount);
+            // console.log(
+            //   "Single edition purchased. Transaction ID:",
+            //   buyResult.transactionId
+            // );
+        }
+        catch (error) {
+            (0, storeImplementation_1.handleError)(error);
+        }
+    });
+}
+main();

package/dist/cjs/library/Irys/irys.d.ts

@@ -0,0 +1,76 @@
+import { Keypair, PublicKey } from "@solana/web3.js";
+interface IrysTransaction {
+    upload(): Promise<any>;
+}
+interface IrysFile {
+    type: string;
+    name: string;
+    nonce?: string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    is_metadata?: boolean;
+    status?: string;
+    arweave?: string;
+    data?: any;
+    payload?: boolean;
+    transaction?: string | IrysTransaction;
+    irys?: {
+        id: string;
+        size: number;
+        url: string;
+        extension: string | null;
+        nonce: string;
+        transaction: IrysTransaction;
+        irys_wallet: string;
+        price: number;
+        slippage_fee: number;
+    };
+}
+export interface UploadOptions {
+    uuid: string;
+    signature: any;
+}
+interface RegisterOptions {
+    files: IrysFile[];
+    uuid: string;
+}
+interface FundingInstructionsOptions {
+    files: any;
+    payer: string | PublicKey | boolean;
+}
+export declare class IrysHelper {
+    private irys;
+    private wallet;
+    private owner;
+    private files_bridge;
+    constructor();
+    private ensureInitialized;
+    verifyBalance(id: any): Promise<any>;
+    getBalance(): Promise<import("bignumber.js").BigNumber>;
+    bundle(file: IrysFile, is_metadata?: boolean): Promise<IrysFile>;
+    getFileExtension(file: IrysFile): string | null;
+    private parseTransaction;
+    getFundingInstructions({ files, payer }: FundingInstructionsOptions): Promise<{
+        instructions: import("@solana/web3.js").TransactionInstruction[];
+        bytes: number;
+        price: any;
+    } | undefined>;
+    generateWallet(): Promise<Keypair>;
+    getWallet(): Promise<Keypair>;
+    private arweaveToID;
+    uploadFiles({ uuid, signature }: UploadOptions): Promise<{
+        errors: string[];
+        succeeds: string[];
+    }>;
+    clean(): Promise<void>;
+    registerFiles({ files, uuid }: RegisterOptions): Promise<number>;
+    sync(address: string): Promise<boolean>;
+    init(address: string, options: {
+        arweave_rpc?: string;
+        rpc?: string;
+    }): Promise<boolean>;
+}
+export declare const init: (address: string, options: {
+    arweave_rpc?: string;
+    rpc?: string;
+}) => Promise<IrysHelper | null>;
+export {};

package/dist/cjs/library/Irys/irys.js

@@ -0,0 +1,347 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = exports.IrysHelper = void 0;
+const sdk_1 = require("@irys/sdk");
+const utils_1 = require("../../utility/utils");
+const PdaManager_1 = require("../../utility/PdaManager");
+const crypto_1 = __importDefault(require("crypto"));
+const web3_js_1 = require("@solana/web3.js");
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+class IrysHelper {
+    constructor() {
+        this.files_bridge = {};
+    }
+    // private irys?: WebIrys;
+    // private wallet?: Keypair;
+    // private owner?: string;
+    ensureInitialized() {
+        if (!this.irys || !this.wallet || !this.owner) {
+            throw new Error("IrysHelper not properly initialized. Call init() first.");
+        }
+    }
+    // async verifyBalance(id: any): Promise<boolean> {
+    //   this.ensureInitialized();
+    //   try {
+    //     const fundtx = await this.irys.fund(id);
+    //     return !!fundtx;
+    //   } catch (e) {
+    //     console.log("CANNOT VERIFY FUND", e);
+    //   }
+    //   return false;
+    // }
+    // async getBalance(): Promise<any> {
+    //   this.ensureInitialized();
+    //   return this.irys.getLoadedBalance();
+    // }
+    verifyBalance(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const submited = yield this.irys.funder.submitTransaction(id);
+                return submited;
+            }
+            catch (e) {
+                console.log("CANNOT VERIFY FUND", e);
+            }
+            return false;
+        });
+    }
+    getBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.irys.getLoadedBalance();
+        });
+    }
+    bundle(file_1) {
+        return __awaiter(this, arguments, void 0, function* (file, is_metadata = false) {
+            console.log("BUNDLE: ", file);
+            console.log("BUNDLE method: ", file.arrayBuffer());
+            this.ensureInitialized();
+            try {
+                const { type, name } = file;
+                const nonce = file.nonce || crypto_1.default.randomBytes(32).toString("base64").slice(0, 32);
+                const tags = [{ name: "Content-Type", value: type }];
+                const irys_wallet = this.irys.address;
+                const arrayBuffer = yield file.arrayBuffer();
+                console.log("main image buffer 2: ", arrayBuffer);
+                const buffer = Buffer.from(arrayBuffer);
+                console.log("main image buffer 3: ", arrayBuffer);
+                let transaction = this.irys.createTransaction(buffer, {
+                    anchor: nonce,
+                    tags,
+                });
+                console.log("TRANSACTION: ", transaction);
+                const { size } = transaction;
+                const price = yield this.irys.getPrice(transaction.size);
+                const slippage_fee = Math.round(price.div(6).toNumber());
+                yield transaction.sign();
+                const extension = this.getFileExtension(file);
+                const id = transaction === null || transaction === void 0 ? void 0 : transaction.id;
+                if (!id)
+                    throw "No id";
+                const url = "https://arweave.net/" +
+                    id +
+                    (extension && !file.is_metadata && !is_metadata
+                        ? "?ext=" + extension
+                        : "");
+                file.payload = false;
+                file.irys = {
+                    id,
+                    size,
+                    url,
+                    extension,
+                    nonce,
+                    transaction,
+                    irys_wallet,
+                    price: price.toNumber(),
+                    slippage_fee,
+                };
+                return file;
+            }
+            catch (e) {
+                console.log("ERRORE", e);
+                throw new Error("error in bundle Irys");
+            }
+        });
+    }
+    getFileExtension(file) {
+        if (!file) {
+            return null;
+        }
+        // Try to get extension from filename
+        if (file.name) {
+            const parts = file.name.split(".");
+            if (parts.length > 1) {
+                const extension = parts.pop(); // Get last part
+                if (extension) {
+                    return extension;
+                }
+            }
+        }
+        // Fallback to MIME type
+        if (file.type) {
+            const parts = file.type.split("/");
+            if (parts.length > 1) {
+                return parts[1];
+            }
+        }
+        return null;
+    }
+    parseTransaction(transactionStr) {
+        try {
+            const parsed = JSON.parse(transactionStr);
+            return Array.isArray(parsed) ? parsed[0] : null;
+        }
+        catch (e) {
+            console.log("Error parsing transaction:", e);
+            return null;
+        }
+    }
+    getFundingInstructions(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ files, payer }) {
+            this.ensureInitialized();
+            if (!payer)
+                payer = this.owner;
+            let bytes = 0;
+            let price = false;
+            if (!files)
+                return;
+            for (const file of files) {
+                if (!file.irys) {
+                    throw new Error("File not properly bundled");
+                }
+                const files_price = yield this.irys.getPrice(file.irys.size);
+                if (!price) {
+                    price = files_price;
+                }
+                else {
+                    price = price.plus(files_price);
+                }
+                bytes += file.irys.size;
+                file.irys.price = price.toNumber();
+            }
+            const irys_address = yield this.irys.utils.getBundlerAddress("solana");
+            const slippage_fee = Math.round(price.div(6).toNumber());
+            price = price.plus(slippage_fee);
+            const from_user_to_manager = web3_js_1.SystemProgram.transfer({
+                fromPubkey: (0, PdaManager_1.toPublicKey)(payer),
+                toPubkey: this.wallet.publicKey,
+                lamports: price,
+            });
+            const from_manager_to_irys = web3_js_1.SystemProgram.transfer({
+                fromPubkey: this.wallet.publicKey,
+                toPubkey: (0, PdaManager_1.toPublicKey)(irys_address),
+                lamports: price,
+            });
+            return {
+                instructions: [from_user_to_manager, from_manager_to_irys],
+                bytes,
+                price: price.toNumber(),
+            };
+        });
+    }
+    generateWallet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return web3_js_1.Keypair.generate();
+        });
+    }
+    getWallet() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.wallet;
+        });
+    }
+    arweaveToID(x) {
+        return "irys-preupload-" + x;
+    }
+    uploadFiles(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ uuid, signature }) {
+            this.ensureInitialized();
+            yield this.irys.ready();
+            const files = [];
+            for (const file in this.files_bridge) {
+                files.push(this.files_bridge[file]);
+            }
+            yield this.verifyBalance(signature);
+            const errors = [];
+            const succeeds = [];
+            for (const _file of files) {
+                if (!_file.irys) {
+                    continue;
+                }
+                if (_file.status == "uploaded" && _file.arweave) {
+                    succeeds.push(_file.arweave);
+                    continue;
+                }
+                const blob = this.files_bridge[this.arweaveToID(_file.irys.id)];
+                if (!blob) {
+                    errors.push(_file.irys.id);
+                    continue;
+                }
+                blob.nonce = _file.irys.nonce;
+                const bundled = yield this.bundle(blob);
+                if (!bundled || !bundled.irys || bundled.irys.id != _file.irys.id) {
+                    errors.push(_file.irys.id);
+                    continue;
+                }
+                try {
+                    const subida = yield bundled.irys.transaction.upload();
+                    if (subida) {
+                        succeeds.push(bundled.irys.id);
+                    }
+                    else {
+                        throw "";
+                    }
+                }
+                catch (e) {
+                    const error = e + "";
+                    if (error.includes("already received")) {
+                        succeeds.push(bundled.irys.id);
+                    }
+                    else {
+                        errors.push(_file.irys.id);
+                    }
+                }
+                yield (0, utils_1.sleep)(100);
+            }
+            const balance = yield this.getBalance();
+            return { errors, succeeds };
+        });
+    }
+    clean() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    registerFiles(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ files, uuid }) {
+            this.ensureInitialized();
+            const owner = this.owner;
+            this.files_bridge = {};
+            for (const [index, _file] of files.entries()) {
+                if (!_file.irys) {
+                    continue;
+                }
+                const arweave = _file.irys.id;
+                const data = {
+                    type: _file.type,
+                    nonce: _file.irys.nonce,
+                    size: _file.irys.size,
+                    fee_at_submit: _file.irys.price,
+                    slippage_fee: _file.irys.slippage_fee,
+                };
+                const tosave = {
+                    owner,
+                    arweave,
+                    uuid,
+                    status: "waiting",
+                    date: (0, utils_1.nowS)(),
+                    data,
+                    payload: _file.payload,
+                };
+                this.files_bridge[this.arweaveToID(arweave)] = _file;
+            }
+            return files.length;
+        });
+    }
+    sync(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.owner != address) {
+                return true;
+            }
+            return true;
+        });
+    }
+    init(address, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const irys_network = (options === null || options === void 0 ? void 0 : options.arweave_rpc) || "https://arweave.devnet.irys.xyz";
+            const rpc = (options === null || options === void 0 ? void 0 : options.rpc) || "https://api.devnet.solana.com";
+            const wallet = yield this.generateWallet();
+            if (!wallet)
+                return false;
+            this.wallet = wallet;
+            const provider = {
+                publicKey: wallet.publicKey,
+                signMessage: (message) => __awaiter(this, void 0, void 0, function* () {
+                    return tweetnacl_1.default.sign.detached(message, this.wallet.secretKey);
+                }),
+            };
+            this.owner = address;
+            this.irys = new sdk_1.NodeIrys({
+                // url: irys_network,
+                token: "solana",
+                key: wallet.secretKey,
+                network: "devnet",
+                config: { providerUrl: irys_network },
+                // wallet: { rpcUrl: rpc, provider },
+            });
+            yield this.irys.ready();
+            const to = yield this.irys.utils.getBundlerAddress("solana");
+            const bal = yield this.getBalance();
+            return true;
+        });
+    }
+}
+exports.IrysHelper = IrysHelper;
+let global = null;
+const init = (address, options) => __awaiter(void 0, void 0, void 0, function* () {
+    if (global) {
+        const g = yield global.sync(address);
+        if (!g)
+            global = null;
+        return global;
+    }
+    global = new IrysHelper();
+    const g = yield global.init(address, options);
+    if (!g)
+        global = null;
+    return global;
+});
+exports.init = init;

package/dist/cjs/library/Store.d.ts

@@ -0,0 +1,18 @@
+import { PublicKey, Signer } from "@solana/web3.js";
+import { StoreConfig, MetadataArgs, SaleConfig, ShortMetadataArgs } from "../types/types";
+import { NetworkType, NetworkConfig } from "../utility/config";
+export interface StoreOptions {
+    network?: NetworkType;
+    customEndpoint?: string;
+    customConfig?: Partial<NetworkConfig>;
+}
+export declare class Store {
+    private connection;
+    private networkConfig;
+    constructor(options?: StoreOptions);
+    createStore(payer: Signer, name: string, storeConfig: StoreConfig, creator?: PublicKey, storeId?: number): Promise<string>;
+    createCollection(payer: Signer, collectionDetails: any, metadata: any, irysData: any, mutable?: Boolean, supply?: number): Promise<string>;
+    createSingleEdition(payer: Signer, storeAccount: PublicKey, supply: number, metadata: ShortMetadataArgs, saleConfig: SaleConfig, category: number[], superCategory: number[], eventCategory: number, hashTraits: number, collection: PublicKey, irysData: any): Promise<string>;
+    buySingleEdition(payer: Signer, distributionBumps: number[], itemAddress: PublicKey, extraAccounts?: any[], globalStoreAccount?: PublicKey, packAccount?: PublicKey, burnProgress?: PublicKey, poolVault?: PublicKey): Promise<string>;
+}
+export { StoreConfig, MetadataArgs, SaleConfig };