add status page tests

src/consts/Types.ts

@@ -1,9 +1,4 @@
 export type ButtonLabelParams = {
     key: string;
-    params?: Record<string, string>;
-};
-
-export type SwapStatusTransaction = {
-    hex?: string;
-    id?: string;
+    params?: Record;
 };

src/context/Pay.tsx

@@ -6,18 +6,18 @@ import {
     useContext,
 } from "solid-js";
 
-import { SwapStatusTransaction } from "../consts/Types";
+import { SwapStatusTransaction } from "../utils/boltzClient";
 import { SomeSwap } from "../utils/swapCreator";
 
 export type PayContextType = {
-    failureReason: Accessor<string>;
-    setFailureReason: Setter<string>;
-    swap: Accessor<SomeSwap | null>;
-    setSwap: Setter<SomeSwap | null>;
-    swapStatus: Accessor<string>;
-    setSwapStatus: Setter<string>;
-    swapStatusTransaction: Accessor<SwapStatusTransaction>;
-    setSwapStatusTransaction: Setter<SwapStatusTransaction>;
+    failureReason: Accessor;
+    setFailureReason: Setter;
+    swap: Accessor;
+    setSwap: Setter;
+    swapStatus: Accessor;
+    setSwapStatus: Setter;
+    swapStatusTransaction: Accessor;
+    setSwapStatusTransaction: Setter;
 };
 
 const PayContext = createContext<PayContextType>();
@@ -30,7 +30,7 @@ const PayProvider = (props: { children: any }) => {
     });
     const [swapStatus, setSwapStatus] = createSignal<string>("");
     const [swapStatusTransaction, setSwapStatusTransaction] =
-        createSignal<SwapStatusTransaction>({});
+        createSignal<SwapStatusTransaction | null>(null);
 
     return (
         <PayContext.Provider

src/status/InvoiceFailedToPay.tsx

@@ -22,14 +22,14 @@ const InvoiceFailedToPay = () => {
                 {t("failure_reason")}: {failureReason()}
             </p>
             <hr />
-            <RefundButton swap={swap as Accessor<SubmarineSwap | ChainSwap>} />
+            <RefundButton swap={swap as Accessor} />
             <Show when={swap().assetSend !== RBTC && !isTaproot}>
                 <DownloadRefund />
             </Show>
             <hr />
             <BlockExplorer
-                asset={swap().assetSend}
-                address={getLockupAddress(swap() as SubmarineSwap)}
+                asset={swap()?.assetSend}
+                address={getLockupAddress(swap() as SubmarineSwap | ChainSwap)}
             />
         </div>
     );

src/status/SwapExpired.tsx

@@ -25,10 +25,10 @@ const SwapExpired = () => {
                 swap().id,
                 swap().type,
             );
-            log.debug(`got swap transaction for ${swap().id}`);
+            log.debug(`got swap transaction for ${swap()?.id}`);
             setTransactionToRefund(res);
         } catch (error: any) {
-            log.warn(`no swap transaction for: ${swap().id}`, error);
+            log.warn(`no swap transaction for: ${swap()?.id}`, error);
         }
     });
 
