Extracted chia specific logic into the infrastructure layer and kept application blockchain agnostic

Signed-off-by: Robert Gogete <[email protected]>

Author: gogeterobert

src/application/interfaces/IBlockChainService.ts

@@ -1,7 +1,34 @@
 import { Block } from "../types/Block";
+import type { Coin, Peer, UnspentCoinsResponse } from '@dignetwork/datalayer-driver';
 
 
 export interface IBlockchainService {
   getCurrentBlockchainHeight(): Promise<number>;
   getBlockchainBlockByHeight(height: number): Promise<Block>;
+  // Key and address methods
+  masterSecretKeyFromSeed(seed: Buffer): Buffer;
+  secretKeyToPublicKey(secretKey: Buffer): Buffer;
+  masterPublicKeyToWalletSyntheticKey(publicKey: Buffer): Buffer;
+  masterSecretKeyToWalletSyntheticSecretKey(secretKey: Buffer): Buffer;
+  masterPublicKeyToFirstPuzzleHash(publicKey: Buffer): Buffer;
+  puzzleHashToAddress(puzzleHash: Buffer, prefix: string): string;
+  signMessage(message: Buffer, privateKey: Buffer): Buffer;
+  // Coin selection
+  getCoinId(coin: Coin): Buffer;
+  selectCoins(coins: Coin[], amount: bigint): Coin[];
+  // ColdWallet/WalletService methods
+  getPuzzleHash(address: string): Buffer;
+  verifyKeySignature(signature: Buffer, publicKey: Buffer, message: Buffer): boolean;
+  listUnspentCoins(
+    peer: Peer,
+    puzzleHash: Buffer,
+    previousHeight: number,
+    previousHeaderHash: Buffer
+  ): Promise<UnspentCoinsResponse>;
+  isCoinSpendable(
+    peer: Peer,
+    coinId: Buffer,
+    lastHeight: number,
+    headerHash: Buffer
+  ): Promise<boolean>;
 }

src/application/services/WalletService.ts

@@ -3,12 +3,16 @@ import * as bip39 from 'bip39';
 import { NconfService } from '../../infrastructure/ConfigurationServices/NconfService';
 import { EncryptionService } from './EncryptionService';
 import { EncryptedData } from '../types/EncryptedData';
-import { Peer, verifySignedMessage } from '@dignetwork/datalayer-driver';
 import { Wallet } from '../types/Wallet';
