refactor: boltz query handling

Author: apotdevin

src/client/src/views/swap/SwapStatus.tsx

@@ -1,5 +1,5 @@
 import { Fragment, useEffect, useState } from 'react';
-import { Trash } from 'react-feather';
+import { RefreshCw, Trash } from 'react-feather';
 import { Tooltip as ReactTooltip } from 'react-tooltip';
 import { ColorButton } from '../../components/buttons/colorButton/ColorButton';
 import { getTransactionLink } from '../../components/generic/helpers';
@@ -11,7 +11,7 @@ import {
   SubTitle,
 } from '../../components/generic/Styled';
 import Modal from '../../components/modal/ReactModal';
-import { useGetBoltzSwapStatusLazyQuery } from '../../graphql/queries/__generated__/getBoltzSwapStatus.generated';
+import { useGetBoltzSwapStatusQuery } from '../../graphql/queries/__generated__/getBoltzSwapStatus.generated';
 import { chartColors, themeColors } from '../../styles/Themes';
 import styled from 'styled-components';
 import { SwapClaim } from './SwapClaim';
@@ -192,20 +192,14 @@ export const SwapStatus = () => {
 
   const [enriched, setEnriched] = useState<EnrichedSwap[]>([]);
 
-  const [getStatus, { data, loading }] = useGetBoltzSwapStatusLazyQuery({
-    pollInterval: 2000,
+  const { data, refetch, networkStatus } = useGetBoltzSwapStatusQuery({
+    notifyOnNetworkStatusChange: true,
+    variables: { ids: swaps.map((s: { id: string }) => s.id).filter(Boolean) },
     fetchPolicy: 'network-only',
+    skip: !swaps.length,
   });
 
-  useEffect(() => {
-    if (swaps.length) {
-      getStatus({
-        variables: {
-          ids: swaps.map((s: { id: string }) => s.id).filter(Boolean),
-        },
-      });
-    }
-  }, [swaps, getStatus]);
+  const loading = [1, 2, 3, 4, 6].includes(networkStatus);
 
   useEffect(() => {
     if (loading || !data?.getBoltzSwapStatus) return;
@@ -232,7 +226,19 @@ export const SwapStatus = () => {
     dispatch({ type: 'cleanup', swaps: cleaned });
   };
 
-  if (!swaps.length || !data?.getBoltzSwapStatus || loading) {
+  if (loading) {
+    return (
+      <>
+        <Card mobileCardPadding={'0'} mobileNoBackground={true}>
+          <SubTitle>Swap History</SubTitle>
+          <Separation />
+          <DarkSubTitle>Loading swap statuses...</DarkSubTitle>
+        </Card>
+      </>
+    );
+  }
+
+  if (!swaps.length || !data?.getBoltzSwapStatus) {
     return (
       <>
         <Card mobileCardPadding={'0'} mobileNoBackground={true}>
@@ -249,11 +255,20 @@ export const SwapStatus = () => {
       <Card mobileCardPadding={'0'} mobileNoBackground={true}>
         <SingleLine>
           <SubTitle>Swap History</SubTitle>
-          <div data-tip data-for={`cleanup`}>
-            <ColorButton disabled={loading} onClick={handleCleanup}>
-              <Trash size={18} />
+          <SingleLine>
+            <ColorButton
+              disabled={loading}
+              onClick={() => refetch()}
+              withMargin="0 4px 0 0"
+            >
+              <RefreshCw size={18} />
             </ColorButton>
-          </div>
+            <div data-tip data-for={`cleanup`}>
+              <ColorButton disabled={loading} onClick={handleCleanup}>
+                <Trash size={18} />
+              </ColorButton>
+            </div>
+          </SingleLine>
         </SingleLine>
         <Separation />
         {enriched.map((swap, index) => (

src/server/modules/api/boltz/boltz.module.ts

@@ -3,19 +3,13 @@ import { FetchModule } from '../../fetch/fetch.module';
 import { NodeModule } from '../../node/node.module';
 import {
   BoltzResolver,
-  BoltzSwapResolver,
   CreateBoltzReverseSwapTypeResolver,
 } from './boltz.resolver';
 import { BoltzService } from './boltz.service';
 
 @Module({
   imports: [NodeModule, FetchModule],
-  providers: [
-    BoltzService,
-    BoltzSwapResolver,
-    CreateBoltzReverseSwapTypeResolver,
-    BoltzResolver,
-  ],
+  providers: [BoltzService, CreateBoltzReverseSwapTypeResolver, BoltzResolver],
   exports: [BoltzService],
 })
 export class BoltzModule {}

src/server/modules/api/boltz/boltz.resolver.ts

@@ -32,53 +32,18 @@ import {
   BoltzInfoType,
   BoltzSwap,
   CreateBoltzReverseSwapType,
+  isBoltzError,
 } from './boltz.types';
 import { getPreimageAndHash } from 'src/server/utils/crypto';
 import { CurrentUser } from '../../security/security.decorators';
 import { UserId } from '../../security/security.types';
 import { toWithError } from 'src/server/utils/async';
 import { ECPairAPI, ECPairFactory } from 'ecpair';
 import * as ecc from 'tiny-secp256k1';
+import { mapSeries } from 'async';
 
 const ECPair: ECPairAPI = ECPairFactory(ecc);
 
-@Resolver(BoltzSwap)
-export class BoltzSwapResolver {
-  constructor(
-    private boltzService: BoltzService,
-    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger
-  ) {}
-
-  @ResolveField()
-  async id(@Parent() parent: string) {
-    return parent;
-  }
-
-  @ResolveField()
-  async boltz(@Parent() parent: string) {
-    const [info, error] = await toWithError(
-      this.boltzService.getSwapStatus(parent)
-    );
-
-    if (error || info?.error) {
-      this.logger.error(`Error getting status for swap with id: ${parent}`, {
-        error: error || info.error,
-      });
-      return null;
-    }
-
-    if (!info?.status) {
-      this.logger.debug(
-        `No status in Boltz response for swap with id: ${parent}`,
-        { info }
-      );
-      return null;
-    }
-
-    return info;
-  }
-}
-
 @Resolver(CreateBoltzReverseSwapType)
 export class CreateBoltzReverseSwapTypeResolver {
   constructor(private nodeService: NodeService) {}
@@ -110,13 +75,14 @@ export class BoltzResolver {
 
   @Query(() => BoltzInfoType)
   async getBoltzInfo() {
-    const info = await this.boltzService.getPairs();
+    const [info, error] = await toWithError(this.boltzService.getPairs());
 
-    if (info?.error) {
+    if (error || isBoltzError(info)) {
       this.logger.error('Error getting swap information from Boltz', {
-        error: info.error,
+        error,
+        boltzError: info,
       });
-      throw new Error(info.error);
+      throw new GraphQLError('Error getting swap informaion from Boltz');
     }
 
     const btcPair = info?.BTC?.BTC;
@@ -137,7 +103,29 @@ export class BoltzResolver {
   async getBoltzSwapStatus(
     @Args('ids', { type: () => [String] }) ids: string[]
   ) {
-    return ids;
+    return mapSeries(ids, async (id: string) => {
+      const [info, error] = await toWithError(
+        this.boltzService.getSwapStatus(id)
+      );
+
+      if (error || isBoltzError(info)) {
+        this.logger.error(`Error getting status for swap with id: ${id}`, {
+          error,
+          boltzError: info,
+        });
+        return { id };
+      }
+
+      if (!info.status) {
+        this.logger.debug(
+          `No status in Boltz response for swap with id: ${id}`,
+          { info }
+        );
+        return { id };
+      }
+
+      return { id, boltz: info };
+    });
   }
 
   @Mutation(() => String)
@@ -289,15 +277,16 @@ export class BoltzResolver {
       publicKey,
     });
 
-    const info = await this.boltzService.createReverseSwap(
-      amount,
-      hash,
-      publicKey
+    const [info, error] = await toWithError(
+      this.boltzService.createReverseSwap(amount, hash, publicKey)
     );
 
-    if (info?.error) {
-      this.logger.error('Error creating reverse swap with Boltz', info.error);
-      throw new Error(info.error);
+    if (error || isBoltzError(info)) {
+      this.logger.error('Error creating reverse swap with Boltz', {
+        error,
+        boltzError: info,
+      });
+      throw new GraphQLError('Error creating reverse swap with Boltz');
     }
 
     const finalInfo = {
@@ -327,17 +316,23 @@ export class BoltzResolver {
   private broadcastTransaction = async (finalTransaction: Transaction) => {
     this.logger.debug('Final transaction', { finalTransaction });
 
-    const response = await this.boltzService.broadcastTransaction(
-      finalTransaction.toHex()
+    const [info, error] = await toWithError(
+      this.boltzService.broadcastTransaction(finalTransaction.toHex())
     );
 
-    this.logger.debug('Response from Boltz', { response });
+    if (error || isBoltzError(info)) {
+      this.logger.error('Error broadcasting transaction through Boltz', {
+        error,
+        boltzError: info,
+      });
+      throw new GraphQLError('Error broadcasting transaction through Boltz');
+    }
 
-    if (!response?.id) {
+    if (!info.id) {
       this.logger.error('Did not receive a transaction id from Boltz');
       throw new Error('NoTransactionIdFromBoltz');
     }
 
-    return response.id;
+    return info.id;
   };
 }