fixup! feat: add web socket based transactions by addresses provider

Author: iccicci

packages/cardano-services/src/WsServer/requests.ts

@@ -3,8 +3,8 @@
 import { Cardano, CardanoNode, CardanoNodeUtil } from '@cardano-sdk/core';
 import { Pool } from 'pg';
 import { ProtocolParamsModel } from '../NetworkInfo/DbSyncNetworkInfoProvider/types';
+import { partialTransactionsByIds, transactionsByIds } from './transactions';
 import { toProtocolParams } from '../NetworkInfo/DbSyncNetworkInfoProvider/mappers';
-import { transactionsByIds } from './transactions';
 
 // Workaround for @types/pg
 declare module 'pg' {
@@ -142,7 +142,7 @@ SELECT DISTINCT tx_id FROM (
 
   if (partialTxIds)
     for (let i = 0; i < partialTxIds.length; i += 100)
-      action!(undefined, await transactionsByIds(partialTxIds.slice(i, i + 100), db));
+      action!(undefined, await partialTransactionsByIds(partialTxIds.slice(i, i + 100), db));
 
   return chunks.flat();
 };

packages/cardano-services/src/WsServer/server.ts

@@ -220,9 +220,9 @@ export class CardanoWsServer extends WsProvider {
         };
 
         const loadTransactions = async () => {
-          const addressesMap = new Map<Cardano.PaymentAddress, true>();
-          for (const ws of this.wss.clients) for (const address of ws.addresses) addressesMap.set(address, true);
-          const addresses = [...addressesMap.keys()];
+          const addressesSet = new Set<Cardano.PaymentAddress>();
+          for (const ws of this.wss.clients) for (const address of ws.addresses) addressesSet.add(address);
+          const addresses = [...addressesSet];
 
           if (debugLog) this.logger.debug(`Transactions for notification ${notification} ${JSON.stringify(addresses)}`);
 

packages/cardano-services/src/WsServer/transactions.ts

@@ -369,6 +369,24 @@ const mapActions = (actions: ActionModel[]) =>
 
 const mapAsset = (asset: [Cardano.AssetId, string]) => [asset[0], BigInt(asset[1])] as const;
 
+/**
+ * Extracts the _compound certificates_ from two lists of _base certificates_.
+ * This is required because **db-sync** stores _compound certificates_ splitting them in _base certificate records_.
+ *
+ * As an example:
+ *
+ * `stake_vote_deleg_cert` certificates are stored as a `stake_delegation` certificate record plus a `vote_deleg_cert`
+ * certificate record splitting `stake_vote_deleg_cert` properties: the `pool_keyhash` is stored in the first record
+ * and the `drep` is stored in the latter record.
+ *
+ * To make the lower amount of queries as possible, we perform one single query on each certificate table, next we use
+ * this function to merge them results.
+ *
+ * @param certs1 The first list _base certificates_.
+ * @param certs2 The second list of _base certificates_.
+ * @param merge The function to merge two _base certificates_ into a _compound certificate_.
+ * @returns The two lists of _base certificates_ (pruned by the ones used to create the _compound certificates_) and the list of _compound certificates_.
+ */
 const compound = <
   C1 extends Cardano.HydratedCertificate,
   C2 extends Cardano.HydratedCertificate,
@@ -382,16 +400,21 @@ const compound = <
   const result: (readonly [number, C3])[] = [];
   const foundIndexes2: number[] = [];
 
+  // Iterate over certificates in the first list.
   for (const c1 of certs1) {
+    // Check if in the second list there is a certificate with the same certificate index: i.e. they are two sources of the same _compound certificate_.
     const c2index = certs2.findIndex((c2) => c1[0] === c2[0]);
 
+    // In negative case, push the certificate from the first list in the return first list.
     if (c2index === -1) result1.push(c1);
+    // In affirmative case, push the merged certificate in the return merged list.
     else {
       foundIndexes2.push(c2index);
       result.push([c1[0], merge(c1[1], certs2[c2index][1])]);
     }
   }
 
+  // Finally create the return second list filtering the second list from the ones used to create the return merged list.
   const result2 = certs2.filter((_, c2index) => !foundIndexes2.includes(c2index));
 
   return [result1, result2, result] as const;
@@ -693,36 +716,37 @@ const vDele = [[null]] as unknown as TxModel['vDele'];
 const votes = [{}] as VoteModel[];
 const withdrawals = [{}] as TxModel['withdrawals'];
 
-export const transactionsByIds = async (ids: string[], db: Pool, onlyUtxos?: boolean) => {
-  const result = await db.query<{ tx: TxModel }>({
-    ...(onlyUtxos ? { name: 'get_utxos', text: getUtxos } : { name: 'get_txs', text: getTransactions }),
-    values: [ids]
-  });
-
-  const rows = onlyUtxos
-    ? result.rows.map(({ tx }) => ({
-        tx: {
-          ...tx,
-          actions,
-          collateral,
-          collaterals,
-          commReg,
-          commRet,
-          deRep,
-          metadata,
-          mint,
-          redeemers,
-          reg,
-          sDele,
-          spReg,
-          spRetire,
-          unReg,
-          vDele,
-          votes,
-          withdrawals
-        }
-      }))
-    : result.rows;
+export const transactionsByIds = async (ids: string[], db: Pool) => {
+  const { rows } = await db.query<{ tx: TxModel }>({ name: 'get_txs', text: getTransactions, values: [ids] });
 
   return rows.map(({ tx }) => mapTx(tx));
 };
+
+export const partialTransactionsByIds = async (ids: string[], db: Pool) => {
+  const { rows } = await db.query<{ tx: TxModel }>({ name: 'get_utxos', text: getUtxos, values: [ids] });
+
+  return rows
+    .map(({ tx }) => ({
+      tx: {
+        ...tx,
+        actions,
+        collateral,
+        collaterals,
+        commReg,
+        commRet,
+        deRep,
+        metadata,
+        mint,
+        redeemers,
+        reg,
+        sDele,
+        spReg,
+        spRetire,
+        unReg,
+        vDele,
+        votes,
+        withdrawals
+      }
+    }))
+    .map(({ tx }) => mapTx(tx));
+};