trucoshi 7.0.0 → 7.1.0

package/dist/lib/classes/Random.d.ts

@@ -1,18 +1,22 @@
 import { IRandom } from "../../types";
 export declare const Random: () => IRandom;
 export interface IRng {
-    combine(client: string, server: string, nonce: number): string;
+    combine(client: string, server: string, bitcoinHash: string, nonce: number): string;
     sha512(string: string): string;
     generateServerSeed(): string;
+    getBitcoinLatestBlockHash(): Promise<{
+        hash: string;
+        height: number;
+    }>;
     hexToBytes(hex: string): Uint8Array;
-    byteGenerator(clientseed: string, serverseed: string, nonce: number): Uint8Array;
-    generateInteger(clientSeed: string, serverSeed: string, nonce: number, min: number, max: number): number;
-    generateFloat(clientSeed: string, serverSeed: string, nonce: number, precision?: number): number;
-    generateBool(clientSeed: string, serverSeed: string, nonce: number): boolean;
+    byteGenerator(clientseed: string, serverseed: string, bitcoinHash: string, nonce: number): Uint8Array;
+    generateInteger(clientSeed: string, serverSeed: string, bitcoinHash: string, nonce: number, min: number, max: number): number;
+    generateFloat(clientSeed: string, serverSeed: string, bitcoinHash: string, nonce: number, precision?: number): number;
+    generateBool(clientSeed: string, serverSeed: string, bitcoinHash: string, nonce: number): boolean;
     selectRandomObject<T extends {
         probability: number;
     } = {
         probability: number;
         [x: string]: any;
-    }>(clientSeed: string, serverSeed: string, nonce: number, objects: Array<T>): T | null;
+    }>(clientSeed: string, serverSeed: string, bitcoinHash: string, nonce: number, objects: Array<T>): T | null;
 }

package/dist/lib/classes/Random.js

@@ -1,18 +1,42 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { accountsApi } from "../../accounts/client";
 import forge from "node-forge";
 const rnd = Rng();
 export const Random = () => {
     const random = {
         secret: rnd.generateServerSeed(),
         clients: [],
+        bitcoinHash: "",
+        bitcoinHeight: 0,
         nonce: 0,
+        getLatestBitcoinBlock() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { hash, height } = yield rnd.getBitcoinLatestBlockHash();
+                random.bitcoinHash = hash;
+                random.bitcoinHeight = height;
+            });
+        },
         pick(key, max) {
-            return rnd.generateInteger(random.clients[key], random.secret, random.nonce, 0, max);
+            return rnd.generateInteger(random.clients[key], random.secret, random.bitcoinHash, random.nonce, 0, max);
         },
         next() {
             random.nonce++;
         },
         reveal() {
-            return { secret: random.secret, clients: [...random.clients] };
+            return {
+                secret: random.secret,
+                clients: [...random.clients],
+                bitcoinHash: random.bitcoinHash,
+                bitcoinHeight: random.bitcoinHeight,
+            };
         },
     };
     return random;
