@dignetwork/dig-sdk 0.0.1-alpha.99 → 0.1.0

package/dist/blockchain/DataStore.js

@@ -1,413 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataStore = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const datalayer_driver_1 = require("@dignetwork/datalayer-driver");
-const util_1 = require("util");
-const FullNodePeer_1 = require("./FullNodePeer");
-const Wallet_1 = require("./Wallet");
-const config_1 = require("../utils/config");
-const coins_1 = require("./coins");
-const colorette_1 = require("colorette");
-const hashUtils_1 = require("../utils/hashUtils");
-const DataIntegrityTree_1 = require("../DataIntegrityTree");
-const prompts_1 = require("../prompts");
-const FileCache_1 = require("../utils/FileCache");
-const DataStoreSerializer_1 = require("./DataStoreSerializer");
-const node_cache_1 = __importDefault(require("node-cache"));
-const config_2 = require("../utils/config");
-// Initialize the cache with a TTL of 180 seconds (3 minutes)
-const rootHistoryCache = new node_cache_1.default({ stdTTL: 180 });
-const stat = (0, util_1.promisify)(fs_1.default.stat);
-const readdir = (0, util_1.promisify)(fs_1.default.readdir);
-class DataStore {
-    constructor(storeId, options) {
-        this.storeId = storeId;
-        let _options;
-        if (options) {
-            _options = options;
-        }
-        else {
-            _options = {
-                storageMode: "local",
-                storeDir: config_1.STORE_PATH,
-            };
-        }
-        this.tree = new DataIntegrityTree_1.DataIntegrityTree(storeId, _options);
-    }
-    get StoreId() {
-        return this.storeId;
-    }
-    get Tree() {
-        return this.tree;
-    }
-    toBuffer() {
-        return Buffer.from(this.storeId, "hex");
-    }
-    toString() {
-        return this.storeId;
-    }
-    serialize() {
-        return JSON.stringify({
-            storeId: this.storeId,
-        });
-    }
-    static async getActiveStore() {
-        const storeId = await (0, config_1.getActiveStoreId)();
-        if (storeId) {
-            return DataStore.from(storeId.toString("hex"));
-        }
-    }
-    static deserialize(serialized) {
-        const parsed = JSON.parse(serialized);
-        return new DataStore(parsed.storeId);
-    }
-    static from(storeId, rootHash) {
-        const existingTreeOptions = {
-            storageMode: "local",
-            storeDir: config_1.STORE_PATH,
-            disableInitialize: true,
-        };
-        if (rootHash) {
-            existingTreeOptions.rootHash = rootHash;
-        }
-        if (storeId instanceof Buffer) {
-            return new DataStore(storeId.toString("hex"), existingTreeOptions);
-        }
-        return new DataStore(storeId, existingTreeOptions);
-    }
-    static async create(inputs = {}) {
-        const finalInputs = await (0, prompts_1.askForStoreDetails)(inputs);
-        try {
-            const peer = await FullNodePeer_1.FullNodePeer.connect();
-            const height = await peer.getPeak();
-            if (!height) {
-                throw new Error("Failed to get peak height");
-            }
-            const hash = await peer.getHeaderHash(height);
-            const newStoreCoin = await this.mint(finalInputs.label, finalInputs.description, BigInt(0), finalInputs.authorizedWriter);
-            console.log("Store submitted to mempool");
-            console.log(`Store ID: ${newStoreCoin.launcherId.toString("hex")}`);
-            try {
-                console.log(`Coin ID: ${(0, datalayer_driver_1.getCoinId)(newStoreCoin.coin).toString("hex")}`);
-                await FullNodePeer_1.FullNodePeer.waitForConfirmation(newStoreCoin.coin.parentCoinInfo);
-            }
-            catch (error) {
-                console.error(error.message);
-            }
-            const dataStore = new DataStore(newStoreCoin.launcherId.toString("hex"));
-            await dataStore.setCreationHeight(height, hash);
-            return dataStore;
-        }
-        catch (error) {
-            console.error("Failed to mint Data Layer Store:", error);
-            throw error;
-        }
-    }
-    static async mint(label, description, sizeInBytes, authorizedWriterPublicSyntheticKey, adminPublicSyntheticKey) {
-        try {
-            const peer = await FullNodePeer_1.FullNodePeer.connect();
-            const wallet = await Wallet_1.Wallet.load("default");
-            const publicSyntheticKey = await wallet.getPublicSyntheticKey();
-            const ownerSyntheicPuzzleHash = (0, datalayer_driver_1.syntheticKeyToPuzzleHash)(publicSyntheticKey);
-            const storeCreationCoins = await (0, coins_1.selectUnspentCoins)(peer, BigInt(1), BigInt(0));
-            const delegationLayers = [];
-            if (adminPublicSyntheticKey) {
-                delegationLayers.push((0, datalayer_driver_1.adminDelegatedPuzzleFromKey)(Buffer.from(adminPublicSyntheticKey, "hex")));
-            }
-            if (authorizedWriterPublicSyntheticKey) {
-                delegationLayers.push((0, datalayer_driver_1.writerDelegatedPuzzleFromKey)(Buffer.from(authorizedWriterPublicSyntheticKey, "hex")));
-            }
-            delegationLayers.push((0, datalayer_driver_1.oracleDelegatedPuzzle)(ownerSyntheicPuzzleHash, BigInt(100000)));
-            const rootHash = Buffer.from("0000000000000000000000000000000000000000000000000000000000000000", "hex");
-            const mintStoreParams = [
-                publicSyntheticKey,
-                storeCreationCoins,
-                rootHash,
-                label || undefined,
-                description || undefined,
-                sizeInBytes || BigInt(0),
-                ownerSyntheicPuzzleHash,
-                delegationLayers,
-            ];
-            const { coinSpends: preflightCoinSpends } = await (0, datalayer_driver_1.mintStore)(
-            // @ts-ignore
-            ...mintStoreParams, 
-            // @ts-ignore
-            BigInt(0));
-            const fee = await (0, coins_1.calculateFeeForCoinSpends)(peer, preflightCoinSpends);
-            const storeCreationResponse = await datalayer_driver_1.mintStore.apply(null, [
-                // @ts-ignore
-                ...mintStoreParams,
-                // @ts-ignore
-                fee,
-            ]);
-            const sig = (0, datalayer_driver_1.signCoinSpends)(storeCreationResponse.coinSpends, [await wallet.getPrivateSyntheticKey()], false);
-            const err = await peer.broadcastSpend(storeCreationResponse.coinSpends, [sig]);
-            if (err) {
-                throw new Error(err);
-            }
-            await new Promise((resolve) => setTimeout(resolve, 5000));
-            return storeCreationResponse.newStore;
-        }
-        catch (error) {
-            console.error("Unable to mint store");
-            throw error;
-        }
-    }
-    /**
-     * Instance method to calculate the disk space used by the store/storeId folder.
-     * @returns {Promise<number>} - The total disk space used by the store in bytes.
-     */
-    async getDiskSpace() {
-        const storePath = path_1.default.join(config_1.STORE_PATH, this.storeId);
-        return await DataStore.calculateFolderSize(storePath);
-    }
-    /**
-     * Static method to calculate the total disk space used by all stores in the store folder.
-     * @returns {Promise<number>} - The total disk space used by the store folder in bytes.
-     */
-    static async getTotalDiskSpace() {
-        return await DataStore.calculateFolderSize(config_1.STORE_PATH);
-    }
-    /**
-     * Helper method to calculate the size of a folder and its subfolders recursively.
-     * @param folderPath - The path of the folder to calculate the size of.
-     * @returns {Promise<number>} - The total size of the folder in bytes.
-     */
-    static async calculateFolderSize(folderPath) {
-        let totalSize = BigInt(0);
-        const files = await readdir(folderPath);
-        for (const file of files) {
-            const filePath = path_1.default.join(folderPath, file);
-            const fileStat = await stat(filePath);
-            if (fileStat.isDirectory()) {
-                totalSize += await this.calculateFolderSize(filePath); // Recursive call for subdirectories
-            }
-            else {
-                totalSize += BigInt(fileStat.size); // Add file size to total
-            }
-        }
-        return totalSize;
-    }
-    static getAllStores() {
-        const storeFolders = fs_1.default.readdirSync(config_1.STORE_PATH);
-        const storIds = storeFolders.filter((folder) => /^[a-f0-9]{64}$/.test(folder) &&
-            fs_1.default.lstatSync(path_1.default.join(config_1.STORE_PATH, folder)).isDirectory());
-        return storIds.map((storeId) => DataStore.from(storeId));
-    }
-    async fetchCoinInfo() {
-        try {
-            // Initialize the cache for the current storeId's coin info
-            const storeCoinCache = new FileCache_1.FileCache(`stores`);
-            // Try to get cached store info
-            const cachedInfo = storeCoinCache.get(this.storeId);
-            if (cachedInfo) {
-                try {
-                    const { latestStore: serializedStore, latestHeight: previousHeight, latestHash: previousHash, } = cachedInfo;
-                    // Deserialize the stored data using DataStoreSerializer
-                    const { latestStore: previousInfo } = DataStoreSerializer_1.DataStoreSerializer.deserialize({
-                        latestStore: serializedStore,
-                        latestHeight: previousHeight.toString(),
-                        latestHash: previousHash,
-                    });
-                    // Sync with peer if necessary
-                    const peer = await FullNodePeer_1.FullNodePeer.connect();
-                    const { latestStore, latestHeight } = await peer.syncStore(previousInfo, previousHeight, Buffer.from(previousHash, "hex"), false);
-                    const latestHash = await peer.getHeaderHash(latestHeight);
-                    // Serialize the store data for caching
-                    const serializedLatestStore = new DataStoreSerializer_1.DataStoreSerializer(latestStore, latestHeight, latestHash).serialize();
-                    // Cache updated store info
-                    storeCoinCache.set(this.storeId, {
-                        latestStore: serializedLatestStore,
-                        latestHeight,
-                        latestHash: latestHash.toString("hex"),
-                    });
-                    return { latestStore, latestHeight, latestHash };
-                }
-                catch {
-                    // Return cached info if sync fails
-                    const { latestStore, latestHeight, latestHash } = DataStoreSerializer_1.DataStoreSerializer.deserialize({
-                        latestStore: cachedInfo.latestStore,
-                        latestHeight: cachedInfo.latestHeight.toString(),
-                        latestHash: cachedInfo.latestHash,
-                    });
-                    return {
-                        latestStore,
-                        latestHeight,
-                        latestHash: latestHash,
-                    };
-                }
-            }
-            // Use getCreationHeight to retrieve height and hash information
-            const { createdAtHeight, createdAtHash } = await this.getCreationHeight();
-            // Sync store from peer
-            const peer = await FullNodePeer_1.FullNodePeer.connect();
-            const { latestStore, latestHeight } = await peer.syncStoreFromLauncherId(Buffer.from(this.storeId, "hex"), createdAtHeight, createdAtHash, false);
-            const latestHash = await peer.getHeaderHash(latestHeight);
-            // Serialize the latest store info for caching
-            const serializedLatestStore = new DataStoreSerializer_1.DataStoreSerializer(latestStore, latestHeight, latestHash).serialize();
-            // Cache the latest store info
-            storeCoinCache.set(this.storeId, {
-                latestStore: serializedLatestStore,
-                latestHeight,
-                latestHash: latestHash.toString("hex"),
-            });
-            return { latestStore, latestHeight, latestHash };
-        }
-        catch (error) {
-            console.trace("Failed to fetch coin info", error);
-            throw error;
-        }
-    }
-    async cacheStoreCreationHeight() {
-        const peer = await FullNodePeer_1.FullNodePeer.connect();
-        const createdAtHeight = await peer.getStoreCreationHeight(Buffer.from(this.storeId, "hex"), null, Buffer.from(config_2.MAIN_NET_GENISES_CHALLENGE, "hex"));
-        // Get just before created at height so we can find the coin
-        const justBeforeCreatedAtHeight = Number(createdAtHeight) - 1;
-        const createdAtHash = await peer.getHeaderHash(justBeforeCreatedAtHeight);
-        await this.setCreationHeight(justBeforeCreatedAtHeight, createdAtHash);
-        return { createdAtHeight: justBeforeCreatedAtHeight, createdAtHash };
-    }
-    async getCreationHeight() {
-        // Initialize the FileCache for the height file
-        const fileCache = new FileCache_1.FileCache(`stores/${this.storeId}`);
-        // Try to retrieve the cached height information
-        const cachedHeightInfo = fileCache.get("height");
-        if (!cachedHeightInfo) {
-            // If no cache, regenerate the cache
-            return this.cacheStoreCreationHeight();
-        }
-        // Parse the cached height and hash values
-        const { height, hash } = cachedHeightInfo;
-        const defaultHeight = config_1.MIN_HEIGHT;
-        const defaultHash = Buffer.from(config_1.MIN_HEIGHT_HEADER_HASH, "hex");
-        return {
-            createdAtHeight: height || defaultHeight,
-            createdAtHash: hash ? Buffer.from(hash, "hex") : defaultHash,
-        };
-    }
-    async setCreationHeight(height, hash) {
-        const fileCache = new FileCache_1.FileCache(`stores/${this.storeId}`);
-        // Cache the height and hash information
-        fileCache.set("height", {
-            height,
-            hash: hash.toString("hex"),
-        });
-    }
-    async getRootHistory(bustCache) {
-        if (bustCache) {
-            rootHistoryCache.del(this.storeId);
-        }
-        // Check if the root history is cached for this storeId
-        const cachedHistory = rootHistoryCache.get(this.storeId);
-        if (cachedHistory) {
-            return cachedHistory;
-        }
-        // Fetch root history from peer if not cached
-        const peer = await FullNodePeer_1.FullNodePeer.connect();
-        const { createdAtHeight, createdAtHash } = await this.getCreationHeight();
-        const { rootHashes, rootHashesTimestamps } = await peer.syncStoreFromLauncherId(Buffer.from(this.storeId, "hex"), createdAtHeight, createdAtHash, true);
-        if (!rootHashes) {
-            return [];
-        }
-        // Build the root history list
-        const rootHistory = rootHashes.map((rootHash, index) => ({
-            root_hash: rootHash.toString("hex"),
-            timestamp: Number(rootHashesTimestamps?.[index].toString()),
-            synced: fs_1.default.existsSync(path_1.default.join(config_1.STORE_PATH, this.storeId, `${rootHash.toString("hex")}.dat`)),
-        }));
-        // Store the root history in the cache
-        rootHistoryCache.set(this.storeId, rootHistory);
-        return rootHistory;
-    }
-    // Generates a fresh manifest file based on the current root history
-    // and what is currently on disk
-    async generateManifestFile(folderPath) {
-        if (!folderPath) {
-            folderPath = path_1.default.join(config_1.STORE_PATH, this.storeId, "data");
-        }
-        const rootHistory = await this.getRootHistory();
-        // Need this for the dataintegrity tree to work properly
-        fs_1.default.writeFileSync(path_1.default.join(folderPath, "manifest.dat"), rootHistory
-            .filter((root) => root.synced)
-            .map((root) => root.root_hash)
-            .join("\n"));
-    }
-    async getMetaData() {
-        const { latestStore } = await this.fetchCoinInfo();
-        return latestStore.metadata;
-    }
-    async isSynced() {
-        const dataStore = await DataStore.from(this.storeId);
-        const rootHistory = await dataStore.getRootHistory();
-        return !rootHistory.some((root) => !root.synced);
-    }
-    async hasMetaWritePermissions(publicSyntheticKey) {
-        const wallet = await Wallet_1.Wallet.load("default");
-        const { latestStore } = await this.fetchCoinInfo();
-        let ownerPuzzleHash = publicSyntheticKey
-            ? (0, datalayer_driver_1.syntheticKeyToPuzzleHash)(publicSyntheticKey)
-            : await wallet.getOwnerPuzzleHash();
-        const isStoreOwner = latestStore.ownerPuzzleHash.equals(ownerPuzzleHash);
-        const hasWriteAccess = latestStore.delegatedPuzzles.some((puzzle) => puzzle.adminInnerPuzzleHash?.equals(ownerPuzzleHash) ||
-            puzzle.writerInnerPuzzleHash?.equals(ownerPuzzleHash));
-        return isStoreOwner || hasWriteAccess;
-    }
-    async updateMetadata(metadata) {
-        const peer = await FullNodePeer_1.FullNodePeer.connect();
-        const wallet = await Wallet_1.Wallet.load("default");
-        const publicSyntheticKey = await wallet.getPublicSyntheticKey();
-        const { latestStore } = await this.fetchCoinInfo();
-        const updateStoreResponse = (0, datalayer_driver_1.updateStoreMetadata)(latestStore, metadata.rootHash, metadata.label, metadata.description, metadata.bytes, publicSyntheticKey, null, null);
-        const fee = await (0, coins_1.calculateFeeForCoinSpends)(peer, null);
-        const unspentCoins = await (0, coins_1.selectUnspentCoins)(peer, BigInt(0), fee);
-        const feeCoinSpends = await (0, datalayer_driver_1.addFee)(publicSyntheticKey, unspentCoins, updateStoreResponse.coinSpends.map((coinSpend) => (0, datalayer_driver_1.getCoinId)(coinSpend.coin)), fee);
-        const combinedCoinSpends = [
-            ...updateStoreResponse.coinSpends,
-            ...feeCoinSpends,
-        ];
-        const sig = (0, datalayer_driver_1.signCoinSpends)(combinedCoinSpends, [await wallet.getPrivateSyntheticKey()], false);
-        const err = await peer.broadcastSpend(combinedCoinSpends, [sig]);
-        if (err) {
-            throw new Error(err);
-        }
-        return updateStoreResponse.newStore;
-    }
-    /**
-     * Retrieve the file set for a given root hash and validate file integrity.
-     *
-     * @param {string} rootHash - The root hash to fetch the file set.
-     * @returns {Promise<{ fileName: string, file: string }[]>} - An array of unique file objects.
-     */
-    async getFileSetForRootHash(rootHash) {
-        const datFilePath = path_1.default.join(config_1.STORE_PATH, this.storeId, `${rootHash}.dat`);
-        const datFileContent = JSON.parse(fs_1.default.readFileSync(datFilePath, "utf-8"));
-        // Use a Set to ensure uniqueness
-        const filesInvolved = new Set();
-        // Iterate over each file and perform an integrity check
-        for (const [fileKey, fileData] of Object.entries(datFileContent.files)) {
-            const filePath = (0, hashUtils_1.getFilePathFromSha256)(datFileContent.files[fileKey].sha256, "data");
-            // Perform the integrity check
-            const integrityCheck = await DataIntegrityTree_1.DataIntegrityTree.validateKeyIntegrityWithForeignTree(fileKey, datFileContent.files[fileKey].sha256, datFileContent, rootHash, path_1.default.join(config_1.STORE_PATH, this.storeId, "data"));
-            if (integrityCheck) {
-                // Add the file to the Set
-                filesInvolved.add({
-                    name: Buffer.from(fileKey, "hex").toString("utf-8"),
-                    path: filePath,
-                });
-            }
-            else {
-                console.error((0, colorette_1.red)(`File ${fileKey} failed the integrity check.`));
-                throw new Error(`Integrity check failed for file: ${fileKey}. Aborting.`);
-            }
-        }
-        // Convert Set to Array and return
-        return Array.from(filesInvolved);
-    }
-}
-exports.DataStore = DataStore;

