Add a way to manage environment variables - task 86c43c329 (#5)

* Added config for dig and moved what will not be changedable as constants to the files their are in scope for

Signed-off-by: Robert Gogete <gogeterobert@yahoo.com>

* Added default for dig path and updated test

Signed-off-by: Robert Gogete <gogeterobert@yahoo.com>

---------

Signed-off-by: Robert Gogete <gogeterobert@yahoo.com>

Author: gogeterobert

.gitignore

@@ -274,3 +274,7 @@ dist
 # Local databases
 
 **/*.sqlite
+
+# Local dig files
+
+.dig

src/application/services/FileCacheService.ts

@@ -1,13 +1,12 @@
 import fs from "fs";
 import path from "path";
-
-export const DIG_FOLDER_PATH = path.join(process.cwd(), ".dig");
+import config from "../../config";
 
 export class FileCacheService<T> {
   private cacheDir: string;
 
-  constructor(relativeFilePath: string, baseDir: string = DIG_FOLDER_PATH) {
-    this.cacheDir = path.join(baseDir, relativeFilePath);
+  constructor(relativeFilePath: string) {
+    this.cacheDir = path.join(config.DIG_FOLDER_PATH, relativeFilePath);
     this.ensureDirectoryExists();
   }
 

src/application/services/WalletService.ts

@@ -3,11 +3,10 @@ import * as bip39 from 'bip39';
 import { NconfService } from '../../infrastructure/ConfigurationServices/NconfService';
 import { EncryptionService } from './EncryptionService';
 import { EncryptedData } from '../types/EncryptedData';
-import { MIN_HEIGHT, MIN_HEIGHT_HEADER_HASH, Wallet } from '../types/Wallet';
 import { Peer, verifySignedMessage } from '@dignetwork/datalayer-driver';
+import { Wallet } from '../types/Wallet';
 
-export const KEYRING_FILE = 'keyring.json';
-export const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+const KEYRING_FILE = 'keyring.json';
 
 export class WalletService {
   public static async loadWallet(walletName: string = 'default'): Promise<Wallet> {
@@ -37,8 +36,8 @@ export class WalletService {
       return [];
     }
 
-    const config = await nconfService.getFullConfig();
-    return Object.keys(config);
+    const configData = await nconfService.getFullConfig();
+    return Object.keys(configData);
   }
 
   public static async verifyKeyOwnershipSignature(
@@ -58,9 +57,9 @@ export class WalletService {
     return BigInt(1000000);
   }
 
-  public static async isCoinSpendable(peer: Peer, coinId: Buffer): Promise<boolean> {
+  public static async isCoinSpendable(peer: Peer, coinId: Buffer, lastHeight: number, lastHeaderHash: string): Promise<boolean> {
     try {
-      return await peer.isCoinSpent(coinId, MIN_HEIGHT, Buffer.from(MIN_HEIGHT_HEADER_HASH, 'hex'));
+      return await peer.isCoinSpent(coinId, lastHeight, Buffer.from(lastHeaderHash, 'hex'));
     } catch {
       return false;
     }

src/application/types/Wallet.ts

@@ -1,5 +1,5 @@
 import {
-    Coin,
+  Coin,
   getCoinId,
   masterPublicKeyToFirstPuzzleHash,
   masterPublicKeyToWalletSyntheticKey,
@@ -13,15 +13,8 @@ import {
 import { mnemonicToSeedSync } from 'bip39';
 import { PrivateKey } from 'chia-bls';
 import { FileCacheService } from '../services/FileCacheService';
-import { CACHE_DURATION } from '../services/WalletService';
-import path from 'path';
-import os from 'os';
 
-export const MIN_HEIGHT = 5777842;
-export const MIN_HEIGHT_HEADER_HASH =
-  "b29a4daac2434fd17a36e15ba1aac5d65012d4a66f99bed0bf2b5342e92e562c";
-  
-export const USER_DIR_PATH = path.join(os.homedir(), '.dig');
+const COIN_CACHE_DURATION = 600000;
 
 export class Wallet {
   private mnemonic: string;
@@ -75,21 +68,18 @@ export class Wallet {
     peer: Peer,
     coinAmount: bigint,
     feeBigInt: bigint,
-    omitCoins: Coin[] = []
+    omitCoins: Coin[] = [],
+    lastHeight: number,
+    lastHeaderHash: string,
   ): Promise<Coin[]> {
-    const cache = new FileCacheService<{ coinId: string; expiry: number }>(
-      "reserved_coins",
-      USER_DIR_PATH
-    );
+    const cache = new FileCacheService<{ coinId: string; expiry: number }>('reserved_coins');
 
     const ownerPuzzleHash = await this.getOwnerPuzzleHash();
 
     // Define a function to attempt selecting unspent coins
     const trySelectCoins = async (): Promise<Coin[]> => {
       const now = Date.now();
-      const omitCoinIds = omitCoins.map((coin) =>
-        getCoinId(coin).toString("hex")
-      );
+      const omitCoinIds = omitCoins.map((coin) => getCoinId(coin).toString('hex'));
 
       // Update omitCoinIds with currently valid reserved coins
       const cachedReservedCoins = cache.getCachedKeys();
@@ -107,12 +97,12 @@ export class Wallet {
 
       const coinsResp = await peer.getAllUnspentCoins(
         ownerPuzzleHash,
-        MIN_HEIGHT,
-        Buffer.from(MIN_HEIGHT_HEADER_HASH, "hex")
+        lastHeight,
+        Buffer.from(lastHeaderHash, 'hex'),
       );
 
       const unspentCoins = coinsResp.coins.filter(
-        (coin) => !omitCoinIds.includes(getCoinId(coin).toString("hex"))
+        (coin) => !omitCoinIds.includes(getCoinId(coin).toString('hex')),
       );
 
       const selectedCoins = selectCoins(unspentCoins, feeBigInt + coinAmount);
@@ -142,15 +132,15 @@ export class Wallet {
           await new Promise((resolve) => setTimeout(resolve, 10000));
         } else {
           // No unspent coins and no reserved coins
-          throw new Error("No unspent coins available.");
+          throw new Error('No unspent coins available.');
         }
       }
     }
 
     // Reserve the selected coins
     selectedCoins.forEach((coin) => {
-      const coinId = getCoinId(coin).toString("hex");
-      cache.set(coinId, { coinId, expiry: Date.now() + CACHE_DURATION });
+      const coinId = getCoinId(coin).toString('hex');
+      cache.set(coinId, { coinId, expiry: Date.now() + COIN_CACHE_DURATION });
     });
 
     return selectedCoins;

src/config/index.ts

@@ -0,0 +1,9 @@
+interface DigConfig {
+  DIG_FOLDER_PATH: string;
+}
+
+const config: DigConfig = {
+  DIG_FOLDER_PATH: '.dig',
+};
+
+export default config;

src/infrastructure/ConfigurationServices/NconfService.ts

@@ -2,17 +2,16 @@ import nconf from 'nconf';
 import fs from 'fs-extra';
 import { Mutex } from 'async-mutex';
 import path from 'path';
-import os from 'os';
 import { IConfigurationService } from '../../application/interfaces/IConfigurationService';
+import config from '../../config';
 
-export const CONF_FOLDER_PATH = path.join(os.homedir(), '.dig');
 const fileMutex = new Mutex();
 
 export class NconfService implements IConfigurationService {
   private configFilePath: string;
 
   constructor(relativePath: string) {
-    this.configFilePath = path.join(CONF_FOLDER_PATH, relativePath);
+    this.configFilePath = path.join(config.DIG_FOLDER_PATH, relativePath);
     this.initializeConfig();
   }
 

test/application/services/FileCacheService.test.ts

@@ -1,9 +1,10 @@
 import fs from 'fs';
 import path from 'path';
-import { FileCacheService, DIG_FOLDER_PATH } from '../../../src/application/services/FileCacheService';
+import config from '../../../src/config';
+import { FileCacheService } from '../../../src/application/services/FileCacheService';
 
 describe('FileCacheService', () => {
-  const testDir = path.join(DIG_FOLDER_PATH, 'jest-test-cache');
+  const testDir = path.join(config.DIG_FOLDER_PATH, 'jest-test-cache');
   const key = 'testKey';
   const value = { foo: 'bar', num: 42 };
 

test/application/services/WalletService.test.ts

@@ -91,20 +91,20 @@ describe('WalletService Integration', () => {
 
     it('should return true if peer.isCoinSpent resolves true', async () => {
       peer.isCoinSpent.mockResolvedValue(true);
-      const result = await WalletService.isCoinSpendable(peer, coinId);
+      const result = await WalletService.isCoinSpendable(peer, coinId, 0, '00'.repeat(32));
       expect(result).toBe(true);
       expect(peer.isCoinSpent).toHaveBeenCalledWith(coinId, expect.any(Number), expect.any(Buffer));
     });
 
     it('should return false if peer.isCoinSpent resolves false', async () => {
       peer.isCoinSpent.mockResolvedValue(false);
-      const result = await WalletService.isCoinSpendable(peer, coinId);
+      const result = await WalletService.isCoinSpendable(peer, coinId, 0, '00'.repeat(32));
       expect(result).toBe(false);
     });
 
     it('should return false if peer.isCoinSpent throws', async () => {
       peer.isCoinSpent.mockRejectedValue(new Error('fail'));
-      const result = await WalletService.isCoinSpendable(peer, coinId);
+      const result = await WalletService.isCoinSpendable(peer, coinId, 0, '00'.repeat(32));
       expect(result).toBe(false);
     });
   });

test/application/types/Wallet.test.ts

@@ -93,7 +93,7 @@ describe('Wallet', () => {
 
     it('should select and reserve coins, respecting omitCoins and cache', async () => {
       const omitCoins = [{ id: '01', amount: 100n }];
-      const result = await wallet.selectUnspentCoins(mockPeer, 50n, 10n, omitCoins);
+      const result = await wallet.selectUnspentCoins(mockPeer, 50n, 10n, omitCoins, 0, '00'.repeat(32));
       expect(mockPeer.getAllUnspentCoins).toHaveBeenCalledWith(mockOwnerPuzzleHash, expect.any(Number), expect.any(Buffer));
       expect(Array.isArray(result)).toBe(true);
       expect(result.length).toBe(1);
@@ -106,15 +106,15 @@ describe('Wallet', () => {
     it('should throw if no coins and no reserved', async () => {
       mockPeer.getAllUnspentCoins.mockResolvedValue({ coins: [] });
       mockCache.getCachedKeys.mockReturnValue([]);
-      await expect(wallet.selectUnspentCoins(mockPeer, 50n, 10n)).rejects.toThrow('No unspent coins available.');
+      await expect(wallet.selectUnspentCoins(mockPeer, 50n, 10n, [], 0, '00'.repeat(32))).rejects.toThrow('No unspent coins available.');
     });
 
     it('should retry if reserved coins exist', async () => {
       // Simulate reserved coins present, but no unspent coins
       mockPeer.getAllUnspentCoins.mockResolvedValue({ coins: [] });
       mockCache.getCachedKeys.mockReturnValue(['deadbeef']);
       mockCache.get.mockReturnValue({ coinId: 'deadbeef', expiry: Date.now() + 10000 });
-      const promise = wallet.selectUnspentCoins(mockPeer, 50n, 10n);
+      const promise = wallet.selectUnspentCoins(mockPeer, 50n, 10n, [], 0, '00'.repeat(32));
       // Fast-fail the wait
       jest.spyOn(global, 'setTimeout').mockImplementation((fn: any) => { fn(); return 0 as any; });
       setTimeout(() => promise.catch(() => {}), 20); // avoid unhandled rejection