@@ -22,12 +46,13 @@ function Rng() {
         /**
          * Generates a random 256 long hex hash
          *
-         * @param   {string} clientSeed - the clientSeed
-         * @param   {string} serverSeed - the serverSeed
-         * @param   {number} nonce      - the nonce
+         * @param   {string} clientSeed  - the clientSeed
+         * @param   {string} serverSeed  - the serverSeed
+         * @param   {string} bitcoinHash - The latest bitcoin block hash.
+         * @param   {number} nonce       - the nonce
          * @returns {string} combined string
          */
-        combine: (clientSeed, serverSeed, nonce) => clientSeed + serverSeed + nonce,
+        combine: (clientSeed, serverSeed, bitcoinHash, nonce) => clientSeed + serverSeed + bitcoinHash + nonce,
         /**
          * Generates a sha512 hash from a string
          *
@@ -62,11 +87,12 @@ function Rng() {
          *
          * @param {string} clientseed - The clientseed to use.
          * @param {string} serverseed - The serverseed to use.
+         * @param {string} bitcoinHash - The latest bitcoin block hash.
          * @param {number} nonce - The nonce to use.
          * @returns {Uint8Array} - The generated bytes as a Uint8Array.
          */
-        byteGenerator: function (clientseed, serverseed, nonce) {
-            const preHash = this.combine(clientseed, serverseed, nonce);
+        byteGenerator: function (clientseed, serverseed, bitcoinHash, nonce) {
+            const preHash = this.combine(clientseed, serverseed, bitcoinHash, nonce);
             const hash = this.sha512(preHash);
             return this.hexToBytes(hash.slice(0, 64));
         },
@@ -75,27 +101,29 @@ function Rng() {
          *
          * @param {string} clientSeed - The client seed.
          * @param {string} serverSeed - The server seed.
+         * @param {string} bitcoinHash - The latest bitcoin block hash.
          * @param {number} nonce - The nonce.
          * @param {number} min - The minimum value of the range.
          * @param {number} max - The maximum value of the range.
          * @returns {number} A random integer between min and max (inclusive).
          */
-        generateInteger: function (clientSeed, serverSeed, nonce, min, max) {
-            const preHash = this.combine(clientSeed, serverSeed, nonce);
+        generateInteger: function (clientSeed, serverSeed, bitcoinHash, nonce, min, max) {
+            const preHash = this.combine(clientSeed, serverSeed, bitcoinHash, nonce);
             const hash = this.sha512(preHash);
             const range = max - min + 1;
-            return (parseInt(hash.slice(0, 8), 16) % range) + min;
+            return (parseInt(hash.slice(0, 16), 16) % range) + min;
         },
         /**
          * Generates a random float between 0 and 1 using the fairjs library.
          * @param {string} clientSeed - The client seed to use for the random number generation.
          * @param {string} serverSeed - The server seed to use for the random number generation.
+         * @param {string} bitcoinHash - The latest bitcoin block hash.
          * @param {number} nonce - The nonce to use for the random number generation.
          * @param {number} [precision=2] - The number of decimal places to include in the result.
          * @returns {number} - The random float between 0 and 1.
          */
-        generateFloat: function (clientSeed, serverSeed, nonce, precision = 2) {
-            const bytes = this.byteGenerator(clientSeed, serverSeed, nonce);
+        generateFloat: function (clientSeed, serverSeed, bitcoinHash, nonce, precision = 2) {
+            const bytes = this.byteGenerator(clientSeed, serverSeed, bitcoinHash, nonce);
             const float = parseFloat("0." + bytes.join(""));
             return parseFloat(float.toFixed(precision));
         },
@@ -107,25 +135,28 @@ function Rng() {
          * @param {number} nonce       - The nonce.
          * @returns {float, boolean} random boolean true/false
          */
-        generateBool: function (clientSeed, serverSeed, nonce) {
-            return this.generateFloat(clientSeed, serverSeed, nonce, 10) <= 0.5 ? true : false;
+        generateBool: function (clientSeed, serverSeed, bitcoinHash, nonce) {
+            return this.generateFloat(clientSeed, serverSeed, bitcoinHash, nonce, 10) <= 0.5
+                ? true
+                : false;
         },
         /**
          * Selects a random object from an array of objects based on their probabilities.
          *
          * @param {string} clientSeed - The client seed.
          * @param {string} serverSeed - The server seed.
+         * @param {string} bitcoinHash - The latest bitcoin block hash.
          * @param {number} nonce      - The nonce.
          * @param {Array}  objects    - An array of objects with an ID and a probability property.
          * @returns {String} The ID of the randomly selected object.
          */
-        selectRandomObject: function (clientSeed, serverSeed, nonce, objects) {
+        selectRandomObject: function (clientSeed, serverSeed, bitcoinHash, nonce, objects) {
             let totalProbability = 0;
             for (const obj of objects) {
                 totalProbability += obj.probability;
             }
             const normalizedProbabilities = objects.map((obj) => obj.probability / totalProbability);
-            const randomFloat = this.generateFloat(clientSeed, serverSeed, nonce, 10);
+            const randomFloat = this.generateFloat(clientSeed, serverSeed, bitcoinHash, nonce, 10);
             let index = 0;
             for (let i = 0; i < normalizedProbabilities.length; i++) {
                 index += normalizedProbabilities[i];
@@ -136,5 +167,23 @@ function Rng() {
             // If no object is selected, return null
             return null;
         },
+        /**
+         * Gets the latest Bitcoin block hash from the LND node
+         *
+         * @returns {Promise<string>} The latest Bitcoin block hash
+         */
+        getBitcoinLatestBlockHash: function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    if (!accountsApi.instance.defaults.baseURL) {
+                        return { hash: "", height: 0 };
+                    }
+                    return (yield accountsApi.wallet.getLatestBitcoinBlock()).data || { hash: "", height: 0 };
+                }
+                catch (error) {
+                    return { hash: "", height: 0 };
+                }
+            });
+        },
     };
 }

package/dist/types.d.ts

@@ -237,12 +237,17 @@ export interface IHandPoints {
 export interface IRandom {
     secret: string;
     clients: string[];
+    bitcoinHash: string;
+    bitcoinHeight: number;
     nonce: number;
+    getLatestBitcoinBlock(): Promise<void>;
     next(): void;
     pick(idx: number, max: number): number;
     reveal(): {
         secret: string;
         clients: string[];
+        bitcoinHash: string;
+        bitcoinHeight: number;
     };
 }
 export type IPublicPlayer = Pick<IPlayer, "idx" | "key" | "name" | "abandonedTime" | "accountId" | "avatarUrl" | "disabled" | "abandoned" | "ready" | "hand" | "usedHand" | "prevHand" | "teamIdx" | "isTurn" | "turnExpiresAt" | "turnExtensionExpiresAt" | "isEnvidoTurn" | "isOwner"> & ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trucoshi",
-  "version": "7.0.0",
+  "version": "7.1.0",
   "description": "Lightning Truco Server",
   "main": "dist/types.js",
   "license": "GPL-3.0",
@@ -76,7 +76,7 @@
     "dotenv-cli": "^7.3.0",
     "form-data": "^4.0.0",
     "jsonwebtoken": "^9.0.2",
-    "lightning-accounts": "^4.1.0",
+    "lightning-accounts": "4.3.0",
     "node-forge": "^1.3.1",
     "path-scurry": "^1.9.2",
     "pino": "^9.3.2",