@dignetwork/dig-sdk 0.0.1-alpha.126 → 0.0.1-alpha.128

package/dist/DigNetwork/DigNetwork.d.ts

@@ -9,7 +9,8 @@ export declare class DigNetwork {
     static getUdiContent(udi: string): Promise<void>;
     static findPeerWithStoreKey(storeId: string, rootHash: string, key?: string, intialBlackList?: string[]): Promise<DigPeer | null>;
     static unsubscribeFromStore(storeId: string): void;
-    syncStoreFromPeers(maxRootsToProcess?: number): Promise<void>;
+    static pingNetworkOfUpdate(storeId: string, rootHash: string): Promise<void>;
+    syncStoreFromPeers(prioritizedPeer?: DigPeer, maxRootsToProcess?: number): Promise<void>;
     fetchAvailablePeers(): Promise<DigPeer[]>;
 }
 //# sourceMappingURL=DigNetwork.d.ts.map

package/dist/DigNetwork/DigNetwork.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DigNetwork.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/DigNetwork.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,qBAAa,UAAU;IACrB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA2B;gBAEpC,OAAO,EAAE,MAAM;WAOP,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAQhD,aAAa,CAAC,GAAG,EAAE,MAAM;WAIzB,oBAAoB,CACtC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,EACZ,eAAe,GAAE,MAAM,EAAO,GAC7B,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;WA2DZ,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAO5C,kBAAkB,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiG7D,mBAAmB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;CAUvD"}
+{"version":3,"file":"DigNetwork.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/DigNetwork.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,qBAAa,UAAU;IACrB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,aAAa,CAA2B;gBAEpC,OAAO,EAAE,MAAM;WAOP,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;WAQhD,aAAa,CAAC,GAAG,EAAE,MAAM;WAIzB,oBAAoB,CACtC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,GAAG,CAAC,EAAE,MAAM,EACZ,eAAe,GAAE,MAAM,EAAO,GAC7B,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;WA2DZ,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;WAOrC,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAU5E,kBAAkB,CAC7B,eAAe,CAAC,EAAE,OAAO,EACzB,iBAAiB,CAAC,EAAE,MAAM,GACzB,OAAO,CAAC,IAAI,CAAC;IAqGH,mBAAmB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;CAUvD"}

package/dist/DigNetwork/DigNetwork.js

@@ -99,7 +99,16 @@ class DigNetwork {
         });
         fs.unlinkSync(path.join(config_1.DIG_FOLDER_PATH, "stores", storeId + ".json"));
     }
