refactor(SwapDeals) Store swapdeals in database (#569)

* refactor(SwapDeals) Store swapdeals in database

Author: ImmanuelSegol

Diff for: lib/Xud.ts

@@ -91,7 +91,8 @@ class Xud extends EventEmitter {
 
       this.pool = new Pool(this.config.p2p, loggers.p2p, this.db.models);
 
-      this.swaps = new Swaps(loggers.swaps, this.pool, this.lndbtcClient, this.lndltcClient);
+      this.swaps = new Swaps(loggers.swaps, this.db.models, this.pool, this.lndbtcClient, this.lndltcClient);
+      initPromises.push(this.swaps.init());
 
       this.orderBook = new OrderBook(loggers.orderbook, this.db.models, this.config.nomatching, this.pool, this.swaps);
       initPromises.push(this.orderBook.init());

Diff for: lib/db/DB.ts

@@ -9,6 +9,7 @@ import { SwapClients } from '../types/enums';
 type Models = {
   Node: Sequelize.Model<db.NodeInstance, db.NodeAttributes>;
   Currency: Sequelize.Model<db.CurrencyInstance, db.CurrencyAttributes>;
+  SwapDeal: Sequelize.Model<db.SwapDealInstance, db.SwapDealAttributes>;
   Pair: Sequelize.Model<db.PairInstance, db.PairAttributes>;
   ReputationEvent: Sequelize.Model<db.ReputationEventInstance, db.ReputationEventAttributes>;
 };
@@ -44,12 +45,13 @@ class DB {
       this.logger.error('unable to connect to the database', err);
       throw err;
     }
-    const { Node, Currency, Pair, ReputationEvent } = this.models;
+    const { Node, Currency, Pair, ReputationEvent, SwapDeal } = this.models;
     // sync schemas with the database in phases, according to FKs dependencies
     await Promise.all([
       Node.sync(),
       Currency.sync(),
       ReputationEvent.sync(),
+      SwapDeal.sync(),
     ]);
     await Promise.all([
       Pair.sync(),

Diff for: lib/db/models/SwapDeal.ts

@@ -0,0 +1,39 @@
+import Sequelize from 'sequelize';
+import { db } from '../../types';
+
+export default (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) => {
+  const attributes: db.SequelizeAttributes<db.SwapDealAttributes> = {
+    role: { type: DataTypes.TINYINT, allowNull: false },
+    state: { type: DataTypes.TINYINT, allowNull: false },
+    phase: { type: DataTypes.TINYINT, allowNull: false },
+    errorReason: { type: DataTypes.STRING, allowNull: true },
+    r_hash: { type: DataTypes.STRING, allowNull: false, unique: true },
+    r_preimage: { type: DataTypes.STRING, allowNull: true },
+    peerPubKey: { type: DataTypes.STRING, allowNull: false },
+    orderId: { type: DataTypes.STRING, allowNull: false },
+    localId: { type: DataTypes.STRING, allowNull: false },
+    proposedQuantity: { type: DataTypes.DECIMAL(8), allowNull: false },
+    quantity: { type: DataTypes.DECIMAL(8), allowNull: true },
+    pairId: { type: DataTypes.STRING, allowNull: false },
+    takerAmount: { type: DataTypes.BIGINT , allowNull: false },
+    takerCurrency: { type: DataTypes.STRING , allowNull: false },
+    takerPubKey: { type: DataTypes.STRING , allowNull: true },
+    price: { type: DataTypes.DECIMAL(8), allowNull: false },
+    takerCltvDelta: { type: DataTypes.SMALLINT, allowNull: false },
+    makerCltvDelta: { type: DataTypes.SMALLINT, allowNull: true },
+    makerAmount: { type: DataTypes.BIGINT, allowNull: false },
+    makerCurrency: { type: DataTypes.STRING, allowNull: false },
+    createTime: { type: DataTypes.BIGINT, allowNull: false },
+    executeTime: { type: DataTypes.BIGINT, allowNull: true },
+    completeTime: { type: DataTypes.BIGINT, allowNull: true },
+  };
+
+  const options: Sequelize.DefineOptions<db.SwapDealInstance>  = {
+    tableName: 'swapdeals',
+    timestamps: false,
+  };
+
+  const SwapDeal = sequelize.define<db.SwapDealInstance, db.SwapDealAttributes>('SwapDeal', attributes, options);
+
+  return SwapDeal;
+};

Diff for: lib/swaps/SwapRepository.ts

@@ -0,0 +1,25 @@
+import { db } from '../types';
+import Bluebird from 'bluebird';
+import { Models } from '../db/DB';
+
+class SwapRepository {
+
+  constructor(private models: Models) {}
+
+  public getSwapDeals = (): Bluebird<db.SwapDealInstance[]> => {
+    return this.models.SwapDeal.findAll();
+  }
+
+  public getSwapDeal = async (r_hash: string): Promise<db.SwapDealInstance | null> => {
+    return this.models.SwapDeal.findOne({
+      where: {
+        r_hash,
+      },
+    });
+  }
+
+  public addSwapDeal = (swapDeal: db.SwapDealFactory): Bluebird<db.SwapDealInstance> => {
+    return this.models.SwapDeal.create(<db.SwapDealAttributes>swapDeal);
+  }
+}
+export default SwapRepository;

Diff for: lib/swaps/Swaps.ts

@@ -7,58 +7,12 @@ import * as lndrpc from '../proto/lndrpc_pb';
 import LndClient from '../lndclient/LndClient';
 import Pool from '../p2p/Pool';
 import { EventEmitter } from 'events';
+import SwapRepository from './SwapRepository';
 import { StampedOwnOrder, StampedPeerOrder, SwapResult } from '../types/orders';
 import assert from 'assert';
-
-type SwapDeal = {
-  /** The role of the local node in the swap. */
-  role: SwapRole;
-  /** The most updated deal phase */
-  phase: SwapPhase;
-  /**
-   * The most updated deal state. State works together with phase to indicate where the
-   * deal is in its life cycle and if the deal is active, errored, or completed.
-   */
-  state: SwapState;
-  /** The reason for being in the current state. */
-  errorReason?: string;
-  /** The xud node pub key of the counterparty to this swap deal. */
-  peerPubKey: string;
-  /** The global order id in the XU network for the order being executed. */
-  orderId: string;
-  /** The local id for the order being executed. */
-  localOrderId: string;
-  /** The quantity of the order to execute as proposed by the taker. */
-  proposedQuantity: number;
-  /** The accepted quantity of the order to execute as accepted by the maker. */
-  quantity?: number;
-  /** The trading pair of the order. The pairId together with the orderId are needed to find the deal in orderBook. */
-  pairId: string;
-  /** The number of satoshis (or equivalent) the taker is expecting to receive. */
-  takerAmount: number;
-  /** The currency the taker is expecting to receive. */
-  takerCurrency: string;
-  /** Taker's lnd pubkey on the taker currency's network. */
-  takerPubKey?: string;
-  /** The CLTV delta from the current height that should be used to set the timelock for the final hop when sending to taker. */
-  takerCltvDelta: number;
-  /** The number of satoshis (or equivalent) the maker is expecting to receive. */
-  makerAmount: number;
-  /** The currency the maker is expecting to receive. */
-  makerCurrency: string;
-  /** The CLTV delta from the current height that should be used to set the timelock for the final hop when sending to maker. */
-  makerCltvDelta?: number;
-  /** The price of the order that's being executed. */
-  price: number;
-  /** The hash of the preimage. */
-  r_hash: string;
-  r_preimage?: string;
-  /** The routes the maker should use to send to the taker. */
-  makerToTakerRoutes?: lndrpc.Route[];
-  createTime: number;
-  executeTime?: number;
-  completeTime?: number
-};
+import { Models } from '../db/DB';
+import { SwapDealInstance } from 'lib/types/db';
+import { SwapDeal } from './types';
 
 type OrderToAccept = {
   quantityToAccept: number;
@@ -76,13 +30,15 @@ interface Swaps {
 class Swaps extends EventEmitter {
   /** A map between r_hash and swap deals. */
   private deals = new Map<string, SwapDeal>();
+  private usedHashes = new Set<string>();
+  private repository: SwapRepository;
 
   /** The number of satoshis in a bitcoin. */
   private static readonly SATOSHIS_PER_COIN = 100000000;
 
-  constructor(private logger: Logger, private pool: Pool, private lndBtcClient: LndClient, private lndLtcClient: LndClient) {
+  constructor(private logger: Logger, private models: Models, private pool: Pool, private lndBtcClient: LndClient, private lndLtcClient: LndClient) {
     super();
-
+    this.repository = new SwapRepository(this.models);
     this.bind();
   }
 
@@ -99,6 +55,14 @@ class Swaps extends EventEmitter {
     return { baseCurrencyAmount, quoteCurrencyAmount };
   }
 
+  public init = async () => {
+    // Load Swaps from data base
+    const result = await this.repository.getSwapDeals();
+    result.forEach((deal: SwapDealInstance) => {
+      this.usedHashes.add(deal.r_hash);
+    });
+  }
+
   private bind() {
     this.pool.on('packet.swapResponse', this.handleSwapResponse);
     this.pool.on('packet.swapComplete', this.handleSwapComplete);
@@ -153,6 +117,17 @@ class Swaps extends EventEmitter {
     return;
   }
 
+  /**
+   * Saves deal to database and deletes from memory.
+   * @param deal The deal to persist.
+   */
+  private persistDeal = async (deal: SwapDeal) => {
+    if (this.usedHashes.has(deal.r_hash)) {
+      await this.repository.addSwapDeal(deal);
+      this.removeDeal(deal);
+    }
+  }
+
   /**
    * Gets a deal by its r_hash value.
    * @param r_hash The r_hash value of the deal to get.
@@ -284,7 +259,7 @@ class Swaps extends EventEmitter {
     const deal: SwapDeal = {
       ...swapRequestBody,
       peerPubKey: peer.nodePubKey!,
-      localOrderId: taker.localId,
+      localId: taker.localId,
       price: maker.price,
       phase: SwapPhase.SwapCreated,
       state: SwapState.Active,
@@ -328,7 +303,7 @@ class Swaps extends EventEmitter {
       takerPubKey,
       peerPubKey: peer.nodePubKey!,
       price: orderToAccept.price,
-      localOrderId: orderToAccept.localId,
+      localId: orderToAccept.localId,
       quantity: orderToAccept.quantityToAccept,
       phase: SwapPhase.SwapCreated,
       state: SwapState.Active,
@@ -581,7 +556,7 @@ class Swaps extends EventEmitter {
       }
 
       const request = new lndrpc.SendToRouteRequest();
-      request.setRoutesList(deal.makerToTakerRoutes!);
+      request.setRoutesList(deal.makerToTakerRoutes ? deal.makerToTakerRoutes : []);
       request.setPaymentHashString(deal.r_hash);
 
       try {
@@ -669,7 +644,7 @@ class Swaps extends EventEmitter {
     if (deal.phase === SwapPhase.AmountReceived) {
       const swapResult = {
         orderId: deal.orderId,
-        localId: deal.localOrderId,
+        localId: deal.localId,
         pairId: deal.pairId,
         quantity: deal.quantity!,
         amountReceived: deal.role === SwapRole.Maker ? deal.makerAmount : deal.takerAmount,
@@ -682,27 +657,28 @@ class Swaps extends EventEmitter {
     }
   }
 
-  private handleSwapComplete = (response: packets.SwapCompletePacket): void  => {
+  private handleSwapComplete = (response: packets.SwapCompletePacket) => {
     const { r_hash } = response.body!;
     const deal = this.getDeal(r_hash);
     if (!deal) {
       this.logger.error(`received swap complete for unknown deal r_hash ${r_hash}`);
       return;
     }
     this.setDealPhase(deal, SwapPhase.SwapCompleted);
+    return this.persistDeal(deal);
   }
 
-  private handleSwapError = (error: packets.SwapErrorPacket): void  => {
+  private handleSwapError = (error: packets.SwapErrorPacket) => {
     const { r_hash, errorMessage } = error.body!;
     const deal = this.getDeal(r_hash);
     if (!deal) {
       this.logger.error(`received swap error for unknown deal r_hash ${r_hash}`);
       return;
     }
     this.setDealState(deal, SwapState.Error, errorMessage);
+    return this.persistDeal(deal);
   }
 
 }
 
 export default Swaps;
-export { SwapDeal };

Diff for: lib/types/db.ts

@@ -1,5 +1,6 @@
 import Sequelize, { DataTypeAbstract, DefineAttributeColumnOptions } from 'sequelize';
 import { Address, NodeConnectionInfo } from './p2p';
+import { SwapDeal } from '../swaps/types';
 import { Currency, Pair } from './orders';
 import { ReputationEvent } from './enums';
 
@@ -17,6 +18,7 @@ export type SequelizeAttributes<T extends { [key: string]: any }> = {
 * "xInstance" is the type definition of a fetched record as a Sequelize row instance, which contains some util properties.
 */
 
+/* Currency */
 export type CurrencyFactory = Currency;
 
 export type CurrencyAttributes = CurrencyFactory & {
@@ -25,6 +27,22 @@ export type CurrencyAttributes = CurrencyFactory & {
 
 export type CurrencyInstance = CurrencyAttributes & Sequelize.Instance<CurrencyAttributes>;
 
+/* SwapDeal */
+export type SwapDealFactory = Pick<SwapDeal, Exclude<keyof SwapDeal, 'makerToTakerRoutes'>>;
+
+export type SwapDealAttributes = SwapDealFactory & {
+  makerCltvDelta: number;
+  r_preimage: string;
+  errorReason: string;
+  quantity: number;
+  takerPubKey: string;
+  executeTime: number;
+  completeTime: number;
+};
+
+export type SwapDealInstance = SwapDealAttributes & Sequelize.Instance<SwapDealAttributes>;
+
+/* Node */
 export type NodeFactory = NodeConnectionInfo;
 
 export type NodeAttributes = NodeFactory & {
@@ -39,6 +57,7 @@ export type NodeInstance = NodeAttributes & Sequelize.Instance<NodeAttributes> &
   reputationScore: number;
 };
 
+/* Pairs */
 export type PairFactory = Pair;
 
 export type PairAttributes = PairFactory & {
@@ -47,6 +66,7 @@ export type PairAttributes = PairFactory & {
 
 export type PairInstance = PairAttributes & Sequelize.Instance<PairAttributes>;
 
+/* Reputation events */
 export type ReputationEventFactory = {
   event: ReputationEvent;
   nodeId: number;

Diff for: lib/types/orders.ts

@@ -1,4 +1,5 @@
-import { SwapClients, SwapRole } from './enums';
+import { SwapClients, SwapRole, SwapState, SwapPhase } from './enums';
+import * as lndrpc from '../proto/lndrpc_pb';
 
 /** An order without a price that is intended to match against any available orders on the opposite side of the book for its trading pair. */
 type MarketOrder = {

Diff for: test/unit/Swaps.spec.ts

@@ -1,5 +1,6 @@
 import { expect } from 'chai';
-import Swaps, { SwapDeal } from '../../lib/swaps/Swaps';
+import Swaps from '../../lib/swaps/Swaps';
+import { SwapDeal } from '../../lib/swaps/types';
 import Logger, { Level } from '../../lib/Logger';
 import { SwapPhase, SwapState, SwapRole } from '../../lib/types/enums';
 
@@ -18,7 +19,7 @@ describe('Swaps', () => {
     state: SwapState.Active,
     peerPubKey: '03029c6a4d80c91da9e40529ec41c93b17cc9d7956b59c7d8334b0318d4a86aef8',
     orderId: 'f8a85c66-7e73-43cd-9ac4-176ff4cc28a8',
-    localOrderId: '1',
+    localId: '1',
     proposedQuantity: quantity,
     pairId: 'LTC/BTC',
     takerCurrency: 'LTC',