fix: protect all HTTP API calls with calls limiter

src/methods/estimate-fee.ts

@@ -1,10 +1,11 @@
 import { prepareMessage } from '../utils/message.js';
 import { blockfrostAPI } from '../utils/blockfrost-api.js';
 import { MessageId } from '../types/message.js';
+import { limiter } from '../utils/limiter.js';
 
 export default async (id: MessageId, clientId: string): Promise<string> => {
-  const epochsLatest = await blockfrostAPI.epochsLatest();
-  const epochsParameters = await blockfrostAPI.epochsParameters(epochsLatest.epoch);
+  const epochsLatest = await limiter(() => blockfrostAPI.epochsLatest());
+  const epochsParameters = await limiter(() => blockfrostAPI.epochsParameters(epochsLatest.epoch));
 
   const message = prepareMessage({
     id,

src/methods/get-ada-handle.ts

@@ -2,15 +2,16 @@ import { prepareMessage } from '../utils/message.js';
 import { blockfrostAPI } from '../utils/blockfrost-api.js';
 import { MessageId } from '../types/message.js';
 import { BlockfrostServerError } from '@blockfrost/blockfrost-js';
+import { limiter } from '../utils/limiter.js';
 
 const policyID = 'f0ff48bbb7bbe9d59a40f1ce90e9e9d0ff5002ec48f232b49ca0fb9a';
 
 export default async (id: MessageId, clientId: string, name: string): Promise<string> => {
   let data: { address: string } | null;
 
   try {
-    const result = await blockfrostAPI.assetsAddresses(
-      policyID + Buffer.from(name, 'utf8').toString('hex'),
+    const result = await limiter(() =>
+      blockfrostAPI.assetsAddresses(policyID + Buffer.from(name, 'utf8').toString('hex')),
     );
 
     if (result.length > 1) {

src/methods/get-block.ts

@@ -1,13 +1,14 @@
 import { prepareMessage } from '../utils/message.js';
 import { blockfrostAPI } from '../utils/blockfrost-api.js';
 import { MessageId } from '../types/message.js';
+import { limiter } from '../utils/limiter.js';
 
 export default async (
   id: MessageId,
   clientId: string,
   hashOrNumber: string | number,
 ): Promise<string> => {
-  const data = await blockfrostAPI.blocks(hashOrNumber);
+  const data = await limiter(() => blockfrostAPI.blocks(hashOrNumber));
   const message = prepareMessage({ id, clientId, data });
 
   return message;

src/methods/get-server-info.ts

@@ -2,11 +2,16 @@ import * as os from 'os';
 import { prepareMessage } from '../utils/message.js';
 import { blockfrostAPI } from '../utils/blockfrost-api.js';
 import { MessageId } from '../types/message.js';
+import { limiter } from '../utils/limiter.js';
 
 export const getServerInfo = async () => {
   const isTestnet = blockfrostAPI.options.network !== 'mainnet';
-  const info = await blockfrostAPI.root();
-  const latestBlock = await blockfrostAPI.blocksLatest();
+
+  const [info, latestBlock] = await Promise.all([
+    limiter(() => blockfrostAPI.root()),
+    limiter(() => blockfrostAPI.blocksLatest()),
+  ]);
+
   const serverInfo = {
     hostname: os.hostname(),
     name: 'Cardano',

src/utils/address.ts

@@ -277,9 +277,10 @@ export const getAddressesData = async (
 
 export const getStakingData = async (stakeAddress: string): Promise<Addresses.StakingData> => {
   try {
-    const stakeAddressData = await blockfrostAPI.accounts(stakeAddress);
-    const drepData = stakeAddressData.drep_id
-      ? await blockfrostAPI.governance.drepsById(stakeAddressData.drep_id)
+    const stakeAddressData = await limiter(() => blockfrostAPI.accounts(stakeAddress));
+    const { drep_id } = stakeAddressData;
+    const drepData = drep_id
+      ? await limiter(() => blockfrostAPI.governance.drepsById(drep_id))
       : null;
 
     return {
@@ -306,7 +307,7 @@ export const getStakingAccountTotal = async (
   stakeAddress: string,
 ): Promise<Responses['account_addresses_total']> => {
   try {
-    const total = await blockfrostAPI.accountsAddressesTotal(stakeAddress);
+    const total = await limiter(() => blockfrostAPI.accountsAddressesTotal(stakeAddress));
 
     return total;
   } catch (error) {

src/utils/blockfrost-api.ts

@@ -4,6 +4,7 @@ import { createRequire } from 'module';
 import { BLOCKFROST_REQUEST_TIMEOUT } from '../constants/config.js';
 import { logger } from './logger.js';
 import { AffectedAddressesInBlock } from '../types/events.js';
+import { limiter } from './limiter.js';
 const require = createRequire(import.meta.url);
 const packageJson = require('../../package.json');
 
@@ -30,15 +31,15 @@ export const getBlockData = async (options?: {
   // Fetch latest block and all addresses affected in the block
   // Fetching of affected addresses may fail, there are 3 retry attempts before throwing an error
   const MAX_ATTEMPTS = 3;
-  const latestBlock = options?.block
-    ? await blockfrostAPI.blocks(options.block)
-    : await blockfrostAPI.blocksLatest();
+  const latestBlock = await limiter(() =>
+    options?.block ? blockfrostAPI.blocks(options.block) : blockfrostAPI.blocksLatest(),
+  );
   let affectedAddresses: AffectedAddressesInBlock = [];
 
   try {
-    affectedAddresses = await blockfrostAPI.blocksAddressesAll(latestBlock.hash, {
-      batchSize: 2,
-    });
+    affectedAddresses = await limiter(() =>
+      blockfrostAPI.blocksAddressesAll(latestBlock.hash, { batchSize: 2 }),
+    );
   } catch (error) {
     if (
       error instanceof BlockfrostServerError &&

src/utils/transaction.ts

@@ -21,9 +21,12 @@ export const sortTransactionsCmp = <
 
 const fetchTxWithUtxo = async (txHash: string, address: string, cbor?: boolean) => {
   try {
-    const txUtxo = await limiter(() => blockfrostAPI.txsUtxos(txHash));
-    const txData = await fetchTransactionData(txHash, cbor);
-    const txUtxos = await transformTransactionUtxo(txUtxo);
+    const [txUtxos, txData] = await Promise.all([
+      limiter(() => blockfrostAPI.txsUtxos(txHash)).then(txUtxo =>
+        transformTransactionUtxo(txUtxo),
+      ),
+      fetchTransactionData(txHash, cbor),
+    ]);
 
     return { txData, txUtxos, address, txHash };
   } catch (error) {