fix: storeCredentials to support passing credentials along

Author: will-break-it

packages/projection-typeorm/src/operators/storeCredentials.ts

@@ -1,78 +1,77 @@
-import { Cardano, ChainSyncEventType, TxBodyCBOR } from '@cardano-sdk/core';
+import { Cardano, ChainSyncEventType } from '@cardano-sdk/core';
 import { Hash28ByteBase16 } from '@cardano-sdk/crypto';
 import { Mappers } from '@cardano-sdk/projection';
 import { credentialsFromAddress } from '@cardano-sdk/projection/src/operators/Mappers/util';
 import { CredentialEntity, CredentialType, OutputEntity } from '../entity';
 import { typeormOperator } from './util';
 
-export const storeCredentials = typeormOperator<Mappers.WithUtxo & Mappers.WithAddresses>(async (evt) => {
-  const {
-    block: { body: txs },
-    eventType,
-    queryRunner
-  } = evt;
+export interface WithTxCredentials {
+  txToCredentials: Map<Cardano.TransactionId, Map<Hash28ByteBase16, CredentialType>>;
+}
 
-  // produced credentials will be automatically deleted via block cascade
-  if (txs.length === 0 || eventType !== ChainSyncEventType.RollForward) return;
+export const storeCredentials = typeormOperator<Mappers.WithUtxo & Mappers.WithAddresses, WithTxCredentials>(
+  async (evt) => {
+    const {
+      block: { body: txs },
+      eventType,
+      queryRunner
+    } = evt;
 
-  const utxoRepository = queryRunner.manager.getRepository(OutputEntity);
-  const txIdToCredentials = new Map<Cardano.TransactionId, Map<Hash28ByteBase16, CredentialType>>();
+    const txToCredentials = new Map<Cardano.TransactionId, Map<Hash28ByteBase16, CredentialType>>();
 
-  const addCredential = (
-    { paymentCredentialHash, stakeCredential }: Mappers.Address,
-    map: Map<Hash28ByteBase16, CredentialType>
-  ) => {
-    if (paymentCredentialHash) {
-      map.set(paymentCredentialHash, CredentialType.PAYMENT);
-    }
-    if (stakeCredential && !('slot' in stakeCredential)) {
-      // FIXME: Support pointer stake credentials
-      map.set(stakeCredential, CredentialType.STAKE);
-    }
-  };
+    // produced credentials will be automatically deleted via block cascade
+    if (txs.length > 0 && eventType === ChainSyncEventType.RollForward) {
+      const utxoRepository = queryRunner.manager.getRepository(OutputEntity);
 
-  // get input & output credentials by tx
-  for (const tx of evt.block.body) {
-    const txCredentials = new Map<Hash28ByteBase16, CredentialType>();
+      // get input & output credentials by tx
+      for (const tx of evt.block.body) {
+        const txCredentials = new Map<Hash28ByteBase16, CredentialType>();
+        const addCredential = (source: OutputEntity | null | Cardano.TxOut) => {
+          if (source && source.address) {
+            const { paymentCredentialHash, stakeCredential } = credentialsFromAddress(source.address);
+            if (paymentCredentialHash) {
+              txCredentials.set(paymentCredentialHash, CredentialType.PAYMENT);
+            }
+            if (stakeCredential && !('slot' in stakeCredential)) {
+              // FIXME: Support pointer stake credentials
+              txCredentials.set(stakeCredential, CredentialType.STAKE);
+            }
+          }
+        };
 
-    // get tx input address
-    const txInOutputs = await Promise.all(
-      tx.body.inputs.map(
-        async ({ txId, index: outputIndex }) =>
-          await utxoRepository.findOne({ select: { address: true }, where: { outputIndex, txId } })
-      )
-    );
+        // get tx input address
+        const txInOutputEntities = await Promise.all(
+          tx.body.inputs.map(
+            async ({ txId, index: outputIndex }) =>
+              await utxoRepository.findOne({ select: { address: true }, where: { outputIndex, txId } })
+          )
+        );
 
-    // add tx input credentials to involved tx credentials
-    for (const txOut of txInOutputs) {
-      if (txOut && txOut.address) {
-        addCredential(credentialsFromAddress(txOut.address), txCredentials);
-      }
-    }
+        // add tx input credentials to involved tx credentials
+        txInOutputEntities.forEach(addCredential);
+        // add tx output credentials to involved tx credentials
+        tx.body.outputs.forEach(addCredential);
 
-    // add tx output credentials to involved tx credentials
-    for (const txOut of tx.body.outputs) {
-      addCredential(credentialsFromAddress(txOut.address), txCredentials);
-    }
+        const credentialEntities = Array.from(txCredentials).map(
+          ([credentialHash, credentialType]): CredentialEntity => ({
+            credentialHash: Buffer.from(credentialHash, 'hex'),
+            credentialType
+          })
+        );
 
-    const credentialEntities = Array.from(txCredentials).map(
-      ([credentialHash, credentialType]): CredentialEntity => ({
-        credentialHash: Buffer.from(credentialHash, 'hex'),
-        credentialType
-      })
-    );
+        await queryRunner.manager
+          .createQueryBuilder()
+          .insert()
+          .into(CredentialEntity)
+          .values(credentialEntities)
+          .orIgnore()
+          .execute();
 
-    await queryRunner.manager
-      .createQueryBuilder()
-      .insert()
-      .into(CredentialEntity)
-      .values(credentialEntities)
-      .orIgnore()
-      .execute();
+        // store tx credentials for transaction entities
+        txToCredentials.set(tx.id, txCredentials);
+      }
+    }
 
-    // store tx credentials for transaction entities
-    txIdToCredentials.set(tx.id, txCredentials);
+    return { txToCredentials: txToCredentials };
   }
-
-  return { txIdToCredentials };
-});
+);