diff --git a/src/components/BlockExplorer.tsx b/src/components/BlockExplorer.tsx
index b7fd14d2..2c6263fd 100644
--- a/src/components/BlockExplorer.tsx
+++ b/src/components/BlockExplorer.tsx
@@ -2,7 +2,7 @@ import { chooseUrl, config } from "../config";
 import { useGlobalContext } from "../context/Global";
 
 const blockExplorerLink = (asset: string, isTxId: boolean, val: string) => {
-    const basePath = chooseUrl(config.assets[asset].blockExplorerUrl);
+    const basePath = chooseUrl(config.assets[asset]?.blockExplorerUrl);
     return `${basePath}/${isTxId ? "tx" : "address"}/${val}`;
 };
 
diff --git a/src/components/BlockExplorerLink.tsx b/src/components/BlockExplorerLink.tsx
deleted file mode 100644
index 132e08b4..00000000
--- a/src/components/BlockExplorerLink.tsx
+++ /dev/null
@@ -1,89 +0,0 @@
-import { Accessor, Show, createEffect, createSignal } from "solid-js";
-
-import { SwapType } from "../consts/Enums";
-import {
-    ChainSwap,
-    ReverseSwap,
-    SomeSwap,
-    SubmarineSwap,
-    getRelevantAssetForSwap,
-} from "../utils/swapCreator";
-import BlockExplorer from "./BlockExplorer";
-
-enum TransactionType {
-    Lockup = "lockupTx",
-    Claim = "claimTx",
-}
-
-const BlockExplorerLink = ({
-    swap,
-    swapStatus,
-    contractTransaction,
-    contractTransactionType,
-}: {
-    swap: Accessor<SomeSwap>;
-    swapStatus: Accessor<string>;
-    contractTransaction: Accessor<string>;
-    contractTransactionType: Accessor<TransactionType>;
-}) => {
-    // Refund transactions are handled in SwapRefunded
-
-    if (swap().type !== SwapType.Chain) {
-        return (
-            <>
-                <Show
-                    when={
-                        getRelevantAssetForSwap(swap()) &&
-                        swapStatus() !== null &&
-                        swapStatus() !== "invoice.set" &&
-                        swapStatus() !== "swap.created"
-                    }>
-                    <BlockExplorer
-                        asset={getRelevantAssetForSwap(swap())}
-                        txId={swap().claimTx}
-                        address={
-                            swap().type === SwapType.Submarine
-                                ? (swap() as SubmarineSwap).address
-                                : (swap() as ReverseSwap).lockupAddress
-                        }
-                    />
-                </Show>
-                <Show
-                    when={
-                        getRelevantAssetForSwap(swap()) &&
-                        contractTransaction() !== undefined
-                    }>
-                    <BlockExplorer
-                        asset={getRelevantAssetForSwap(swap())}
-                        txId={contractTransaction()}
-                        typeLabel={contractTransactionType()}
-                    />
-                </Show>
-            </>
-        );
-    }
-
-    // TODO: RSK
-
-    const [hasBeenClaimed, setHasBeenClaimed] = createSignal<boolean>(false);
-
-    createEffect(() => {
-        setHasBeenClaimed(swap().claimTx !== undefined);
-    });
-
-    return (
-        <BlockExplorer
-            asset={hasBeenClaimed() ? swap().assetReceive : swap().assetSend}
-            txId={swap().claimTx}
-            address={
-                // When it has been claimed, the "txId" is populated
-                hasBeenClaimed()
-                    ? undefined
-                    : (swap() as ChainSwap).lockupDetails.lockupAddress
-            }
-        />
-    );
-};
-
-export default BlockExplorerLink;
-export { TransactionType };
diff --git a/src/consts/Types.ts b/src/consts/Types.ts
index bcbd86dd..5e9a02d4 100644
--- a/src/consts/Types.ts
+++ b/src/consts/Types.ts
@@ -1,4 +1,4 @@
 export type ButtonLabelParams = {
     key: string;
-    params?: Record<string, string>;
+    params?: Record;
 };