package/dist/blockchain/DataStoreSerializer.d.ts

@@ -1,52 +0,0 @@
-import { DataStore } from "@dignetwork/datalayer-driver";
-import { Buffer } from "buffer";
-export declare class DataStoreSerializer {
-    private storeInfo;
-    private latestHeight;
-    private latestHash;
-    constructor(storeInfo: DataStore, latestHeight: number, latestHash: Buffer);
-    serialize(): {
-        coin: {
-            parentCoinInfo: string;
-            puzzleHash: string;
-            amount: string;
-        };
-        launcherId: string;
-        proof: {
-            lineageProof: {
-                parentParentCoinInfo: string;
-                parentInnerPuzzleHash: string;
-                parentAmount: string;
-            } | undefined;
-            eveProof: {
-                parentParentCoinInfo: string;
-                parentAmount: string;
-            } | undefined;
-        };
-        metadata: {
-            rootHash: string;
-            label: string | undefined;
-            description: string | undefined;
-            bytes: string | undefined;
-        };
-        ownerPuzzleHash: string;
-        delegatedPuzzles: {
-            adminInnerPuzzleHash: string | undefined;
-            writerInnerPuzzleHash: string | undefined;
-            oraclePaymentPuzzleHash: string | undefined;
-            oracleFee: string | undefined;
-        }[];
-        latestHeight: string;
-        latestHash: string;
-    };
-    static deserialize(data: {
-        latestStore: any;
-        latestHeight: string;
-        latestHash: string;
-    }): {
-        latestStore: DataStore;
-        latestHeight: number;
-        latestHash: Buffer;
-    };
-}
-//# sourceMappingURL=DataStoreSerializer.d.ts.map

