@tradelayerprotocol/tradelayer 1.9.1

package/tradelayer.js/src/tradeHistoryManager.js

@@ -0,0 +1,552 @@
+const dbInstance = require('./db.js')
+const BigNumber = require('bignumber.js');
+
+class TradeHistory {
+
+ async loadTradeHistory(contractId) {
+  const stringKey = `contract-${contractId}`;
+  console.log('key to load trades ' + JSON.stringify({ key: stringKey }));
+
+  const tradeHistoryDB = await dbInstance.getDatabase('tradeHistory');
+
+  // Try single doc per contract
+  const doc = await tradeHistoryDB.findOneAsync({ _id: stringKey });
+  if (doc) {
+    if (Array.isArray(doc.trades)) return doc.trades;
+    if (doc.trade) return [doc.trade];
+    return [doc];
+  }
+
+  // Legacy fallback: docs with prefix contract-<id>-
+  if (typeof tradeHistoryDB.findAsync === 'function') {
+    const re = new RegExp(`^${stringKey}-`);
+    const legacyRows = await tradeHistoryDB.findAsync({ _id: { $regex: re } });
+    if (legacyRows && legacyRows.length) {
+      return legacyRows.map(r => r.trade ?? r);
+    }
+  }
+
+
+  // Last resort: filter whole db
+  const all = await dbInstance.getDatabase('tradeHistory');
+  return (Array.isArray(all) ? all : [])
+    .filter(r => r?.key === stringKey || String(r?._id || '').startsWith(`${stringKey}-`))
+    .map(r => r.trade ?? r);
+}
+
+async getTradeHistoryForAddress(address, contractId) {
+  console.log('about to call load history for contract ' + contractId);
+  const trades = await this.loadTradeHistory(contractId);
+
+  return trades.filter(t => {
+    const buyer = t?.buyer || t?.buyerAddress || t?.counterpartyAddress;
+    const seller = t?.seller || t?.sellerAddress || t?.liquidatingAddress;
+    return buyer === address || seller === address;
+  });
+}
+
+
+  // Order-independent token pair + address filter
+static async getTokenTradeHistoryForAddress(propertyId1, propertyId2, address) {
+  try{
+  const tradeDB = await dbInstance.getDatabase('tradeHistory');
+
+  // Support either pair ordering
+  const a = Number(propertyId1);
+  const b = Number(propertyId2);
+  const keys = [`token-${a}-${b}`, `token-${b}-${a}`];
+
+  const addr  = String(address || '');
+  const addrL = addr.toLowerCase();
+
+  const docs = await tradeDB.findAsync({
+    $and: [
+      { key: { $in: keys } },
+      {
+        $or: [
+          { 'trade.buyer': addr },
+          { 'trade.seller': addr },
+          { 'trade.buyer': addrL },
+          { 'trade.seller': addrL },
+        ]
+      }
+    ]
+  });
+
+  return (docs || []).map(d => d.trade);
+  }catch{
+    return "error in trade manager"
+  }
+}
+
+// Contract + address filter
+static async getContractTradeHistoryForAddress(contractId, address) {
+  const tradeDB = await dbInstance.getDatabase('tradeHistory');
+
+  const key   = `contract-${contractId}`;
+  const addr  = String(address || '');
+  const addrL = addr.toLowerCase();
+
+  const docs = await tradeDB.findAsync({
+    $and: [
+      { key },
+      {
+        $or: [
+          { 'trade.buyer': addr },
+          { 'trade.seller': addr },
+          { 'trade.buyer': addrL },
+          { 'trade.seller': addrL },
+        ]
+      }
+    ]
+  });
+
+  return (docs || []).map(d => d.trade);
+}
+
+
+  async getPositionHistoryForContract(address, contractId) {
+    //console.log('about to call trade history for contract '+contractId)
+    const addressTradeHistory = await this.getTradeHistoryForAddress(address,contractId);
+    addressTradeHistory.sort((a, b) => a.blockHeight - b.blockHeight);
+
+    //console.log('filtered trade history for address  '+address+  '  ' +JSON.stringify(addressTradeHistory))
+    const positionHistory = [];
+    var position = 0
+
+    for (const trade of addressTradeHistory) {
+      //console.log(JSON.stringify(trade))
+      if (trade.trade.contractId === contractId) {
+        if(trade.trade.sellerAddress==address){
+          trade.trade.amount *= -1
+        }
+        // Check if the trade is a close
+        const isClose = Math.abs(position) > Math.abs(position + trade.trade.amount);
+        //console.log(Math.abs(position) + ' '+ Math.abs(position +trade.trade.amount))
+        position = position + trade.trade.amount
+
+        const snapshot = {
+          amount: position,
+          price: trade.trade.price,
+          blockHeight: trade.blockHeight,
+          isClose: isClose
+        };
+        //console.log(snapshot)
+        positionHistory.push(snapshot);
+
+      }
+    }
+    //console.log(positionHistory)
+    return positionHistory;
+  }
+
+  async getTxIdsForContract(address, contractId, action) {
+    const addressTradeHistory = await this.getTradeHistoryForAddress(address);
+    const txIds = [];
+
+    for (const trade of addressTradeHistory) {
+      if (trade.trade.contractId === contractId && trade.trade.buyerAddress === address) {
+        txIds.push({
+          txId: trade.trade.buyerTx, 
+          blockHeight: trade.blockHeight,
+        });
+      }else if(trade.trade.contractId === contractId && trade.trade.sellerAddress === address){
+        txIds.push({
+          txId: trade.trade.sellerTx, 
+          blockHeight: trade.blockHeight,
+        });
+      }
+    }
+
+    return txIds;
+  }
+async getCategorizedTrades(address, contractId) {
+    const trades = await this.getTradeHistoryForAddress(address, contractId);
+
+    let openTrades = [];
+    let closeTrades = [];
+
+    for (let i = 0; i < trades.length; i++) {
+        const currentTrade = trades[i].trade;
+        console.log('checking currentTrade'+JSON.stringify(currentTrade))
+        let individualTrade = {
+            address: '',
+            contractId: currentTrade.contractId,
+            price: currentTrade.price,
+            amount: 0,
+            block: currentTrade.block,
+            fullyClosesPosition: false,
+        };
+
+        if (currentTrade.buyerClose == 0&&currentTrade.buyerAddress==address) {
+            individualTrade.amount = currentTrade.amount;
+            individualTrade.address = currentTrade.buyerAddress;
+            openTrades.push(individualTrade);
+        } else if((currentTrade.buyerClose>0||currentTrade.buyerClose==null)&&currentTrade.buyerAddress==address){
+            individualTrade.amount = currentTrade.buyerClosed;
+            individualTrade.address = currentTrade.buyerAddress;
+            individualTrade.fullyClosesPosition = currentTrade.buyerFullClose;
+            closeTrades.push(individualTrade);
+            if (currentTrade.flipLong > 0) {
+                // flip trade
+                console.log('flip long before ajustment '+JSON.stringify(individualTrade))
+                individualTrade.amount = currentTrade.flipLong;
+                individualTrade.address = currentTrade.buyerAddress;
+                individualTrade.fullyClosesPosition = true;
+                console.log('flip long after adjustment '+JSON.stringify(individualTrade))
+                openTrades.push(individualTrade);
+            }
+        }
+
+        if (currentTrade.sellerClose == 0&&currentTrade.sellerAddress==address) {
+            individualTrade.amount = currentTrade.amount*-1;
+            individualTrade.address = currentTrade.sellerAddress;
+            openTrades.push(individualTrade);
+        } else if((currentTrade.sellerClose>0||currentTrade.sellerClose==null)&&currentTrade.sellerAddress==address){
+            individualTrade.amount = currentTrade.sellerClosed*-1;
+            individualTrade.address = currentTrade.sellerAddress;
+            individualTrade.fullyClosesPosition = currentTrade.sellerFullClose;
+            closeTrades.push(individualTrade);
+            if (currentTrade.flipShort> 0) {
+                // flip trade
+                individualTrade.amount = currentTrade.sellerClosed*-1;
+                individualTrade.address = currentTrade.sellerAddress;
+                individualTrade.fullyClosesPosition = true;
+                openTrades.push(individualTrade);
+            }
+        }
+    }
+
+    // Sort open and close trades by block height
+    openTrades.sort((a, b) => a.block - b.block);
+    closeTrades.sort((a, b) => a.block - b.block);
+
+    const categorizedTrades = {
+        openTrades: openTrades,
+        closeTrades: closeTrades,
+    };
+
+    return categorizedTrades;
+}
+
+
+computeAverageEntryPrices(openTrades) {
+    let sum = new BigNumber(0);
+    let count = new BigNumber(0);
+
+    for (let i = 0; i < openTrades.length; i++) {
+        const trade = openTrades[i];
+        const price = new BigNumber(trade.price);
+        const amount = new BigNumber(trade.amount);
+
+        sum = sum.plus(price.times(amount.abs()));;
+        count = count.plus(amount.abs());
+    }
+
+    const avgEntryPrice = count.isGreaterThan(0) ? sum.dividedBy(count) : new BigNumber(0);
+    return avgEntryPrice.toNumber();
+}
+
+
+async trackPositionHistory(address, contractId) {
+    const { openTrades, closeTrades } = await this.getCategorizedTrades(address, contractId);
+    //console.log('open trades for ' + address + ' ' + JSON.stringify(openTrades) + ' close trades ' + JSON.stringify(closeTrades));
+
+    // Sort open and close trades by block height
+    const sortedOpenTrades = openTrades.sort((a, b) => a.blockHeight - b.blockHeight);
+    const sortedCloseTrades = closeTrades.sort((a, b) => a.blockHeight - b.blockHeight);
+
+    // Break up opening trades based on consecutive closing trades
+    const separatedOpenTrades = this.breakUpOpeningTrades([...sortedOpenTrades], sortedCloseTrades);
+    //console.log('separatedOpenTrades ' + JSON.stringify(separatedOpenTrades));
+    const positionHistory = [];
+
+    for (const openTradesSubset of separatedOpenTrades) {
+        // Compute the average entry price for the current subset
+        const avgEntryPrice = this.computeAverageEntryPrices(openTradesSubset);
+        //console.log('avgEntryPrice for address ' + address + ' ' + avgEntryPrice);
+
+        let position = new BigNumber(0);  // Reset position for each subset
+        let prevBlockHeight = 0;
+
+      openTradesSubset.forEach((trade) => {
+          const blockHeight = trade.block;
+
+          if (avgEntryPrice !== undefined) {
+              const entryPrice = avgEntryPrice;
+              const fullyClosesPosition = sortedCloseTrades.some(
+                  (closeTrade) => closeTrade.block === blockHeight && closeTrade.fullyClosesPosition
+              );
+
+              // Check if it's a closing trade
+              if (fullyClosesPosition) {
+                  // Calculate realized PNL for the closing trade
+                  const pnl = entryPrice.minus(trade.price).times(trade.amount);
+                  console.log('Realized PNL: ' + pnl.toNumber());
+                  
+                  // Adjust position based on the closing trade
+                  position = position.plus(pnl);
+              } else {
+                  // It's an opening trade, update position accordingly
+                  position = position.plus(trade.amount);
+              }
+
+              if (blockHeight !== prevBlockHeight) {
+                  // If the block height changes, add a new entry to position history
+                  positionHistory.push({
+                      blockHeight,
+                      position: position.toNumber(),
+                      avgEntryPrice: entryPrice,
+                      fullyClosesPosition,
+                  });
+
+                  // Reset the position for the new block height
+                  position = new BigNumber(0);
+              }
+
+              if (!fullyClosesPosition) {
+                  // Only update if the trade doesn't fully close the position
+                  trade.position = position.toNumber();
+              }
+          }
+      })
+    }
+
+    return positionHistory;
+}
+
+
+
+
+breakUpOpeningTrades(openTrades, closeTrades) {
+    const separatedOpenTrades = [];
+    let currentBlockHeight = null;
+    let currentOpenTrades = [];
+    console.log('open and close trades in breakUpOpeningTrades ' + JSON.stringify(openTrades) + ' ' + JSON.stringify(closeTrades));
+    
+    let closeTrade = null; // Initialize closeTrade
+
+    for (const trade of openTrades) {
+        const blockHeight = trade.blockHeight;
+
+        if (currentBlockHeight !== blockHeight) {
+            // Check for consecutive closing trades
+            if (closeTrade && closeTrade.blockHeight === blockHeight - 1) {
+                console.log('close trade blockHeight ' + closeTrade.blockHeight + ' ' + (blockHeight - 1));
+            }
+
+            const consecutiveCloses = closeTrades.filter(
+                close => close.blockHeight === blockHeight - 1
+            );
+
+            if (consecutiveCloses.length > 0) {
+                // Consecutive closing trade found, start a new array for open trades
+                separatedOpenTrades.push([...currentOpenTrades]);
+                currentOpenTrades = [];
+            }
+        }
+
+        currentOpenTrades.push(trade);
+        currentBlockHeight = blockHeight;
+    }
+
+    // Add the last set of open trades to the result array
+    separatedOpenTrades.push([...currentOpenTrades]);
+
+    return separatedOpenTrades;
+}
+
+
+
+
+async calculateLIFOEntry(address, amount, contractId) {
+      const categorizedTrades = await this.getCategorizedTrades(address, contractId);
+      console.log('open trades ' +JSON.stringify(categorizedTrades.openTrades));
+
+      // Sort trades by block height in descending order (LIFO)
+      categorizedTrades.openTrades.sort((a, b) => b.blockHeight - a.blockHeight);
+
+      // Calculate the LIFO entry based on the sorted trades
+      let remainingAmount = Math.abs(amount);
+      let totalCost = 0;
+      const blockTimes = [];
+
+      for (const trade of categorizedTrades.openTrades) {
+        const tradeAmount = Math.abs(trade.tradedAmount);
+        const tradeCost = tradeAmount * trade.price;
+        console.log('old open trade ' +JSON.stringify(trade)+ ' '+totalCost)
+        if (tradeAmount <= remainingAmount) {
+          // Fully cover the remaining amount with the current trade
+          totalCost += tradeCost;
+          remainingAmount -= tradeAmount;
+          blockTimes.push(trade.blockHeight); // Add block time of the closing trade
+        } else {
+          // Partially cover the remaining amount with the current trade
+          totalCost += (remainingAmount / tradeAmount) * tradeCost;
+          remainingAmount = 0;
+          blockTimes.push(trade.blockHeight); // Add block time of the closing trade
+        }
+
+        if (remainingAmount === 0) {
+          // Fully covered the given amount
+          break;
+        }
+      }
+
+      // Return an object with total cost and block times
+      return {
+        totalCost,
+        blockTimes,
+      };
+    }
+
+    /**
+     * Save PNL data to the trade history database.
+     *
+     * @param {number} currentBlockHeight - The current block height.
+     * @param {string} contractId - The contract ID associated with the trade.
+     * @param {number} accountingPNL - The accounting PNL value.
+     * @param {string} buyerAddress - The address of the buyer.
+     * @param {number} orderAmount - The amount in the buy order.
+     * @param {number} orderPrice - The price in the buy order.
+     * @param {string} collateralPropertyId - The ID of the collateral property.
+     * @param {string} timestamp - The timestamp of the trade.
+     * @param {string} buyerTx - The buyer's transaction ID.
+     * @param {number} settlementPNL - The settlement PNL value.
+     * @param {number} reduction - The reduction value.
+     * @param {object} LIFO - The LIFO data object.
+     * @returns {Promise<string>} - A Promise that resolves to the key under which the data is saved.
+     */
+    async savePNL(params) {
+      // Assuming tradeHistoryManager is an instance of a database manager or similar
+      // Adjust the following code based on your actual database handling implementation
+
+      // Assuming rPNL-address-contractId-block is the key structure you want to use
+      const key = `rPNL-${params.address}-${params.contractId}-${params.height}`;
+      console.log('preparing to save PNL '+JSON.stringify(params))
+
+      // Assuming tradeHistoryManager.save is a method to save data to the database
+      await this.save(key, params);
+
+      // Optionally, you can return the key or any other relevant information
+      return key;
+    }
+
+     /**
+       * Save data to the trade history database.
+       *
+       * @param {string} key - The key under which to save the data.
+       * @param {object} data - The data to be saved.
+       * @returns {Promise<void>} - A Promise that resolves once the data is saved.
+       */
+      async save(key, data) {
+        try {
+          const db = await dbInstance.getDatabase('tradeHistory');
+          const value = JSON.stringify(data);
+
+          console.log(`updating tradeHistoryDB with ${value}`);
+
+          // Save the data to the database
+          await db.updateAsync({ _id: key }, { $set: { value } }, { upsert: true });
+
+          console.log(`tradeHistoryDB saved successfully.`);
+        } catch (err) {
+          console.error(`Error saving tradeHistory rPNL:`, err);
+          throw err;
+        }
+      }
+
+    async displayPositionHistory(address, contractId) {
+      const positionHistory = this.getPositionHistoryForContract(address, contractId);
+      console.log(`Position History for Address ${address} and Contract ID ${contractId}:`);
+      console.table(positionHistory);
+    }
+
+    async saveTrade(tradeRecord) {
+            const tradeDB = await dbInstance.getDatabase('tradeHistory');
+
+            const uuid = uuidv4();
+
+            // Use the key provided in the trade record for storage
+            const tradeId = `${tradeRecord.key}-${uuid}-${tradeRecord.blockHeight}`;
+
+            // Construct the document to be saved
+            const tradeDoc = {
+                _id: tradeId,
+                ...tradeRecord
+            };
+
+            // Save or update the trade record in the database
+            try {
+                await tradeDB.updateAsync(
+                    { _id: tradeId },
+                    tradeDoc,
+                    { upsert: true }
+                );
+                //console.log(`Trade record saved successfully: ${tradeId}`);
+            } catch (error) {
+                //console.error(`Error saving trade record: ${tradeId}`, error);
+                throw error; // Rethrow the error for handling upstream
+            }
+    }
+
+    // Returns trade history rows for a contract within [startBlock, endBlock] inclusive.
+    // This is a lightweight in-memory filter over loadTradeHistory(contractId),
+    // which already handles single-doc, legacy, and fallback formats.
+    static async getTradesForContractBetweenBlocks(contractId, startBlock, endBlock) {
+      const tradeDB = await dbInstance.getDatabase('tradeHistory');
+
+      const key = `contract-${contractId}`;
+
+      // Fast indexed-style query
+      const docs = await tradeDB.findAsync({
+        key,
+        blockHeight: { $gte: startBlock, $lte: endBlock }
+      });
+
+      if (!docs || !docs.length) return [];
+
+      return docs.map(d => d.trade ?? d);
+    }
+
+    async getFirstTradeBlock(contractId) {
+      const tradeDB = await dbInstance.getDatabase('tradeHistory');
+      const key = `contract-${contractId}`;
+
+      return new Promise((resolve, reject) => {
+          tradeDB.find(
+              { key, type: 'contract' },
+              { blockHeight: 1 }
+          )
+          .sort({ blockHeight: 1 })
+          .limit(1)
+          .exec((err, docs) => {
+              if (err) return reject(err);
+              if (!docs || docs.length === 0) return resolve(null);
+
+              resolve(docs[0].blockHeight);
+          });
+      })
+    }
+
+    // ------------------------------------------------------------------
+    // Return liquidation trades for a contract at an exact block height
+    // Authoritative source for liquidation-stage accounting
+    // ------------------------------------------------------------------
+    static async getLiquidationTradesForContractAtBlock(contractId, blockHeight) {
+      const trades = await this.getTradesForContractBetweenBlocks(
+        contractId,
+        blockHeight,
+        blockHeight
+      );
+      console.log('trades in get liq trades '+JSON.stringify(trades))
+      if (!trades || !trades.length) return [];
+
+      // Normalize + filter
+      return trades
+        .map(t => t.trade ?? t)
+        .filter(t => t && t.liquidation === true);
+    }
+}
+
+module.exports = TradeHistory;