diff --git a/src/context/Global.tsx b/src/context/Global.tsx
index c30308f9..e520b194 100644
--- a/src/context/Global.tsx
+++ b/src/context/Global.tsx
@@ -37,8 +37,6 @@ export type GlobalContextType = {
     setWasmSupported: Setter<boolean>;
     refundAddress: Accessor<string | null>;
     setRefundAddress: Setter<string | null>;
-    transactionToRefund: Accessor<string | null>;
-    setTransactionToRefund: Setter<string | null>;
     i18n: Accessor<string | null>;
     setI18n: Setter<string | null>;
     notification: Accessor<string>;
@@ -107,10 +105,6 @@ const GlobalProvider = (props: { children: any }) => {
     const [wasmSupported, setWasmSupported] = createSignal<boolean>(true);
     const [refundAddress, setRefundAddress] = createSignal<string | null>(null);
 
-    const [transactionToRefund, setTransactionToRefund] = createSignal<
-        string | null
-    >(null);
-
     const [i18n, setI18n] = createSignal<string | null>(null);
 
     const [notification, setNotification] = createSignal<string>("");
@@ -326,8 +320,6 @@ const GlobalProvider = (props: { children: any }) => {
                 setWasmSupported,
                 refundAddress,
                 setRefundAddress,
-                transactionToRefund,
-                setTransactionToRefund,
                 i18n,
                 setI18n,
                 notification,
diff --git a/src/context/Pay.tsx b/src/context/Pay.tsx
index 662506d5..0f695d82 100644
--- a/src/context/Pay.tsx
+++ b/src/context/Pay.tsx
@@ -6,26 +6,22 @@ import {
     useContext,
 } from "solid-js";
 
+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>();
 
-type SwapStatusTransaction = {
-    hex?: string;
-    id?: string;
-};
-
 const PayProvider = (props: { children: any }) => {
     const [failureReason, setFailureReason] = createSignal<string>("");
     const [swap, setSwap] = createSignal<SomeSwap | null>(null, {
@@ -34,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
diff --git a/src/pages/Pay.tsx b/src/pages/Pay.tsx
index e5c1bdaa..e304d689 100644
--- a/src/pages/Pay.tsx
+++ b/src/pages/Pay.tsx
@@ -1,22 +1,11 @@
 import { useParams } from "@solidjs/router";
 import log from "loglevel";
-import {
-    Match,
-    Show,
-    Switch,
-    createEffect,
-    createSignal,
-    onCleanup,
-} from "solid-js";
+import { Match, Show, Switch, createEffect, onCleanup } from "solid-js";
 
-import BlockExplorerLink, {
-    TransactionType,
-} from "../components/BlockExplorerLink";
 import LoadingSpinner from "../components/LoadingSpinner";
 import { SwapIcons } from "../components/SwapIcons";
 import SettingsCog from "../components/settings/SettingsCog";
 import SettingsMenu from "../components/settings/SettingsMenu";
-import { RBTC } from "../consts/Assets";
 import { SwapType } from "../consts/Enums";
 import {
     swapStatusFailed,
@@ -42,11 +31,6 @@ import { getRelevantAssetForSwap } from "../utils/swapCreator";
 
 const Pay = () => {
     const params = useParams();
-    const [contractTransaction, setContractTransaction] =
-        createSignal<string>(undefined);
-    const [contractTransactionType, setContractTransactionType] = createSignal(
-        TransactionType.Lockup,
-    );
 
     const { getSwap, t } = useGlobalContext();
     const {
@@ -68,24 +52,6 @@ const Pay = () => {
             setSwapStatus(res.status);
             setSwapStatusTransaction(res.transaction);
             setFailureReason(res.failureReason);
-
-            // RSK
-            if (
-                asset === RBTC &&
-                res.transaction &&
-                currentSwap.claimTx === undefined
-            ) {
-                setContractTransaction(res.transaction.id);
-            }
-
-            if (asset === RBTC && currentSwap["lockupTx"]) {
-                setContractTransaction(currentSwap["lockupTx"]);
-            }
-
-            if (asset === RBTC && currentSwap.claimTx) {
-                setContractTransaction(currentSwap.claimTx);
-                setContractTransactionType(TransactionType.Claim);
-            }
         }
     });
 
@@ -208,12 +174,6 @@ const Pay = () => {
                             <SwapCreated />
                         </Match>
                     </Switch>
-                    <BlockExplorerLink
-                        swap={swap}
-                        swapStatus={swapStatus}
-                        contractTransaction={contractTransaction}
-                        contractTransactionType={contractTransactionType}
-                    />
                 </Show>
             </Show>
             <Show when={!swap()}>
diff --git a/src/status/InvoiceFailedToPay.tsx b/src/status/InvoiceFailedToPay.tsx
index 4a2e46b9..e885912b 100644
--- a/src/status/InvoiceFailedToPay.tsx
+++ b/src/status/InvoiceFailedToPay.tsx
@@ -1,11 +1,13 @@
 import { OutputType } from "boltz-core";
 import { Accessor, Show } from "solid-js";
 
+import BlockExplorer from "../components/BlockExplorer";
 import DownloadRefund from "../components/DownloadRefund";
 import RefundButton from "../components/RefundButton";
 import { RBTC } from "../consts/Assets";
 import { useGlobalContext } from "../context/Global";
 import { usePayContext } from "../context/Pay";
+import { getLockupAddress } from "../utils/helper";
 import { ChainSwap, SubmarineSwap } from "../utils/swapCreator";
 
 const InvoiceFailedToPay = () => {
@@ -20,11 +22,15 @@ 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 | ChainSwap)}
+            />
         </div>
     );
 };
diff --git a/src/status/InvoicePending.tsx b/src/status/InvoicePending.tsx
index 378ddd4b..e4db2f57 100644
--- a/src/status/InvoicePending.tsx
+++ b/src/status/InvoicePending.tsx
@@ -1,12 +1,24 @@
+import { Show } from "solid-js";
+
+import BlockExplorer from "../components/BlockExplorer";
 import LoadingSpinner from "../components/LoadingSpinner";
 import { useGlobalContext } from "../context/Global";
+import { usePayContext } from "../context/Pay";
 
 const InvoicePending = () => {
     const { t } = useGlobalContext();
+    const { swap, swapStatusTransaction } = usePayContext();
     return (
         <div>
             <p>{t("invoice_pending")}</p>
             <LoadingSpinner />
+            <Show when={swapStatusTransaction()}>
+                <BlockExplorer
+                    asset={swap().assetSend}
+                    txId={swapStatusTransaction().id}
+                    typeLabel="lockup_tx"
+                />
+            </Show>
         </div>
     );
 };
diff --git a/src/status/SwapExpired.tsx b/src/status/SwapExpired.tsx
index c1448e3d..9ab113e3 100644
--- a/src/status/SwapExpired.tsx
+++ b/src/status/SwapExpired.tsx
@@ -1,18 +1,21 @@
 import { useNavigate } from "@solidjs/router";
 import log from "loglevel";
-import { Accessor, Show, createEffect } from "solid-js";
+import { Accessor, Show, createEffect, createSignal } from "solid-js";
 
+import BlockExplorer from "../components/BlockExplorer";
 import RefundButton from "../components/RefundButton";
 import { useGlobalContext } from "../context/Global";
 import { usePayContext } from "../context/Pay";
-import { getLockupTransaction } from "../utils/boltzClient";
+import { LockupTransaction, getLockupTransaction } from "../utils/boltzClient";
 import { ChainSwap, SubmarineSwap } from "../utils/swapCreator";
 
 const SwapExpired = () => {
     const navigate = useNavigate();
     const { failureReason, swap } = usePayContext();
-    const { t, setTransactionToRefund, transactionToRefund } =
-        useGlobalContext();
+    const { t } = useGlobalContext();
+
+    const [transactionToRefund, setTransactionToRefund] =
+        createSignal<LockupTransaction>(null);
 
     createEffect(async () => {
         setTransactionToRefund(null);
@@ -22,10 +25,10 @@ const SwapExpired = () => {
                 swap().id,
                 swap().type,
             );
-            log.debug(`got swap transaction for ${swap().id}`);
-            setTransactionToRefund(res.hex);
+            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);
         }
     });
 
@@ -36,10 +39,13 @@ const SwapExpired = () => {
             </p>
             <hr />
             <Show when={transactionToRefund() !== null}>
-                <RefundButton
-                    swap={swap as Accessor<SubmarineSwap | ChainSwap>}
-                />
+                <RefundButton swap={swap as Accessor} />
                 <hr />
+                <BlockExplorer
+                    typeLabel="lockup_tx"
+                    asset={swap()?.assetSend}
+                    txId={transactionToRefund()?.id}
+                />
             </Show>
             <button class="btn" onClick={() => navigate("/swap")}>
                 {t("new_swap")}
diff --git a/src/status/TransactionClaimed.tsx b/src/status/TransactionClaimed.tsx
index 9d8d5cf4..69f9e964 100644
--- a/src/status/TransactionClaimed.tsx
+++ b/src/status/TransactionClaimed.tsx
@@ -2,16 +2,17 @@ import { useNavigate } from "@solidjs/router";
 import { BigNumber } from "bignumber.js";
 import { Show, createEffect, createSignal } from "solid-js";
 
+import BlockExplorer from "../components/BlockExplorer";
 import LoadingSpinner from "../components/LoadingSpinner";
 import { RBTC } from "../consts/Assets";
 import { SwapType } from "../consts/Enums";
 import { useGlobalContext } from "../context/Global";
 import { usePayContext } from "../context/Pay";
 import { formatAmount } from "../utils/denomination";
+import { SubmarineSwap } from "../utils/swapCreator";
 
 const Broadcasting = () => {
     const { t } = useGlobalContext();
-
     return (
         <div>
             <h2>{t("broadcasting_claim")}</h2>
@@ -59,6 +60,15 @@ const TransactionClaimed = () => {
                     })}
                 </p>
                 <hr />
+                <BlockExplorer
+                    asset={
+                        swap().claimTx ? swap().assetReceive : swap().assetSend
+                    }
+                    txId={swap().claimTx || swap().lockupTx}
+                    address={
+                        swap().claimAddress || (swap() as SubmarineSwap).address
+                    }
+                />
                 <span class="btn" onClick={() => navigate("/swap")}>
                     {t("new_swap")}
                 </span>
diff --git a/src/status/TransactionConfirmed.tsx b/src/status/TransactionConfirmed.tsx
index fd0de28b..1dfb1e60 100644
--- a/src/status/TransactionConfirmed.tsx
+++ b/src/status/TransactionConfirmed.tsx
@@ -1,3 +1,6 @@
+import { Show } from "solid-js";
+
+import BlockExplorer from "../components/BlockExplorer";
 import ContractTransaction from "../components/ContractTransaction";
 import LoadingSpinner from "../components/LoadingSpinner";
 import { RBTC } from "../consts/Assets";
@@ -53,7 +56,7 @@ const ClaimRsk = ({
 
 const TransactionConfirmed = () => {
     const { t } = useGlobalContext();
-    const { swap } = usePayContext();
+    const { swapStatusTransaction, swap } = usePayContext();
 
     if (swap().assetReceive === RBTC) {
         if (swap().type === SwapType.Chain) {
@@ -88,6 +91,13 @@ const TransactionConfirmed = () => {
             <h2>{t("tx_confirmed")}</h2>
             <p>{t("tx_ready_to_claim")}</p>
             <LoadingSpinner />
+            <Show when={swapStatusTransaction()}>
+                <BlockExplorer
+                    asset={swap().assetSend}
+                    txId={swapStatusTransaction().id}
+                    typeLabel="lockup_tx"
+                />
+            </Show>
         </div>
     );
 };
diff --git a/src/status/TransactionLockupFailed.tsx b/src/status/TransactionLockupFailed.tsx
index 8e20b7e7..761b9576 100644
--- a/src/status/TransactionLockupFailed.tsx
+++ b/src/status/TransactionLockupFailed.tsx
@@ -1,15 +1,16 @@
 import { Accessor, Show } from "solid-js";
 
+import BlockExplorer from "../components/BlockExplorer";
 import RefundButton from "../components/RefundButton";
 import { useGlobalContext } from "../context/Global";
 import { usePayContext } from "../context/Pay";
 import NotFound from "../pages/NotFound";
+import { getLockupAddress } from "../utils/helper";
 import { ChainSwap, SubmarineSwap } from "../utils/swapCreator";
 
 const TransactionLockupFailed = () => {
     const { failureReason, swap } = usePayContext();
     const { t } = useGlobalContext();
-
     return (
         <Show when={swap() !== null} fallback={<NotFound />}>
             <div>
@@ -22,6 +23,12 @@ const TransactionLockupFailed = () => {
                     swap={swap as Accessor<SubmarineSwap | ChainSwap>}
                 />
                 <hr />
+                <BlockExplorer
+                    asset={swap().assetSend}
+                    address={getLockupAddress(
+                        swap() as SubmarineSwap | ChainSwap,
+                    )}
+                />
             </div>
         </Show>
     );
diff --git a/src/status/TransactionMempool.tsx b/src/status/TransactionMempool.tsx
index 6fd83a51..8543377a 100644
--- a/src/status/TransactionMempool.tsx
+++ b/src/status/TransactionMempool.tsx
@@ -1,13 +1,25 @@
+import { Show } from "solid-js";
+
+import BlockExplorer from "../components/BlockExplorer";
 import LoadingSpinner from "../components/LoadingSpinner";
 import { useGlobalContext } from "../context/Global";
+import { usePayContext } from "../context/Pay";
 
 const TransactionMempool = () => {
     const { t } = useGlobalContext();
+    const { swap, swapStatusTransaction } = usePayContext();
     return (
         <div>
             <h2>{t("tx_in_mempool")}</h2>
             <p>{t("tx_in_mempool_subline")}</p>
             <LoadingSpinner />
+            <Show when={swapStatusTransaction()}>
+                <BlockExplorer
+                    asset={swap()?.assetSend}
+                    txId={swapStatusTransaction()?.id}
+                    typeLabel="lockup_tx"
+                />
+            </Show>
         </div>
     );
 };
diff --git a/src/utils/boltzClient.ts b/src/utils/boltzClient.ts
index 60e6a060..addb64f9 100644
--- a/src/utils/boltzClient.ts
+++ b/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,23 +349,25 @@ 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, {
         hex: txHex,
     });
 
-export const getLockupTransaction = async (
-    asset: string,
-    id: string,
-    type: SwapType,
-): Promise<{
+export type LockupTransaction = {
     id: string;
     hex: string;
     timeoutBlockHeight: number;
     timeoutEta?: number;
-}> => {
+};
+
+export const getLockupTransaction = async (
+    asset: string,
+    id: string,
+    type: SwapType,
+): Promise => {
     switch (type) {
         case SwapType.Submarine:
             return fetcher<{
@@ -402,16 +398,20 @@ 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?: SwapStatusTransaction;
+};
+
 export const getSwapStatus = (asset: string, id: string) =>
-    fetcher<{
-        status: string;
-        failureReason?: string;
-        zeroConfRejected?: boolean;
-        transaction?: {
-            id: string;
-            hex: string;
-        };
-    }>(`/v2/swap/${id}`, asset);
+    fetcher<SwapStatus>(`/v2/swap/${id}`, asset);
 
 export const getChainSwapClaimDetails = (asset: string, id: string) =>
     fetcher<{
diff --git a/src/utils/helper.ts b/src/utils/helper.ts
index 302b8c11..60abc217 100644
--- a/src/utils/helper.ts
+++ b/src/utils/helper.ts
@@ -18,6 +18,13 @@ export const isIos = () =>
 export const isMobile = () =>
     isIos() || !!navigator.userAgent.match(/android|blackberry/gi) || false;
 
+export const getLockupAddress = (swap: SubmarineSwap | ChainSwap) => {
+    if (swap.type === SwapType.Submarine) {
+        return (swap as SubmarineSwap).address;
+    }
+    return (swap as ChainSwap).lockupDetails?.lockupAddress;
+};
+
 export const parseBlindingKey = (swap: SomeSwap, isRefund: boolean) => {
     let blindingKey: string | undefined;
 
diff --git a/tests/components/BlockExplorerLink.spec.tsx b/tests/components/BlockExplorerLink.spec.tsx
deleted file mode 100644
index 9a32f848..00000000
--- a/tests/components/BlockExplorerLink.spec.tsx
+++ /dev/null
@@ -1,151 +0,0 @@
-import { render, screen } from "@solidjs/testing-library";
-import { createSignal } from "solid-js";
-
-import BlockExplorerLink, {
-    TransactionType,
-} from "../../src/components/BlockExplorerLink";
-import { config } from "../../src/config";
-import { BTC, LBTC } from "../../src/consts/Assets";
-import { SwapType } from "../../src/consts/Enums";
-import { ChainSwap, SomeSwap } from "../../src/utils/swapCreator";
-import { contextWrapper } from "../helper";
-
-describe("BlockExplorerLink", () => {
-    describe("Submarine and Reverse Swaps", () => {
-        test.each`
-            type                  | asset   | address  | params
-            ${SwapType.Submarine} | ${BTC}  | ${"bc1"} | ${{ type: SwapType.Submarine, assetSend: BTC, address: "bc1" }}
-            ${SwapType.Reverse}   | ${LBTC} | ${"lq1"} | ${{ type: SwapType.Reverse, assetReceive: LBTC, lockupAddress: "lq1" }}
-        `(
-            "should show lockup address for $type when not claimed yet",
-            async ({ params, asset, address }) => {
-                const [swap] = createSignal<SomeSwap>(params);
-
-                render(
-                    () => (
-                        <BlockExplorerLink
-                            swap={swap}
-                            swapStatus={() => "transaction.mempool"}
-                            contractTransaction={() => undefined}
-                            contractTransactionType={() =>
-                                TransactionType.Lockup
-                            }
-                        />
-                    ),
-                    { wrapper: contextWrapper },
-                );
-
-                const button = (await screen.findByText(
-                    "open lockup address",
-                )) as HTMLAnchorElement;
-
-                expect(button.href).toEqual(
-                    `${config.assets[asset].blockExplorerUrl.normal}/address/${address}`,
-                );
-            },
-        );
-
-        test.each`
-            type                  | asset   | params
-            ${SwapType.Submarine} | ${BTC}  | ${{ type: SwapType.Submarine, assetSend: BTC, claimTx: "123" }}
-            ${SwapType.Reverse}   | ${LBTC} | ${{ type: SwapType.Reverse, assetReceive: LBTC, claimTx: "123" }}
-        `(
-            "should show claim transaction for $type",
-            async ({ params, asset }) => {
-                const [swap] = createSignal<SomeSwap>(params);
-
-                render(
-                    () => (
-                        <BlockExplorerLink
-                            swap={swap}
-                            swapStatus={() => "transaction.claimed"}
-                            contractTransaction={() => undefined}
-                            contractTransactionType={() =>
-                                TransactionType.Lockup
-                            }
-                        />
-                    ),
-                    { wrapper: contextWrapper },
-                );
-
-                const button = (await screen.findByText(
-                    "open claim transaction",
-                )) as HTMLAnchorElement;
-
-                expect(button.href).toEqual(
-                    `${config.assets[asset].blockExplorerUrl.normal}/tx/${params.claimTx}`,
-                );
-            },
-        );
-    });
-
-    describe("Chain Swaps", () => {
-        test("should show lockup address when not claimed yet", async () => {
-            const [swap] = createSignal<ChainSwap>({
-                type: SwapType.Chain,
-                assetSend: LBTC,
-                assetReceive: BTC,
-                lockupDetails: {
-                    lockupAddress: "bc1",
-                },
-            } as any);
-
-            render(
-                () => (
-                    <BlockExplorerLink
-                        swap={swap}
-                        swapStatus={() => ""}
-                        contractTransaction={() => undefined}
-                        contractTransactionType={() => TransactionType.Lockup}
-                    />
-                ),
-                { wrapper: contextWrapper },
-            );
-
-            const button = (await screen.findByText(
-                "open lockup address",
-            )) as HTMLAnchorElement;
-
-            expect(button.href).toEqual(
-                `${config.assets[LBTC].blockExplorerUrl.normal}/address/${swap().lockupDetails.lockupAddress}`,
-            );
-        });
-
-        test("should reactively show claim transaction", async () => {
-            const [swap, setSwap] = createSignal<ChainSwap>({
-                type: SwapType.Chain,
-                assetSend: LBTC,
-                assetReceive: BTC,
-                lockupDetails: {
-                    lockupAddress: "bc1",
-                },
-            } as any);
-
-            render(
-                () => (
-                    <BlockExplorerLink
-                        swap={swap}
-                        swapStatus={() => ""}
-                        contractTransaction={() => undefined}
-                        contractTransactionType={() => TransactionType.Lockup}
-                    />
-                ),
-                { wrapper: contextWrapper },
-            );
-
-            const button = (await screen.findByText(
-                "open lockup address",
-            )) as HTMLAnchorElement;
-
-            expect(button.href).toEqual(
-                `${config.assets[LBTC].blockExplorerUrl.normal}/address/${swap().lockupDetails.lockupAddress}`,
-            );
-
-            setSwap({ ...swap(), claimTx: "123" });
-
-            expect(button.href).toEqual(
-                `${config.assets[BTC].blockExplorerUrl.normal}/tx/${swap().claimTx}`,
-            );
-        });
-    });
-});
diff --git a/tests/status/SwapExpired.spec.tsx b/tests/status/SwapExpired.spec.tsx
new file mode 100644
index 00000000..67e96be2
--- /dev/null
+++ b/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");
+    });
+});
diff --git a/tests/status/TransactionClaimed.spec.tsx b/tests/status/TransactionClaimed.spec.tsx
index 6b48cabf..1e3103bb 100644
--- a/tests/status/TransactionClaimed.spec.tsx
+++ b/tests/status/TransactionClaimed.spec.tsx
@@ -1,31 +1,20 @@
 import { render, screen } from "@solidjs/testing-library";
 
-import { BTC, LBTC, RBTC } from "../../src/consts/Assets";
+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";
 
-jest.mock("../../src/utils/boltzClient", () => ({
-    getReverseTransaction: jest.fn().mockResolvedValue({
-        hex: "txHex",
-    }),
-}));
-
 describe("TransactionClaimed", () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-
     test.each`
-        name                                                | swap
-        ${"normal swaps"}                                   | ${{ reverse: false }}
-        ${"reverse swaps to RBTC"} | ${{
-    reverse: true,
-    asset: RBTC,
-}}
-        ${"reverse swaps to BTC with claim transactions"}   | ${{ reverse: true, asset: BTC, claimTx: "txid" }}
-        ${"reverse swaps to L-BTC with claim transactions"} | ${{ reverse: true, asset: 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(
             () => (
                 <>
@@ -42,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);
     });
 });
diff --git a/tests/status/TransactionLockupFailed.spec.tsx b/tests/status/TransactionLockupFailed.spec.tsx
index eb1b0406..dfe9ac2d 100644
--- a/tests/status/TransactionLockupFailed.spec.tsx
+++ b/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);
+    });
 });
diff --git a/tests/status/TransactionMempool.spec.tsx b/tests/status/TransactionMempool.spec.tsx
new file mode 100644
index 00000000..acf3e372
--- /dev/null
+++ b/tests/status/TransactionMempool.spec.tsx
@@ -0,0 +1,40 @@
+import { render, screen } from "@solidjs/testing-library";
+
+import { BTC } from "../../src/consts/Assets";
+import i18n from "../../src/i18n/i18n";
+import TransactionMempool from "../../src/status/TransactionMempool";
+import { TestComponent, contextWrapper, payContext } from "../helper";
+
+describe("TransactionMempool", () => {
+    test("should show blockexplorer lockup transaction button", async () => {
+        render(
+            () => (
+                <>
+                    <TestComponent />
+                    <TransactionMempool />
+                </>
+            ),
+            {
+                wrapper: contextWrapper,
+            },
+        );
+        payContext.setSwap({
+            assetSend: BTC,
+        } as any);
+
+        payContext.setSwapStatusTransaction({
+            id: "txid",
+            hex: "hex",
+        });
+
+        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");
+    });
+});