@dignetwork/dig-sdk 0.0.1-alpha.2

package/dist/blockchain/DataStore.js

@@ -0,0 +1,410 @@
+"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("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 utils_1 = require("../utils");
+const DataIntegrityTree_1 = require("../DataIntegrityTree");
+const prompts_1 = require("../prompts");
+const FileCache_1 = require("../utils/FileCache");
+const DataStoreSerializer_1 = require("./DataStoreSerializer");
+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) {
+        const existingTreeOptions = {
+            storageMode: "local",
+            storeDir: config_1.STORE_PATH,
+            disableInitialize: true,
+        };
+        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 getCreationHeight() {
+        const defaultHeight = config_1.MIN_HEIGHT;
+        const defaultHash = Buffer.from(config_1.MIN_HEIGHT_HEADER_HASH, "hex");
+        // 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, return the default values
+            return { createdAtHeight: defaultHeight, createdAtHash: defaultHash };
+        }
+        // Parse the cached height and hash values
+        const { height, hash } = cachedHeightInfo;
+        return {
+            createdAtHeight: height || defaultHeight,
+            createdAtHash: Buffer.from(hash || config_1.MIN_HEIGHT_HEADER_HASH, "hex"),
+        };
+    }
+    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() {
+        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 [];
+        }
+        return rootHashes.map((rootHash, index) => ({
+            root_hash: rootHash.toString("hex"),
+            timestamp: Number(rootHashesTimestamps?.[index].toString()),
+        }));
+    }
+    async getLocalRootHistory() {
+        const manifestFilePath = (0, config_1.getManifestFilePath)(this.storeId);
+        if (!fs_1.default.existsSync(manifestFilePath)) {
+            console.error("Manifest file not found", manifestFilePath);
+            return undefined;
+        }
+        const manifestHashes = fs_1.default
+            .readFileSync(manifestFilePath, "utf-8")
+            .split("\n")
+            .filter(Boolean);
+        return manifestHashes.map((rootHash) => ({
+            root_hash: rootHash,
+            timestamp: 0, // Timestamps are not yet included in the manifest
+        }));
+    }
+    async validate() {
+        const rootHistory = await this.getRootHistory();
+        const manifestFilePath = (0, config_1.getManifestFilePath)(this.storeId);
+        if (!fs_1.default.existsSync(manifestFilePath)) {
+            console.error("Manifest file not found", manifestFilePath);
+            return false;
+        }
+        const manifestHashes = fs_1.default
+            .readFileSync(manifestFilePath, "utf-8")
+            .split("\n")
+            .filter(Boolean);
+        if (manifestHashes.length > rootHistory.length) {
+            console.error("The store is corrupted: Manifest file has more hashes than the root history.");
+            return false;
+        }
+        if (rootHistory.length > manifestHashes.length) {
+            console.error("The store is not synced: Root history has more hashes than the manifest file.");
+            return false;
+        }
+        for (let i = 0; i < manifestHashes.length; i++) {
+            if (manifestHashes[i] !== rootHistory[i]?.root_hash) {
+                console.error(`Root hash mismatch at position ${i}: expected ${manifestHashes[i]} but found ${rootHistory[i]?.root_hash}`);
+                return false;
+            }
+        }
+        let filesIntegrityIntact = true;
+        for (const rootHash of manifestHashes) {
+            const datFilePath = path_1.default.join(config_1.STORE_PATH, this.storeId, `${rootHash}.dat`);
+            if (!fs_1.default.existsSync(datFilePath)) {
+                console.error(`Data file for root hash ${rootHash} not found`);
+                return false;
+            }
+            const datFileContent = JSON.parse(fs_1.default.readFileSync(datFilePath, "utf-8"));
+            if (datFileContent.root !== rootHash) {
+                console.error(`Root hash in data file does not match: ${datFileContent.root} !== ${rootHash}`);
+                return false;
+            }
+            for (const [fileKey, fileData] of Object.entries(datFileContent.files)) {
+                const integrityCheck = (0, utils_1.validateFileSha256)(fileData.sha256, path_1.default.join(config_1.STORE_PATH, this.storeId, "data"));
+                if (!integrityCheck) {
+                    filesIntegrityIntact = false;
+                }
+            }
+        }
+        if (!filesIntegrityIntact) {
+            console.error("Store Corrupted: Data failed SHA256 validation.");
+            return false;
+        }
+        return true;
+    }
+    async getMetaData() {
+        const { latestStore } = await this.fetchCoinInfo();
+        return latestStore.metadata;
+    }
+    async isSynced() {
+        const rootHistory = await this.getRootHistory();
+        const manifestFilePath = (0, config_1.getManifestFilePath)(this.storeId);
+        if (!fs_1.default.existsSync(manifestFilePath)) {
+            return false;
+        }
+        const manifestHashes = fs_1.default
+            .readFileSync(manifestFilePath, "utf-8")
+            .split("\n")
+            .filter(Boolean);
+        return rootHistory.length === manifestHashes.length;
+    }
+    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;
+    }
+}
+exports.DataStore = DataStore;

package/dist/blockchain/DataStoreSerializer.d.ts

@@ -0,0 +1,52 @@
+import { DataStore } from "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

@@ -0,0 +1 @@
+{"version":3,"file":"DataStoreSerializer.d.ts","sourceRoot":"","sources":["../../src/blockchain/DataStoreSerializer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EAKV,MAAM,kBAAkB,CAAC;AAC1B,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

@@ -0,0 +1,109 @@
+"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

@@ -0,0 +1,17 @@
+import { Peer } from "datalayer-driver";
+export declare class FullNodePeer {
+    private static cachedPeer;
+    private static memoizedFetchNewPeerIPs;
+    private peer;
+    private constructor();
+    static connect(): Promise<Peer>;
+    private static isPortReachable;
+    private static isValidIpAddress;
+    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

@@ -0,0 +1 @@
+{"version":3,"file":"FullNodePeer.d.ts","sourceRoot":"","sources":["../../src/blockchain/FullNodePeer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAmBxC,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,UAAU,CAAkD;IAC3E,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAA0B;IAChE,OAAO,CAAC,IAAI,CAAO;IAQnB,OAAO;WAIa,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5C,OAAO,CAAC,MAAM,CAAC,eAAe;IAiB9B,OAAO,CAAC,MAAM,CAAC,gBAAgB;mBAOV,eAAe;mBAkDf,UAAU;IAyB/B,OAAO,CAAC,MAAM,CAAC,eAAe;mBA4BT,WAAW;IAgGzB,OAAO,IAAI,IAAI;WAIF,mBAAmB,CACrC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;CAwBpB"}