fixup! feat(cardano-services): implement missing Blockfrost providers features and tests

Author: ginnun

packages/cardano-services/sil.json

@@ -0,0 +1 @@
+Handling project rate limit errors

packages/cardano-services/src/Asset/BlockfrostAssetProvider/BlockfrostAssetProvider.ts

@@ -2,7 +2,7 @@
 import { Asset, AssetProvider, Cardano, GetAssetArgs, GetAssetsArgs } from '@cardano-sdk/core';
 import { BlockFrostAPI, Responses } from '@blockfrost/blockfrost-js';
 import { BlockfrostProvider } from '../../util/BlockfrostProvider/BlockfrostProvider';
-import { blockfrostMetadataToTxMetadata, fetchSequentially } from '../../util';
+import { blockfrostMetadataToTxMetadata, blockfrostToProviderError, fetchSequentially } from '../../util';
 import { replaceNullsWithUndefineds } from '@cardano-sdk/util';
 
 export class BlockfrostAssetProvider extends BlockfrostProvider implements AssetProvider {
@@ -48,32 +48,36 @@ export class BlockfrostAssetProvider extends BlockfrostProvider implements Asset
   }
   // getAsset: (args: GetAssetArgs) => Promise<Asset.AssetInfo>;
   async getAsset({ assetId, extraData }: GetAssetArgs) {
-    const response = await this.blockfrost.assetsById(assetId.toString());
-    const name = Cardano.AssetId.getAssetName(assetId);
-    const policyId = Cardano.PolicyId(response.policy_id);
-    const quantity = BigInt(response.quantity);
+    try {
+      const response = await this.blockfrost.assetsById(assetId.toString());
+      const name = Cardano.AssetId.getAssetName(assetId);
+      const policyId = Cardano.PolicyId(response.policy_id);
+      const quantity = BigInt(response.quantity);
 
-    const nftMetadata = async () => {
-      let lastMintedTxHash: string = response.initial_mint_tx_hash;
-      if (response.mint_or_burn_count > 1) {
-        const lastMintedTx = await this.getLastMintedTx(assetId);
-        if (lastMintedTx) lastMintedTxHash = lastMintedTx.tx_hash;
-      }
-      return this.getNftMetadata({ name, policyId }, lastMintedTxHash);
-    };
+      const nftMetadata = async () => {
+        let lastMintedTxHash: string = response.initial_mint_tx_hash;
+        if (response.mint_or_burn_count > 1) {
+          const lastMintedTx = await this.getLastMintedTx(assetId);
+          if (lastMintedTx) lastMintedTxHash = lastMintedTx.tx_hash;
+        }
+        return this.getNftMetadata({ name, policyId }, lastMintedTxHash);
+      };
 
-    return {
-      assetId,
-      fingerprint: Cardano.AssetFingerprint(response.fingerprint),
-      // history: extraData?.history ? await history() : undefined,
-      mintOrBurnCount: response.mint_or_burn_count,
-      name,
-      nftMetadata: extraData?.nftMetadata ? await nftMetadata() : undefined,
-      policyId,
-      quantity,
-      supply: quantity,
-      tokenMetadata: extraData?.tokenMetadata ? this.mapMetadata(assetId, response.metadata) : undefined
-    };
+      return {
+        assetId,
+        fingerprint: Cardano.AssetFingerprint(response.fingerprint),
+        // history: extraData?.history ? await history() : undefined,
+        mintOrBurnCount: response.mint_or_burn_count,
+        name,
+        nftMetadata: extraData?.nftMetadata ? await nftMetadata() : undefined,
+        policyId,
+        quantity,
+        supply: quantity,
+        tokenMetadata: extraData?.tokenMetadata ? this.mapMetadata(assetId, response.metadata) : undefined
+      };
+    } catch (error) {
+      throw blockfrostToProviderError(error);
+    }
   }
   async getAssets({ assetIds, extraData }: GetAssetsArgs) {
     return Promise.all(assetIds.map((assetId) => this.getAsset({ assetId, extraData })));

packages/cardano-services/src/ChainHistory/BlockrostChainHistoryProvider/BlockfrostChainHistoryProvider.ts

@@ -5,6 +5,7 @@ import {
   BlockfrostToCore,
   BlockfrostTransactionContent,
   blockfrostMetadataToTxMetadata,
+  blockfrostToProviderError,
   fetchByAddressSequentially,
   isBlockfrostNotFoundError
 } from '../../util';
@@ -185,111 +186,128 @@ export class BlockfrostChainHistoryProvider extends BlockfrostProvider implement
   protected parseValidityInterval = (num: string | null) => Cardano.Slot(Number.parseInt(num || '')) || undefined;
 
   protected async fetchTransaction(hash: Cardano.TransactionId): Promise<Cardano.HydratedTx> {
-    const utxos: Responses['tx_content_utxo'] = await this.blockfrost.txsUtxos(hash.toString());
-    const { inputs, outputs, collaterals } = BlockfrostToCore.transactionUtxos(utxos);
+    try {
+      const utxos: Responses['tx_content_utxo'] = await this.blockfrost.txsUtxos(hash.toString());
+      const { inputs, outputs, collaterals } = BlockfrostToCore.transactionUtxos(utxos);
 
-    const response = await this.blockfrost.txs(hash.toString());
-    const metadata = await this.fetchJsonMetadata(hash);
-    const certificates = await this.fetchCertificates(response);
-    const withdrawals = await this.fetchWithdrawals(response);
-    return {
-      auxiliaryData: metadata
-        ? {
-            blob: metadata
-          }
-        : undefined,
+      const response = await this.blockfrost.txs(hash.toString());
+      const metadata = await this.fetchJsonMetadata(hash);
+      const certificates = await this.fetchCertificates(response);
+      const withdrawals = await this.fetchWithdrawals(response);
+      return {
+        auxiliaryData: metadata
+          ? {
+              blob: metadata
+            }
+          : undefined,
 
-      blockHeader: {
-        blockNo: Cardano.BlockNo(response.block_height),
-        hash: Cardano.BlockId(response.block),
-        slot: Cardano.Slot(response.slot)
-      },
-      body: {
-        certificates,
-        collaterals,
-        fee: BigInt(response.fees),
-        inputs,
-        mint: this.gatherMintsFromUtxos(response, utxos),
-        outputs,
-        validityInterval: {
-          invalidBefore: this.parseValidityInterval(response.invalid_before),
-          invalidHereafter: this.parseValidityInterval(response.invalid_hereafter)
+        blockHeader: {
+          blockNo: Cardano.BlockNo(response.block_height),
+          hash: Cardano.BlockId(response.block),
+          slot: Cardano.Slot(response.slot)
         },
-        withdrawals
-      },
-      id: hash,
-      index: response.index,
-      inputSource: inputs && inputs.length > 0 ? Cardano.InputSource.inputs : Cardano.InputSource.collaterals,
-      txSize: response.size,
-      witness: {
-        redeemers: await this.fetchRedeemers(response),
-        signatures: new Map() // not available in blockfrost @todo check again
-      }
-    };
+        body: {
+          certificates,
+          collaterals,
+          fee: BigInt(response.fees),
+          inputs,
+          mint: this.gatherMintsFromUtxos(response, utxos),
+          outputs,
+          validityInterval: {
+            invalidBefore: this.parseValidityInterval(response.invalid_before),
+            invalidHereafter: this.parseValidityInterval(response.invalid_hereafter)
+          },
+          withdrawals
+        },
+        id: hash,
+        index: response.index,
+        inputSource: inputs && inputs.length > 0 ? Cardano.InputSource.inputs : Cardano.InputSource.collaterals,
+        txSize: response.size,
+        witness: {
+          redeemers: await this.fetchRedeemers(response),
+          signatures: new Map() // not available in blockfrost @todo check again
+        }
+      };
+    } catch (error) {
+      throw blockfrostToProviderError(error);
+    }
   }
 
   public async blocksByHashes({ ids }: BlocksByIdsArgs): Promise<Cardano.ExtendedBlockInfo[]> {
-    const responses = await Promise.all(ids.map((id) => this.blockfrost.blocks(id.toString())));
-    return responses.map((response) => {
-      if (!response.epoch || !response.epoch_slot || !response.height || !response.slot || !response.block_vrf) {
-        throw new ProviderError(ProviderFailure.Unknown, null, 'Queried unsupported block');
-      }
-      return {
-        confirmations: response.confirmations,
-        date: new Date(response.time * 1000),
-        epoch: Cardano.EpochNo(response.epoch),
-        epochSlot: response.epoch_slot,
-        fees: BigInt(response.fees || '0'),
-        header: {
-          blockNo: Cardano.BlockNo(response.height),
-          hash: Cardano.BlockId(response.hash),
-          slot: Cardano.Slot(response.slot)
-        },
-        nextBlock: response.next_block ? Cardano.BlockId(response.next_block) : undefined,
-        previousBlock: response.previous_block ? Cardano.BlockId(response.previous_block) : undefined,
-        size: Cardano.BlockSize(response.size),
-        slotLeader: Cardano.SlotLeader(response.slot_leader),
-        totalOutput: BigInt(response.output || '0'),
-        txCount: response.tx_count,
-        vrf: Cardano.VrfVkBech32(response.block_vrf)
-      };
-    });
+    try {
+      const responses = await Promise.all(ids.map((id) => this.blockfrost.blocks(id.toString())));
+      return responses.map((response) => {
+        if (!response.epoch || !response.epoch_slot || !response.height || !response.slot || !response.block_vrf) {
+          throw new ProviderError(ProviderFailure.Unknown, null, 'Queried unsupported block');
+        }
+        return {
+          confirmations: response.confirmations,
+          date: new Date(response.time * 1000),
+          epoch: Cardano.EpochNo(response.epoch),
+          epochSlot: response.epoch_slot,
+          fees: BigInt(response.fees || '0'),
+          header: {
+            blockNo: Cardano.BlockNo(response.height),
+            hash: Cardano.BlockId(response.hash),
+            slot: Cardano.Slot(response.slot)
+          },
+          nextBlock: response.next_block ? Cardano.BlockId(response.next_block) : undefined,
+          previousBlock: response.previous_block ? Cardano.BlockId(response.previous_block) : undefined,
+          size: Cardano.BlockSize(response.size),
+          slotLeader: Cardano.SlotLeader(response.slot_leader),
+          totalOutput: BigInt(response.output || '0'),
+          txCount: response.tx_count,
+          vrf: Cardano.VrfVkBech32(response.block_vrf)
+        };
+      });
+    } catch (error) {
+      throw blockfrostToProviderError(error);
+    }
   }
 
   public async transactionsByHashes({ ids }: TransactionsByIdsArgs): Promise<Cardano.HydratedTx[]> {
-    return Promise.all(ids.map((id) => this.fetchTransaction(id)));
+    try {
+      return Promise.all(ids.map((id) => this.fetchTransaction(id)));
+    } catch (error) {
+      throw blockfrostToProviderError(error);
+    }
   }
 
   public async transactionsByAddresses({
     addresses,
     blockRange
   }: TransactionsByAddressesArgs): Promise<Paginated<Cardano.HydratedTx>> {
-    const addressTransactions = await Promise.all(
-      addresses.map(async (address) =>
-        fetchByAddressSequentially<
-          { tx_hash: string; tx_index: number; block_height: number },
-          BlockfrostTransactionContent
-        >({
-          address,
-          haveEnoughItems: blockRange?.lowerBound
-            ? (transactions) =>
-                transactions.length > 0 && transactions[transactions.length - 1].block_height < blockRange!.lowerBound!
-            : undefined,
-          request: (addr: Cardano.PaymentAddress, paginationOptions) =>
-            this.blockfrost.addressesTransactions(addr.toString(), paginationOptions)
-        })
-      )
-    );
+    try {
+      const addressTransactions = await Promise.all(
+        addresses.map(async (address) =>
+          fetchByAddressSequentially<
+            { tx_hash: string; tx_index: number; block_height: number },
+            BlockfrostTransactionContent
+          >({
+            address,
+            haveEnoughItems: blockRange?.lowerBound
+              ? (transactions) =>
+                  transactions.length > 0 &&
+                  transactions[transactions.length - 1].block_height < blockRange!.lowerBound!
+              : undefined,
+            request: (addr: Cardano.PaymentAddress, paginationOptions) =>
+              this.blockfrost.addressesTransactions(addr.toString(), paginationOptions)
+          })
+        )
+      );
 
-    const allTransactions = addressTransactions
-      .flat(1)
-      .sort((a, b) => b.block_height - a.block_height || b.tx_index - a.tx_index);
-    const addressTransactionsSinceBlock = blockRange?.lowerBound
-      ? allTransactions.filter(({ block_height }) => block_height >= blockRange!.lowerBound!)
-      : allTransactions;
-    const ids = addressTransactionsSinceBlock.map(({ tx_hash }) => Cardano.TransactionId(tx_hash));
-    const pageResults = await this.transactionsByHashes({ ids });
+      const allTransactions = addressTransactions
+        .flat(1)
+        .sort((a, b) => b.block_height - a.block_height || b.tx_index - a.tx_index);
+      const addressTransactionsSinceBlock = blockRange?.lowerBound
+        ? allTransactions.filter(({ block_height }) => block_height >= blockRange!.lowerBound!)
+        : allTransactions;
+      const ids = addressTransactionsSinceBlock.map(({ tx_hash }) => Cardano.TransactionId(tx_hash));
+      const pageResults = await this.transactionsByHashes({ ids });
 
-    return { pageResults, totalResultCount: allTransactions.length };
+      return { pageResults, totalResultCount: allTransactions.length };
+    } catch (error) {
+      throw blockfrostToProviderError(error);
+    }
   }
 }