Initial Handshake Implementation

apps/rosen-service/config/default.yaml

@@ -70,6 +70,17 @@ doge:
     # - url:
     #   username:
     #   password:
+handshake:
+  addresses:
+    lock:
+    eventTrigger:
+    permit:
+    fraud:
+    commitment:
+  tokens:
+    rwt:
+  initialHeight:
+  rpcUrl:
 ethereum:
   addresses:
     lock:
@@ -105,6 +116,7 @@ calculator:
     bitcoin: []
     bitcoin-runes: []
     doge: []
+    handshake: []
     ethereum: []
     binance: []
 healthCheck:
@@ -120,6 +132,8 @@ healthCheck:
   ethereumScannerCriticalDiff: 5
   binanceScannerWarnDiff: 3
   binanceScannerCriticalDiff: 5
+  handshakeScannerWarnDiff: 3
+  handshakeScannerCriticalDiff: 5
   interval: 60 # health check update interval (in seconds)
   duration: 600 # log duration time check (in seconds)
   maxAllowedErrorCount: 1 # maximum allowed error log lines

apps/rosen-service/package.json

@@ -38,6 +38,8 @@
     "@rosen-bridge/ergo-scanner": "^0.1.4",
     "@rosen-bridge/evm-observation-extractor": "^5.4.1",
     "@rosen-bridge/evm-scanner": "^0.1.4",
+    "@rosen-bridge/handshake-rpc-observation-extractor": "^0.1.0",
+    "@rosen-bridge/handshake-rpc-scanner": "^0.1.0",
     "@rosen-bridge/health-check": "^8.0.0",
     "@rosen-bridge/log-level-check": "^3.0.0",
     "@rosen-bridge/scanner-interfaces": "^0.2.1",

apps/rosen-service/src/calculator/calculator-service.ts

@@ -78,6 +78,10 @@ const start = async () => {
       addresses: config.calculator.addresses.doge,
       blockcypherUrl: config.doge.blockcypherUrl,
     },
+    {
+      addresses: config.calculator.addresses.handshake,
+      rpcUrl: config.handshake.rpcUrl,
+    },
     dataSource,
     logger,
   );

apps/rosen-service/src/configs.ts

@@ -144,6 +144,22 @@ const getConfig = () => {
           }>
         >('doge.rpcConnections'),
       },
+      handshake: {
+        addresses: {
+          lock: nodeConfig.get<string>('handshake.addresses.lock'),
+          eventTrigger: nodeConfig.get<string>(
+            'handshake.addresses.eventTrigger',
+          ),
+          permit: nodeConfig.get<string>('handshake.addresses.permit'),
+          fraud: nodeConfig.get<string>('handshake.addresses.fraud'),
+          commitment: nodeConfig.get<string>('handshake.addresses.commitment'),
+        },
+        initialHeight: nodeConfig.get<number>('handshake.initialHeight'),
+        tokens: {
+          rwt: nodeConfig.get<string>('handshake.tokens.rwt'),
+        },
+        rpcUrl: nodeConfig.get<string>('handshake.rpcUrl'),
+      },
       postgres: {
         url: nodeConfig.get<string>('postgres.url'),
         logging: nodeConfig.get<boolean>('postgres.logging'),
@@ -160,6 +176,7 @@ const getConfig = () => {
           ethereum: nodeConfig.get<string[]>('calculator.addresses.ethereum'),
           binance: nodeConfig.get<string[]>('calculator.addresses.binance'),
           doge: nodeConfig.get<string[]>('calculator.addresses.doge'),
+          handshake: nodeConfig.get<string[]>('calculator.addresses.handshake'),
         },
         interval: nodeConfig.get<number>('calculator.interval'),
       },