+import type { IBlockchainService } from '../interfaces/IBlockChainService';
+import { ChiaBlockchainService } from '../../infrastructure/BlockchainServices/ChiaBlockchainService';
+import { Peer } from '@dignetwork/datalayer-driver';
 
 const KEYRING_FILE = 'keyring.json';
 
 export class WalletService {
+  private static blockchain: IBlockchainService = new ChiaBlockchainService();
+
   public static async loadWallet(walletName: string = 'default'): Promise<Wallet> {
     const mnemonic = await this.getMnemonicFromKeyring(walletName);
     if (mnemonic) return new Wallet(mnemonic);
@@ -46,7 +50,7 @@ export class WalletService {
     publicKey: string,
   ): Promise<boolean> {
     const message = `Signing this message to prove ownership of key.\n\nNonce: ${nonce}`;
-    return verifySignedMessage(
+    return this.blockchain.verifyKeySignature(
       Buffer.from(signature, 'hex'),
       Buffer.from(publicKey, 'hex'),
       Buffer.from(message, 'utf-8'),
@@ -59,7 +63,7 @@ export class WalletService {
 
   public static async isCoinSpendable(peer: Peer, coinId: Buffer, lastHeight: number, lastHeaderHash: string): Promise<boolean> {
     try {
-      return await peer.isCoinSpent(coinId, lastHeight, Buffer.from(lastHeaderHash, 'hex'));
+      return await this.blockchain.isCoinSpendable(peer, coinId, lastHeight, Buffer.from(lastHeaderHash, 'hex'));
     } catch {
       return false;
     }

src/application/types/ColdWallet.ts

@@ -1,31 +1,37 @@
-import { Peer, UnspentCoinsResponse, addressToPuzzleHash, verifySignedMessage, masterPublicKeyToWalletSyntheticKey, masterPublicKeyToFirstPuzzleHash } from '@dignetwork/datalayer-driver';
+import type { Peer, UnspentCoinsResponse } from '@dignetwork/datalayer-driver';
+import type { IBlockchainService } from '../interfaces/IBlockChainService';
 
 export interface IColdWallet {
   getPuzzleHash(address: string): Buffer;
   verifyKeySignature(signature: Buffer, publicKey: Buffer, message: Buffer): boolean;
   listUnspentCoins(
     peer: Peer,
     puzzleHash: Buffer,
-    previousHeight: number | undefined | null,
+    previousHeight: number,
     previousHeaderHash: Buffer
   ): Promise<UnspentCoinsResponse>;
   isCoinSpendable(
     peer: Peer,
     coinId: Buffer,
-    lastHeight: number | undefined | null,
+    lastHeight: number,
     headerHash: Buffer
   ): Promise<boolean>;
   masterPublicKeyToWalletSyntheticKey(publicKey: Buffer): Buffer;
   masterPublicKeyToFirstPuzzleHash(publicKey: Buffer): Buffer;
 }
 
 export class ColdWallet implements IColdWallet {
+  private blockchain: IBlockchainService;
+  constructor(blockchain: IBlockchainService) {
+    this.blockchain = blockchain;
+  }
+
   getPuzzleHash(address: string): Buffer {
-    return addressToPuzzleHash(address);
+    return this.blockchain.getPuzzleHash(address);
   }
 
   verifyKeySignature(signature: Buffer, publicKey: Buffer, message: Buffer): boolean {
-    return verifySignedMessage(signature, publicKey, message);
+    return this.blockchain.verifyKeySignature(signature, publicKey, message);
   }
 
   async listUnspentCoins(
@@ -34,7 +40,7 @@ export class ColdWallet implements IColdWallet {
     previousHeight: number,
     previousHeaderHash: Buffer
   ) {
-    return await peer.getAllUnspentCoins(puzzleHash, previousHeight, previousHeaderHash);
+    return await this.blockchain.listUnspentCoins(peer, puzzleHash, previousHeight, previousHeaderHash);
   }
 
   async isCoinSpendable(
@@ -43,14 +49,14 @@ export class ColdWallet implements IColdWallet {
     lastHeight: number,
     headerHash: Buffer
   ): Promise<boolean> {
-    return !(await peer.isCoinSpent(coinId, lastHeight, headerHash));
+    return await this.blockchain.isCoinSpendable(peer, coinId, lastHeight, headerHash);
   }
 
   masterPublicKeyToWalletSyntheticKey(publicKey: Buffer): Buffer {
-    return masterPublicKeyToWalletSyntheticKey(publicKey);
+    return this.blockchain.masterPublicKeyToWalletSyntheticKey(publicKey);
   }
 
   masterPublicKeyToFirstPuzzleHash(publicKey: Buffer): Buffer {
-    return masterPublicKeyToFirstPuzzleHash(publicKey);
+    return this.blockchain.masterPublicKeyToFirstPuzzleHash(publicKey);
   }
 }

src/application/types/Wallet.ts

@@ -1,18 +1,8 @@
-import {
-  Coin,
-  getCoinId,
-  masterPublicKeyToFirstPuzzleHash,
-  masterPublicKeyToWalletSyntheticKey,
-  masterSecretKeyToWalletSyntheticSecretKey,
-  Peer,
-  puzzleHashToAddress,
-  secretKeyToPublicKey,
-  selectCoins,
-  signMessage,
-} from '@dignetwork/datalayer-driver';
 import { mnemonicToSeedSync } from 'bip39';
-import { PrivateKey } from 'chia-bls';
 import { FileCacheService } from '../services/FileCacheService';
+import type { IBlockchainService } from '../interfaces/IBlockChainService';
+import { Coin, Peer } from '@dignetwork/datalayer-driver';
+import { ChiaBlockchainService } from '../../infrastructure/BlockchainServices/ChiaBlockchainService';
 
 const COIN_CACHE_DURATION = 600000;
 
@@ -36,9 +26,11 @@ export interface IWallet {
 
 export class Wallet implements IWallet {
   private mnemonic: string;
+  private blockchain: IBlockchainService;
 
   public constructor(mnemonic: string) {
     this.mnemonic = mnemonic;
+    this.blockchain = new ChiaBlockchainService();
   }
 
   public getMnemonic(): string {
@@ -50,35 +42,35 @@ export class Wallet implements IWallet {
 
   public async getMasterSecretKey(): Promise<Buffer> {
     const seed = mnemonicToSeedSync(this.getMnemonic());
-    return Buffer.from(PrivateKey.fromSeed(seed).toHex(), 'hex');
+    return this.blockchain.masterSecretKeyFromSeed(seed);
   }
 
   public async getPublicSyntheticKey(): Promise<Buffer> {
     const master_sk = await this.getMasterSecretKey();
-    const master_pk = secretKeyToPublicKey(master_sk);
-    return masterPublicKeyToWalletSyntheticKey(master_pk);
+    const master_pk = this.blockchain.secretKeyToPublicKey(master_sk);
+    return this.blockchain.masterPublicKeyToWalletSyntheticKey(master_pk);
   }
 
   public async getPrivateSyntheticKey(): Promise<Buffer> {
     const master_sk = await this.getMasterSecretKey();
-    return masterSecretKeyToWalletSyntheticSecretKey(master_sk);
+    return this.blockchain.masterSecretKeyToWalletSyntheticSecretKey(master_sk);
   }
 
   public async getOwnerPuzzleHash(): Promise<Buffer> {
     const master_sk = await this.getMasterSecretKey();
-    const master_pk = secretKeyToPublicKey(master_sk);
-    return masterPublicKeyToFirstPuzzleHash(master_pk);
+    const master_pk = this.blockchain.secretKeyToPublicKey(master_sk);
+    return this.blockchain.masterPublicKeyToFirstPuzzleHash(master_pk);
   }
 
   public async getOwnerPublicKey(): Promise<string> {
     const ownerPuzzleHash = await this.getOwnerPuzzleHash();
-    return puzzleHashToAddress(ownerPuzzleHash, 'xch'); // might need to also add txch for testnet
+    return this.blockchain.puzzleHashToAddress(ownerPuzzleHash, 'xch');
   }
 
   public async createKeyOwnershipSignature(nonce: string): Promise<string> {
     const message = `Signing this message to prove ownership of key.\n\nNonce: ${nonce}`;
     const privateSyntheticKey = await this.getPrivateSyntheticKey();
-    const signature = signMessage(Buffer.from(message, 'utf-8'), privateSyntheticKey);
+    const signature = this.blockchain.signMessage(Buffer.from(message, 'utf-8'), privateSyntheticKey);
     return signature.toString('hex');
   }
 
@@ -97,7 +89,7 @@ export class Wallet implements IWallet {
     // 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) => this.blockchain.getCoinId(coin).toString('hex'));
 
       // Update omitCoinIds with currently valid reserved coins
       const cachedReservedCoins = cache.getCachedKeys();
@@ -120,10 +112,10 @@ export class Wallet implements IWallet {
       );
 
       const unspentCoins = coinsResp.coins.filter(
-        (coin) => !omitCoinIds.includes(getCoinId(coin).toString('hex')),
+        (coin) => !omitCoinIds.includes(this.blockchain.getCoinId(coin).toString('hex')),
       );
 
-      const selectedCoins = selectCoins(unspentCoins, feeBigInt + coinAmount);
+      const selectedCoins = this.blockchain.selectCoins(unspentCoins, feeBigInt + coinAmount);
 
       return selectedCoins;
     };
@@ -157,7 +149,7 @@ export class Wallet implements IWallet {
 
     // Reserve the selected coins
     selectedCoins.forEach((coin) => {
-      const coinId = getCoinId(coin).toString('hex');
+      const coinId = this.blockchain.getCoinId(coin).toString('hex');
       cache.set(coinId, { coinId, expiry: Date.now() + COIN_CACHE_DURATION });
     });
 

src/infrastructure/BlockchainServices/ChiaBlockchainService.ts

@@ -1,12 +1,87 @@
-
 import { IBlockchainService } from "../../application/interfaces/IBlockChainService";
 import { Block } from "../../application/types/Block";
+import {
+  masterSecretKeyToWalletSyntheticSecretKey,
+  masterPublicKeyToWalletSyntheticKey,
+  masterPublicKeyToFirstPuzzleHash,
+  secretKeyToPublicKey,
+  puzzleHashToAddress,
+  signMessage,
+  getCoinId,
+  selectCoins,
+  addressToPuzzleHash,
+  verifySignedMessage,
+} from '@dignetwork/datalayer-driver';
+import type { Coin, Peer, UnspentCoinsResponse } from '@dignetwork/datalayer-driver';
+import { PrivateKey } from 'chia-bls';
 
 export class ChiaBlockchainService implements IBlockchainService {
   async getCurrentBlockchainHeight(): Promise<number> {
     return 0;
   }
+
   async getBlockchainBlockByHeight(height: number): Promise<Block> {
     return { hash: Buffer.from('abc', 'hex'), blockHeight: height };
   }
+
+  masterSecretKeyFromSeed(seed: Buffer): Buffer {
+    return Buffer.from(PrivateKey.fromSeed(seed).toHex(), 'hex');
+  }
+
+  secretKeyToPublicKey(secretKey: Buffer): Buffer {
+    return secretKeyToPublicKey(secretKey);
+  }
+
+  masterPublicKeyToWalletSyntheticKey(publicKey: Buffer): Buffer {
+    return masterPublicKeyToWalletSyntheticKey(publicKey);
+  }
+
+  masterSecretKeyToWalletSyntheticSecretKey(secretKey: Buffer): Buffer {
+    return masterSecretKeyToWalletSyntheticSecretKey(secretKey);
+  }
+  
+  masterPublicKeyToFirstPuzzleHash(publicKey: Buffer): Buffer {
+    return masterPublicKeyToFirstPuzzleHash(publicKey);
+  }
+
+  puzzleHashToAddress(puzzleHash: Buffer, prefix: string): string {
+    return puzzleHashToAddress(puzzleHash, prefix);
+  }
+
+  signMessage(message: Buffer, privateKey: Buffer): Buffer {
+    return signMessage(message, privateKey);
+  }
+
+  getCoinId(coin: Coin): Buffer {
+    return getCoinId(coin);
+  }
+
+  selectCoins(coins: Coin[], amount: bigint): Coin[] {
+    return selectCoins(coins, amount);
+  }
+
+  getPuzzleHash(address: string): Buffer {
+    return addressToPuzzleHash(address);
+  }
+  verifyKeySignature(signature: Buffer, publicKey: Buffer, message: Buffer): boolean {
+    return verifySignedMessage(signature, publicKey, message);
+  }
+
+  async listUnspentCoins(
+    peer: Peer,
+    puzzleHash: Buffer,
+    previousHeight: number,
+    previousHeaderHash: Buffer
+  ): Promise<UnspentCoinsResponse> {
+    return await peer.getAllUnspentCoins(puzzleHash, previousHeight, previousHeaderHash);
+  }
+  
+  async isCoinSpendable(
+    peer: Peer,
+    coinId: Buffer,
+    lastHeight: number,
+    headerHash: Buffer
+  ): Promise<boolean> {
+    return !(await peer.isCoinSpent(coinId, lastHeight, headerHash));
+  }
 }

src/infrastructure/BlockchainServices/TestBlockchainService.ts

@@ -1,7 +1,8 @@
-
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { IBlockchainService } from "../../application/interfaces/IBlockChainService";
 import { Block } from "../../application/types/Block";
 import Database from 'better-sqlite3';
+import type { Coin, Peer, UnspentCoinsResponse } from '@dignetwork/datalayer-driver';
 
 export class TestBlockchainService implements IBlockchainService {
   private db: Database.Database;
@@ -24,4 +25,39 @@ export class TestBlockchainService implements IBlockchainService {
       blockHeight: row.blockHeight,
     };
   }
+
+  masterSecretKeyFromSeed(seed: Buffer): Buffer { return Buffer.alloc(32, 1); }
+  secretKeyToPublicKey(secretKey: Buffer): Buffer { return Buffer.alloc(32, 2); }
+  masterPublicKeyToWalletSyntheticKey(publicKey: Buffer): Buffer { return Buffer.alloc(32, 3); }
+  masterSecretKeyToWalletSyntheticSecretKey(secretKey: Buffer): Buffer { return Buffer.alloc(32, 4); }
+  masterPublicKeyToFirstPuzzleHash(publicKey: Buffer): Buffer { return Buffer.alloc(32, 5); }
+  puzzleHashToAddress(puzzleHash: Buffer, prefix: string): string { return prefix + puzzleHash.toString('hex'); }
+  signMessage(message: Buffer, privateKey: Buffer): Buffer { return Buffer.from('deadbeef', 'hex'); }
+  getCoinId(coin: Coin): Buffer { return Buffer.from('cafebabe', 'hex'); }
+  selectCoins(coins: Coin[], amount: bigint): Coin[] { return coins.slice(0, 1); }
+
+  // New methods for ColdWallet/WalletService
+  getPuzzleHash(address: string): Buffer {
+    return Buffer.from(address, 'utf-8'); // Dummy
+  }
+  verifyKeySignature(signature: Buffer, publicKey: Buffer, message: Buffer): boolean {
+    return true; // Dummy
+  }
+  async listUnspentCoins(
+    peer: Peer,
+    puzzleHash: Buffer,
+    previousHeight: number,
+    previousHeaderHash: Buffer
+  ): Promise<UnspentCoinsResponse> {
+    // Dummy: return a fake response
+    return { coins: [], lastHeight: 0, lastHeaderHash: Buffer.alloc(32) };
+  }
+  async isCoinSpendable(
+    peer: Peer,
+    coinId: Buffer,
+    lastHeight: number,
+    headerHash: Buffer
+  ): Promise<boolean> {
+    return true; // Dummy
+  }
 }