package/dist/blockchain/DataStoreSerializer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DataStoreSerializer.d.ts","sourceRoot":"","sources":["../../src/blockchain/DataStoreSerializer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAKV,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,UAAU,CAAS;gBAEf,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAOnE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgDF,WAAW,CACvB,IAAI,EAAE;QACJ,WAAW,EAAE,GAAG,CAAC;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB,GACA;QACD,WAAW,EAAE,SAAS,CAAC;QACvB,YAAY,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC;KACpB;CAuEF"}

package/dist/blockchain/DataStoreSerializer.js

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataStoreSerializer = void 0;
-const buffer_1 = require("buffer");
-class DataStoreSerializer {
-    constructor(storeInfo, latestHeight, latestHash) {
-        this.storeInfo = storeInfo;
-        this.latestHeight = latestHeight;
-        this.latestHash = latestHash;
-    }
-    // Serialize the DataStore object and additional fields
-    serialize() {
-        return {
-            coin: {
-                parentCoinInfo: this.storeInfo.coin.parentCoinInfo.toString("hex"),
-                puzzleHash: this.storeInfo.coin.puzzleHash.toString("hex"),
-                amount: this.storeInfo.coin.amount.toString(),
-            },
-            launcherId: this.storeInfo.launcherId.toString("hex"),
-            proof: {
-                lineageProof: this.storeInfo.proof.lineageProof
-                    ? {
-                        parentParentCoinInfo: this.storeInfo.proof.lineageProof.parentParentCoinInfo.toString("hex"),
-                        parentInnerPuzzleHash: this.storeInfo.proof.lineageProof.parentInnerPuzzleHash.toString("hex"),
-                        parentAmount: this.storeInfo.proof.lineageProof.parentAmount.toString(),
-                    }
-                    : undefined,
-                eveProof: this.storeInfo.proof.eveProof
-                    ? {
-                        parentParentCoinInfo: this.storeInfo.proof.eveProof.parentParentCoinInfo.toString("hex"),
-                        parentAmount: this.storeInfo.proof.eveProof.parentAmount.toString(),
-                    }
-                    : undefined,
-            },
-            metadata: {
-                rootHash: this.storeInfo.metadata.rootHash.toString("hex"),
-                label: this.storeInfo.metadata.label,
-                description: this.storeInfo.metadata.description,
-                bytes: this.storeInfo.metadata.bytes?.toString(),
-            },
-            ownerPuzzleHash: this.storeInfo.ownerPuzzleHash.toString("hex"),
-            delegatedPuzzles: this.storeInfo.delegatedPuzzles.map((puzzle) => ({
-                adminInnerPuzzleHash: puzzle.adminInnerPuzzleHash?.toString("hex"),
-                writerInnerPuzzleHash: puzzle.writerInnerPuzzleHash?.toString("hex"),
-                oraclePaymentPuzzleHash: puzzle.oraclePaymentPuzzleHash?.toString("hex"),
-                oracleFee: puzzle.oracleFee?.toString(),
-            })),
-            latestHeight: this.latestHeight.toString(),
-            latestHash: this.latestHash.toString("base64"), // Use base64 for Buffer
-        };
-    }
-    // Deserialize the data back into DataStore and associated fields
-    static deserialize(data) {
-        const coin = {
-            parentCoinInfo: buffer_1.Buffer.from(data.latestStore.coin.parentCoinInfo, "hex"),
-            puzzleHash: buffer_1.Buffer.from(data.latestStore.coin.puzzleHash, "hex"),
-            amount: BigInt(data.latestStore.coin.amount),
-        };
-        const proof = {
-            lineageProof: data.latestStore.proof.lineageProof
-                ? {
-                    parentParentCoinInfo: buffer_1.Buffer.from(data.latestStore.proof.lineageProof.parentParentCoinInfo, "hex"),
-                    parentInnerPuzzleHash: buffer_1.Buffer.from(data.latestStore.proof.lineageProof.parentInnerPuzzleHash, "hex"),
-                    parentAmount: BigInt(data.latestStore.proof.lineageProof.parentAmount),
-                }
-                : undefined,
-            eveProof: data.latestStore.proof.eveProof
-                ? {
-                    parentParentCoinInfo: buffer_1.Buffer.from(data.latestStore.proof.eveProof.parentParentCoinInfo, "hex"),
-                    parentAmount: BigInt(data.latestStore.proof.eveProof.parentAmount),
-                }
-                : undefined,
-        };
-        const metadata = {
-            rootHash: buffer_1.Buffer.from(data.latestStore.metadata.rootHash, "hex"),
-            label: data.latestStore.metadata.label,
-            description: data.latestStore.metadata.description,
-            bytes: data.latestStore.metadata.bytes
-                ? BigInt(data.latestStore.metadata.bytes)
-                : undefined,
-        };
-        const delegatedPuzzles = data.latestStore.delegatedPuzzles.map((puzzle) => ({
-            adminInnerPuzzleHash: puzzle.adminInnerPuzzleHash
-                ? buffer_1.Buffer.from(puzzle.adminInnerPuzzleHash, "hex")
-                : undefined,
-            writerInnerPuzzleHash: puzzle.writerInnerPuzzleHash
-                ? buffer_1.Buffer.from(puzzle.writerInnerPuzzleHash, "hex")
-                : undefined,
-            oraclePaymentPuzzleHash: puzzle.oraclePaymentPuzzleHash
-                ? buffer_1.Buffer.from(puzzle.oraclePaymentPuzzleHash, "hex")
-                : undefined,
-            oracleFee: puzzle.oracleFee ? BigInt(puzzle.oracleFee) : undefined,
-        }));
-        const dataStoreInfo = {
-            coin,
-            launcherId: buffer_1.Buffer.from(data.latestStore.launcherId, "hex"),
-            proof,
-            metadata,
-            ownerPuzzleHash: buffer_1.Buffer.from(data.latestStore.ownerPuzzleHash, "hex"),
-            delegatedPuzzles,
-        };
-        return {
-            latestStore: dataStoreInfo,
-            latestHeight: parseInt(data.latestHeight, 10),
-            latestHash: buffer_1.Buffer.from(data.latestHash, "base64"), // Deserialize from base64
-        };
-    }
-}
-exports.DataStoreSerializer = DataStoreSerializer;