@@ -39,13 +39,12 @@ const SwapExpired = () => {
             </p>
             <hr />
             <Show when={transactionToRefund() !== null}>
-                <RefundButton
-                    swap={swap as Accessor<SubmarineSwap | ChainSwap>}
-                />
+                <RefundButton swap={swap as Accessor} />
                 <hr />
                 <BlockExplorer
-                    asset={swap().assetSend}
-                    txId={transactionToRefund().id}
+                    typeLabel="lockup_tx"
+                    asset={swap()?.assetSend}
+                    txId={transactionToRefund()?.id}
                 />
             </Show>
             <button class="btn" onClick={() => navigate("/swap")}>

src/status/TransactionMempool.tsx

@@ -15,8 +15,8 @@ const TransactionMempool = () => {
             <LoadingSpinner />
             <Show when={swapStatusTransaction()}>
                 <BlockExplorer
-                    asset={swap().assetSend}
-                    txId={swapStatusTransaction().id}
+                    asset={swap()?.assetSend}
+                    txId={swapStatusTransaction()?.id}
                     typeLabel="lockup_tx"
                 />
             </Show>

src/utils/boltzClient.ts

@@ -63,17 +63,11 @@ type ChainPairTypeTaproot = PairType & {
     };
 };
 
-type SubmarinePairsTaproot = Record<
-    string,
-    Record<string, SubmarinePairTypeTaproot>
->;
+type SubmarinePairsTaproot = Record;
 
-type ReversePairsTaproot = Record<
-    string,
-    Record<string, ReversePairTypeTaproot>
->;
+type ReversePairsTaproot = Record;
 
-type ChainPairsTaproot = Record<string, Record<string, ChainPairTypeTaproot>>;
+type ChainPairsTaproot = Record;
 
 type Pairs = {
     [SwapType.Submarine]: SubmarinePairsTaproot;
@@ -90,7 +84,7 @@ type Contracts = {
     network: {
         chainId: number;
     };
-    tokens: Record<string, string>;
+    tokens: Record;
     swapContracts: {
         EtherSwap: string;
         ERC20Swap: string;
@@ -168,7 +162,7 @@ type ChainSwapTransaction = {
 
 type TransactionInterface = Transaction | LiquidTransaction;
 
-export const getPairs = async (asset: string): Promise<Pairs> => {
+export const getPairs = async (asset: string): Promise => {
     const [submarine, reverse, chain] = await Promise.all([
         fetcher<SubmarinePairsTaproot>("/v2/swap/submarine", asset),
         fetcher<ReversePairsTaproot>("/v2/swap/reverse", asset),
@@ -196,7 +190,7 @@ export const createSubmarineSwap = (
     pairHash: string,
     referralId: string,
     refundPublicKey?: string,
-): Promise<SubmarineCreatedResponse> =>
+): Promise =>
     fetcher("/v2/swap/submarine", to, {
         from,
         to,
@@ -215,7 +209,7 @@ export const createReverseSwap = (
     referralId: string,
     claimPublicKey?: string,
     claimAddress?: string,
-): Promise<ReverseCreatedResponse> =>
+): Promise =>
     fetcher("/v2/swap/reverse", to, {
         from,
         to,
@@ -237,7 +231,7 @@ export const createChainSwap = (
     claimAddress: string | undefined,
     pairHash: string,
     referralId: string,
-): Promise<ChainSwapCreatedResponse> =>
+): Promise =>
     fetcher("/v2/swap/chain", to, {
         from,
         to,
@@ -257,7 +251,7 @@ export const getPartialRefundSignature = async (
     pubNonce: Buffer,
     transaction: TransactionInterface,
     index: number,
-): Promise<PartialSignature> => {
+): Promise => {
     checkCooperative();
     const res = await fetcher(
         `/v2/swap/${
@@ -283,7 +277,7 @@ export const getPartialReverseClaimSignature = async (
     pubNonce: Buffer,
     transaction: TransactionInterface,
     index: number,
-): Promise<PartialSignature> => {
+): Promise => {
     checkCooperative();
     const res = await fetcher(`/v2/swap/reverse/${id}/claim`, asset, {
         index,
@@ -332,7 +326,7 @@ export const getEipRefundSignature = (
 };
 
 export const getFeeEstimations = (asset: string) =>
-    fetcher<Record<string, number>>("/v2/chain/fees", asset);
+    fetcher<Record>("/v2/chain/fees", asset);
 
 export const getNodes = (asset: string) =>
     fetcher<{
@@ -355,7 +349,7 @@ export const getNodeStats = (asset: string) =>
     }>("/v2/nodes/stats", asset);
 
 export const getContracts = (asset: string) =>
-    fetcher<Record<string, Contracts>>("/v2/chain/contracts", asset);
+    fetcher<Record>("/v2/chain/contracts", asset);
 
 export const broadcastTransaction = (asset: string, txHex: string) =>
     fetcher<{ id: string }>(`/v2/chain/${asset}/transaction`, asset, {
@@ -373,7 +367,7 @@ export const getLockupTransaction = async (
     asset: string,
     id: string,
     type: SwapType,
-): Promise<LockupTransaction> => {
+): Promise => {
     switch (type) {
         case SwapType.Submarine:
             return fetcher<{
@@ -404,14 +398,16 @@ export const getReverseTransaction = (asset: string, id: string) =>
         timeoutBlockHeight: number;
     }>(`/v2/swap/reverse/${id}/transaction`, asset);
 
+export type SwapStatusTransaction = {
+    hex: string;
+    id: string;
+};
+
 export type SwapStatus = {
     status: string;
     failureReason?: string;
     zeroConfRejected?: boolean;
-    transaction?: {
-        id: string;
-        hex: string;
-    };
+    transaction?: SwapStatusTransaction;
 };
 
 export const getSwapStatus = (asset: string, id: string) =>

tests/status/SwapExpired.spec.tsx

@@ -0,0 +1,48 @@
+import { render, screen } from "@solidjs/testing-library";
+
+import { BTC } from "../../src/consts/Assets";
+import i18n from "../../src/i18n/i18n";
+import SwapExpired from "../../src/status/SwapExpired";
+import { TestComponent, contextWrapper, payContext } from "../helper";
+
+jest.mock("../../src/utils/boltzClient", () => {
+    const originalModule = jest.requireActual("../../src/utils/boltzClient");
+
+    return {
+        __esModule: true,
+        ...originalModule,
+        getLockupTransaction: jest.fn(() => {
+            return { id: "txid" };
+        }),
+    };
+});
+
+describe("SwapExpired", () => {
+    test("should show blockexplorer lockup transaction button", async () => {
+        render(
+            () => (
+                <>
+                    <TestComponent />
+                    <SwapExpired />
+                </>
+            ),
+            {
+                wrapper: contextWrapper,
+            },
+        );
+        payContext.setSwap({
+            assetSend: BTC,
+            id: "swapid",
+        } as any);
+
+        const type_label = i18n.en[`blockexplorer_lockup_tx`];
+        const label = i18n.en.blockexplorer.replace(
+            "{{ typeLabel }}",
+            type_label,
+        );
+
+        const button = await screen.findByText(label);
+        expect(button).not.toBeUndefined();
+        expect(button.getAttribute("href")).toMatch("txid");
+    });
+});

tests/status/TransactionClaimed.spec.tsx

@@ -1,19 +1,20 @@
 import { render, screen } from "@solidjs/testing-library";
 
 import { BTC, LBTC, LN, RBTC } from "../../src/consts/Assets";
+import { SwapType } from "../../src/consts/Enums";
 import i18n from "../../src/i18n/i18n";
 import TransactionClaimed from "../../src/status/TransactionClaimed";
 import { TestComponent, contextWrapper, payContext } from "../helper";
 
 describe("TransactionClaimed", () => {
     test.each`
-        name                                                  | swap
-        ${"normal swaps"}                                     | ${{ assetSend: RBTC, assetReceive: LN, address: "address" }}
-        ${"reverse swaps to RBTC"}                            | ${{ assetSend: LN, assetReceive: RBTC, claimTx: "txid" }}
-        ${"reverse swaps to BTC with claim transactions"}     | ${{ assetSend: LN, assetReceive: LBTC, claimTx: "txid" }}
-        ${"reverse swaps to L-BTC with claim transactions"}   | ${{ assetSend: LN, assetReceive: BTC, claimTx: "txid" }}
-        ${"chain swaps BTC to L-BTC with claim transactions"} | ${{ assetSend: BTC, assetReceive: LBTC, claimTx: "txid" }}
-    `("should show success for $name", async ({ swap }) => {
+        name                                                  | label               | swap
+        ${"normal swaps"}                                     | ${"lockup_address"} | ${{ type: SwapType.Submarine, assetSend: RBTC, assetReceive: LN, address: "bc12" }}
+        ${"reverse swaps to RBTC"}                            | ${"claim_tx"}       | ${{ type: SwapType.Reverse, assetSend: LN, assetReceive: RBTC, claimTx: "txid" }}
+        ${"reverse swaps to BTC with claim transactions"}     | ${"claim_tx"}       | ${{ type: SwapType.Reverse, assetSend: LN, assetReceive: LBTC, claimTx: "txid" }}
+        ${"reverse swaps to L-BTC with claim transactions"}   | ${"claim_tx"}       | ${{ type: SwapType.Reverse, assetSend: LN, assetReceive: BTC, claimTx: "txid" }}
+        ${"chain swaps BTC to L-BTC with claim transactions"} | ${"claim_tx"}       | ${{ type: SwapType.Chain, assetSend: BTC, assetReceive: LBTC, claimTx: "txid" }}
+    `("should show success for $name", async ({ label, swap }) => {
         render(
             () => (
                 <>
@@ -30,5 +31,16 @@ describe("TransactionClaimed", () => {
         await expect(
             screen.findByText(i18n.en.congrats),
         ).resolves.not.toBeUndefined();
+
+        const type_label = i18n.en[`blockexplorer_${label}`];
+        const _label = i18n.en.blockexplorer.replace(
+            "{{ typeLabel }}",
+            type_label,
+        );
+        const address_or_tx =
+            swap.type === SwapType.Submarine ? swap.address : swap.claimTx;
+        const button = screen.getByText(_label);
+        expect(button).not.toBeUndefined();
+        expect(button.getAttribute("href")).toMatch(address_or_tx);
     });
 });

tests/status/TransactionLockupFailed.spec.tsx

@@ -1,7 +1,8 @@
 import { render, screen } from "@solidjs/testing-library";
 import { OutputType } from "boltz-core";
 
-import { BTC, RBTC } from "../../src/consts/Assets";
+import { BTC, LBTC, RBTC } from "../../src/consts/Assets";
+import { SwapType } from "../../src/consts/Enums";
 import i18n from "../../src/i18n/i18n";
 import TransactionLockupFailed from "../../src/status/TransactionLockupFailed";
 import { TestComponent, contextWrapper, payContext } from "../helper";
@@ -84,4 +85,36 @@ describe("TransactionLockupFailed", () => {
             screen.findByText(i18n.en.refund),
         ).resolves.not.toBeUndefined();
     });
+
+    test.each`
+        swap
+        ${{ assetSend: BTC, type: SwapType.Submarine, address: "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq" }}
+        ${{ assetSend: LBTC, type: SwapType.Chain, lockupDetails: { lockupAddress: "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq" } }}
+    `("should show blockexplorer lockup address button", async ({ swap }) => {
+        render(
+            () => (
+                <>
+                    <TestComponent />
+                    <TransactionLockupFailed />
+                </>
+            ),
+            {
+                wrapper: contextWrapper,
+            },
+        );
+        const lockup_address =
+            swap.type === SwapType.Submarine
+                ? swap.address
+                : swap.lockupDetails.lockupAddress;
+        payContext.setSwap(swap);
+
+        const type_label = i18n.en.blockexplorer_lockup_address;
+        const label = i18n.en.blockexplorer.replace(
+            "{{ typeLabel }}",
+            type_label,
+        );
+        const button = screen.getByText(label);
+        expect(button).not.toBeUndefined();
+        expect(button.getAttribute("href")).toMatch(lockup_address);
+    });
 });