@@ -200,6 +217,12 @@ const getConfig = () => {
         binanceScannerCriticalDiff: nodeConfig.get<number>(
           'healthCheck.binanceScannerCriticalDiff',
         ),
+        handshakeScannerWarnDiff: nodeConfig.get<number>(
+          'healthCheck.handshakeScannerWarnDiff',
+        ),
+        handshakeScannerCriticalDiff: nodeConfig.get<number>(
+          'healthCheck.handshakeScannerCriticalDiff',
+        ),
         updateInterval: nodeConfig.get<number>('healthCheck.interval'),
         logDuration: nodeConfig.get<number>('healthCheck.duration'),
         errorLogAllowedCount: nodeConfig.get<number>(

apps/rosen-service/src/constants.ts

@@ -4,13 +4,15 @@ export const ERGO_SCANNER_INTERVAL = 2 * 60 * 1000;
 export const CARDANO_SCANNER_INTERVAL = 30 * 1000;
 export const BITCOIN_SCANNER_INTERVAL = 10 * 60 * 1000;
 export const DOGE_SCANNER_INTERVAL = 60 * 1000;
+export const HANDSHAKE_SCANNER_INTERVAL = 10 * 60 * 1000;
 export const ETHEREUM_SCANNER_INTERVAL = 60 * 1000;
 export const BINANCE_SCANNER_INTERVAL = 10 * 1000;
 
 export const ERGO_SCANNER_LOGGER_NAME = 'ergo-scanner';
 export const CARDANO_SCANNER_LOGGER_NAME = 'cardano-scanner';
 export const BITCOIN_SCANNER_LOGGER_NAME = 'bitcoin-scanner';
 export const DOGE_SCANNER_LOGGER_NAME = 'doge-scanner';
+export const HANDSHAKE_SCANNER_LOGGER_NAME = 'handshake-scanner';
 export const ETHEREUM_SCANNER_LOGGER_NAME = 'ethereum-scanner';
 export const BINANCE_SCANNER_LOGGER_NAME = 'binance-scanner';
 export const ERGO_BLOCK_TIME = 120;
@@ -19,5 +21,6 @@ export const BITCOIN_BLOCK_TIME = 600;
 export const ETHEREUM_BLOCK_TIME = 12;
 export const BINANCE_BLOCK_TIME = 3;
 export const DOGE_BLOCK_TIME = 60;
+export const HANDSHAKE_BLOCK_TIME = 600;
 
 export const BITCOIN_RUNES_CONFIG_KEY = 'bitcoinRunes';

apps/rosen-service/src/event-trigger/event-trigger-service.ts

@@ -32,6 +32,10 @@ const binanceEventTriggerExtractorLogger =
   );
 const dogeEventTriggerExtractorLogger =
   CallbackLoggerFactory.getInstance().getLogger('doge-event-trigger-extractor');
+const handshakeEventTriggerExtractorLogger =
+  CallbackLoggerFactory.getInstance().getLogger(
+    'handshake-event-trigger-extractor',
+  );
 
 /**
  * register event trigger extractors for all chains
@@ -116,13 +120,25 @@ export const registerExtractors = async (scanner: ErgoScanner) => {
       configs.binance.addresses.fraud,
       binanceEventTriggerExtractorLogger,
     );
+    const handshakeEventTriggerExtractor = new EventTriggerExtractor(
+      'handshake-extractor',
+      dataSource,
+      ErgoNetworkType.Explorer,
+      configs.ergo.explorerUrl,
+      configs.handshake.addresses.eventTrigger,
+      configs.handshake.tokens.rwt,
+      configs.handshake.addresses.permit,
+      configs.handshake.addresses.fraud,
+      handshakeEventTriggerExtractorLogger,
+    );
     await scanner.registerExtractor(ergoEventTriggerExtractor);
     await scanner.registerExtractor(cardanoEventTriggerExtractor);
     await scanner.registerExtractor(bitcoinEventTriggerExtractor);
     await scanner.registerExtractor(bitcoinRunesEventTriggerExtractor);
     await scanner.registerExtractor(dogeEventTriggerExtractor);
     await scanner.registerExtractor(ethereumEventTriggerExtractor);
     await scanner.registerExtractor(binanceEventTriggerExtractor);
+    await scanner.registerExtractor(handshakeEventTriggerExtractor);
 
     logger.debug('event trigger extractors registered', {
       scannerName: scanner.name(),
@@ -134,6 +150,7 @@ export const registerExtractors = async (scanner: ErgoScanner) => {
         dogeEventTriggerExtractor.getId(),
         ethereumEventTriggerExtractor.getId(),
         binanceEventTriggerExtractor.getId(),
+        handshakeEventTriggerExtractor.getId(),
       ],
     });
   } catch (error) {

apps/rosen-service/src/observation/chains/handshake.ts

@@ -0,0 +1,43 @@
+import { CallbackLoggerFactory } from '@rosen-bridge/callback-logger';
+import { HandshakeRpcObservationExtractor } from '@rosen-bridge/handshake-rpc-observation-extractor';
+import { HandshakeRpcScanner } from '@rosen-bridge/handshake-rpc-scanner';
+
+import config from '../../configs';
+import dataSource from '../../data-source';
+import AppError from '../../errors/AppError';
+import { getTokenMap } from '../../utils';
+
+const logger = CallbackLoggerFactory.getInstance().getLogger(import.meta.url);
+
+/**
+ * register an observation extractor for the provided scanner
+ * @param scanner
+ */
+export const registerHandshakeExtractor = async (
+  scanner: HandshakeRpcScanner,
+) => {
+  try {
+    const observationExtractor = new HandshakeRpcObservationExtractor(
+      config.handshake.addresses.lock,
+      dataSource,
+      await getTokenMap(),
+      logger,
+    );
+
+    await scanner.registerExtractor(observationExtractor);
+
+    logger.debug('handshake observation extractor registered', {
+      scannerName: scanner.name(),
+    });
+  } catch (error) {
+    throw new AppError(
+      `cannot create or register handshake observation extractor due to error: ${error}`,
+      false,
+      'error',
+      error instanceof Error ? error.stack : undefined,
+      {
+        scannerName: scanner.name(),
+      },
+    );
+  }
+};

apps/rosen-service/src/observation/observation-service.ts

@@ -5,11 +5,13 @@ import { registerCardanoExtractor } from './chains/cardano';
 import { registerDogeExtractor } from './chains/doge';
 import { registerErgoExtractor } from './chains/ergo';
 import { registerEthereumExtractor } from './chains/ethereum';
+import { registerHandshakeExtractor } from './chains/handshake';
 
 const observationService = {
   registerBitcoinExtractor,
   registerBitcoinRunesExtractor,
   registerDogeExtractor,
+  registerHandshakeExtractor,
   registerCardanoExtractor,
   registerErgoExtractor,
   registerEthereumExtractor,

apps/rosen-service/src/scanner/chains/handshake.ts

@@ -0,0 +1,76 @@
+import {
+  FailoverStrategy,
+  NetworkConnectorManager,
+} from '@rosen-bridge/abstract-scanner';
+import { CallbackLoggerFactory } from '@rosen-bridge/callback-logger';
+import {
+  HandshakeRpcNetwork,
+  HandshakeRpcScanner,
+  HandshakeRpcTransaction,
+} from '@rosen-bridge/handshake-rpc-scanner';
+
+import config from '../../configs';
+import {
+  HANDSHAKE_SCANNER_INTERVAL,
+  HANDSHAKE_SCANNER_LOGGER_NAME,
+  SCANNER_API_TIMEOUT,
+} from '../../constants';
+import dataSource from '../../data-source';
+import AppError from '../../errors/AppError';
+import observationService from '../../observation/observation-service';
+import { startScanner } from '../scanner-utils';
+
+const logger = CallbackLoggerFactory.getInstance().getLogger(import.meta.url);
+const scannerLogger = CallbackLoggerFactory.getInstance().getLogger(
+  HANDSHAKE_SCANNER_LOGGER_NAME,
+);
+
+/**
+ * Creates and configures a NetworkConnectorManager instance for handshake scanner
+ */
+export const createHandshakeNetworkConnectorManager = () => {
+  const networkConnectorManager =
+    new NetworkConnectorManager<HandshakeRpcTransaction>(
+      new FailoverStrategy(),
+      scannerLogger,
+    );
+
+  networkConnectorManager.addConnector(
+    new HandshakeRpcNetwork(
+      config.handshake.rpcUrl,
+      SCANNER_API_TIMEOUT * 1000,
+    ),
+  );
+
+  return networkConnectorManager;
+};
+
+/**
+ * create a handshake scanner, initializing it and calling its update method
+ * periodically
+ */
+export const startHandshakeScanner = async () => {
+  try {
+    const scanner = new HandshakeRpcScanner({
+      dataSource,
+      initialHeight: config.handshake.initialHeight,
+      logger: scannerLogger,
+      network: createHandshakeNetworkConnectorManager(),
+    });
+
+    await observationService.registerHandshakeExtractor(scanner);
+
+    startScanner(scanner, import.meta.url, HANDSHAKE_SCANNER_INTERVAL);
+
+    logger.debug('handshake scanner started');
+
+    return scanner;
+  } catch (error) {
+    throw new AppError(
+      `cannot create or start handshake scanner due to error: ${error}`,
+      false,
+      'error',
+      error instanceof Error ? error.stack : undefined,
+    );
+  }
+};

apps/rosen-service/src/scanner/scanner-service.ts

@@ -6,6 +6,7 @@ import { CallbackLoggerFactory } from '@rosen-bridge/callback-logger';
 import { CardanoKoiosScanner } from '@rosen-bridge/cardano-scanner';
 import { ErgoScanner } from '@rosen-bridge/ergo-scanner';
 import { EvmRpcScanner } from '@rosen-bridge/evm-scanner';
+import { HandshakeRpcScanner } from '@rosen-bridge/handshake-rpc-scanner';
 
 import { handleError } from '../utils';
 import { startBinanceScanner } from './chains/binance';
@@ -14,6 +15,7 @@ import { startCardanoScanner } from './chains/cardano';
 import { startDogeScanner } from './chains/doge';
 import { startErgoScanner } from './chains/ergo';
 import { startEthereumScanner } from './chains/ethereum';
+import { startHandshakeScanner } from './chains/handshake';
 
 const logger = CallbackLoggerFactory.getInstance().getLogger(import.meta.url);
 
@@ -24,6 +26,7 @@ let bitcoinScanner: BitcoinRpcScanner;
 let ethereumScanner: EvmRpcScanner;
 let binanceScanner: EvmRpcScanner;
 let dogeScanner: DogeRpcScanner;
+let handshakeScanner: HandshakeRpcScanner;
 
 /**
  * start all scanners and register their extractors
@@ -37,13 +40,15 @@ const start = async () => {
       ethereumScanner,
       binanceScanner,
       dogeScanner,
+      handshakeScanner,
     ] = await Promise.all([
       startErgoScanner(),
       startCardanoScanner(),
       startBitcoinScanner(),
       startEthereumScanner(),
       startBinanceScanner(),
       startDogeScanner(),
+      startHandshakeScanner(),
     ]);
 
     logger.debug('all scanners started and their extractors registered', {
@@ -54,6 +59,7 @@ const start = async () => {
         ethereumScanner.name(),
         binanceScanner.name(),
         dogeScanner.name(),
+        handshakeScanner.name(),
       ],
     });
   } catch (error) {
@@ -70,6 +76,7 @@ const scannerService = {
   getEthereumScanner: () => ethereumScanner,
   getBinanceScanner: () => binanceScanner,
   getDogeScanner: () => dogeScanner,
+  getHandshakeScanner: () => handshakeScanner,
 };
 
 export default scannerService;

apps/rosen/.env.example

@@ -11,6 +11,7 @@ ETHEREUM_RPC_API=''
 BINANCE_RPC_API=''
 BITCOIN_RUNES_API=''
 BITCOIN_RUNES_SECRET=''
+HANDSHAKE_RPC_API=''
 
 DISCORD_LOGGER_WEBHOOK_URL=''
 

apps/rosen/package.json

@@ -37,10 +37,12 @@
     "@rosen-network/bitcoin-runes": "^1.0.2",
     "@rosen-network/cardano": "^2.5.2",
     "@rosen-network/doge": "^0.4.2",
+    "@rosen-network/handshake": "^0.1.0",
     "@rosen-network/ergo": "^2.5.3",
     "@rosen-network/ethereum": "^0.4.3",
     "@rosen-network/evm": "^0.3.5",
     "@rosen-ui/asset-calculator": "^2.3.0",
+    "@rosen-ui/shake-wallet": "^0.1.0",
     "@rosen-ui/constants": "^1.0.0",
     "@rosen-ui/data-source": "^0.2.1",
     "@rosen-ui/eternl-wallet": "^3.1.4",

apps/rosen/src/networks/handshake/client.ts

@@ -0,0 +1,12 @@
+import { HandshakeNetwork } from '@rosen-network/handshake/dist/client';
+
+import { unwrapFromObject } from '@/safeServerAction';
+
+import { LOCK_ADDRESSES } from '../../../configs';
+import * as actions from './server';
+
+export const handshake = new HandshakeNetwork({
+  lockAddress: LOCK_ADDRESSES.handshake,
+  nextHeightInterval: 1,
+  ...unwrapFromObject(actions),
+});

apps/rosen/src/networks/handshake/index.ts

@@ -0,0 +1 @@
+export * from './client';