package/dist/blockchain/FullNodePeer.d.ts

@@ -1,31 +0,0 @@
-import { Peer } from "@dignetwork/datalayer-driver";
-export declare class FullNodePeer {
-    private static cachedPeer;
-    private static memoizedFetchNewPeerIPs;
-    private peer;
-    private static deprioritizedIps;
-    private constructor();
-    /**
-     * Connect to the best peer, optionally using custom certificate and key file paths.
-     * @param {string} [certFilePath] - Optional custom certificate file path.
-     * @param {string} [keyFilePath] - Optional custom key file path.
-     * @returns {Promise<Peer>} The connected peer.
-     */
-    static connect(certFilePath?: string, keyFilePath?: string): Promise<Peer>;
-    private static isPortReachable;
-    private static isValidIpAddress;
-    /**
-     * Retrieves the TRUSTED_FULLNODE IP from the environment
-     * and verifies if it is a valid IP address.
-     *
-     * @returns {string | null} The valid IP address or null if invalid
-     */
-    private static getTrustedFullNode;
-    private static fetchNewPeerIPs;
-    private static getPeerIPs;
-    private static createPeerProxy;
-    private static getBestPeer;
-    getPeer(): Peer;
-    static waitForConfirmation(parentCoinInfo: Buffer): Promise<boolean>;
-}
-//# sourceMappingURL=FullNodePeer.d.ts.map

package/dist/blockchain/FullNodePeer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FullNodePeer.d.ts","sourceRoot":"","sources":["../../src/blockchain/FullNodePeer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AAqBpD,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAkD;IAC3E,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAA0B;IAChE,OAAO,CAAC,IAAI,CAAO;IACnB,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAA0B;IAQzD,OAAO;IAIP;;;;;OAKG;WACiB,OAAO,CACzB,YAAY,CAAC,EAAE,MAAM,EACrB,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC;IAKhB,OAAO,CAAC,MAAM,CAAC,eAAe;IAiB9B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAM/B;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;mBASZ,eAAe;mBA6Df,UAAU;IA2B/B,OAAO,CAAC,MAAM,CAAC,eAAe;mBAyDT,WAAW;IA+HzB,OAAO,IAAI,IAAI;WAIF,mBAAmB,CACrC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;CAwBpB"}