-    async syncStoreFromPeers(maxRootsToProcess) {
+    static async pingNetworkOfUpdate(storeId, rootHash) {
+        const serverCoin = new blockchain_1.ServerCoin(storeId);
+        // When an update is made, ping 10 network peers to pull updates from this store
+        const digPeers = await serverCoin.sampleCurrentEpoch(10);
+        for (const peer of digPeers) {
+            const digPeer = new DigPeer_1.DigPeer(peer, storeId);
+            await digPeer.propagationServer.pingUpdate(rootHash);
+        }
+    }
+    async syncStoreFromPeers(prioritizedPeer, maxRootsToProcess) {
         console.log("Starting file download process...");
         let peerBlackList = [];
         try {
@@ -126,7 +135,12 @@ class DigNetwork {
                 while (true) {
                     try {
                         // Find a peer with the store and root hash
-                        selectedPeer = await DigNetwork.findPeerWithStoreKey(this.dataStore.StoreId, rootInfo.root_hash, undefined, peerBlackList);
+                        if (prioritizedPeer) {
+                            selectedPeer = prioritizedPeer;
+                        }
+                        else {
+                            selectedPeer = await DigNetwork.findPeerWithStoreKey(this.dataStore.StoreId, rootInfo.root_hash, undefined, peerBlackList);
+                        }
                         if (!selectedPeer) {
                             console.error(`No peer found with root hash ${rootInfo.root_hash}. Moving to next root.`);
                             break; // Exit the while loop to proceed to the next rootInfo

package/dist/DigNetwork/PropagationServer.d.ts

@@ -21,6 +21,11 @@ export declare class PropagationServer {
      * Create an Axios HTTPS Agent with self-signed certificate allowance.
      */
     createHttpsAgent(): https.Agent;
+    /**
+     * Ping the current peer about an update to the store, passing rootHash.
+     * @param rootHash - The root hash for the store update.
+     */
+    pingUpdate(rootHash: string): Promise<void>;
     /**
      * Adds a custom inactivity timeout for large file transfers.
      */

package/dist/DigNetwork/PropagationServer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PropagationServer.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/PropagationServer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,MAAM,OAAO,CAAC;AAY1B,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAkBrC,qBAAa,iBAAiB;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,GAAG,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAE7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAQ;IACpC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAQ;gBAErC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAY9C;;OAEG;IACG,gBAAgB;IAOtB;;OAEG;IACH,gBAAgB;IAQhB;;OAEG;IACH,oBAAoB,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM;IAyB3D;;OAEG;IACG,gBAAgB,CACpB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,WAAW,EAAE,OAAO,CAAC;QAAC,cAAc,EAAE,OAAO,CAAA;KAAE,CAAC;IA4C7D;;OAEG;IACG,kBAAkB,CAAC,QAAQ,EAAE,MAAM;IAyDzC;;OAEG;IACG,YAAY,CAChB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,OAAO,CAAA;KAAE,CAAC;IA2BlD;;;OAGG;IACG,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,GAAE,OAAe;IAqH7E;;OAEG;IACG,mBAAmB;IAkCzB;;OAEG;WACU,WAAW,CACtB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM;IA0DnB;;;OAGG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAkFlD;;OAEG;IACG,cAAc,CAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IA4B7C;;;OAGG;IACG,YAAY,CAChB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM;IA0GjB;;OAEG;WACU,aAAa,CACxB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM;CA2FpB"}
+{"version":3,"file":"PropagationServer.d.ts","sourceRoot":"","sources":["../../src/DigNetwork/PropagationServer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,MAAM,OAAO,CAAC;AAY1B,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAkBrC,qBAAa,iBAAiB;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,GAAG,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAE7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAQ;IACpC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAQ;gBAErC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAY9C;;OAEG;IACG,gBAAgB;IAOtB;;OAEG;IACH,gBAAgB;IAQhB;;;OAGG;IACG,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA2CjD;;OAEG;IACH,oBAAoB,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM;IAyB3D;;OAEG;IACG,gBAAgB,CACpB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;QAAE,WAAW,EAAE,OAAO,CAAC;QAAC,cAAc,EAAE,OAAO,CAAA;KAAE,CAAC;IA4C7D;;OAEG;IACG,kBAAkB,CAAC,QAAQ,EAAE,MAAM;IAyDzC;;OAEG;IACG,YAAY,CAChB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,OAAO,CAAA;KAAE,CAAC;IA2BlD;;;OAGG;IACG,UAAU,CACd,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,UAAU,GAAE,OAAe;IAsH7B;;OAEG;IACG,mBAAmB;IAkCzB;;OAEG;WACU,WAAW,CACtB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM;IA0DnB;;;OAGG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAkFlD;;OAEG;IACG,cAAc,CAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IA4B7C;;;OAGG;IACG,YAAY,CAChB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM;IA0GjB;;OAEG;WACU,aAAa,CACxB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM;CA2FpB"}

package/dist/DigNetwork/PropagationServer.js

@@ -86,6 +86,46 @@ class PropagationServer {
             rejectUnauthorized: false,
         });
     }
+    /**
+     * Ping the current peer about an update to the store, passing rootHash.
+     * @param rootHash - The root hash for the store update.
+     */
+    async pingUpdate(rootHash) {
+        const spinner = (0, nanospinner_1.createSpinner)(`Pinging peer ${this.ipAddress}...`).start();
+        try {
+            const httpsAgent = this.createHttpsAgent();
+            const url = `https://${(0, network_1.formatHost)(this.ipAddress)}:${PropagationServer.port}/update`;
+            const config = {
+                httpsAgent,
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            };
+            // Data to send in the request (storeId and rootHash)
+            const data = {
+                storeId: this.storeId,
+                rootHash: rootHash,
+                updateTime: new Date().toISOString(),
+            };
+            try {
+                const response = await axios_1.default.post(url, data, config);
+                console.log((0, colorette_1.green)(`✔ Successfully pinged peer: ${this.ipAddress}`));
+                spinner.success({
+                    text: (0, colorette_1.green)(`✔ Successfully pinged peer ${this.ipAddress} with rootHash ${rootHash}`),
+                });
+                return response.data;
+            }
+            catch (error) {
+                console.error((0, colorette_1.red)(`✖ Failed to ping peer: ${this.ipAddress}`));
+                console.error((0, colorette_1.red)(error.message));
+                throw error;
+            }
+        }
+        catch (error) {
+            spinner.error({ text: (0, colorette_1.red)("✖ Error pinging network peer.") });
+            console.error((0, colorette_1.red)(error.message));
+        }
+    }
     /**
      * Adds a custom inactivity timeout for large file transfers.
      */

package/dist/blockchain/FullNodePeer.d.ts

@@ -1,25 +1,109 @@
 import { Peer } from "@dignetwork/datalayer-driver";
+/**
+ * FullNodePeer manages connections to full nodes, prioritizing certain peers and handling reliability.
+ */
 export declare class FullNodePeer {
-    private static cachedPeer;
-    private static memoizedFetchNewPeerIPs;
     private peer;
-    private static deprioritizedIps;
+    private static instance;
+    private static cachedPeer;
+    private static cooldownCache;
+    private static peerWeights;
+    private static prioritizedPeers;
+    private static peerInfos;
+    private static peerIPCache;
     private constructor();
+    /**
+     * Retrieves the singleton instance of FullNodePeer.
+     * @returns {FullNodePeer} The singleton instance.
+     */
+    static getInstance(): FullNodePeer;
+    /**
+     * Initializes the singleton instance by connecting to the best peer.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Connects and returns the best available peer.
+     * Implements singleton behavior.
+     * @returns {Promise<Peer>} The connected Peer instance.
+     */
     static connect(): Promise<Peer>;
+    /**
+     * Checks if a given port on a host is reachable.
+     * @param {string} host - The host IP address.
+     * @param {number} port - The port number.
+     * @param {number} timeout - Connection timeout in milliseconds.
+     * @returns {Promise<boolean>} Whether the port is reachable.
+     */
     private static isPortReachable;
+    /**
+     * Validates an IPv4 address.
+     * @param {string} ip - The IP address to validate.
+     * @returns {boolean} Whether the IP address is valid.
+     */
     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
+     * Retrieves the TRUSTED_FULLNODE IP from the environment and verifies its validity.
+     * @returns {string | null} The trusted full node IP or null if invalid.
      */
     private static getTrustedFullNode;
+    /**
+     * Fetches new peer IPs from DNS introducers and prioritized hosts.
+     * Utilizes caching to avoid redundant DNS resolutions.
+     * @returns {Promise<string[]>} An array of reachable peer IPs.
+     */
     private static fetchNewPeerIPs;
+    /**
+     * Shuffles an array using the Fisher-Yates algorithm.
+     * @param {T[]} array - The array to shuffle.
+     * @returns {T[]} The shuffled array.
+     */
+    private static shuffleArray;
+    /**
+     * Initializes the peer weights map.
+     * Assigns higher initial weights to prioritized peers.
+     * @param {string[]} peerIPs - An array of peer IPs.
+     */
+    private static initializePeerWeights;
+    /**
+     * Selects a peer based on weighted random selection.
+     * Prioritized peers have higher weights.
+     * @returns {string} The selected peer IP.
+     */
+    private static selectPeerByWeight;
+    /**
+     * Retrieves all reachable peer IPs, excluding those in cooldown.
+     * @returns {Promise<string[]>} An array of reachable peer IPs.
+     */
     private static getPeerIPs;
-    private static createPeerProxy;
+    /**
+     * Initializes the peer weights based on prioritization and reliability.
+     * @param {string[]} peerIPs - An array of peer IPs.
+     */
+    private static setupPeers;
+    /**
+     * Connects to the best available peer based on weighted selection and reliability.
+     * @returns {Promise<Peer>} The connected Peer instance.
+     */
     private static getBestPeer;
-    getPeer(): Peer;
+    /**
+     * Creates a proxy for the peer to handle errors and implement retries.
+     * @param {Peer} peer - The Peer instance.
+     * @param {string} peerIP - The IP address of the peer.
+     * @param {number} [retryCount=0] - The current retry attempt.
+     * @returns {Peer} The proxied Peer instance.
+     */
+    private static createPeerProxy;
+    /**
+     * Extracts the IP address from a Peer instance.
+     * @param {Peer} peer - The Peer instance.
+     * @returns {string | null} The extracted IP address or null if not found.
+     */
+    private static extractPeerIP;
+    /**
+   * Waits for a coin to be confirmed (spent) on the blockchain.
+   * @param {Buffer} parentCoinInfo - The parent coin information.
+   * @returns {Promise<boolean>} Whether the coin was confirmed.
+   */
     static waitForConfirmation(parentCoinInfo: Buffer): Promise<boolean>;
 }
 //# sourceMappingURL=FullNodePeer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"FullNodePeer.d.ts","sourceRoot":"","sources":["../../src/blockchain/FullNodePeer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAO,MAAM,8BAA8B,CAAC;AAoBzD,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;WAIa,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5C,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;IAsGzB,OAAO,IAAI,IAAI;WAIF,mBAAmB,CACrC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;CAwBpB"}
+{"version":3,"file":"FullNodePeer.d.ts","sourceRoot":"","sources":["../../src/blockchain/FullNodePeer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAO,MAAM,8BAA8B,CAAC;AAiCzD;;GAEG;AACH,qBAAa,YAAY;IAuBH,OAAO,CAAC,IAAI;IArBhC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA6B;IAGpD,OAAO,CAAC,MAAM,CAAC,UAAU,CAAkD;IAG3E,OAAO,CAAC,MAAM,CAAC,aAAa,CAAuD;IAGnF,OAAO,CAAC,MAAM,CAAC,WAAW,CAAkC;IAG5D,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAgB;IAG/C,OAAO,CAAC,MAAM,CAAC,SAAS,CAAoC;IAG5D,OAAO,CAAC,MAAM,CAAC,WAAW,CAAoD;IAG9E,OAAO;IAEP;;;OAGG;WACW,WAAW,IAAI,YAAY;IAOzC;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAaxC;;;;OAIG;WACiB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5C;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAuB9B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAM/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IASjC;;;;OAIG;mBACkB,eAAe;IAyFpC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAS3B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAgBpC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAwBjC;;;OAGG;mBACkB,UAAU;IAK/B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;IAIzB;;;OAGG;mBACkB,WAAW;IAyEhC;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAuE9B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,aAAa;IAS1B;;;;KAIC;WACmB,mBAAmB,CACrC,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC;CAyBtB"}

package/dist/blockchain/FullNodePeer.js

@@ -10,10 +10,11 @@ const fs_1 = __importDefault(require("fs"));
 const datalayer_driver_1 = require("@dignetwork/datalayer-driver");
 const promises_1 = require("dns/promises");
 const net_1 = __importDefault(require("net"));
-const lodash_1 = require("lodash");
 const nanospinner_1 = require("nanospinner");
 const config_1 = require("../utils/config");
 const Environment_1 = require("../utils/Environment");
+const node_cache_1 = __importDefault(require("node-cache"));
+// Constants
 const FULLNODE_PORT = 8444;
 const LOCALHOST = "127.0.0.1";
 const CHIA_NODES_HOST = "chia-nodes";
@@ -23,37 +24,92 @@ const DNS_HOSTS = [
     "seeder.dexie.space",
     "chia.hoffmang.com",
 ];
-const CONNECTION_TIMEOUT = 2000;
-const CACHE_DURATION = 30000; // Cache duration in milliseconds
+const CONNECTION_TIMEOUT = 2000; // in milliseconds
+const CACHE_DURATION = 30000; // in milliseconds
+const COOLDOWN_DURATION = 60000; // in milliseconds
+const MAX_PEERS_TO_FETCH = 5; // Maximum number of peers to fetch from DNS
+const MAX_RETRIES = 3; // Maximum number of retry attempts
+/**
+ * FullNodePeer manages connections to full nodes, prioritizing certain peers and handling reliability.
+ */
 class FullNodePeer {
+    // Private constructor for singleton pattern
     constructor(peer) {
         this.peer = peer;
     }
+    /**
+     * Retrieves the singleton instance of FullNodePeer.
+     * @returns {FullNodePeer} The singleton instance.
+     */
+    static getInstance() {
+        if (!FullNodePeer.instance) {
+            FullNodePeer.instance = new FullNodePeer(null); // Temporarily set to null
+        }
+        return FullNodePeer.instance;
+    }
+    /**
+     * Initializes the singleton instance by connecting to the best peer.
+     */
+    async initialize() {
+        if (this.peer)
+            return; // Already initialized
+        try {
+            const bestPeer = await FullNodePeer.getBestPeer();
+            this.peer = bestPeer;
+            FullNodePeer.instance = this; // Assign the initialized instance
+        }
+        catch (error) {
+            console.error(`Initialization failed: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Connects and returns the best available peer.
+     * Implements singleton behavior.
+     * @returns {Promise<Peer>} The connected Peer instance.
+     */
     static async connect() {
-        const peer = await FullNodePeer.getBestPeer();
-        return new FullNodePeer(peer).peer;
+        const instance = FullNodePeer.getInstance();
+        await instance.initialize();
+        return instance.peer;
     }
+    /**
+     * Checks if a given port on a host is reachable.
+     * @param {string} host - The host IP address.
+     * @param {number} port - The port number.
+     * @param {number} timeout - Connection timeout in milliseconds.
+     * @returns {Promise<boolean>} Whether the port is reachable.
+     */
     static isPortReachable(host, port, timeout = CONNECTION_TIMEOUT) {
         return new Promise((resolve) => {
             const socket = new net_1.default.Socket()
                 .setTimeout(timeout)
-                .once("error", () => resolve(false))
-                .once("timeout", () => resolve(false))
+                .once("error", () => {
+                socket.destroy();
+                resolve(false);
+            })
+                .once("timeout", () => {
+                socket.destroy();
+                resolve(false);
+            })
                 .connect(port, host, () => {
                 socket.end();
                 resolve(true);
             });
         });
     }
+    /**
+     * Validates an IPv4 address.
+     * @param {string} ip - The IP address to validate.
+     * @returns {boolean} Whether the IP address is valid.
+     */
     static isValidIpAddress(ip) {
-        const ipv4Regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+        const ipv4Regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/;
         return ipv4Regex.test(ip);
     }
     /**
-     * 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
+     * Retrieves the TRUSTED_FULLNODE IP from the environment and verifies its validity.
+     * @returns {string | null} The trusted full node IP or null if invalid.
      */
     static getTrustedFullNode() {
         const trustedNodeIp = Environment_1.Environment.TRUSTED_FULLNODE || null;
@@ -62,44 +118,65 @@ class FullNodePeer {
         }
         return null;
     }
+    /**
+     * Fetches new peer IPs from DNS introducers and prioritized hosts.
+     * Utilizes caching to avoid redundant DNS resolutions.
+     * @returns {Promise<string[]>} An array of reachable peer IPs.
+     */
     static async fetchNewPeerIPs() {
         const trustedNodeIp = FullNodePeer.getTrustedFullNode();
         const priorityIps = [];
-        // Prioritize trustedNodeIp unless it's deprioritized
+        // Define prioritized peers
+        FullNodePeer.prioritizedPeers = [
+            ...DNS_HOSTS, // Assuming CHIA_NODES_HOST is included in DNS_HOSTS
+            LOCALHOST,
+        ];
+        // Add trustedNodeIp if available
+        if (trustedNodeIp) {
+            FullNodePeer.prioritizedPeers.unshift(trustedNodeIp);
+        }
+        // Prioritize trustedNodeIp
         if (trustedNodeIp &&
-            !FullNodePeer.deprioritizedIps.has(trustedNodeIp) &&
+            !FullNodePeer.cooldownCache.has(trustedNodeIp) &&
             (await FullNodePeer.isPortReachable(trustedNodeIp, FULLNODE_PORT))) {
             priorityIps.push(trustedNodeIp);
         }
-        // Prioritize LOCALHOST unless it's deprioritized
-        if (!FullNodePeer.deprioritizedIps.has(LOCALHOST) &&
+        // Prioritize LOCALHOST
+        if (!FullNodePeer.cooldownCache.has(LOCALHOST) &&
             (await FullNodePeer.isPortReachable(LOCALHOST, FULLNODE_PORT))) {
             priorityIps.push(LOCALHOST);
         }
-        // Prioritize CHIA_NODES_HOST unless it's deprioritized
-        if (!FullNodePeer.deprioritizedIps.has(CHIA_NODES_HOST) &&
+        // Prioritize CHIA_NODES_HOST
+        if (!FullNodePeer.cooldownCache.has(CHIA_NODES_HOST) &&
             (await FullNodePeer.isPortReachable(CHIA_NODES_HOST, FULLNODE_PORT))) {
             priorityIps.push(CHIA_NODES_HOST);
         }
         if (priorityIps.length > 0) {
             return priorityIps;
         }
+        // Check if cached peer IPs exist
+        const cachedPeerIPs = FullNodePeer.peerIPCache.get("peerIPs");
+        if (cachedPeerIPs) {
+            return cachedPeerIPs;
+        }
         // Fetch peers from DNS introducers
+        const fetchedPeers = [];
         for (const DNS_HOST of DNS_HOSTS) {
             try {
                 const ips = await (0, promises_1.resolve4)(DNS_HOST);
                 if (ips && ips.length > 0) {
-                    const shuffledIps = ips.sort(() => 0.5 - Math.random());
+                    const shuffledIps = FullNodePeer.shuffleArray(ips);
                     const reachableIps = [];
                     for (const ip of shuffledIps) {
-                        if (await FullNodePeer.isPortReachable(ip, FULLNODE_PORT)) {
+                        if (!FullNodePeer.cooldownCache.has(ip) &&
+                            (await FullNodePeer.isPortReachable(ip, FULLNODE_PORT))) {
                             reachableIps.push(ip);
                         }
-                        if (reachableIps.length === 5)
-                            break;
+                        if (reachableIps.length === MAX_PEERS_TO_FETCH)
+                            break; // Limit to MAX_PEERS_TO_FETCH peers
                     }
                     if (reachableIps.length > 0) {
-                        return reachableIps;
+                        fetchedPeers.push(...reachableIps);
                     }
                 }
             }
@@ -107,67 +184,209 @@ class FullNodePeer {
                 console.error(`Failed to resolve IPs from ${DNS_HOST}: ${error.message}`);
             }
         }
+        // Cache the fetched peer IPs
+        if (fetchedPeers.length > 0) {
+            FullNodePeer.peerIPCache.set("peerIPs", fetchedPeers);
+            return fetchedPeers;
+        }
         throw new Error("No reachable IPs found in any DNS records.");
     }
-    static async getPeerIPs() {
-        const ips = await FullNodePeer.memoizedFetchNewPeerIPs();
-        const reachableIps = await Promise.all(ips.map(async (ip) => {
-            if (ip && (await FullNodePeer.isPortReachable(ip, FULLNODE_PORT))) {
-                return ip;
+    /**
+     * Shuffles an array using the Fisher-Yates algorithm.
+     * @param {T[]} array - The array to shuffle.
+     * @returns {T[]} The shuffled array.
+     */
+    static shuffleArray(array) {
+        const shuffled = [...array];
+        for (let i = shuffled.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+        }
+        return shuffled;
+    }
+    /**
+     * Initializes the peer weights map.
+     * Assigns higher initial weights to prioritized peers.
+     * @param {string[]} peerIPs - An array of peer IPs.
+     */
+    static initializePeerWeights(peerIPs) {
+        for (const ip of peerIPs) {
+            if (!FullNodePeer.peerWeights.has(ip)) {
+                if (ip === CHIA_NODES_HOST ||
+                    ip === LOCALHOST ||
+                    ip === FullNodePeer.getTrustedFullNode()) {
+                    FullNodePeer.peerWeights.set(ip, 5); // Higher weight for prioritized peers
+                }
+                else {
+                    FullNodePeer.peerWeights.set(ip, 1); // Default weight
+                }
+            }
+        }
+    }
+    /**
+     * Selects a peer based on weighted random selection.
+     * Prioritized peers have higher weights.
+     * @returns {string} The selected peer IP.
+     */
+    static selectPeerByWeight() {
+        const peers = Array.from(FullNodePeer.peerWeights.entries())
+            .filter(([ip, _]) => !FullNodePeer.cooldownCache.has(ip))
+            .map(([ip, weight]) => ({ ip, weight }));
+        const totalWeight = peers.reduce((sum, peer) => sum + peer.weight, 0);
+        if (totalWeight === 0) {
+            throw new Error("All peers are in cooldown.");
+        }
+        const random = Math.random() * totalWeight;
+        let cumulative = 0;
+        for (const peer of peers) {
+            cumulative += peer.weight;
+            if (random < cumulative) {
+                return peer.ip;
             }
-            return null;
-        })).then((results) => results.filter((ip) => ip !== null));
-        if (reachableIps.length > 0) {
-            return reachableIps;
         }
-        // @ts-ignore
-        if (FullNodePeer.memoizedFetchNewPeerIPs?.cache?.clear) {
-            // Clear cache and reset deprioritized IPs when cache is cleared
-            FullNodePeer.deprioritizedIps.clear();
-            // @ts-ignore
-            FullNodePeer.memoizedFetchNewPeerIPs.cache.clear();
+        // Fallback
+        return peers[peers.length - 1].ip;
+    }
+    /**
+     * Retrieves all reachable peer IPs, excluding those in cooldown.
+     * @returns {Promise<string[]>} An array of reachable peer IPs.
+     */
+    static async getPeerIPs() {
+        const peerIPs = await FullNodePeer.fetchNewPeerIPs();
+        return peerIPs;
+    }
+    /**
+     * Initializes the peer weights based on prioritization and reliability.
+     * @param {string[]} peerIPs - An array of peer IPs.
+     */
+    static setupPeers(peerIPs) {
+        FullNodePeer.initializePeerWeights(peerIPs);
+    }
+    /**
+     * Connects to the best available peer based on weighted selection and reliability.
+     * @returns {Promise<Peer>} The connected Peer instance.
+     */
+    static async getBestPeer() {
+        const now = Date.now();
+        // Refresh cachedPeer if expired
+        if (FullNodePeer.cachedPeer &&
+            now - FullNodePeer.cachedPeer.timestamp < CACHE_DURATION) {
+            return FullNodePeer.cachedPeer.peer;
+        }
+        // Fetch peer IPs
+        const peerIPs = await FullNodePeer.getPeerIPs();
+        // Setup peer weights with prioritization
+        FullNodePeer.setupPeers(peerIPs);
+        // Weighted random selection
+        let selectedPeerIP;
+        try {
+            selectedPeerIP = FullNodePeer.selectPeerByWeight();
+        }
+        catch (error) {
+            throw new Error(`Failed to select a peer: ${error.message}`);
+        }
+        // Attempt to create a peer connection
+        const sslFolder = path_1.default.resolve(os_1.default.homedir(), ".dig", "ssl");
+        const certFile = path_1.default.join(sslFolder, "public_dig.crt");
+        const keyFile = path_1.default.join(sslFolder, "public_dig.key");
+        if (!fs_1.default.existsSync(sslFolder)) {
+            fs_1.default.mkdirSync(sslFolder, { recursive: true });
+        }
+        const tls = new datalayer_driver_1.Tls(certFile, keyFile);
+        let peer;
+        try {
+            peer = await datalayer_driver_1.Peer.new(`${selectedPeerIP}:${FULLNODE_PORT}`, false, tls);
+        }
+        catch (error) {
+            console.error(`Failed to create peer for IP ${selectedPeerIP}: ${error.message}`);
+            // Add to cooldown
+            FullNodePeer.cooldownCache.set(selectedPeerIP, true);
+            // Decrease weight or remove peer
+            const currentWeight = FullNodePeer.peerWeights.get(selectedPeerIP) || 1;
+            if (currentWeight > 1) {
+                FullNodePeer.peerWeights.set(selectedPeerIP, currentWeight - 1);
+            }
+            else {
+                FullNodePeer.peerWeights.delete(selectedPeerIP);
+            }
+            throw new Error(`Unable to connect to peer ${selectedPeerIP}`);
         }
-        return FullNodePeer.memoizedFetchNewPeerIPs();
+        // Wrap the peer with proxy to handle errors and retries
+        const proxiedPeer = FullNodePeer.createPeerProxy(peer, selectedPeerIP);
+        // Store PeerInfo
+        FullNodePeer.peerInfos.set(selectedPeerIP, {
+            peer: proxiedPeer,
+            weight: FullNodePeer.peerWeights.get(selectedPeerIP) || 1,
+            address: selectedPeerIP,
+        });
+        // Cache the peer
+        FullNodePeer.cachedPeer = { peer: proxiedPeer, timestamp: now };
+        console.log(`Using Fullnode Peer: ${selectedPeerIP}`);
+        return proxiedPeer;
     }
-    static createPeerProxy(peer) {
+    /**
+     * Creates a proxy for the peer to handle errors and implement retries.
+     * @param {Peer} peer - The Peer instance.
+     * @param {string} peerIP - The IP address of the peer.
+     * @param {number} [retryCount=0] - The current retry attempt.
+     * @returns {Peer} The proxied Peer instance.
+     */
+    static createPeerProxy(peer, peerIP, retryCount = 0) {
         return new Proxy(peer, {
             get: (target, prop) => {
                 const originalMethod = target[prop];
                 if (typeof originalMethod === "function") {
                     return async (...args) => {
-                        let timeoutId;
-                        // Start the timeout to forget the peer after 1 minute
-                        const timeoutPromise = new Promise((_, reject) => {
-                            timeoutId = setTimeout(() => {
-                                FullNodePeer.cachedPeer = null;
-                                reject(new Error("Operation timed out. Reconnecting to a new peer."));
-                            }, 60000); // 1 minute
-                        });
                         try {
-                            // Run the original method and race it against the timeout
-                            const result = await Promise.race([
-                                originalMethod.apply(target, args),
-                                timeoutPromise,
-                            ]);
-                            // Clear the timeout if the operation succeeded
-                            if (timeoutId) {
-                                clearTimeout(timeoutId);
-                            }
+                            const result = await originalMethod.apply(target, args);
+                            // On successful operation, increase the weight slightly
+                            const currentWeight = FullNodePeer.peerWeights.get(peerIP) || 1;
+                            FullNodePeer.peerWeights.set(peerIP, currentWeight + 0.1); // Increment weight
                             return result;
                         }
                         catch (error) {
-                            // If the error is WebSocket-related or timeout, reset the peer
+                            console.error(`Peer ${peerIP} encountered an error: ${error.message}`);
+                            // Check if the error is related to WebSocket or Operation timed out
                             if (error.message.includes("WebSocket") ||
                                 error.message.includes("Operation timed out")) {
-                                FullNodePeer.cachedPeer = null;
-                                // @ts-ignore
-                                FullNodePeer.memoizedFetchNewPeerIPs.cache.clear();
-                                FullNodePeer.deprioritizedIps.clear();
-                                console.info(`Fullnode Peer error, reconnecting to a new peer...`);
-                                const newPeer = await FullNodePeer.getBestPeer();
-                                return newPeer[prop](...args);
+                                // Add the faulty peer to the cooldown cache
+                                FullNodePeer.cooldownCache.set(peerIP, true);
+                                // Decrease weight or remove peer
+                                const currentWeight = FullNodePeer.peerWeights.get(peerIP) || 1;
+                                if (currentWeight > 1) {
+                                    FullNodePeer.peerWeights.set(peerIP, currentWeight - 1);
+                                }
+                                else {
+                                    FullNodePeer.peerWeights.delete(peerIP);
+                                }
+                                // If maximum retries reached, throw the error
+                                if (retryCount >= MAX_RETRIES) {
+                                    console.error(`Max retries reached for method ${String(prop)} on peer ${peerIP}.`);
+                                    throw error;
+                                }
+                                // Attempt to select a new peer and retry the method
+                                try {
+                                    console.info(`Selecting a new peer to retry method ${String(prop)}...`);
+                                    const newPeer = await FullNodePeer.getBestPeer();
+                                    // Extract new peer's IP address
+                                    const newPeerIP = FullNodePeer.extractPeerIP(newPeer);
+                                    if (!newPeerIP) {
+                                        throw new Error("Unable to extract IP from the new peer.");
+                                    }
+                                    // Wrap the new peer with a proxy, incrementing the retry count
+                                    const proxiedNewPeer = FullNodePeer.createPeerProxy(newPeer, newPeerIP, retryCount + 1);
+                                    // Retry the method on the new peer
+                                    return await proxiedNewPeer[prop](...args);
+                                }
+                                catch (retryError) {
+                                    console.error(`Retry failed on a new peer: ${retryError.message}`);
+                                    throw retryError;
+                                }
+                            }
+                            else {
+                                // For other errors, handle normally
+                                throw error;
                             }
-                            throw error;
                         }
                     };
                 }
@@ -175,76 +394,24 @@ class FullNodePeer {
             },
         });
     }
-    static async getBestPeer() {
-        const now = Date.now();
-        if (FullNodePeer.cachedPeer &&
-            now - FullNodePeer.cachedPeer.timestamp < CACHE_DURATION) {
-            return FullNodePeer.cachedPeer.peer;
-        }
-        const sslFolder = path_1.default.resolve(os_1.default.homedir(), ".dig", "ssl");
-        const certFile = path_1.default.join(sslFolder, "public_dig.crt");
-        const keyFile = path_1.default.join(sslFolder, "public_dig.key");
-        if (!fs_1.default.existsSync(sslFolder)) {
-            fs_1.default.mkdirSync(sslFolder, { recursive: true });
-        }
-        const tls = new datalayer_driver_1.Tls(certFile, keyFile);
-        const peerIPs = await FullNodePeer.getPeerIPs();
-        const trustedNodeIp = Environment_1.Environment.TRUSTED_FULLNODE || null;
-        const peers = await Promise.all(peerIPs.map(async (ip) => {
-            if (ip) {
-                // Allow override of the trusted fullnode port if the override exists
-                let port = FULLNODE_PORT;
-                if (trustedNodeIp && ip === trustedNodeIp) {
-                    const trustedFullNodePort = Environment_1.Environment.TRUSTED_FULLNODE_PORT;
-                    if (trustedFullNodePort) {
-                        port = trustedFullNodePort;
-                    }
-                }
-                try {
-                    const peer = await datalayer_driver_1.Peer.new(`${ip}:${port}`, false, tls);
-                    return FullNodePeer.createPeerProxy(peer);
-                }
-                catch (error) {
-                    console.error(`Failed to create peer for IP ${ip}: ${error.message}`);
-                    return null;
-                }
+    /**
+     * Extracts the IP address from a Peer instance.
+     * @param {Peer} peer - The Peer instance.
+     * @returns {string | null} The extracted IP address or null if not found.
+     */
+    static extractPeerIP(peer) {
+        for (const [ip, info] of FullNodePeer.peerInfos.entries()) {
+            if (info.peer === peer) {
+                return ip;
             }
-            return null;
-        })).then((results) => results.filter((peer) => peer !== null));
-        if (peers.length === 0) {
-            throw new Error("No peers available, please try again.");
-        }
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        const peakHeights = await Promise.all(peers.map((peer) => peer
-            .getPeak()
-            .then((height) => height)
-            .catch((error) => {
-            console.error(`Failed to get peak for peer: ${error.message}`);
-            return null;
-        })));
-        const validHeights = peakHeights.filter((height) => height !== null);
-        if (validHeights.length === 0) {
-            throw new Error("No valid peak heights obtained from any peer.");
-        }
-        const highestPeak = Math.max(...validHeights);
-        // Prioritize LOCALHOST, TRUSTED_NODE_IP, and CHIA_NODES_HOST if they have the highest peak height
-        let bestPeerIndex = validHeights.findIndex((height, index) => height === highestPeak &&
-            !FullNodePeer.deprioritizedIps.has(peerIPs[index]) && // Exclude deprioritized IPs
-            (peerIPs[index] === LOCALHOST ||
-                peerIPs[index] === trustedNodeIp ||
-                peerIPs[index] === CHIA_NODES_HOST));
-        // If LOCALHOST, TRUSTED_NODE_IP, or CHIA_NODES_HOST don't have the highest peak, select any peer with the highest peak
-        if (bestPeerIndex === -1) {
-            bestPeerIndex = validHeights.findIndex((height) => height === highestPeak);
         }
-        const bestPeer = peers[bestPeerIndex];
-        FullNodePeer.cachedPeer = { peer: bestPeer, timestamp: now };
-        console.log(`Using Fullnode Peer: ${peerIPs[bestPeerIndex]}`);
-        return bestPeer;
-    }
-    getPeer() {
-        return this.peer;
+        return null;
     }
+    /**
+   * Waits for a coin to be confirmed (spent) on the blockchain.
+   * @param {Buffer} parentCoinInfo - The parent coin information.
+   * @returns {Promise<boolean>} Whether the coin was confirmed.
+   */
     static async waitForConfirmation(parentCoinInfo) {
         const spinner = (0, nanospinner_1.createSpinner)("Waiting for confirmation...").start();
         const peer = await FullNodePeer.connect();
@@ -260,13 +427,23 @@ class FullNodePeer {
         }
         catch (error) {
             spinner.error({ text: "Error while waiting for confirmation." });
+            console.error(`waitForConfirmation error: ${error.message}`);
             throw error;
         }
     }
 }
 exports.FullNodePeer = FullNodePeer;
+// Singleton instance
+FullNodePeer.instance = null;
+// Cached peer with timestamp
 FullNodePeer.cachedPeer = null;
-FullNodePeer.deprioritizedIps = new Set(); // New set for deprioritized IPs
-(() => {
-    FullNodePeer.memoizedFetchNewPeerIPs = (0, lodash_1.memoize)(FullNodePeer.fetchNewPeerIPs);
-})();
+// Cooldown cache to exclude faulty peers temporarily
+FullNodePeer.cooldownCache = new node_cache_1.default({ stdTTL: COOLDOWN_DURATION / 1000 });
+// Peer reliability weights
+FullNodePeer.peerWeights = new Map();
+// List of prioritized peers
+FullNodePeer.prioritizedPeers = [];
+// Map to store PeerInfo
+FullNodePeer.peerInfos = new Map();
+// Cache for fetched peer IPs
+FullNodePeer.peerIPCache = new node_cache_1.default({ stdTTL: CACHE_DURATION / 1000 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dignetwork/dig-sdk",
-  "version": "0.0.1-alpha.126",
+  "version": "0.0.1-alpha.128",
   "description": "",
   "type": "commonjs",
   "main": "./dist/index.js",