diff --git a/packages/extension/.env.example b/packages/extension/.env.example
new file mode 100644
index 000000000..aa9ba3fa6
--- /dev/null
+++ b/packages/extension/.env.example
@@ -0,0 +1,2 @@
+# VITE_DEBUG_LOG="swap:*"
+VITE_DEBUG_LOG=
diff --git a/packages/extension/src/libs/activity-state/index.ts b/packages/extension/src/libs/activity-state/index.ts
index ff9c339c8..735c91e29 100644
--- a/packages/extension/src/libs/activity-state/index.ts
+++ b/packages/extension/src/libs/activity-state/index.ts
@@ -61,6 +61,7 @@ class ActivityState {
       this.getActivityId(options),
     );
   }
+
   async updateActivity(
     activity: Activity,
     options: ActivityOptions,
@@ -75,11 +76,13 @@ class ActivityState {
     });
     await this.setActivitiesById(clone, this.getActivityId(options));
   }
+
   async setCacheTime(options: ActivityOptions): Promise<void> {
     await this.#storage.set(this.getActivityCacheId(options), {
       [STORAGE_KEY]: new Date().getTime(),
     });
   }
+
   async getCacheTime(options: ActivityOptions): Promise<number> {
     const cacheTime: Record<string, number> = await this.#storage.get(
       this.getActivityCacheId(options),
@@ -87,12 +90,15 @@ class ActivityState {
     if (!cacheTime || !cacheTime[STORAGE_KEY]) return 0;
     return cacheTime[STORAGE_KEY];
   }
+
   async getAllActivities(options: ActivityOptions): Promise<Activity[]> {
     return this.getActivitiesById(this.getActivityId(options));
   }
+
   async deleteAllActivities(options: ActivityOptions): Promise<void> {
     this.setActivitiesById([], this.getActivityId(options));
   }
+
   private async setActivitiesById(
     activities: Activity[],
     id: string,
@@ -101,6 +107,7 @@ class ActivityState {
       [STORAGE_KEY]: activities,
     });
   }
+
   private async getActivitiesById(id: string): Promise<Activity[]> {
     const allStates: Record<string, Activity[]> = await this.#storage.get(id);
     if (!allStates || !allStates[STORAGE_KEY]) return [];
diff --git a/packages/extension/src/libs/utils/unicode-detection.ts b/packages/extension/src/libs/utils/unicode-detection.ts
new file mode 100644
index 000000000..58146051c
--- /dev/null
+++ b/packages/extension/src/libs/utils/unicode-detection.ts
@@ -0,0 +1,22 @@
+const fixedHex = (number: number, length: number) => {
+  let str = number.toString(16).toUpperCase();
+  while (str.length < length) str = '0' + str;
+  return str;
+};
+
+/* Creates a unicode literal based on the string */
+const unicodeLiteral = (str: string) => {
+  let i;
+  let result = '';
+  for (i = 0; i < str.length; ++i) {
+    if (str.charCodeAt(i) > 126 || str.charCodeAt(i) < 32)
+      result += '\\u' + fixedHex(str.charCodeAt(i), 4);
+    else result += str[i];
+  }
+  return result;
+};
+export const getRTLOLTLOSafeString = (str: string): string => {
+  const dangerous = /[\u202A-\u202E\u2066-\u2069\u200E\u200F\u061C]/.test(str);
+  if (dangerous) return unicodeLiteral(str);
+  return str;
+};
diff --git a/packages/extension/src/providers/bitcoin/ui/btc-sign-message.vue b/packages/extension/src/providers/bitcoin/ui/btc-sign-message.vue
index 15b9d69a0..988d2ce00 100644
--- a/packages/extension/src/providers/bitcoin/ui/btc-sign-message.vue
+++ b/packages/extension/src/providers/bitcoin/ui/btc-sign-message.vue
@@ -65,6 +65,7 @@ import { ProviderRequestOptions } from '@/types/provider';
 import { BitcoinNetwork } from '../types/bitcoin-network';
 import { EnkryptAccount } from '@enkryptcom/types';
 import { MessageSigner } from './libs/signer';
+import { getRTLOLTLOSafeString } from '@/libs/utils/unicode-detection';
 
 const windowPromise = WindowPromiseHandler(4);
 const network = ref<BitcoinNetwork>(DEFAULT_BTC_NETWORK);
@@ -92,7 +93,7 @@ onBeforeMount(async () => {
   account.value = Request.value.params![2] as EnkryptAccount;
   identicon.value = network.value.identicon(account.value.address);
   Options.value = options;
-  message.value = Request.value.params![0];
+  message.value = getRTLOLTLOSafeString(Request.value.params![0]);
   type.value = Request.value.params![1];
 });
 
diff --git a/packages/extension/src/providers/bitcoin/ui/send-transaction/index.vue b/packages/extension/src/providers/bitcoin/ui/send-transaction/index.vue
index 410ee13fe..66138e361 100644
--- a/packages/extension/src/providers/bitcoin/ui/send-transaction/index.vue
+++ b/packages/extension/src/providers/bitcoin/ui/send-transaction/index.vue
@@ -312,7 +312,10 @@ const isInputsValid = computed<boolean>(() => {
     isSendToken.value
   )
     return false;
-  if (new BigNumber(sendAmount.value).gt(assetMaxValue.value)) return false;
+
+  const sendAmountBigNumber = new BigNumber(sendAmount.value)
+  if (sendAmountBigNumber.isNaN()) return false
+  if (sendAmountBigNumber.gt(assetMaxValue.value)) return false;
   return true;
 });
 
diff --git a/packages/extension/src/providers/common/libs/new-features.ts b/packages/extension/src/providers/common/libs/new-features.ts
index 2f0faadd1..189011b41 100644
--- a/packages/extension/src/providers/common/libs/new-features.ts
+++ b/packages/extension/src/providers/common/libs/new-features.ts
@@ -1,6 +1,6 @@
 import { NetworkNames } from '@enkryptcom/types';
 
-const newNetworks = [NetworkNames.Solana];
+const newNetworks = [NetworkNames.Bitrock, NetworkNames.Fraxtal];
 const newSwaps: NetworkNames[] = [];
 
 export { newNetworks, newSwaps };
diff --git a/packages/extension/src/providers/common/ui/send-transaction/send-input-amount.vue b/packages/extension/src/providers/common/ui/send-transaction/send-input-amount.vue
index 206a5fafd..d444b943a 100644
--- a/packages/extension/src/providers/common/ui/send-transaction/send-input-amount.vue
+++ b/packages/extension/src/providers/common/ui/send-transaction/send-input-amount.vue
@@ -73,9 +73,16 @@ const amount = computed({
 
 const onlyNumber = ($event: KeyboardEvent) => {
   const keyCode = $event.keyCode ? $event.keyCode : $event.which;
-  if ((keyCode < 48 || keyCode > 57) && keyCode !== 46) {
-    $event.preventDefault();
+  // Numeric
+  if (keyCode >= /* 0 */ 48 && keyCode <= /* 9 */ 57) {
+    return;
   }
+  // Only allow a single period
+  if (keyCode === /* '.' */ 46 && amount.value.indexOf('.') === -1) {
+    return;
+  }
+  // Alphabetical (/non-numeric) or mulitple periods. Don't propagate change
+  $event.preventDefault();
 };
 const changeFocus = () => {
   isFocus.value = !isFocus.value;
diff --git a/packages/extension/src/providers/ethereum/libs/transaction/gas-utils.ts b/packages/extension/src/providers/ethereum/libs/transaction/gas-utils.ts
index c2246bf1a..8abbb3228 100644
--- a/packages/extension/src/providers/ethereum/libs/transaction/gas-utils.ts
+++ b/packages/extension/src/providers/ethereum/libs/transaction/gas-utils.ts
@@ -62,7 +62,7 @@ const getGasBasedOnType = (
   }
 };
 const getMinPriorityFee = (): BNType => {
-  return toBN(toWei('0.1', 'gwei'));
+  return toBN(toWei('1', 'gwei'));
 };
 const getPriorityFeeAvg = (arr: BNType[]): BNType => {
   const sum = arr.reduce((a, v) => a.add(v));
diff --git a/packages/extension/src/providers/ethereum/libs/transaction/index.ts b/packages/extension/src/providers/ethereum/libs/transaction/index.ts
index a0e740936..8936a04d0 100644
--- a/packages/extension/src/providers/ethereum/libs/transaction/index.ts
+++ b/packages/extension/src/providers/ethereum/libs/transaction/index.ts
@@ -38,14 +38,13 @@ class Transaction {
       value: this.tx.value || '0x0',
     });
   }
-  async getOPfees(): Promise<BNType> {
+  async getOPfees(
+    fTx: LegacyTransaction | FeeMarketEIP1559Transaction,
+  ): Promise<BNType> {
     const OPContract = new this.web3.Contract(
       OPTIMISM_PRICE_ORACLE_ABI as any,
       OPTIMISM_PRICE_ORACLE,
     );
-    const fTx = await this.getFinalizedTransaction({
-      gasPriceType: GasPriceTypes.ECONOMY,
-    });
     const serializedTx = fTx.serialize();
     return OPContract.methods
       .getL1Fee(bufferToHex(serializedTx))
@@ -87,6 +86,7 @@ class Transaction {
     maxFeePerGas?: string;
     gasLimit: string;
     formattedFeeHistory?: FormattedFeeHistory;
+    finalizedTransaction: LegacyTransaction | FeeMarketEIP1559Transaction;
   }> {
     const latestBlock = await this.web3.getBlock('latest', false);
     const { isFeeMarketNetwork, feeHistory } = await this.web3
@@ -123,10 +123,20 @@ class Transaction {
         nonce: this.tx.nonce || (numberToHex(nonce) as `0x${string}`),
         value: this.tx.value || '0x0',
       };
+      const common = Common.custom({
+        chainId: BigInt(this.tx.chainId),
+      });
+      const finalizedTransaction = LegacyTransaction.fromTxData(
+        legacyTx as FinalizedLegacyEthereumTransaction,
+        {
+          common,
+        },
+      );
       return {
         transaction: legacyTx,
         gasPrice: gasPrice,
         gasLimit: legacyTx.gasLimit,
+        finalizedTransaction,
       };
     } else {
       // Fee market transaction (post EIP1559)
@@ -141,7 +151,7 @@ class Transaction {
       const gasLimit =
         this.tx.gasLimit ||
         (numberToHex(await this.estimateGas()) as `0x${string}`);
-      const maxFeePerGas = !options.totalGasPrice
+      let maxFeePerGas = !options.totalGasPrice
         ? feeMarket.maxFeePerGas
         : options.totalGasPrice.div(toBN(gasLimit));
       const maxPriorityFeePerGas = feeMarket.maxPriorityFeePerGas;
@@ -162,6 +172,35 @@ class Transaction {
         type: '0x02',
         accessList: this.tx.accessList || [],
       };
+      const common = Common.custom({
+        chainId: BigInt(this.tx.chainId),
+        defaultHardfork: Hardfork.London,
+      });
+      let finalizedTransaction = FeeMarketEIP1559Transaction.fromTxData(
+        feeMarketTx as FinalizedFeeMarketEthereumTransaction,
+        {
+          common,
+        },
+      );
+      if (options.totalGasPrice) {
+        const opFee = await this.getOPfees(finalizedTransaction);
+        if (opFee.gtn(0)) {
+          const gasFeeWithoutOPFee = options.totalGasPrice.sub(opFee);
+          maxFeePerGas = gasFeeWithoutOPFee.div(toBN(gasLimit));
+          feeMarketTx.maxFeePerGas = numberToHex(maxFeePerGas) as `0x${string}`;
+          feeMarketTx.maxPriorityFeePerGas = numberToHex(
+            maxPriorityFeePerGas.gt(maxFeePerGas)
+              ? maxFeePerGas
+              : maxPriorityFeePerGas,
+          ) as `0x${string}`;
+          finalizedTransaction = FeeMarketEIP1559Transaction.fromTxData(
+            feeMarketTx as FinalizedFeeMarketEthereumTransaction,
+            {
+              common,
+            },
+          );
+        }
+      }
       return {
         transaction: feeMarketTx,
         gasLimit: feeMarketTx.gasLimit,
@@ -169,6 +208,7 @@ class Transaction {
         maxFeePerGas: numberToHex(feeMarket.maxFeePerGas),
         maxPriorityFeePerGas: numberToHex(feeMarket.maxPriorityFeePerGas),
         formattedFeeHistory,
+        finalizedTransaction,
       };
     }
   }
@@ -182,30 +222,8 @@ class Transaction {
   async getFinalizedTransaction(
     options: TransactionOptions,
   ): Promise<LegacyTransaction | FeeMarketEIP1559Transaction> {
-    const { transaction } = await this.finalizeTransaction(options);
-
-    if (!transaction.maxFeePerGas) {
-      const common = Common.custom({
-        chainId: BigInt(transaction.chainId),
-      });
-      return LegacyTransaction.fromTxData(
-        transaction as FinalizedLegacyEthereumTransaction,
-        {
-          common,
-        },
-      );
-    } else {
-      const common = Common.custom({
-        chainId: BigInt(transaction.chainId),
-        defaultHardfork: Hardfork.London,
-      });
-      return FeeMarketEIP1559Transaction.fromTxData(
-        transaction as FinalizedFeeMarketEthereumTransaction,
-        {
-          common,
-        },
-      );
-    }
+    const { finalizedTransaction } = await this.finalizeTransaction(options);
+    return finalizedTransaction;
   }
 
   async getMessageToSign(options: TransactionOptions): Promise<Uint8Array> {
@@ -214,35 +232,38 @@ class Transaction {
   }
 
   async getGasCosts(): Promise<GasCosts> {
-    const { gasLimit, gasPrice, baseFeePerGas, formattedFeeHistory } =
-      await this.finalizeTransaction({
-        gasPriceType: GasPriceTypes.ECONOMY,
-      });
-    const opFee = await this.getOPfees();
+    const {
+      gasLimit,
+      gasPrice,
+      baseFeePerGas,
+      formattedFeeHistory,
+      finalizedTransaction,
+    } = await this.finalizeTransaction({
+      gasPriceType: GasPriceTypes.ECONOMY,
+    });
     if (gasPrice) {
       return {
         [GasPriceTypes.ECONOMY]: numberToHex(
-          getGasBasedOnType(gasPrice, GasPriceTypes.ECONOMY)
-            .mul(toBN(gasLimit))
-            .add(opFee),
+          getGasBasedOnType(gasPrice, GasPriceTypes.ECONOMY).mul(
+            toBN(gasLimit),
+          ),
         ),
         [GasPriceTypes.REGULAR]: numberToHex(
-          getGasBasedOnType(gasPrice, GasPriceTypes.REGULAR)
-            .mul(toBN(gasLimit))
-            .add(opFee),
+          getGasBasedOnType(gasPrice, GasPriceTypes.REGULAR).mul(
+            toBN(gasLimit),
+          ),
         ),
         [GasPriceTypes.FAST]: numberToHex(
-          getGasBasedOnType(gasPrice, GasPriceTypes.FAST)
-            .mul(toBN(gasLimit))
-            .add(opFee),
+          getGasBasedOnType(gasPrice, GasPriceTypes.FAST).mul(toBN(gasLimit)),
         ),
         [GasPriceTypes.FASTEST]: numberToHex(
-          getGasBasedOnType(gasPrice, GasPriceTypes.FASTEST)
-            .mul(toBN(gasLimit))
-            .add(opFee),
+          getGasBasedOnType(gasPrice, GasPriceTypes.FASTEST).mul(
+            toBN(gasLimit),
+          ),
         ),
       };
     } else {
+      const opFee = await this.getOPfees(finalizedTransaction);
       return {
         [GasPriceTypes.ECONOMY]: numberToHex(
           this.getFeeMarketGasInfo(
diff --git a/packages/extension/src/providers/ethereum/networks/maticzk.ts b/packages/extension/src/providers/ethereum/networks/maticzk.ts
index 16d5437ad..c546e667e 100644
--- a/packages/extension/src/providers/ethereum/networks/maticzk.ts
+++ b/packages/extension/src/providers/ethereum/networks/maticzk.ts
@@ -14,11 +14,11 @@ const maticOptions: EvmNetworkOptions = {
   blockExplorerAddr: 'https://zkevm.polygonscan.com/address/[[address]]',
   chainID: '0x44d',
   isTestNetwork: false,
-  currencyName: 'POL',
-  currencyNameLong: 'Polygon POL',
+  currencyName: 'ETH',
+  currencyNameLong: 'Ethereum',
   node: 'wss://nodes.mewapi.io/ws/maticzk',
   icon,
-  coingeckoID: 'polygon-ecosystem-token',
+  coingeckoID: 'ethereum',
   coingeckoPlatform: CoingeckoPlatform.MaticZK,
   NFTHandler: shNFTHandler,
   assetsInfoHandler,
diff --git a/packages/extension/src/providers/ethereum/ui/eth-sign-message.vue b/packages/extension/src/providers/ethereum/ui/eth-sign-message.vue
index d2d716d6d..5d26a9ae9 100644
--- a/packages/extension/src/providers/ethereum/ui/eth-sign-message.vue
+++ b/packages/extension/src/providers/ethereum/ui/eth-sign-message.vue
@@ -59,6 +59,7 @@ import HardwareWalletMsg from '@/providers/common/ui/verify-transaction/hardware
 import { EvmNetwork } from '../types/evm-network';
 import { EnkryptAccount } from '@enkryptcom/types';
 import { MessageSigner } from './libs/signer';
+import { getRTLOLTLOSafeString } from '@/libs/utils/unicode-detection';
 
 const windowPromise = WindowPromiseHandler(3);
 const network = ref<EvmNetwork>(DEFAULT_EVM_NETWORK);
@@ -85,7 +86,7 @@ onBeforeMount(async () => {
   identicon.value = network.value.identicon(account.value.address);
   Options.value = options;
   message.value = isUtf8(Request.value.params![0])
-    ? hexToUtf8(Request.value.params![0])
+    ? getRTLOLTLOSafeString(hexToUtf8(Request.value.params![0]))
     : Request.value.params![0];
 });
 
diff --git a/packages/extension/src/providers/ethereum/ui/send-transaction/components/send-alert.vue b/packages/extension/src/providers/ethereum/ui/send-transaction/components/send-alert.vue
new file mode 100644
index 000000000..046f53424
--- /dev/null
+++ b/packages/extension/src/providers/ethereum/ui/send-transaction/components/send-alert.vue
@@ -0,0 +1,53 @@
+<template>
+  <div class="send-alert" role="alert" aria-live="polite">
+    <alert-icon />
+    <p aria-label="Error message">{{ errorMsg }}</p>
+  </div>
+</template>
+
+<script setup lang="ts">
+import AlertIcon from '@action/icons/send/alert-icon.vue';
+
+interface IProps {
+  errorMsg: string;
+}
+
+defineProps<IProps>();
+</script>
+
+<style lang="less">
+@import '@action/styles/theme.less';
+
+.send-alert {
+  margin: 0 32px 8px 32px;
+  background: @error01;
+  border-radius: 10px;
+  padding: 12px 16px 12px 57px;
+  position: relative;
+  box-sizing: border-box;
+
+  svg {
+    position: absolute;
+    left: 16px;
+    top: 50%;
+    margin-top: -12px;
+  }
+
+  p {
+    font-weight: 400;
+    font-size: 14px;
+    line-height: 20px;
+    letter-spacing: 0.25px;
+    color: @error;
+    margin: 0;
+
+    a {
+      color: @error;
+
+      &:hover {
+        text-decoration: none;
+      }
+    }
+  }
+}
+</style>
diff --git a/packages/extension/src/providers/ethereum/ui/send-transaction/index.vue b/packages/extension/src/providers/ethereum/ui/send-transaction/index.vue
index 5d638b745..4fd40a1f8 100644
--- a/packages/extension/src/providers/ethereum/ui/send-transaction/index.vue
+++ b/packages/extension/src/providers/ethereum/ui/send-transaction/index.vue
@@ -103,18 +103,7 @@
         @gas-type-changed="selectFee"
       />
 
-      <send-alert
-        v-show="hasEnoughBalance && nativeBalanceAfterTransaction.isNeg()"
-        :native-symbol="network.currencyName"
-        :price="accountAssets[0]?.price || '0'"
-        :native-value="
-          fromBase(
-            nativeBalanceAfterTransaction.abs().toString(),
-            network.decimals,
-          )
-        "
-        :decimals="network.decimals"
-      />
+      <send-alert v-show="errorMsg" :error-msg="errorMsg" />
 
       <div class="send-transaction__buttons">
         <div class="send-transaction__buttons-cancel">
@@ -143,7 +132,7 @@ import SendContactsList from '@/providers/common/ui/send-transaction/send-contac
 import AssetsSelectList from '@action/views/assets-select-list/index.vue';
 import NftSelectList from '@/providers/common/ui/send-transaction/nft-select-list/index.vue';
 import SendTokenSelect from './components/send-token-select.vue';
-import SendAlert from '@/providers/common/ui/send-transaction/send-alert.vue';
+import SendAlert from './components/send-alert.vue';
 import SendNftSelect from '@/providers/common/ui/send-transaction/send-nft-select.vue';
 import SendInputAmount from '@/providers/common/ui/send-transaction/send-input-amount.vue';
 import SendFeeSelect from '@/providers/common/ui/send-transaction/send-fee-select.vue';
@@ -169,6 +158,7 @@ import erc721 from '../../libs/abi/erc721';
 import erc1155 from '../../libs/abi/erc1155';
 import { SendTransactionDataType, VerifyTransactionParams } from '../types';
 import {
+  formatFiatValue,
   formatFloatingPointValue,
   isNumericPositive,
 } from '@/libs/utils/number-formatter';
@@ -217,11 +207,19 @@ const accountAssets = ref<Erc20Token[]>([]);
 const selectedAsset = ref<Erc20Token | Partial<Erc20Token>>(loadingAsset);
 const amount = ref<string>('');
 const isEstimateValid = ref(true);
+const hasValidDecimals = computed(() => {
+  return isValidDecimals(sendAmount.value, selectedAsset.value.decimals!);
+});
+const hasPositiveSendAmount = computed(() => {
+  return isNumericPositive(sendAmount.value);
+});
 const hasEnoughBalance = computed(() => {
-  if (!isValidDecimals(sendAmount.value, selectedAsset.value.decimals!)) {
+  if (!hasValidDecimals.value) {
+    return false;
+  }
+  if (!hasPositiveSendAmount.value) {
     return false;
   }
-
   // check if valid sendAmount.value
   if (!isNumericPositive(sendAmount.value)) {
     return false;
@@ -341,7 +339,11 @@ const Tx = computed(() => {
   return tx;
 });
 
-const nativeBalanceAfterTransaction = computed(() => {
+/**
+ * Native balance after the transaction in the base unit of the
+ * native currency (eg in WETH, Lamports, Satoshis, ...)
+ */
+const nativeBalanceAfterTransactionInBaseUnits = computed(() => {
   if (
     isSendToken.value &&
     nativeBalance.value &&
@@ -390,6 +392,71 @@ const nativeBalanceAfterTransaction = computed(() => {
   return toBN(0);
 });
 
+/**
+ * Native balance after the transaction in the human unit of the
+ * native currency (eg in ETH, SOL, BTC, ...)
+ */
+const nativeBalanceAfterTransactionInHumanUnits = computed(() => {
+  return fromBase(
+    nativeBalanceAfterTransactionInBaseUnits.value.abs().toString(),
+    props.network.decimals,
+  );
+});
+
+const nativeCurrencyUsdPrice = computed(() => {
+  return accountAssets.value[0]?.price || '0';
+});
+
+const balanceAfterInUsd = computed(() => {
+  return new BigNumber(
+    nativeBalanceAfterTransactionInHumanUnits.value.toString(),
+  )
+    .times(nativeCurrencyUsdPrice.value ?? '0')
+    .toFixed();
+});
+
+const errorMsg = computed(() => {
+  if (!hasValidDecimals.value) {
+    return `Too many decimals.`;
+  }
+
+  if (!hasPositiveSendAmount.value) {
+    return `Invalid amount.`;
+  }
+
+  if (
+    !hasEnoughBalance.value &&
+    nativeBalanceAfterTransactionInBaseUnits.value.isNeg()
+  ) {
+    return `Not enough funds. You are
+      ~${formatFloatingPointValue(nativeBalanceAfterTransactionInHumanUnits.value).value}
+      ${props.network.currencyName} ($ ${
+        formatFiatValue(balanceAfterInUsd.value).value
+      }) short.`;
+  }
+
+  if (!props.network.isAddress(addressTo.value) && addressTo.value !== '') {
+    return `Invalid to address.`;
+  }
+
+  if (
+    isSendToken.value &&
+    !isValidDecimals(sendAmount.value, selectedAsset.value.decimals!)
+  ) {
+    return `Invalid decimals for ${selectedAsset.value.symbol}.`;
+  }
+
+  if (!isSendToken.value && !selectedNft.value.id) {
+    return `Invalid NFT selected.`;
+  }
+
+  if (new BigNumber(sendAmount.value).gt(assetMaxValue.value)) {
+    return `Amount exceeds maximum value.`;
+  }
+
+  return '';
+});
+
 const setTransactionFees = (tx: Transaction) => {
   return tx
     .getGasCosts()
@@ -479,7 +546,7 @@ const sendButtonTitle = computed(() => {
 
 const isValidSend = computed<boolean>(() => {
   if (!isInputsValid.value) return false;
-  if (nativeBalanceAfterTransaction.value.isNeg()) return false;
+  if (nativeBalanceAfterTransactionInBaseUnits.value.isNeg()) return false;
   if (!isEstimateValid.value) return false;
   return true;
 });
@@ -495,7 +562,9 @@ const isInputsValid = computed<boolean>(() => {
   if (!isSendToken.value && !selectedNft.value.id) {
     return false;
   }
-  if (new BigNumber(sendAmount.value).gt(assetMaxValue.value)) return false;
+  const sendAmountBigNumber = new BigNumber(sendAmount.value)
+  if (sendAmountBigNumber.isNaN()) return false
+  if (sendAmountBigNumber.gt(assetMaxValue.value)) return false;
   if (gasCostValues.value.REGULAR.nativeValue === '0') return false;
   if (!isNumericPositive(sendAmount.value)) return false;
   return true;
diff --git a/packages/extension/src/providers/kadena/ui/kda-sign-message.vue b/packages/extension/src/providers/kadena/ui/kda-sign-message.vue
index e5142f655..462e10489 100644
--- a/packages/extension/src/providers/kadena/ui/kda-sign-message.vue
+++ b/packages/extension/src/providers/kadena/ui/kda-sign-message.vue
@@ -64,6 +64,7 @@ import {
   DEFAULT_KADENA_NETWORK,
   getNetworkByName,
 } from '@/libs/utils/networks';
+import { getRTLOLTLOSafeString } from '@/libs/utils/unicode-detection';
 
 const windowPromise = WindowPromiseHandler(0);
 const network = ref<KadenaNetwork>(DEFAULT_KADENA_NETWORK);
@@ -81,7 +82,7 @@ const account = ref({ address: '' } as EnkryptAccount);
 onBeforeMount(async () => {
   const { Request, options } = await windowPromise;
   Options.value = options;
-  message.value = Request.value.params![0].data;
+  message.value = getRTLOLTLOSafeString(Request.value.params![0].data);
   account.value = Request.value.params![1] as EnkryptAccount;
   network.value = (await getNetworkByName(
     Request.value.params![0].network,
diff --git a/packages/extension/src/providers/polkadot/ui/dot-sign-message.vue b/packages/extension/src/providers/polkadot/ui/dot-sign-message.vue
index 6751f4b19..3708a8384 100644
--- a/packages/extension/src/providers/polkadot/ui/dot-sign-message.vue
+++ b/packages/extension/src/providers/polkadot/ui/dot-sign-message.vue
@@ -56,6 +56,7 @@ import { ProviderRequestOptions } from '@/types/provider';
 import { EnkryptAccount } from '@enkryptcom/types';
 import { MessageSigner } from './libs/signer';
 import { hexToBuffer } from '@enkryptcom/utils';
+import { getRTLOLTLOSafeString } from '@/libs/utils/unicode-detection';
 
 const windowPromise = WindowPromiseHandler(0);
 
@@ -74,7 +75,9 @@ onBeforeMount(async () => {
   Options.value = options;
 
   message.value = isUtf8(Request.value.params![0])
-    ? u8aToString(u8aUnwrapBytes(Request.value.params![0]))
+    ? getRTLOLTLOSafeString(
+        u8aToString(u8aUnwrapBytes(Request.value.params![0])),
+      )
     : Request.value.params![0];
 
   account.value = Request.value.params![1] as EnkryptAccount;
diff --git a/packages/extension/src/providers/solana/libs/api.ts b/packages/extension/src/providers/solana/libs/api.ts
index 9931e7526..2893cbdae 100644
--- a/packages/extension/src/providers/solana/libs/api.ts
+++ b/packages/extension/src/providers/solana/libs/api.ts
@@ -23,36 +23,48 @@ class API implements ProviderAPIInterface {
     return getSolAddress(pubkey);
   }
 
-  async init(): Promise<void> {}
+  async init(): Promise<void> { }
+
+  /**
+   * Returns null if the transaction hasn't been received by the node
+   * or has been dropped
+   */
   async getTransactionStatus(hash: string): Promise<SOLRawInfo | null> {
-    return this.web3
-      .getTransaction(hash, {
-        maxSupportedTransactionVersion: 0,
-        commitment: 'confirmed',
-      })
-      .then(tx => {
-        if (!tx) return null;
-        const retVal: SOLRawInfo = {
-          blockNumber: tx.slot,
-          timestamp: tx.blockTime,
-          transactionHash: hash,
-          status: tx.meta?.err ? false : true,
-        };
-        return retVal;
-      });
+    const tx = await this.web3.getTransaction(hash, {
+      maxSupportedTransactionVersion: 0,
+      commitment: 'confirmed',
+    })
+
+    if (!tx) {
+      // Transaction hasn't been picked up by the node
+      // (maybe it's too soon, or maybe node is behind, or maybe it's been dropped)
+      return null;
+    }
+
+    const retVal: SOLRawInfo = {
+      blockNumber: tx.slot,
+      timestamp: tx.blockTime,
+      transactionHash: hash,
+      status: tx.meta?.err ? false : true,
+    };
+
+    return retVal;
   }
+
   async getBalance(pubkey: string): Promise<string> {
     const balance = await this.web3.getBalance(
       new PublicKey(this.getAddress(pubkey)),
     );
     return numberToHex(balance);
   }
+
   async broadcastTx(rawtx: string): Promise<boolean> {
     return this.web3
       .sendRawTransaction(hexToBuffer(rawtx))
       .then(() => true)
       .catch(() => false);
   }
+
   getTokenInfo = async (contractAddress: string): Promise<SPLTokenInfo> => {
     interface TokenDetails {
       address: string;
diff --git a/packages/extension/src/providers/solana/ui/send-transaction/index.vue b/packages/extension/src/providers/solana/ui/send-transaction/index.vue
index 1f59aeda9..0ecf92072 100644
--- a/packages/extension/src/providers/solana/ui/send-transaction/index.vue
+++ b/packages/extension/src/providers/solana/ui/send-transaction/index.vue
@@ -140,6 +140,7 @@ import { VerifyTransactionParams, SendTransactionDataType } from '../types';
 import {
   formatFloatingPointValue,
   formatFiatValue,
+  isNumericPositive,
 } from '@/libs/utils/number-formatter';
 import { routes as RouterNames } from '@/ui/action/router';
 import getUiPath from '@/libs/utils/get-ui-path';
@@ -172,6 +173,7 @@ import {
 import getPriorityFees from '../libs/get-priority-fees';
 import bs58 from 'bs58';
 import SolanaAPI from '@/providers/solana/libs/api';
+import { ComputedRefSymbol } from '@vue/reactivity';
 
 const props = defineProps({
   network: {
@@ -211,8 +213,17 @@ const amount = ref<string>('');
 const isEstimateValid = ref(true);
 const storageFee = ref(0);
 const SolTx = ref<SolTransaction>();
-const hasEnoughBalance = computed(() => {
-  if (!isValidDecimals(sendAmount.value, selectedAsset.value.decimals!)) {
+const hasValidDecimals = computed((): boolean => {
+  return isValidDecimals(sendAmount.value, selectedAsset.value.decimals!);
+});
+const hasPositiveSendAmount = computed(() => {
+  return isNumericPositive(sendAmount.value);
+});
+const hasEnoughBalance = computed((): boolean => {
+  if (!hasValidDecimals.value) {
+    return false;
+  }
+  if (!hasPositiveSendAmount.value) {
     return false;
   }
   return toBN(selectedAsset.value.balance ?? '0').gte(
@@ -276,7 +287,11 @@ const TxInfo = computed<SendTransactionDataType>(() => {
   };
 });
 
-const nativeBalanceAfterTransaction = computed(() => {
+/**
+ * Native balance after the transaction in the base unit of the
+ * native currency (eg in WETH, Lamports, Satoshis, ...)
+ */
+const nativeBalanceAfterTransactionInBaseUnits = computed(() => {
   if (
     isSendToken.value &&
     nativeBalance.value &&
@@ -320,47 +335,71 @@ const nativeBalanceAfterTransaction = computed(() => {
   return toBN(0);
 });
 
-const nativeValue = computed(() => {
+/**
+ * Native balance after the transaction in the human unit of the
+ * native currency (eg in ETH, SOL, BTC, ...)
+ */
+const nativeBalanceAfterTransactionInHumanUnits = computed(() => {
   return fromBase(
-    nativeBalanceAfterTransaction.value.toString(),
+    nativeBalanceAfterTransactionInBaseUnits.value.abs().toString(),
     props.network.decimals,
   );
 });
 
-const nativePrice = computed(() => {
+const nativeCurrencyUsdPrice = computed(() => {
   return accountAssets.value[0]?.price || '0';
 });
 
-const priceDifference = computed(() => {
-  return new BigNumber(nativeValue.value)
-    .times(nativePrice.value ?? '0')
+const balanceAfterInUsd = computed(() => {
+  return new BigNumber(
+    nativeBalanceAfterTransactionInHumanUnits.value.toString(),
+  )
+    .times(nativeCurrencyUsdPrice.value ?? '0')
     .toFixed();
 });
 
 const errorMsg = computed(() => {
-  if (hasEnoughBalance.value && nativeBalanceAfterTransaction.value.isNeg()) {
+  if (!hasValidDecimals.value) {
+    return `Too many decimals.`;
+  }
+
+  if (!hasPositiveSendAmount.value) {
+    return `Invalid amount.`;
+  }
+
+  if (
+    !hasEnoughBalance.value &&
+    nativeBalanceAfterTransactionInBaseUnits.value.isNeg()
+  ) {
     return `Not enough funds. You are
-      ~${formatFloatingPointValue(nativeValue.value).value}
+      ~${formatFloatingPointValue(nativeBalanceAfterTransactionInHumanUnits.value).value}
       ${props.network.currencyName} ($ ${
-        formatFiatValue(priceDifference.value).value
+        formatFiatValue(balanceAfterInUsd.value).value
       }) short.`;
   }
+
   if (
     !props.network.isAddress(getAddress(addressTo.value)) &&
     addressTo.value !== ''
-  )
+  ) {
     return `Invalid to address.`;
+  }
+
   if (
     isSendToken.value &&
     !isValidDecimals(sendAmount.value, selectedAsset.value.decimals!)
   ) {
     return `Invalid decimals for ${selectedAsset.value.symbol}.`;
   }
+
   if (!isSendToken.value && !selectedNft.value.id) {
     return `Invalid NFT selected.`;
   }
-  if (new BigNumber(sendAmount.value).gt(assetMaxValue.value))
+
+  if (new BigNumber(sendAmount.value).gt(assetMaxValue.value)) {
     return `Amount exceeds maximum value.`;
+  }
+
   return '';
 });
 
@@ -418,7 +457,7 @@ const sendButtonTitle = computed(() => {
 
 const isValidSend = computed<boolean>(() => {
   if (!isInputsValid.value) return false;
-  if (nativeBalanceAfterTransaction.value.isNeg()) return false;
+  if (nativeBalanceAfterTransactionInBaseUnits.value.isNeg()) return false;
   if (!isEstimateValid.value) return false;
   if (gasCostValues.value.ECONOMY.nativeValue === '0') return false;
   return true;
@@ -435,7 +474,9 @@ const isInputsValid = computed<boolean>(() => {
   if (!isSendToken.value && !selectedNft.value.id) {
     return false;
   }
-  if (new BigNumber(sendAmount.value).gt(assetMaxValue.value)) return false;
+  const sendAmountBigNumber = new BigNumber(sendAmount.value);
+  if (sendAmountBigNumber.isNaN()) return false;
+  if (sendAmountBigNumber.gt(assetMaxValue.value)) return false;
   return true;
 });
 
diff --git a/packages/extension/src/providers/solana/ui/sol-sign-message.vue b/packages/extension/src/providers/solana/ui/sol-sign-message.vue
index 210b33b36..7859c18e8 100644
--- a/packages/extension/src/providers/solana/ui/sol-sign-message.vue
+++ b/packages/extension/src/providers/solana/ui/sol-sign-message.vue
@@ -76,6 +76,7 @@ import { SolSignInResponse } from './types';
 import { isUtf8 } from '@polkadot/util';
 import { hexToUtf8 } from 'web3-utils';
 import { MessageSigner } from './libs/signer';
+import { getRTLOLTLOSafeString } from '@/libs/utils/unicode-detection';
 
 const windowPromise = WindowPromiseHandler(3);
 const keyring = new PublicKeyRing();
@@ -144,7 +145,7 @@ onBeforeMount(async () => {
   } else if (reqMethod.value === 'sol_signMessage') {
     signMessage.value = JSON.parse(Request.value.params![1]);
     message.value = isUtf8(signMessage.value!.message)
-      ? hexToUtf8(signMessage.value!.message)
+      ? getRTLOLTLOSafeString(hexToUtf8(signMessage.value!.message))
       : signMessage.value!.message;
     keyring
       .getAccount(bufferToHex(bs58.decode(signMessage.value!.address)))
diff --git a/packages/extension/src/types/activity.ts b/packages/extension/src/types/activity.ts
index 89db8af7d..1c7511af8 100644
--- a/packages/extension/src/types/activity.ts
+++ b/packages/extension/src/types/activity.ts
@@ -95,6 +95,7 @@ enum ActivityStatus {
   pending = 'pending',
   success = 'success',
   failed = 'failed',
+  dropped = 'dropped',
 }
 
 enum ActivityType {
@@ -121,13 +122,13 @@ interface Activity {
   status: ActivityStatus;
   type: ActivityType;
   rawInfo?:
-    | EthereumRawInfo
-    | SubstrateRawInfo
-    | SubscanExtrinsicInfo
-    | BTCRawInfo
-    | SwapRawInfo
-    | KadenaRawInfo
-    | SOLRawInfo;
+  | EthereumRawInfo
+  | SubstrateRawInfo
+  | SubscanExtrinsicInfo
+  | BTCRawInfo
+  | SwapRawInfo
+  | KadenaRawInfo
+  | SOLRawInfo;
 }
 
 export {
diff --git a/packages/extension/src/types/env.d.ts b/packages/extension/src/types/env.d.ts
new file mode 100644
index 000000000..4e906114c
--- /dev/null
+++ b/packages/extension/src/types/env.d.ts
@@ -0,0 +1,4 @@
+interface ImportMetaEnv {
+  VITE_DEBUG_LOG?: string
+}
+
diff --git a/packages/extension/src/types/window.d.ts b/packages/extension/src/types/window.d.ts
index 77fed48f1..22508aa6d 100644
--- a/packages/extension/src/types/window.d.ts
+++ b/packages/extension/src/types/window.d.ts
@@ -1,3 +1,12 @@
 interface Window {
   [key: string]: any;
+  __ENKRYPT_DEBUG_LOG_CONF__: undefined | string
 }
+
+declare global {
+  var __ENKRYPT_DEBUG_LOG_CONF__: undefined | string
+}
+
+// Required to make the `delare global` exports work for some reason
+export { }
+
diff --git a/packages/extension/src/ui/action/main.ts b/packages/extension/src/ui/action/main.ts
index 04cfdd9ec..7ec2bcbf2 100644
--- a/packages/extension/src/ui/action/main.ts
+++ b/packages/extension/src/ui/action/main.ts
@@ -6,6 +6,11 @@ import Vue3Lottie from 'vue3-lottie';
 
 global.WeakMap = WeakMap;
 
+if (import.meta.env.DEV) {
+  globalThis.__ENKRYPT_DEBUG_LOG_CONF__ = import.meta.env.VITE_DEBUG_LOG
+}
+
+
 const app = createApp(App);
 
 app.use(router).use(Vue3Lottie, { name: 'vue3lottie' });
diff --git a/packages/extension/src/ui/action/views/network-activity/components/network-activity-transaction.vue b/packages/extension/src/ui/action/views/network-activity/components/network-activity-transaction.vue
index 1f4795de8..1f81a6f8a 100644
--- a/packages/extension/src/ui/action/views/network-activity/components/network-activity-transaction.vue
+++ b/packages/extension/src/ui/action/views/network-activity/components/network-activity-transaction.vue
@@ -37,7 +37,10 @@
           <p>
             <span
               class="network-activity__transaction-info-status"
-              :class="{ error: activity.status === ActivityStatus.failed }"
+              :class="{
+                error: activity.status === ActivityStatus.failed,
+                dropped: activity.status === ActivityStatus.dropped,
+              }"
               >{{ status }}</span
             >
             <transaction-timer
@@ -81,14 +84,15 @@
 
         <div class="network-activity__transaction-info-name">
           <h4>
-            Swap from
-            {{ (activity.rawInfo as SwapRawInfo).fromToken.symbol }} to
-            {{ (activity.rawInfo as SwapRawInfo).toToken.symbol }}
+            {{ swapMessage }}
           </h4>
           <p>
             <span
               class="network-activity__transaction-info-status"
-              :class="{ error: activity.status === ActivityStatus.failed }"
+              :class="{
+                error: activity.status === ActivityStatus.failed,
+                dropped: activity.status === ActivityStatus.dropped,
+              }"
               >{{ status }}</span
             >
             <transaction-timer
@@ -120,7 +124,7 @@
 </template>
 
 <script setup lang="ts">
-import { computed, onMounted, PropType, ref } from 'vue';
+import { computed, onMounted, PropType, ref, watch } from 'vue';
 import moment from 'moment';
 import TransactionTimer from './transaction-timer.vue';
 import {
@@ -131,6 +135,7 @@ import {
 } from '@/types/activity';
 import { BaseNetwork } from '@/types/base-network';
 import { fromBase } from '@enkryptcom/utils';
+import { getNetworkByName } from '@/libs/utils/networks';
 import BigNumber from 'bignumber.js';
 import { imageLoadError } from '@/ui/action/utils/misc';
 const props = defineProps({
@@ -153,40 +158,122 @@ const transactionURL = computed(() => {
     props.activity.transactionHash,
   );
 });
+
 const getFiatValue = computed(() => {
   return new BigNumber(props.activity.token.price || '0').times(
     fromBase(props.activity.value, props.activity.token.decimals),
   );
 });
+
+type SwapActivityDescriptionData = {
+  fromNetworkName: string;
+  toNetworkName: string;
+  fromTokenSymbol: string;
+  toTokenSymbol: string;
+};
+
+const getSwapActivityDescriptionSync = (
+  data: SwapActivityDescriptionData,
+): string => {
+  const { fromNetworkName, toNetworkName, fromTokenSymbol, toTokenSymbol } =
+    data;
+  if (fromNetworkName === toNetworkName || fromTokenSymbol !== toTokenSymbol) {
+    return `Swap from` + ` ${fromTokenSymbol}` + ` to ${toTokenSymbol}`;
+  }
+
+  return (
+    `Swap from` +
+    ` ${fromTokenSymbol}` +
+    ` to ${toTokenSymbol}` +
+    ` (Loading...)`
+  );
+};
+
+const getSwapActivityDescriptionAsync = async (
+  data: SwapActivityDescriptionData,
+): Promise<string> => {
+  const { fromNetworkName, toNetworkName, fromTokenSymbol, toTokenSymbol } =
+    data;
+  if (fromNetworkName === toNetworkName || fromTokenSymbol !== toTokenSymbol) {
+    return `Swap from` + ` ${fromTokenSymbol}` + ` to ${toTokenSymbol}`;
+  }
+
+  const toNetwork = await getNetworkByName(toNetworkName);
+  if (!toNetwork) {
+    return (
+      `Swap from` +
+      ` ${fromTokenSymbol}` +
+      ` to ${fromTokenSymbol}` +
+      ` (Unknown)`
+    );
+  }
+
+  return (
+    `Swap from` +
+    ` ${fromTokenSymbol}` +
+    ` to ${toTokenSymbol}` +
+    ` (${toNetwork.name_long})`
+  );
+};
+
+const swapMessage = ref('');
+/** Used to avoid updating the description to include (Loading...) when nothing has changed */
+let swapActivityDescriptionId: null | string = null;
+watch(
+  () => props.activity,
+  function (activity) {
+    if (activity.type !== ActivityType.swap) return;
+    const rawInfo = activity.rawInfo as SwapRawInfo;
+    const data: SwapActivityDescriptionData = {
+      fromNetworkName: activity.network,
+      toNetworkName: rawInfo.toToken.networkInfo.name,
+      fromTokenSymbol: rawInfo.fromToken.symbol,
+      toTokenSymbol: rawInfo.toToken.symbol,
+    };
+    const thisId = JSON.stringify(data);
+    // no change
+    if (swapActivityDescriptionId === thisId) return;
+    swapActivityDescriptionId = thisId;
+    swapMessage.value = getSwapActivityDescriptionSync(data);
+    getSwapActivityDescriptionAsync(data).then(asyncMessage => {
+      if (swapActivityDescriptionId !== thisId) return;
+      swapMessage.value = asyncMessage;
+    });
+  },
+  { immediate: true },
+);
+
 onMounted(() => {
   date.value = moment(props.activity.timestamp).fromNow();
   if (
     props.activity.status === ActivityStatus.success &&
     props.activity.isIncoming
-  )
+  ) {
     status.value =
       props.activity.type === ActivityType.transaction ? 'Received' : 'Swapped';
-  else if (
+  } else if (
     props.activity.status === ActivityStatus.success &&
     !props.activity.isIncoming
-  )
+  ) {
     status.value =
       props.activity.type === ActivityType.transaction ? 'Sent' : 'Swapped';
-  else if (
+  } else if (
     props.activity.status === ActivityStatus.pending &&
     props.activity.isIncoming
-  )
+  ) {
     status.value =
       props.activity.type === ActivityType.transaction
         ? 'Receiving'
         : 'Swapping';
-  else if (
+  } else if (
     props.activity.status === ActivityStatus.pending &&
     !props.activity.isIncoming
-  )
+  ) {
     status.value =
       props.activity.type === ActivityType.transaction ? 'Sending' : 'Swapping';
-  else {
+  } else if (props.activity.status === ActivityStatus.dropped) {
+    status.value = 'Dropped';
+  } else {
     status.value = 'Failed';
   }
 });
@@ -256,6 +343,9 @@ onMounted(() => {
           .error {
             color: @error;
           }
+          .dropped {
+            /* TODO: Consider different color */
+          }
         }
       }
 
diff --git a/packages/extension/src/ui/action/views/network-activity/index.vue b/packages/extension/src/ui/action/views/network-activity/index.vue
index e15b39ada..5a9b9f243 100644
--- a/packages/extension/src/ui/action/views/network-activity/index.vue
+++ b/packages/extension/src/ui/action/views/network-activity/index.vue
@@ -116,10 +116,13 @@ apiPromise.then(api => {
   });
 });
 
-const activityCheckTimers: any[] = [];
+/** Intervals that trigger calls to check for updates in transaction activity */
+const activityCheckTimers: ReturnType<typeof setInterval>[] = [];
+
 const activityAddress = computed(() =>
   props.network.displayAddress(props.accountInfo.selectedAccount!.address),
 );
+
 const updateVisibleActivity = (activity: Activity): void => {
   activities.value.forEach((act, idx) => {
     if (act.transactionHash === activity.transactionHash) {
@@ -129,96 +132,135 @@ const updateVisibleActivity = (activity: Activity): void => {
   forceUpdateVal.value++;
 };
 
+/** Set a timer to periodically check (and update) the status of an activity item (transaction) */
 const checkActivity = (activity: Activity): void => {
   activity = toRaw(activity);
   const timer = setInterval(() => {
     apiPromise.then(api => {
       api.getTransactionStatus(activity.transactionHash).then(info => {
-        getInfo(activity, info, timer);
+        handleActivityUpdate(activity, info, timer);
       });
     });
-  }, 5000);
+  }, 5_000);
+
+  // Register the interval timer so we can destroy it on component teardown
   activityCheckTimers.push(timer);
 };
-const getInfo = (activity: Activity, info: any, timer: any) => {
-  if (info) {
-    if (props.network.provider === ProviderName.ethereum) {
-      const evmInfo = info as EthereumRawInfo;
-      activity.status = evmInfo.status
+
+const handleActivityUpdate = (activity: Activity, info: any, timer: any) => {
+  if (props.network.provider === ProviderName.ethereum) {
+    if (!info) return;
+    const evmInfo = info as EthereumRawInfo;
+    activity.status = evmInfo.status
+      ? ActivityStatus.success
+      : ActivityStatus.failed;
+    activity.rawInfo = evmInfo;
+    activityState
+      .updateActivity(activity, {
+        address: activityAddress.value,
+        network: props.network.name,
+      })
+      .then(() => updateVisibleActivity(activity));
+  } else if (props.network.provider === ProviderName.polkadot) {
+    if (!info) return;
+    const subInfo = info as SubscanExtrinsicInfo;
+    if (!subInfo.pending) {
+      activity.status = subInfo.success
         ? ActivityStatus.success
         : ActivityStatus.failed;
-      activity.rawInfo = evmInfo;
+      activity.rawInfo = subInfo;
       activityState
         .updateActivity(activity, {
           address: activityAddress.value,
           network: props.network.name,
         })
         .then(() => updateVisibleActivity(activity));
-    } else if (props.network.provider === ProviderName.polkadot) {
-      const subInfo = info as SubscanExtrinsicInfo;
-      if (!subInfo.pending) {
-        activity.status = subInfo.success
-          ? ActivityStatus.success
-          : ActivityStatus.failed;
-        activity.rawInfo = subInfo;
-        activityState
-          .updateActivity(activity, {
-            address: activityAddress.value,
-            network: props.network.name,
-          })
-          .then(() => updateVisibleActivity(activity));
-      }
-    } else if (props.network.provider === ProviderName.bitcoin) {
-      const btcInfo = info as BTCRawInfo;
-      activity.status = ActivityStatus.success;
-      activity.rawInfo = btcInfo;
-      activityState
-        .updateActivity(activity, {
-          address: activityAddress.value,
-          network: props.network.name,
-        })
-        .then(() => updateVisibleActivity(activity));
-    } else if (props.network.provider === ProviderName.kadena) {
-      const kadenaInfo = info as KadenaRawInfo;
-      activity.status =
-        kadenaInfo.result.status == 'success'
-          ? ActivityStatus.success
-          : ActivityStatus.failed;
-      activity.rawInfo = kadenaInfo as KadenaRawInfo;
+    }
+  } else if (props.network.provider === ProviderName.bitcoin) {
+    if (!info) return;
+    const btcInfo = info as BTCRawInfo;
+    activity.status = ActivityStatus.success;
+    activity.rawInfo = btcInfo;
+    activityState
+      .updateActivity(activity, {
+        address: activityAddress.value,
+        network: props.network.name,
+      })
+      .then(() => updateVisibleActivity(activity));
+  } else if (props.network.provider === ProviderName.kadena) {
+    if (!info) return;
+    const kadenaInfo = info as KadenaRawInfo;
+    activity.status =
+      kadenaInfo.result.status == 'success'
+        ? ActivityStatus.success
+        : ActivityStatus.failed;
+    activity.rawInfo = kadenaInfo as KadenaRawInfo;
 
+    activityState
+      .updateActivity(activity, {
+        address: activityAddress.value,
+        network: props.network.name,
+      })
+      .then(() => updateVisibleActivity(activity));
+  } else if (props.network.provider === ProviderName.solana) {
+    if (info) {
+      console.log('[[ ??? doing something ??? ]]', info);
+      const solInfo = info as SOLRawInfo;
+      activity.status = info.status
+        ? ActivityStatus.success
+        : ActivityStatus.failed;
+      activity.rawInfo = solInfo;
       activityState
         .updateActivity(activity, {
           address: activityAddress.value,
           network: props.network.name,
         })
         .then(() => updateVisibleActivity(activity));
-    } else if (props.network.provider === ProviderName.solana) {
-      const solInfo = info as SOLRawInfo;
-      activity.status = info.status
-        ? ActivityStatus.success
-        : ActivityStatus.failed;
-      activity.rawInfo = solInfo;
+    } else if (Date.now() > activity.timestamp + 3 * 60_000) {
+      // Either our node is behind or the transaction was dropped
+      // Consider the transaction expired
+      activity.status = ActivityStatus.dropped;
       activityState
         .updateActivity(activity, {
           address: activityAddress.value,
           network: props.network.name,
         })
         .then(() => updateVisibleActivity(activity));
+    } else {
+      return; /* Give the transaction more time to be mined */
     }
-    clearInterval(timer);
   }
+
+  // If we're this far in then the transaction has reached a terminal status
+  // No longer need to check this activity
+  clearInterval(timer);
 };
+
 const checkSwap = (activity: Activity): void => {
   activity = toRaw(activity);
   const timer = setInterval(() => {
     if (swap) {
       swap.initPromise.then(() => {
         swap.getStatus((activity.rawInfo as SwapRawInfo).status).then(info => {
-          if (info === TransactionStatus.pending) return;
-          activity.status =
-            info === TransactionStatus.success
-              ? ActivityStatus.success
-              : ActivityStatus.failed;
+          switch (info) {
+            case TransactionStatus.pending:
+              // noop
+              return;
+            case TransactionStatus.success:
+              activity.status = ActivityStatus.success;
+              break;
+            case TransactionStatus.failed:
+            case null:
+              activity.status = ActivityStatus.failed;
+              break;
+            case TransactionStatus.dropped:
+              activity.status = ActivityStatus.dropped;
+              break;
+            default:
+              info satisfies never;
+              console.error('Unknown swap status:', info);
+              return;
+          }
           activityState
             .updateActivity(activity, {
               address: activityAddress.value,
@@ -241,15 +283,19 @@ const setActivities = () => {
       isNoActivity.value = all.length === 0;
       activities.value.forEach(act => {
         if (
-          act.status === ActivityStatus.pending &&
+          (act.status === ActivityStatus.pending ||
+            act.status === ActivityStatus.dropped) &&
           act.type === ActivityType.transaction
-        )
+        ) {
           checkActivity(act);
+        }
         if (
-          act.status === ActivityStatus.pending &&
+          (act.status === ActivityStatus.pending ||
+            act.status === ActivityStatus.dropped) &&
           act.type === ActivityType.swap
-        )
+        ) {
           checkSwap(act);
+        }
       });
     });
   else activities.value = [];
@@ -259,9 +305,11 @@ watch([selectedAddress, selectedNetworkName], setActivities);
 onMounted(() => {
   setActivities();
   activityCheckTimers.forEach(timer => clearInterval(timer));
+  activityCheckTimers.length = 0;
 });
 onUnmounted(() => {
   activityCheckTimers.forEach(timer => clearInterval(timer));
+  activityCheckTimers.length = 0;
 });
 </script>
 
diff --git a/packages/extension/src/ui/action/views/swap/components/swap-error/index.vue b/packages/extension/src/ui/action/views/swap/components/swap-error/index.vue
index 5890dc1d7..3d48193ec 100644
--- a/packages/extension/src/ui/action/views/swap/components/swap-error/index.vue
+++ b/packages/extension/src/ui/action/views/swap/components/swap-error/index.vue
@@ -130,7 +130,7 @@ const supportedNets = getSupportedNetworks()
 
   &__container {
     width: 100%;
-    height: 600px;
+    height: 100%;
     left: 0px;
     top: 0px;
     position: fixed;
diff --git a/packages/extension/src/ui/action/views/swap/components/swap-loading/index.vue b/packages/extension/src/ui/action/views/swap/components/swap-loading/index.vue
index 3310af9ee..68a0a5968 100644
--- a/packages/extension/src/ui/action/views/swap/components/swap-loading/index.vue
+++ b/packages/extension/src/ui/action/views/swap/components/swap-loading/index.vue
@@ -84,7 +84,7 @@ withDefaults(defineProps<Props>(), {
 
   &__container {
     width: 100%;
-    height: 600px;
+    height: 100%;
     left: 0px;
     top: 0px;
     position: fixed;
diff --git a/packages/extension/src/ui/action/views/swap/index.vue b/packages/extension/src/ui/action/views/swap/index.vue
index a3caa71c0..ea0b71530 100644
--- a/packages/extension/src/ui/action/views/swap/index.vue
+++ b/packages/extension/src/ui/action/views/swap/index.vue
@@ -840,7 +840,7 @@ const sendAction = async () => {
 
   const tradeStatusOptions = trades.map(t =>
     t!.getStatusObject({
-      transactionHashes: [],
+      transactions: [],
     }),
   );
 
diff --git a/packages/extension/src/ui/action/views/swap/libs/send-transactions.ts b/packages/extension/src/ui/action/views/swap/libs/send-transactions.ts
index d5cef90db..192357bb7 100644
--- a/packages/extension/src/ui/action/views/swap/libs/send-transactions.ts
+++ b/packages/extension/src/ui/action/views/swap/libs/send-transactions.ts
@@ -75,7 +75,7 @@ const getBaseActivity = (options: ExecuteSwapOptions): Activity => {
  */
 export const executeSwap = async (
   options: ExecuteSwapOptions,
-): Promise<string[]> => {
+): Promise<{ hash: string, sentAt: number }[]> => {
   const activityState = new ActivityState();
   const api = await options.network.api();
   if (options.networkType === NetworkType.Bitcoin) {
@@ -116,7 +116,7 @@ export const executeSwap = async (
           network: options.network.name,
         });
       });
-    return [signedTx.getId() as `0x${string}`];
+    return [{ hash: signedTx.getId() as `0x${string}`, sentAt: Date.now() }];
   } else if (options.networkType === NetworkType.Substrate) {
     const substrateTx = await getSubstrateNativeTransation(
       options.network as SubstrateNetwork,
@@ -173,12 +173,12 @@ export const executeSwap = async (
           { address: txActivity.from, network: options.network.name },
         );
       });
-    return [hash];
+    return [{ hash, sentAt: Date.now(), }];
   } else if (options.networkType === NetworkType.Solana) {
     // Execute the swap on Solana
     const conn = (api as SolanaAPI).api.web3;
 
-    const solTxHashes: string[] = [];
+    const solTxs: { hash: string, sentAt: number, }[] = [];
 
     /** Enkrypt representation of the swap transactions */
     const enkSolTxs = options.swap.transactions as EnkryptSolanaTransaction[];
@@ -200,7 +200,7 @@ export const executeSwap = async (
           const hasThirdPartySignatures =
             // Serialized versioned transaction was already signed
             legacyTx.signatures.length > 1 ||
-            // Need to apply third aprty signatures to the transaction
+            // Need to apply third party signatures to the transaction
             thirdPartySignatures.length > 0;
 
           if (hasThirdPartySignatures) {
@@ -219,7 +219,7 @@ export const executeSwap = async (
               // Might need to update the block hash
               console.warn(
                 `Failed to get fee for legacy transaction while checking` +
-                  ` whether to update block hash: ${String(err)}`,
+                ` whether to update block hash: ${String(err)}`,
               );
               shouldUpdateBlockHash = true;
             }
@@ -228,7 +228,7 @@ export const executeSwap = async (
             if (shouldUpdateBlockHash) {
               console.warn(
                 `Unsigned legacy transaction might have an` +
-                  ` out-of-date block hash, trying to update it...`,
+                ` out-of-date block hash, trying to update it...`,
               );
               const backoff = [0, 500, 1_000, 2_000];
               let backoffi = 0;
@@ -238,7 +238,7 @@ export const executeSwap = async (
                   // Just continue and hope for the best with old block hash...
                   console.warn(
                     `Failed to get latest blockhash after ${backoffi} attempts,` +
-                      ` continuing with old block hash for legacy transaction...`,
+                    ` continuing with old block hash for legacy transaction...`,
                   );
                   break update_block_hash;
                 }
@@ -246,7 +246,7 @@ export const executeSwap = async (
                 if (backoffMs > 0) {
                   console.warn(
                     `Waiting ${backoffMs}ms before retrying latest block` +
-                      ` hash for legacy transaction...`,
+                    ` hash for legacy transaction...`,
                   );
                   await new Promise(res => setTimeout(res, backoffMs));
                 }
@@ -257,7 +257,7 @@ export const executeSwap = async (
                 } catch (err) {
                   console.warn(
                     `Failed to get latest blockhash on attempt` +
-                      ` ${backoffi + 1}: ${String(err)}`,
+                    ` ${backoffi + 1}: ${String(err)}`,
                   );
                 }
                 backoffi++;
@@ -330,7 +330,7 @@ export const executeSwap = async (
               // Might need to update the block hash
               console.warn(
                 `Failed to get fee for versioned transaction while checking` +
-                  ` whether to update block hash: ${String(err)}`,
+                ` whether to update block hash: ${String(err)}`,
               );
               shouldUpdateBlockHash = true;
             }
@@ -339,7 +339,7 @@ export const executeSwap = async (
             if (shouldUpdateBlockHash) {
               console.warn(
                 `Unsigned versioned transaction might have an` +
-                  ` out-of-date block hash, trying to update it...`,
+                ` out-of-date block hash, trying to update it...`,
               );
               const backoff = [0, 500, 1_000, 2_000];
               let backoffi = 0;
@@ -349,7 +349,7 @@ export const executeSwap = async (
                   // Just continue and hope for the best with old block hash...
                   console.warn(
                     `Failed to get latest blockhash after ${backoffi} attempts,` +
-                      ` continuing with old block hash for versioned transaction...`,
+                    ` continuing with old block hash for versioned transaction...`,
                   );
                   break update_block_hash;
                 }
@@ -357,7 +357,7 @@ export const executeSwap = async (
                 if (backoffMs > 0) {
                   console.warn(
                     `Waiting ${backoffMs}ms before retrying latest block` +
-                      ` hash for versioned transaction...`,
+                    ` hash for versioned transaction...`,
                   );
                   await new Promise(res => setTimeout(res, backoffMs));
                 }
@@ -368,7 +368,7 @@ export const executeSwap = async (
                 } catch (err) {
                   console.warn(
                     `Failed to get latest blockhash on attempt` +
-                      ` ${backoffi + 1}: ${String(err)}`,
+                    ` ${backoffi + 1}: ${String(err)}`,
                   );
                 }
                 backoffi++;
@@ -434,8 +434,8 @@ export const executeSwap = async (
             );
             throw new Error(
               'Failed to send Solana swap transaction: blockhash not found.' +
-                ' Too much time may have passed between the creation and sending' +
-                ' of the transaction',
+              ' Too much time may have passed between the creation and sending' +
+              ' of the transaction',
             );
           }
 
@@ -454,7 +454,7 @@ export const executeSwap = async (
         } else {
           console.error(
             `Failed to send Solana swap transaction,` +
-              ` unhandled error ${(err as Error).name}`,
+            ` unhandled error ${(err as Error).name}`,
           );
         }
         // Solana transactions can have big errors
@@ -475,12 +475,12 @@ export const executeSwap = async (
         network: options.network.name,
       });
 
-      solTxHashes.push(txHash);
+      solTxs.push({ hash: txHash, sentAt: Date.now(), });
     }
 
     // Finished executing the swap on Solana
 
-    return solTxHashes;
+    return solTxs;
   } else if (options.networkType === NetworkType.EVM) {
     const web3 = (api as EvmAPI).web3;
     const nonce = await web3.getTransactionCount(options.from.address);
@@ -504,7 +504,7 @@ export const executeSwap = async (
     );
     const txs = await Promise.all(txsPromises);
     /** Hashes of transactions successfully sent & mined, in order of execution */
-    const txPromises: `0x${string}`[] = [];
+    const txPromises: { hash: `0x${string}`, sentAt: number, }[] = [];
 
     for (const txInfo of txs) {
       // Submit each transaction, in-order one-by-one
@@ -566,7 +566,7 @@ export const executeSwap = async (
             );
           }),
         );
-      txPromises.push(hash);
+      txPromises.push({ hash, sentAt: Date.now(), });
     }
     return txPromises;
   } else {
diff --git a/packages/extension/src/ui/action/views/swap/views/swap-best-offer/components/swap-best-offer-block/components/best-offer-warning.vue b/packages/extension/src/ui/action/views/swap/views/swap-best-offer/components/swap-best-offer-block/components/best-offer-warning.vue
index 2f1597081..890f48586 100644
--- a/packages/extension/src/ui/action/views/swap/views/swap-best-offer/components/swap-best-offer-block/components/best-offer-warning.vue
+++ b/packages/extension/src/ui/action/views/swap/views/swap-best-offer/components/swap-best-offer-block/components/best-offer-warning.vue
@@ -15,6 +15,8 @@
 </template>
 
 <script setup lang="ts">
+// TODO: Is this component deprecated?
+
 import WarningIcon from '@action/icons/send/warning-icon.vue';
 defineProps({
   feeWarning: {
diff --git a/packages/extension/src/ui/action/views/swap/views/swap-best-offer/index.vue b/packages/extension/src/ui/action/views/swap/views/swap-best-offer/index.vue
index dfb84bb60..8f1e8e271 100644
--- a/packages/extension/src/ui/action/views/swap/views/swap-best-offer/index.vue
+++ b/packages/extension/src/ui/action/views/swap/views/swap-best-offer/index.vue
@@ -11,11 +11,7 @@
         </a>
       </div>
       <div class="swap-best-offer__wrap">
-        <hardware-wallet-msg
-          v-if="account"
-          :wallet-type="account.walletType"
-          style="width: 90%"
-        />
+        <hardware-wallet-msg v-if="account" :wallet-type="account.walletType" />
         <custom-scrollbar
           ref="bestOfferScrollRef"
           class="swap-best-offer__scroll-area"
@@ -395,8 +391,8 @@ const sendAction = async () => {
       swap: pickedTrade.value,
       toToken: swapData.toToken,
     })
-      .then(hashes => {
-        pickedTrade.value.status!.options.transactionHashes = hashes;
+      .then(txs => {
+        pickedTrade.value.status!.options.transactions = txs;
         const swapRaw: SwapRawInfo = {
           fromToken: swapData.fromToken,
           toToken: swapData.toToken,
@@ -421,7 +417,7 @@ const sendAction = async () => {
           timestamp: new Date().getTime(),
           type: ActivityType.swap,
           value: pickedTrade.value.toTokenAmount.toString(),
-          transactionHash: `${hashes[0]}-swap`,
+          transactionHash: `${txs[0].hash}-swap`,
           rawInfo: JSON.parse(JSON.stringify(swapRaw)),
         };
         const activityState = new ActivityState();
diff --git a/packages/extension/src/ui/onboard/main.ts b/packages/extension/src/ui/onboard/main.ts
index 4f222a028..41ba43c24 100644
--- a/packages/extension/src/ui/onboard/main.ts
+++ b/packages/extension/src/ui/onboard/main.ts
@@ -7,6 +7,10 @@ import * as filters from '@action/utils/filters';
 
 global.WeakMap = WeakMap;
 
+if (import.meta.env.DEV) {
+  globalThis.__ENKRYPT_DEBUG_LOG_CONF__ = import.meta.env.VITE_DEBUG_LOG
+}
+
 const router = createRouter({
   history: createWebHashHistory(),
   routes,
diff --git a/packages/extension/src/ui/provider-pages/main.ts b/packages/extension/src/ui/provider-pages/main.ts
index 01417dac9..6a1eff238 100644
--- a/packages/extension/src/ui/provider-pages/main.ts
+++ b/packages/extension/src/ui/provider-pages/main.ts
@@ -7,6 +7,10 @@ import Vue3Lottie from 'vue3-lottie';
 
 global.WeakMap = WeakMap;
 
+if (import.meta.env.DEV) {
+  globalThis.__ENKRYPT_DEBUG_LOG_CONF__ = import.meta.env.VITE_DEBUG_LOG
+}
+
 const router = createRouter({
   history: createWebHashHistory(),
   routes,
diff --git a/packages/swap/src/providers/changelly/index.ts b/packages/swap/src/providers/changelly/index.ts
index b10fb64f5..50cd460d7 100644
--- a/packages/swap/src/providers/changelly/index.ts
+++ b/packages/swap/src/providers/changelly/index.ts
@@ -1,6 +1,6 @@
 import type Web3Eth from "web3-eth";
 import { v4 as uuidv4 } from "uuid";
-import { fromBase, toBase } from "@enkryptcom/utils";
+import { DebugLogger, fromBase, toBase } from "@enkryptcom/utils";
 import { numberToHex, toBN } from "web3-utils";
 import {
   VersionedTransaction,
@@ -68,40 +68,10 @@ import {
   SPL_TOKEN_ATA_ACCOUNT_SIZE_BYTES,
 } from "../../utils/solana";
 
-/** Enables debug logging in this file */
-const DEBUG = false;
+const logger = new DebugLogger("swap:changelly");
 
 const BASE_URL = "https://partners.mewapi.io/changelly-v2";
 
-let debug: (context: string, message: string, ...args: any[]) => void;
-if (DEBUG) {
-  debug = (context: string, message: string, ...args: any[]): void => {
-    const now = new Date();
-    const ymdhms =
-      // eslint-disable-next-line prefer-template
-      now.getFullYear().toString().padStart(4, "0") +
-      "-" +
-      (now.getMonth() + 1).toString().padStart(2, "0") +
-      "-" +
-      now.getDate().toString().padStart(2, "0") +
-      " " +
-      now.getHours().toString().padStart(2, "0") +
-      ":" +
-      now.getMinutes().toString().padStart(2, "0") +
-      ":" +
-      now.getSeconds().toString().padStart(2, "0") +
-      "." +
-      now.getMilliseconds().toString().padStart(3, "0");
-    console.info(
-      `\x1b[90m${ymdhms}\x1b[0m \x1b[32mChangellySwapProvider.${context}\x1b[0m: ${message}`,
-      ...args,
-    );
-  };
-} else {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
-  debug = () => {};
-}
-
 class Changelly extends ProviderClass {
   tokenList: TokenType[];
 
@@ -132,12 +102,11 @@ class Changelly extends ProviderClass {
   }
 
   async init(): Promise<void> {
-    debug("init", "Initialising...");
+    logger.info("init: Initialising...");
 
     if (!Changelly.isSupported(this.network)) {
-      debug(
-        "init",
-        `Enkrypt does not support Changelly on this network  network=${this.network}`,
+      logger.info(
+        `init: Enkrypt does not support Changelly on this network  network=${this.network}`,
       );
       return;
     }
@@ -195,9 +164,8 @@ class Changelly extends ProviderClass {
         );
     });
 
-    debug(
-      "init",
-      `Finished initialising  this.changellyList.length=${this.changellyList.length}`,
+    logger.info(
+      `init: Finished initialising  this.changellyList.length=${this.changellyList.length}`,
     );
   }
 
@@ -302,9 +270,8 @@ class Changelly extends ProviderClass {
     }
 
     const isValid = response.result.result;
-    debug(
-      "isValidAddress",
-      `Changelly validateAddress result` +
+    logger.info(
+      `isValidAddress: Changelly validateAddress result` +
         `  address=${address}` +
         `  ticker=${ticker}` +
         `  isValid=${isValid}`,
@@ -373,9 +340,8 @@ class Changelly extends ProviderClass {
         minimumTo: toBN(toBase(result.minTo, toToken.decimals)),
         maximumTo: toBN(toBase(result.maxTo, toToken.decimals)),
       };
-      debug(
-        "getMinMaxAmount",
-        `Successfully got min and max of swap pair` +
+      logger.info(
+        `getMinMaxAmount: Successfully got min and max of swap pair` +
           `  fromToken=${fromToken.symbol} (${params.from})` +
           `  toToken=${toToken.symbol} (${params.to})` +
           `  took=${(Date.now() - startedAt).toLocaleString()}ms`,
@@ -403,9 +369,8 @@ class Changelly extends ProviderClass {
 
     const startedAt = Date.now();
 
-    debug(
-      "getQuote",
-      `Getting Changelly quote` +
+    logger.info(
+      `getQuote: Getting Changelly quote` +
         `  srcToken=${options.fromToken.symbol}` +
         `  dstToken=${options.toToken.symbol}` +
         `  fromAddress=${options.fromAddress}` +
@@ -419,27 +384,24 @@ class Changelly extends ProviderClass {
         options.toToken.networkInfo.name as SupportedNetworkName,
       )
     ) {
-      debug(
-        "getQuote",
-        `No swap: Enkrypt does not support Changelly on the destination network` +
+      logger.info(
+        `getQuote: No swap: Enkrypt does not support Changelly on the destination network` +
           `  dstNetwork=${options.toToken.networkInfo.name}`,
       );
       return null;
     }
 
     if (!Changelly.isSupported(this.network)) {
-      debug(
-        "getQuote",
-        `No swap: Enkrypt does not support Changelly on the source network` +
+      logger.info(
+        `getQuote: No swap: Enkrypt does not support Changelly on the source network` +
           `  srcNetwork=${this.network}`,
       );
       return null;
     }
 
     if (!this.getTicker(options.fromToken, this.network)) {
-      debug(
-        "getQuote",
-        `No swap: Failed to find ticker for src token` +
+      logger.info(
+        `getQuote: No swap: Failed to find ticker for src token` +
           `  srcToken=${options.fromToken.symbol}` +
           `  srcNetwork=${this.network}`,
       );
@@ -452,9 +414,8 @@ class Changelly extends ProviderClass {
         options.toToken.networkInfo.name as SupportedNetworkName,
       )
     ) {
-      debug(
-        "getQuote",
-        `No swap: Failed to find ticker for dst token` +
+      logger.info(
+        `getQuote: No swap: Failed to find ticker for dst token` +
           `  dstToken=${options.toToken.symbol}` +
           `  dstNetwork=${options.toToken.networkInfo.name}`,
       );
@@ -475,9 +436,8 @@ class Changelly extends ProviderClass {
       quoteRequestAmount = minMax.maximumFrom;
 
     if (quoteRequestAmount.toString() === "0") {
-      debug(
-        "getQuote",
-        `No swap: Quote request amount is zero` +
+      logger.info(
+        `getQuote: No swap: Quote request amount is zero` +
           `  fromToken=${options.fromToken.symbol}` +
           `  toToken=${options.toToken.symbol}` +
           `  minimumFrom=${minMax.minimumFrom.toString()}` +
@@ -486,7 +446,7 @@ class Changelly extends ProviderClass {
       return null;
     }
 
-    debug("getQuote", `Requesting changelly swap...`);
+    logger.info(`getQuote: Requesting changelly swap...`);
 
     try {
       const params: ChangellyApiGetFixRateForAmountParams = {
@@ -508,7 +468,7 @@ class Changelly extends ProviderClass {
           { signal },
         );
 
-      debug("getQuote", `Received Changelly swap response`);
+      logger.info(`getQuote: Received Changelly swap response`);
 
       if (response.error) {
         console.warn(
@@ -580,9 +540,8 @@ class Changelly extends ProviderClass {
         const rounded = (BigInt(fixed) - BigInt(1)).toString();
         toTokenAmountBase = rounded;
 
-        debug(
-          "getQuote",
-          `Fixed amountTo` +
+        logger.info(
+          `getQuote: Fixed amountTo` +
             `  firstChangellyFixRateQuote.amountTo=${firstChangellyFixRateQuote.amountTo}` +
             `  toTokenAmountBase=${toTokenAmountBase}` +
             `  options.toToken.decimals=${options.toToken.decimals}` +
@@ -617,9 +576,8 @@ class Changelly extends ProviderClass {
         const rounded = (BigInt(fixed) + BigInt(1)).toString();
         networkFeeBase = rounded;
 
-        debug(
-          "getQuote",
-          `Fixed networkFee` +
+        logger.info(
+          `getQuote: Fixed networkFee` +
             `  firstChangellyFixRateQuote.networkFee=${firstChangellyFixRateQuote.networkFee}` +
             `  networkFeeBase=${networkFeeBase}` +
             `  options.toToken.decimals=${options.toToken.decimals}` +
@@ -650,9 +608,8 @@ class Changelly extends ProviderClass {
         minMax,
       };
 
-      debug(
-        "getQuote",
-        `Successfully retrieved quote from Changelly via "getFixRateForAmount"` +
+      logger.info(
+        `getQuote: Successfully retrieved quote from Changelly via "getFixRateForAmount"` +
           `  took=${(Date.now() - startedAt).toLocaleString()}ms`,
       );
 
@@ -675,12 +632,11 @@ class Changelly extends ProviderClass {
     const signal = context?.signal;
 
     const startedAt = Date.now();
-    debug("getSwap", `Requesting swap transaction from Changelly...`);
+    logger.info(`getSwap: Requesting swap transaction from Changelly...`);
 
     if (!Changelly.isSupported(this.network)) {
-      debug(
-        "getSwap",
-        `Enkrypt does not support Changelly on the source network, returning no swap` +
+      logger.info(
+        `getSwap: Enkrypt does not support Changelly on the source network, returning no swap` +
           `  srcNetwork=${this.network}`,
       );
       return null;
@@ -691,9 +647,8 @@ class Changelly extends ProviderClass {
         quote.options.toToken.networkInfo.name as SupportedNetworkName,
       )
     ) {
-      debug(
-        "getSwap",
-        `Enkrypt does not support Changelly on the destination network, returning no swap` +
+      logger.info(
+        `getSwap: Enkrypt does not support Changelly on the destination network, returning no swap` +
           `  dstNetwork=${quote.options.toToken.networkInfo.name}`,
       );
       return null;
@@ -749,7 +704,7 @@ class Changelly extends ProviderClass {
       let transaction: SwapTransaction;
       switch (quote.options.fromToken.type) {
         case NetworkType.EVM: {
-          debug("getSwap", `Preparing EVM transaction for Changelly swap`);
+          logger.info(`getSwap: Preparing EVM transaction for Changelly swap`);
           if (quote.options.fromToken.address === NATIVE_TOKEN_ADDRESS) {
             transaction = {
               from: quote.options.fromAddress,
@@ -779,7 +734,9 @@ class Changelly extends ProviderClass {
           break;
         }
         case NetworkType.Solana: {
-          debug("getSwap", `Changelly is not supported on Solana at this time`);
+          logger.info(
+            `getSwap: Changelly is not supported on Solana at this time`,
+          );
 
           const conn = this.web3 as Connection;
 
@@ -790,9 +747,8 @@ class Changelly extends ProviderClass {
           if (quote.options.fromToken.address === NATIVE_TOKEN_ADDRESS) {
             // Swapping from native SOL
 
-            debug(
-              "getSwap",
-              `Preparing Solana Changelly SOL swap transaction` +
+            logger.info(
+              `getSwap: Preparing Solana Changelly SOL swap transaction` +
                 `  quote.options.fromAddress=${quote.options.fromAddress}` +
                 `  latestBlockHash=${latestBlockHash.blockhash}` +
                 `  lastValidBlockHeight=${latestBlockHash.lastValidBlockHeight}` +
@@ -834,9 +790,8 @@ class Changelly extends ProviderClass {
               tokenProgramId,
             );
             const amount = BigInt(quote.options.amount.toString());
-            debug(
-              "getSwap",
-              `Preparing Solana Changelly SPL token swap transaction` +
+            logger.info(
+              `getSwap: Preparing Solana Changelly SPL token swap transaction` +
                 `  srcMint=${mint.toBase58()}` +
                 `  srcTokenProgramId=${tokenProgramId.toBase58()}` +
                 `  wallet=${wallet.toBase58()}` +
@@ -855,12 +810,13 @@ class Changelly extends ProviderClass {
 
             const instructions: TransactionInstruction[] = [];
             if (payinAtaExists) {
-              debug(
-                "getSwap",
-                `Payin ATA already exists. No need to create it.`,
+              logger.info(
+                `getSwap: Payin ATA already exists. No need to create it.`,
               );
             } else {
-              debug("getSwap", `Payin ATA does not exist. Need to create it.`);
+              logger.info(
+                `getSwap: Payin ATA does not exist. Need to create it.`,
+              );
               const extraRentFee = await conn.getMinimumBalanceForRentExemption(
                 SPL_TOKEN_ATA_ACCOUNT_SIZE_BYTES,
               );
@@ -921,9 +877,8 @@ class Changelly extends ProviderClass {
 
             // Set priority fee
             if (recentFeeMinAvg <= 0) {
-              debug(
-                "getSwap",
-                `No recent fees, not setting priority fee` +
+              logger.info(
+                `getSwap: No recent fees, not setting priority fee` +
                   `  recentFeeCount=${recentFeeCount}` +
                   `  recentFeeCountWithoutZeroes=${recentFeeCountWithoutZeroes}` +
                   `  recentFeeSum=${recentFeeSum}` +
@@ -934,9 +889,8 @@ class Changelly extends ProviderClass {
                   `  recentFeeMinAvg=${recentFeeMinAvg}`,
               );
             } else {
-              debug(
-                "getSwap",
-                `Setting priority fee` +
+              logger.info(
+                `getSwap: Setting priority fee` +
                   `  priority_fee=${recentFeeMinAvg} micro_lamports/compute_unit` +
                   `  recentFeeCount=${recentFeeCount}` +
                   `  recentFeeCountWithoutZeroes=${recentFeeCountWithoutZeroes}` +
@@ -1023,9 +977,8 @@ class Changelly extends ProviderClass {
         const rounded = (BigInt(fixed) - BigInt(1)).toString();
         baseToAmount = rounded;
 
-        debug(
-          "getQuote",
-          `Fixed amountExpectedTo` +
+        logger.info(
+          `getQuote: Fixed amountExpectedTo` +
             `  changellyFixedRateTx.amountExpectedTo=${changellyFixedRateTx.amountExpectedTo}` +
             `  baseToAmount=${baseToAmount}` +
             `  quote.options.toToken.decimals=${quote.options.toToken.decimals}` +
@@ -1053,9 +1006,8 @@ class Changelly extends ProviderClass {
           provider: this.name,
         }),
       };
-      debug(
-        "getSwap",
-        `Successfully extracted Changelly swap transaction via "createFixTransaction"` +
+      logger.info(
+        `getSwap: Successfully extracted Changelly swap transaction via "createFixTransaction"` +
           `  took=${(Date.now() - startedAt).toLocaleString()}ms`,
       );
       return retResponse;
@@ -1070,6 +1022,9 @@ class Changelly extends ProviderClass {
   }
 
   async getStatus(options: StatusOptions): Promise<TransactionStatus> {
+    // TODO: If a Solana transaction hasn't been found after 3 minutes then consider dropping it
+    // I'm not sure how Rango's API handles Solana transactions being dropped...
+
     const params: ChangellyApiGetStatusParams = {
       id: options.swapId,
     };
diff --git a/packages/swap/src/providers/changelly/supported.ts b/packages/swap/src/providers/changelly/supported.ts
index 0ff55132d..143e5cc1a 100644
--- a/packages/swap/src/providers/changelly/supported.ts
+++ b/packages/swap/src/providers/changelly/supported.ts
@@ -27,6 +27,10 @@ const supportedNetworks: {
     changellyName: "binance_smart_chain",
     isAddress: (address: string) => Promise.resolve(isEVMAddress(address)),
   },
+  [SupportedNetworkName.Base]: {
+    changellyName: "BASE",
+    isAddress: (address: string) => Promise.resolve(isEVMAddress(address)),
+  },
   [SupportedNetworkName.Matic]: {
     changellyName: "polygon",
     isAddress: (address: string) => Promise.resolve(isEVMAddress(address)),
diff --git a/packages/swap/src/providers/jupiter/index.ts b/packages/swap/src/providers/jupiter/index.ts
index ef92eb65d..696b70c83 100644
--- a/packages/swap/src/providers/jupiter/index.ts
+++ b/packages/swap/src/providers/jupiter/index.ts
@@ -52,9 +52,9 @@ import {
   JupiterSwapResponse,
   JupiterTokenInfo,
 } from "./types";
+import { DebugLogger } from "@enkryptcom/utils";
 
-/** Enables debug logging in this file */
-const DEBUG = false;
+const logger = new DebugLogger("swap:jupiter");
 
 /**
  * # Jupiter swap flow
@@ -134,35 +134,6 @@ const JUPITER_REFERRAL_PROGRAM_PUBKEY = new PublicKey(
  */
 const JUPITER_REFERRAL_ATA_ACCOUNT_SIZE_BYTES = 165;
 
-let debug: (context: string, message: string, ...args: any[]) => void;
-if (DEBUG) {
-  debug = (context: string, message: string, ...args: any[]): void => {
-    const now = new Date();
-    const ymdhms =
-      // eslint-disable-next-line prefer-template
-      now.getFullYear().toString().padStart(4, "0") +
-      "-" +
-      (now.getMonth() + 1).toString().padStart(2, "0") +
-      "-" +
-      now.getDate().toString().padStart(2, "0") +
-      " " +
-      now.getHours().toString().padStart(2, "0") +
-      ":" +
-      now.getMinutes().toString().padStart(2, "0") +
-      ":" +
-      now.getSeconds().toString().padStart(2, "0") +
-      "." +
-      now.getMilliseconds().toString().padStart(3, "0");
-    console.info(
-      `\x1b[90m${ymdhms}\x1b[0m \x1b[32mJupiterSwapProvider.${context}\x1b[0m: ${message}`,
-      ...args,
-    );
-  };
-} else {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
-  debug = () => {};
-}
-
 // Jupiter API Tokens
 
 /**
@@ -370,9 +341,8 @@ export class Jupiter extends ProviderClass {
     const extraInstructions: TransactionInstruction[] = [];
 
     if (referrerATAExists) {
-      debug(
-        "querySwapInfo",
-        `Referrer ATA already exists. No need to record additional rent fees.` +
+      logger.info(
+        `querySwapInfo: Referrer ATA already exists. No need to record additional rent fees.` +
           ` ATA pubkey: ${referrerATAPubkey.toBase58()},` +
           ` Source mint: ${srcMint.toBase58()}`,
       );
@@ -397,9 +367,8 @@ export class Jupiter extends ProviderClass {
       extraInstructions.push(instruction);
       rentFees += extraRentFees;
 
-      debug(
-        "querySwapInfo",
-        `Referrer ATA does not exist. Updating transaction with instruction to create it.` +
+      logger.info(
+        `querySwapInfo: Referrer ATA does not exist. Updating transaction with instruction to create it.` +
           ` Referral ATA pubkey: ${referrerATAPubkey.toBase58()},` +
           ` Rent: ${extraRentFees} lamports,` +
           ` Total Rent: ${extraRentFees} lamports`,
@@ -410,9 +379,8 @@ export class Jupiter extends ProviderClass {
     const dstATAExists = await solAccountExists(this.conn, dstATAPubkey);
 
     if (dstATAExists) {
-      debug(
-        "querySwapInfo",
-        `Wallet destination mint ATA already exists. No need to record additional rent fees.` +
+      logger.info(
+        `querySwapInfo: Wallet destination mint ATA already exists. No need to record additional rent fees.` +
           ` ATA pubkey: ${dstATAPubkey.toBase58()},` +
           ` Destination mint: ${dstMint.toBase58()}`,
       );
@@ -434,9 +402,8 @@ export class Jupiter extends ProviderClass {
       rentFees += extraRentFee;
       extraInstructions.push(instruction);
 
-      debug(
-        "querySwapInfo",
-        `Wallet destination mint ATA does not exist, registering custom instruction to create it.` +
+      logger.info(
+        `querySwapInfo: Wallet destination mint ATA does not exist, registering custom instruction to create it.` +
           ` Adding ATA rent to extra transaction fees.` +
           ` ATA pubkey: ${dstATAPubkey.toBase58()},` +
           ` Destination mint: ${dstMint.toBase58()},` +
@@ -472,9 +439,8 @@ export class Jupiter extends ProviderClass {
     context?: { signal?: AbortSignal },
   ): Promise<null | ProviderQuoteResponse> {
     if (options.toToken.networkInfo.name !== SupportedNetworkName.Solana) {
-      debug(
-        "getQuote",
-        `ignoring quote request to network ${options.toToken.networkInfo.name},` +
+      logger.info(
+        `getQuote: ignoring quote request to network ${options.toToken.networkInfo.name},` +
           ` cross network swaps not supported`,
       );
       return null;
@@ -489,13 +455,11 @@ export class Jupiter extends ProviderClass {
     // 3. Transaction referral fees: fees paid to MEW (97.5%) and Jupiter (2.5%) as the wallet provider
     // 4. Rent for ATA accounts that may need to be created; the referral fee account and mint account
 
-    debug(
-      "getQuote",
-      `Quote inAmount:  ${jupiterQuote.inAmount} ${options.fromToken.symbol}`,
+    logger.info(
+      `getQuote: Quote inAmount: ${jupiterQuote.inAmount} ${options.fromToken.symbol}`,
     );
-    debug(
-      "getQuote",
-      `Quote outAmount: ${jupiterQuote.outAmount} ${options.toToken.symbol}`,
+    logger.info(
+      `getQuote: Quote outAmount: ${jupiterQuote.outAmount} ${options.toToken.symbol}`,
     );
 
     const result: ProviderQuoteResponse = {
@@ -541,13 +505,11 @@ export class Jupiter extends ProviderClass {
       thirdPartySignatures: [],
     };
 
-    debug(
-      "getSwap",
-      `Quote inAmount:  ${jupiterQuote.inAmount} ${quote.options.fromToken.symbol}`,
+    logger.info(
+      `getSwap: Quote inAmount:  ${jupiterQuote.inAmount} ${quote.options.fromToken.symbol}`,
     );
-    debug(
-      "getSwap",
-      `Quote outAmount: ${jupiterQuote.outAmount} ${quote.options.toToken.symbol}`,
+    logger.info(
+      `getSwap: Quote outAmount: ${jupiterQuote.outAmount} ${quote.options.toToken.symbol}`,
     );
 
     const result: ProviderSwapResponse = {
@@ -574,17 +536,23 @@ export class Jupiter extends ProviderClass {
   }
 
   async getStatus(options: StatusOptions): Promise<TransactionStatus> {
-    if (options.transactionHashes.length !== 1) {
+    if (options.transactions.length !== 1) {
       throw new TypeError(
-        `JupiterSwap.getStatus: Expected one transaction hash but got ${options.transactionHashes.length}`,
+        `JupiterSwap.getStatus: Expected one transaction hash but got ${options.transactions.length}`,
       );
     }
-    const [txhash] = options.transactionHashes;
-    const txResponse = await this.conn.getTransaction(txhash, {
+    const [{ sentAt, hash }] = options.transactions;
+    const txResponse = await this.conn.getTransaction(hash, {
       maxSupportedTransactionVersion: 0,
     });
 
     if (txResponse == null) {
+      // Consider dropped (/failed) if it's still null after 3 minutes
+      // (block hashes expire after 2 minutes so 3 minutes gives 1 minute of leeway)
+      if (Date.now() > sentAt + 3 * 60_000) {
+        return TransactionStatus.dropped;
+      }
+
       // Transaction hasn't been picked up by the node yet
       return TransactionStatus.pending;
     }
@@ -616,7 +584,7 @@ async function getJupiterTokens(abortable?: {
   const url = JUPITER_TOKENS_URL;
   let failed = false;
   let tokens: JupiterTokenInfo[];
-  const backoff = [0, 100, 500, 1000, 2_500, 5_000];
+  const backoff = [0, 100, 500, 1000, 2_000, 4_000];
   let backoffi = 0;
   let errRef: undefined | { err: Error };
 
@@ -637,7 +605,7 @@ async function getJupiterTokens(abortable?: {
 
     if (backoff[backoffi] > 0) {
       // Previous request failed, wait before retrying
-      debug("getJupiterTokens", `Retrying after ${backoff[backoffi]}ms...`);
+      logger.info(`getJupiterTokens: Retrying after ${backoff[backoffi]}ms...`);
       await sleep(backoff[backoffi], abortable);
     }
 
@@ -665,9 +633,8 @@ async function getJupiterTokens(abortable?: {
     signal?.addEventListener("abort", onAbort);
 
     try {
-      debug(
-        "getJupiterTokens",
-        `Initiating HTTP request for Jupiter tokens ${url}`,
+      logger.info(
+        `getJupiterTokens: Initiating HTTP request for Jupiter tokens ${url}`,
       );
       const res = await fetch(url, {
         signal: aborter.signal,
@@ -715,9 +682,8 @@ async function getJupiterTokens(abortable?: {
     } catch (err) {
       if (signal?.aborted) throw signal.reason;
       if (failed) throw err;
-      debug(
-        "getJupiterTokens",
-        `Failed to get Jupiter tokens on attempt ${backoffi + 1}/${
+      logger.info(
+        `getJupiterTokens: Failed to get Jupiter tokens on attempt ${backoffi + 1}/${
           backoff.length
         }: ${String(err)}`,
       );
@@ -795,7 +761,7 @@ async function getJupiterQuote(
 
   let failed = false;
   let quote: JupiterQuoteResponse;
-  const backoff = [0, 100, 500, 1000, 2_500, 5_000];
+  const backoff = [0, 100, 500, 1000, 2_000, 4_000];
   let backoffi = 0;
   let errRef: undefined | { err: Error };
 
@@ -813,9 +779,8 @@ async function getJupiterQuote(
 
     if (backoff[backoffi] > 0) {
       // Previous request failed, wait before retrying
-      debug(
-        "getJupiterQuote",
-        `Retrying ${url} after ${backoff[backoffi]}ms...`,
+      logger.info(
+        `getJupiterQuote: Retrying ${url} after ${backoff[backoffi]}ms...`,
       );
       await sleep(backoff[backoffi], abortable);
     }
@@ -844,9 +809,8 @@ async function getJupiterQuote(
     abortable?.signal?.addEventListener("abort", onAbort);
 
     try {
-      debug(
-        "getJupiterQuote",
-        `Initiating HTTP request for Jupiter quote ${url}`,
+      logger.info(
+        `getJupiterQuote: Initiating HTTP request for Jupiter quote ${url}`,
       );
       const res = await fetch(url, {
         signal: aborter.signal,
@@ -936,12 +900,23 @@ async function getJupiterSwap(
     feeAccount: referrerATAPubkey?.toBase58(),
     quoteResponse: quote,
     destinationTokenAccount: dstATAPubkey?.toBase58(),
+    /** @see https://station.jup.ag/api-v6/post-swap */
+    prioritizationFeeLamports: {
+      /**
+       * The automatic fee seems low and frequently causes transactions
+       * to be dropped when traffic is high
+       *
+       * This number has been arbitrary selected from manual testing @ 2024-11-21
+       * where there's been a bunch of network activity causing dropped transactions
+       */
+      autoMultiplier: 6,
+    },
   };
 
   const url = `${JUPITER_API_URL}swap`;
   let failed = false;
   let swap: JupiterSwapResponse;
-  const backoff = [0, 100, 500, 1000, 2_500, 5_000];
+  const backoff = [0, 100, 500, 1000, 2_000, 4_000];
   let backoffi = 0;
   let errRef: undefined | { err: Error };
 
@@ -959,9 +934,8 @@ async function getJupiterSwap(
 
     if (backoff[backoffi] > 0) {
       // Previous request failed, wait before retrying
-      debug(
-        "getJupiterSwap",
-        `Retrying ${url} after ${backoff[backoffi]}ms...`,
+      logger.info(
+        `getJupiterSwap: Retrying ${url} after ${backoff[backoffi]}ms...`,
       );
       await sleep(backoff[backoffi], abortable);
     }
@@ -990,9 +964,8 @@ async function getJupiterSwap(
     abortable?.signal?.addEventListener("abort", onAbort);
 
     try {
-      debug(
-        "getJupiterSwap",
-        `Initiating HTTP request for Jupiter swap ${url}`,
+      logger.info(
+        `getJupiterSwap: Initiating HTTP request for Jupiter swap ${url}`,
       );
       const res = await fetch(url, {
         signal: aborter.signal,
@@ -1045,9 +1018,8 @@ async function getJupiterSwap(
       return swap;
     } catch (err) {
       if (failed) throw err;
-      debug(
-        "getJupiterSwap",
-        `Failed to get Jupiter swap on attempt ${backoffi + 1}/${
+      logger.info(
+        `getJupiterSwap: Failed to get Jupiter swap on attempt ${backoffi + 1}/${
           backoff.length
         }: ${String(err)}`,
       );
@@ -1197,6 +1169,6 @@ function sleep(
       clearTimeout(timeout);
     }
     abortable?.signal?.addEventListener("abort", onAbortDuringSleep);
-    const timeout = setTimeout(onTimeout);
+    const timeout = setTimeout(onTimeout, duration);
   });
 }
diff --git a/packages/swap/src/providers/jupiter/types.ts b/packages/swap/src/providers/jupiter/types.ts
index c776f6c14..614ac217d 100644
--- a/packages/swap/src/providers/jupiter/types.ts
+++ b/packages/swap/src/providers/jupiter/types.ts
@@ -87,7 +87,14 @@ export type JupiterSwapParams = {
   trackingAccount?: string;
   /** Integer */
   computeUnitPriceMicroLamports?: number;
-  prioritizationFeeLamports?: number;
+  /** Integer */
+  prioritizationFeeLamports?:
+    | number
+    | "auto"
+    | {
+        /** Integer */
+        autoMultiplier: number;
+      };
   /** Default: false */
   asLegacyTransaction?: boolean;
   /** Default: false */
diff --git a/packages/swap/src/providers/oneInch/index.ts b/packages/swap/src/providers/oneInch/index.ts
index d5b931219..af3e83a79 100644
--- a/packages/swap/src/providers/oneInch/index.ts
+++ b/packages/swap/src/providers/oneInch/index.ts
@@ -295,7 +295,7 @@ class OneInch extends ProviderClass {
   }
 
   getStatus(options: StatusOptions): Promise<TransactionStatus> {
-    const promises = options.transactionHashes.map((hash) =>
+    const promises = options.transactions.map(({ hash }) =>
       this.web3eth.getTransactionReceipt(hash),
     );
     return Promise.all(promises).then((receipts) => {
diff --git a/packages/swap/src/providers/paraswap/index.ts b/packages/swap/src/providers/paraswap/index.ts
index 956b2cc19..a3ee7f010 100644
--- a/packages/swap/src/providers/paraswap/index.ts
+++ b/packages/swap/src/providers/paraswap/index.ts
@@ -350,7 +350,7 @@ class ParaSwap extends ProviderClass {
   }
 
   getStatus(options: StatusOptions): Promise<TransactionStatus> {
-    const promises = options.transactionHashes.map((hash) =>
+    const promises = options.transactions.map(({ hash }) =>
       this.web3eth.getTransactionReceipt(hash),
     );
     return Promise.all(promises).then((receipts) => {
diff --git a/packages/swap/src/providers/rango/index.ts b/packages/swap/src/providers/rango/index.ts
index adc5ea683..aaa4f5651 100644
--- a/packages/swap/src/providers/rango/index.ts
+++ b/packages/swap/src/providers/rango/index.ts
@@ -63,9 +63,9 @@ import { RangoNetworkedTransactions, RangoSwapResponse } from "./types";
 import { TOKEN_AMOUNT_INFINITY_AND_BEYOND } from "../../utils/approvals";
 import estimateEVMGasList from "../../common/estimateGasList";
 import { isEVMAddress } from "../../utils/common";
+import { DebugLogger } from "@enkryptcom/utils";
 
-/** Enables debug logging in this file */
-const DEBUG = false;
+const logger = new DebugLogger("swap:rango");
 
 /**
  * curl -sL https://raw.githubusercontent.com/enkryptcom/dynamic-data/refs/heads/main/swaplists/rango.json | jq . -C | less -R
@@ -76,33 +76,6 @@ const RANGO_LIST =
 const RANGO_PUBLIC_API_KEY = "ee7da377-0ed8-4d42-aaf9-fa978a32b18d";
 const rangoClient = new RangoClient(RANGO_PUBLIC_API_KEY);
 
-let debug: (context: string, message: string, ...args: any[]) => void;
-if (DEBUG) {
-  debug = (context: string, message: string, ...args: any[]): void => {
-    const now = new Date();
-    const ymdhms =
-      now.getFullYear().toString().padStart(4, "0") +
-      "-" +
-      (now.getMonth() + 1).toString().padStart(2, "0") +
-      "-" +
-      now.getDate().toString().padStart(2, "0") +
-      " " +
-      now.getHours().toString().padStart(2, "0") +
-      ":" +
-      now.getMinutes().toString().padStart(2, "0") +
-      ":" +
-      now.getSeconds().toString().padStart(2, "0") +
-      "." +
-      now.getMilliseconds().toString().padStart(3, "0");
-    console.info(
-      `\x1b[90m${ymdhms}\x1b[0m \x1b[32mRangoSwapProvider.${context}\x1b[0m: ${message}`,
-      ...args,
-    );
-  };
-} else {
-  debug = () => {};
-}
-
 type SupportedNetworkInfo = {
   /** Standard base10 chain ID, can be obtained from `https://chainlist.org` */
   realChainId: string;
@@ -336,7 +309,7 @@ class Rango extends ProviderClass {
   }
 
   async init(tokenList?: TokenType[]): Promise<void> {
-    debug("init", `Initialising against ${tokenList?.length} tokens...`);
+    logger.info(`init: Initialising against ${tokenList?.length} tokens...`);
 
     const [rangoMeta, swaplist] = await Promise.all([
       rangoClient.meta({
@@ -400,9 +373,8 @@ class Rango extends ProviderClass {
       tokensByBlockchainAddress: rangoTokensByBlockchainAddress,
     };
 
-    debug(
-      "init",
-      "Rango meta" +
+    logger.info(
+      "init: Rango meta" +
         `  tokens.length=${rangoMeta.tokens.length}` +
         `  blockchains.length=${rangoMeta.blockchains.length}`,
     );
@@ -410,14 +382,16 @@ class Rango extends ProviderClass {
     const supportedNetworkInfo = supportedNetworkInfoByName.get(this.network);
 
     if (!supportedNetworkInfo) {
-      debug("init", `Network not supported on Enkrypt+Rango: ${this.network}`);
+      logger.info(
+        `init: Network not supported on Enkrypt+Rango: ${this.network}`,
+      );
       return;
     }
 
     if (
       !Rango.isNetworkSupportedByRango(supportedNetworkInfo, rangoBlockchains)
     ) {
-      debug("init", `Network not supported on Rango: ${this.network}`);
+      logger.info(`init: Network not supported on Rango: ${this.network}`);
       return;
     }
 
@@ -437,7 +411,7 @@ class Rango extends ProviderClass {
       }
     }
 
-    debug("init", `Finished initialising`);
+    logger.info(`init: Finished initialising`);
   }
 
   static findRangoBlockchainForSupportedNetwork(
@@ -604,9 +578,8 @@ class Rango extends ProviderClass {
     const { blockchains } = this.rangoMeta;
     const startedAt = Date.now();
 
-    debug(
-      "getRangoSwap",
-      `Getting swap` +
+    logger.info(
+      `getRangoSwap: Getting swap` +
         `  fromNetwork=${this.network}` +
         `  toNetwork=${options.toToken.networkInfo.name}` +
         `  fromToken=${options.fromToken.symbol}` +
@@ -623,9 +596,8 @@ class Rango extends ProviderClass {
       // (note: probably redundant since we should always support rango on the source network if we got this far)
       const fromNetworkInfo = supportedNetworkInfoByName.get(this.network);
       if (!fromNetworkInfo) {
-        debug(
-          "getRangoSwap",
-          "No swap:" +
+        logger.info(
+          "getRangoSwap: No swap:" +
             ` Enkrypt does not support Rango swap on the source network` +
             `  fromNetwork=${this.network}`,
         );
@@ -637,9 +609,8 @@ class Rango extends ProviderClass {
         options.toToken.networkInfo.name as SupportedNetworkName,
       );
       if (!toNetworkInfo) {
-        debug(
-          "getRangoSwap",
-          "No swap:" +
+        logger.info(
+          "getRangoSwap: No swap:" +
             ` Enkrypt does not support Rango swap on the destination network` +
             `  fromNetwork=${this.network}`,
         );
@@ -652,9 +623,8 @@ class Rango extends ProviderClass {
         blockchains,
       );
       if (!fromRangoBlockchain?.enabled) {
-        debug(
-          "getRangoSwap",
-          `No swap:` +
+        logger.info(
+          `getRangoSwap: No swap:` +
             ` Rango does not support swap on the source network` +
             `  fromNetwork=${this.network}` +
             `  fromBlockchain=${fromRangoBlockchain.name}` +
@@ -670,9 +640,8 @@ class Rango extends ProviderClass {
         blockchains,
       );
       if (!toRangoBlockchain?.enabled) {
-        debug(
-          "getRangoSwap",
-          `No swap:` +
+        logger.info(
+          `getRangoSwap: No swap:` +
             ` Rango does not support swap on the destination network` +
             `  toNetwork=${options.toToken.networkInfo.name}` +
             `  toBlockchain=${toRangoBlockchain.name}` +
@@ -685,9 +654,8 @@ class Rango extends ProviderClass {
       // Does Rango support these tokens?
       const feeConfig = FEE_CONFIGS[this.name][meta.walletIdentifier];
 
-      debug(
-        "getRangoSwap",
-        `Rango block chains ids` +
+      logger.info(
+        `getRangoSwap: Rango block chains ids` +
           `  fromRangoBlockchain=${fromRangoBlockchainName}` +
           `  toRangoBlockchain=${toRangoBlockchainName}`,
       );
@@ -709,9 +677,8 @@ class Rango extends ProviderClass {
 
       // If we can't get symbols for the tokens then we don't support them
       if (!fromRangoTokenSymbol || !toRangoTokenSymbol) {
-        debug(
-          "getRangoSwap",
-          `No swap: No symbol for src token or dst token` +
+        logger.info(
+          `getRangoSwap: No swap: No symbol for src token or dst token` +
             `  fromTokenSymbol=${fromRangoTokenSymbol}` +
             `  toTokenSymbol=${toRangoTokenSymbol}`,
         );
@@ -748,9 +715,8 @@ class Rango extends ProviderClass {
         disableEstimate: true,
       };
 
-      debug(
-        "getRangoSwap",
-        `Requesting quote from rango sdk...` +
+      logger.info(
+        `getRangoSwap: Requesting quote from rango sdk...` +
           `  fromRangoBlockchain=${fromRangoBlockchainName}` +
           `  toRangoBlockchain=${toRangoBlockchainName}` +
           `  fromToken=${fromRangoTokenSymbol}` +
@@ -762,7 +728,7 @@ class Rango extends ProviderClass {
           `  referrerFee=${params.referrerFee}`,
       );
       const rangoSwapResponse = await rangoClient.swap(params, abortable);
-      debug("getRangoSwap", `Received quote from rango sdk`);
+      logger.info(`getRangoSwap: Received quote from rango sdk`);
 
       abortable?.signal?.throwIfAborted();
 
@@ -771,12 +737,12 @@ class Rango extends ProviderClass {
         rangoSwapResponse.resultType !== RoutingResultType.OK
       ) {
         // Rango experienced some kind of error or is unable to route the swap
-        debug("getRangoSwap", `Rango swap SDK returned an error`);
+        logger.info(`getRangoSwap: Rango swap SDK returned an error`);
         console.error("Rango swap SDK error:", rangoSwapResponse.error);
         return null;
       }
 
-      debug("getRangoSwap", `Rango swap SDK returned OK`);
+      logger.info(`getRangoSwap: Rango swap SDK returned OK`);
 
       // We have a swap transaction provided by Rango that can be executed
 
@@ -792,9 +758,8 @@ class Rango extends ProviderClass {
         }
       });
 
-      debug(
-        "getRangoSwap",
-        `Additional non-network source fees ${additionalNativeFees.toString()}`,
+      logger.info(
+        `getRangoSwap: Additional non-network source fees ${additionalNativeFees.toString()}`,
       );
 
       // Fill in gas values, add approval transactions, etc
@@ -803,7 +768,7 @@ class Rango extends ProviderClass {
       switch (rangoSwapResponse.tx?.type) {
         // Process Rango swap EVM transaction
         case RangoTransactionType.EVM: {
-          debug("getRangoSwap", `Received EVM transaction`);
+          logger.info(`getRangoSwap: Received EVM transaction`);
 
           const transactions: EVMTransaction[] = [];
           const tx = rangoSwapResponse.tx as RangoEvmTransaction;
@@ -856,16 +821,15 @@ class Rango extends ProviderClass {
         // Process Rango swap Solana transaction
         case RangoTransactionType.SOLANA: {
           const conn = this.web3 as Connection;
-          debug("getRangoSwap", "Received Solana transaction");
+          logger.info("getRangoSwap: Received Solana transaction");
 
           let enkSolTx: SolanaTransaction;
           switch (rangoSwapResponse.tx.txType) {
             case "LEGACY": {
               let legacyTx: SolanaLegacyTransaction;
               if (rangoSwapResponse.tx.serializedMessage) {
-                debug(
-                  "getRangoSwap",
-                  `Deserializing Solana legacy unsigned transaction`,
+                logger.info(
+                  `getRangoSwap: Deserializing Solana legacy unsigned transaction`,
                 );
                 // Legacy transaction, not signed (we can modify it)
                 // > When serialized message appears, there is no need for other fields and you just sign and send it
@@ -874,9 +838,8 @@ class Rango extends ProviderClass {
                   rangoSwapResponse.tx.serializedMessage,
                 );
               } else {
-                debug(
-                  "getRangoSwap",
-                  `Constructing Solana legacy signed transaction`,
+                logger.info(
+                  `getRangoSwap: Constructing Solana legacy signed transaction`,
                 );
                 // Legacy transaction signed by Rango, we cannot alter this transaction
                 // Since the recent block hash gets signed too, this transaction will need to be consumed quickly
@@ -888,15 +851,14 @@ class Rango extends ProviderClass {
                 );
               }
 
-              debug(
-                "getRangoSwap",
-                "Extracting third party Rango signatures...",
+              logger.info(
+                "getRangoSwap: Extracting third party Rango signatures...",
               );
               const thirdPartySignatures =
                 extractSignaturesFromRangoTransaction(rangoSwapResponse.tx);
 
               // Verify Rango signatures incase rango gives us invalid transaction signatures
-              debug("getRangoSwap", "Checking Rango signatures...");
+              logger.info("getRangoSwap: Checking Rango signatures...");
               const signaturesAreValid = checkSolanaLegacyTransactionSignatures(
                 legacyTx,
                 thirdPartySignatures,
@@ -930,7 +892,7 @@ class Rango extends ProviderClass {
 
               // Sometimes Rango gives us bad transactions @ 2024-09-25
               // Simulate the transaction to check if it actually works so we don't use it to quote the user
-              debug("getRangoSwap", "Simulating transaction...");
+              logger.info("getRangoSwap: Simulating transaction...");
               const statusResult =
                 await checkExpectedSolanaLegacyTransactionStatus(
                   conn,
@@ -974,9 +936,8 @@ class Rango extends ProviderClass {
             case "VERSIONED": {
               let versionedTx: VersionedTransaction;
               if (rangoSwapResponse.tx.serializedMessage) {
-                debug(
-                  "getRangoSwap",
-                  `Deserializing Solana versioned unsigned transaction`,
+                logger.info(
+                  `getRangoSwap: Deserializing Solana versioned unsigned transaction`,
                 );
                 // Versioned transaction, not signed (we can modify it)
                 // > When serialized message appears, there is no need for other fields and you just sign and send it
@@ -986,9 +947,8 @@ class Rango extends ProviderClass {
                 );
                 versionedTx = VersionedTransaction.deserialize(bytes);
               } else {
-                debug(
-                  "getRangoSwap",
-                  `Constructing Solana versioned signed transaction`,
+                logger.info(
+                  `getRangoSwap: Constructing Solana versioned signed transaction`,
                 );
                 // Versioned transaction signed by Rango, we cannot alter this transaction
                 // Since the recent block hash gets signed too, this transaction will need to be consumed quickly
@@ -1000,17 +960,15 @@ class Rango extends ProviderClass {
                 );
               }
 
-              debug(
-                "getRangoSwap",
-                "Extracting third party Rango signatures...",
+              logger.info(
+                "getRangoSwap: Extracting third party Rango signatures...",
               );
               const thirdPartySignatures =
                 extractSignaturesFromRangoTransaction(rangoSwapResponse.tx);
 
               // Verify Rango signatures incase rango gives us invalid transaction signatures
-              debug(
-                "getRangoSwap",
-                `Checking Rango signatures...` +
+              logger.info(
+                `getRangoSwap: Checking Rango signatures...` +
                   `  signatures=${thirdPartySignatures.length}`,
                 `  pubkeys=${thirdPartySignatures
                   .map(({ pubkey }) => pubkey)
@@ -1050,7 +1008,7 @@ class Rango extends ProviderClass {
 
               // Sometimes Rango gives us bad transactions @ 2024-09-25
               // Simulate the transaction to check if it actually works so we don't use it to quote the user
-              debug("getRangoSwap", "Simulating transaction...");
+              logger.info("getRangoSwap: Simulating transaction...");
               const statusResult =
                 await checkExpectedSolanaVersionedTransactionStatus(
                   conn,
@@ -1125,9 +1083,8 @@ class Rango extends ProviderClass {
         requestId: rangoSwapResponse.requestId,
       };
 
-      debug(
-        "getRangoSwap",
-        `Done  took=${(Date.now() - startedAt).toLocaleString()}ms`,
+      logger.info(
+        `getRangoSwap: Done  took=${(Date.now() - startedAt).toLocaleString()}ms`,
       );
 
       return result;
@@ -1235,30 +1192,34 @@ class Rango extends ProviderClass {
   }
 
   async getStatus(options: StatusOptions): Promise<TransactionStatus> {
-    const { requestId, transactionHashes } = options;
+    const { requestId, transactions } = options;
+
+    // TODO: If a Solana transaction hasn't been found after 3 minutes then consider dropping it
+    // I'm not sure how Rango's API handles Solana transactions being dropped...
 
-    const transactionHash =
-      transactionHashes.length > 0
-        ? transactionHashes[transactionHashes.length - 1]
-        : transactionHashes[0];
+    const mostRecentTransactionHash =
+      transactions.length > 0
+        ? transactions[transactions.length - 1].hash
+        : transactions[0].hash;
 
     const isAlreadySuccessOrFailed = [
       RangoTransactionStatus.FAILED,
       RangoTransactionStatus.SUCCESS,
     ].includes(
-      this.transactionsStatus.find((t) => t.hash === transactionHash)?.status,
+      this.transactionsStatus.find((t) => t.hash === mostRecentTransactionHash)
+        ?.status,
     );
 
     if (requestId && !isAlreadySuccessOrFailed) {
       const res = await rangoClient.status({
-        txId: transactionHash,
+        txId: mostRecentTransactionHash,
         requestId,
       });
 
       if (res.error || res.status === RangoTransactionStatus.FAILED) {
         this.transactionsStatus.push({
           status: RangoTransactionStatus.FAILED,
-          hash: transactionHash,
+          hash: mostRecentTransactionHash,
         });
         return TransactionStatus.failed;
       }
@@ -1267,7 +1228,7 @@ class Rango extends ProviderClass {
       }
       this.transactionsStatus.push({
         status: RangoTransactionStatus.SUCCESS,
-        hash: transactionHash,
+        hash: mostRecentTransactionHash,
       });
       return TransactionStatus.success;
     }
@@ -1278,7 +1239,7 @@ class Rango extends ProviderClass {
         // Get status of Solana transactions
         const sigStatuses = await (
           this.web3 as Connection
-        ).getSignatureStatuses(transactionHashes);
+        ).getSignatureStatuses(transactions.map(({ hash }) => hash));
         for (let i = 0, len = sigStatuses.value.length; i < len; i++) {
           const sigStatus = sigStatuses.value[i];
           if (sigStatus == null) {
@@ -1295,7 +1256,7 @@ class Rango extends ProviderClass {
       default: {
         // Get status of EVM transactions
         const receipts = await Promise.all(
-          transactionHashes.map((hash) =>
+          transactions.map(({ hash }) =>
             (this.web3 as Web3Eth).getTransactionReceipt(hash),
           ),
         );
@@ -1611,9 +1572,8 @@ async function checkExpectedSolanaLegacyTransactionStatus(
       // so we'll modify the block hash and retry a few times in-case (only works for unsigned
       // transactions)
       const latestBlockHash = await conn.getLatestBlockhash();
-      debug(
-        "checkExpectedSolanaLegacyTransactionStatus",
-        `Retrying Rango Solana unsigned legacy transaction simulation` +
+      logger.info(
+        `checkExpectedSolanaLegacyTransactionStatus: Retrying Rango Solana unsigned legacy transaction simulation` +
           ` with updated block hash ${latestBlockHash.blockhash}...`,
       );
       legacyTx.recentBlockhash = latestBlockHash.blockhash;
@@ -1667,9 +1627,8 @@ async function checkExpectedSolanaVersionedTransactionStatus(
       // so we'll modify the block hash and retry a few times in-case (only works for unsigned
       // transactions)
       const latestBlockHash = await conn.getLatestBlockhash();
-      debug(
-        "checkExpectedSolanaVersionedTransactionStatus",
-        `Retrying Rango Solana unsigned versioned transaction simulation` +
+      logger.info(
+        `checkExpectedSolanaVersionedTransactionStatus: Retrying Rango Solana unsigned versioned transaction simulation` +
           ` with updated block hash ${latestBlockHash.blockhash}...`,
       );
       versionedTx.message.recentBlockhash = latestBlockHash.blockhash;
diff --git a/packages/swap/src/providers/rango/supported.ts b/packages/swap/src/providers/rango/supported.ts
new file mode 100644
index 000000000..0b4f5fb10
--- /dev/null
+++ b/packages/swap/src/providers/rango/supported.ts
@@ -0,0 +1,182 @@
+import { SupportedNetworkName, } from '../../types'
+
+export type SupportedNetworkInfo = {
+  /** Standard base10 chain ID, can be obtained from `https://chainlist.org` */
+  realChainId: string;
+  /** Rango's chainId for Solana is "mainnet-beta" */
+  rangoChainId: string;
+  /** Rango blockchain name (Rango's identifier for the chain) of a network */
+  rangoBlockchain: string;
+};
+
+/**
+ * `name` is the blockchain id on Rango
+ *
+ * You can use the Rango API to get a list of tokens to figure out the Rango name of a network
+ *
+ * @see https://rango-api.readme.io/reference/meta
+ *
+ * ```sh
+ * # Rango token meta (list of all tokens with token metadata, blockchain info, etc)
+ * curl 'https://api.rango.exchange/basic/meta?apiKey=c6381a79-2817-4602-83bf-6a641a409e32' -sL -H 'Accept:application/json' | jq .
+ * # {
+ * #   "tokens": [
+ * #     {
+ * #       "blockchain": "ETH",
+ * #       "symbol": "USDT",
+ * #       "name": "USD Tether",
+ * #       "isPopular": true,
+ * #       "chainId": "1",
+ * #       "address": "0xdac17f958d2ee523a2206206994597c13d831ec7",
+ * #       "decimals": 6,
+ * #       "image": "https://rango.vip/i/r3Oex6",
+ * #       "blockchainImage": "https://raw.githubusercontent.com/rango-exchange/assets/main/blockchains/ETH/icon.svg",
+ * #       "usdPrice": 1.001,
+ * #       "supportedSwappers": [
+ * #         "Arbitrum Bridge",
+ * #         "ThorChain",
+ * # ...
+ *
+ * # Rango token count per blockchain
+ * curl 'https://api.rango.exchange/basic/meta?apiKey=c6381a79-2817-4602-83bf-6a641a409e32' -sL -H 'Accept:application/json' | jq --raw-output .tokens[].blockchain | sort | uniq -c | sort -n
+ * # count blockchain
+ * # ...
+ * #    36 MOONBEAM
+ * #    42 CELO
+ * #    48 OKC
+ * #    50 MOONRIVER
+ * #    55 AURORA
+ * #    56 LINEA
+ * #    58 ZKSYNC
+ * #    61 BLAST
+ * #   146 OSMOSIS
+ * #   147 HECO
+ * #   158 CRONOS
+ * #   301 OPTIMISM
+ * #   368 AVAX_CCHAIN
+ * #   437 BASE
+ * #   594 POLYGON
+ * #   596 ARBITRUM
+ * #   833 BSC
+ * #  1509 SOLANA
+ * #  5610 ETH
+ *
+ * # Rango token count per blockchain & chain id
+ * curl 'https://api.rango.exchange/basic/meta?apiKey=c6381a79-2817-4602-83bf-6a641a409e32' -sL -H 'Accept:application/json' | jq -r '.tokens[] | "\(.blockchain)\t\(.chainId)"' | sort | uniq -c | sort -n | sed 's/^ *\([0-9]*\) *\(.*\)/\1\t\2/' | column -s $'\t' -t
+ * # count blockchain     chain id
+ * # ...
+ * # 50    MOONRIVER      1285
+ * # 55    AURORA         1313161554
+ * # 56    LINEA          59144
+ * # 58    ZKSYNC         324
+ * # 61    BLAST          81457
+ * # 146   OSMOSIS        osmosis-1
+ * # 147   HECO           128
+ * # 158   CRONOS         25
+ * # 301   OPTIMISM       10
+ * # 368   AVAX_CCHAIN    43114
+ * # 437   BASE           8453
+ * # 594   POLYGON        137
+ * # 596   ARBITRUM       42161
+ * # 833   BSC            56
+ * # 1509  SOLANA         mainnet-beta
+ * # 5610  ETH            1
+ * ```
+ */
+const supportedNetworks: Readonly<{
+  [key in SupportedNetworkName]?: SupportedNetworkInfo;
+}> = {
+  [SupportedNetworkName.Ethereum]: {
+    realChainId: "1",
+    rangoChainId: "1",
+    rangoBlockchain: "ETH",
+  },
+  [SupportedNetworkName.Binance]: {
+    realChainId: "56",
+    rangoChainId: "56",
+    rangoBlockchain: "BSC",
+  },
+  [SupportedNetworkName.Base]: {
+    realChainId: "8453",
+    rangoChainId: "8453",
+    rangoBlockchain: "BASE",
+  },
+  [SupportedNetworkName.Matic]: {
+    realChainId: "137",
+    rangoChainId: "137",
+    rangoBlockchain: "POLYGON",
+  },
+  [SupportedNetworkName.Optimism]: {
+    realChainId: "10",
+    rangoChainId: "10",
+    rangoBlockchain: "OPTIMISM",
+  },
+  [SupportedNetworkName.Avalanche]: {
+    realChainId: "43114",
+    rangoChainId: "43114",
+    rangoBlockchain: "AVAX_CCHAIN",
+  },
+  [SupportedNetworkName.Fantom]: {
+    realChainId: "250",
+    rangoChainId: "250",
+    rangoBlockchain: "FANTOM",
+  },
+  [SupportedNetworkName.Aurora]: {
+    realChainId: "1313161554",
+    rangoChainId: "1313161554",
+    rangoBlockchain: "AURORA",
+  },
+  [SupportedNetworkName.Gnosis]: {
+    realChainId: "100",
+    rangoChainId: "100",
+    rangoBlockchain: "GNOSIS",
+  },
+  [SupportedNetworkName.Arbitrum]: {
+    realChainId: "42161",
+    rangoChainId: "42161",
+    rangoBlockchain: "ARBITRUM",
+  },
+  [SupportedNetworkName.Moonbeam]: {
+    realChainId: "1284",
+    rangoChainId: "1284",
+    rangoBlockchain: "MOONBEAM",
+  },
+  [SupportedNetworkName.Solana]: {
+    realChainId: "900",
+    rangoChainId: "mainnet-beta",
+    rangoBlockchain: "SOLANA",
+  },
+  [SupportedNetworkName.Blast]: {
+    realChainId: "81457",
+    rangoChainId: "81457",
+    rangoBlockchain: "BLAST",
+  },
+  [SupportedNetworkName.Telos]: {
+    realChainId: "40",
+    rangoChainId: "40",
+    rangoBlockchain: "TELOS",
+  },
+};
+
+// Freeze because we index below so modifications would make the indexes stale
+Object.freeze(supportedNetworks);
+
+/** Enkrypt supported network name -> network info */
+export const supportedNetworkInfoByName = new Map(
+  Object.entries(supportedNetworks),
+) as unknown as Map<SupportedNetworkName, SupportedNetworkInfo>;
+
+/** Rango blockchain name -> network info & enkrypt network name */
+export const supportedNetworkByRangoBlockchain = new Map<
+  string,
+  { info: SupportedNetworkInfo; name: SupportedNetworkName }
+>(
+  Object.entries(supportedNetworks).map(([supportedNetwork, networkInfo]) => [
+    networkInfo.rangoBlockchain,
+    {
+      info: networkInfo,
+      name: supportedNetwork as unknown as SupportedNetworkName,
+    },
+  ]),
+);
+
diff --git a/packages/swap/src/providers/zerox/index.ts b/packages/swap/src/providers/zerox/index.ts
index 552243e8a..bc2edfeac 100644
--- a/packages/swap/src/providers/zerox/index.ts
+++ b/packages/swap/src/providers/zerox/index.ts
@@ -272,7 +272,7 @@ class ZeroX extends ProviderClass {
   }
 
   getStatus(options: StatusOptions): Promise<TransactionStatus> {
-    const promises = options.transactionHashes.map((hash) =>
+    const promises = options.transactions.map(({ hash }) =>
       this.web3eth.getTransactionReceipt(hash),
     );
     return Promise.all(promises).then((receipts) => {
diff --git a/packages/swap/src/types/index.ts b/packages/swap/src/types/index.ts
index 48dc702a7..6d9443dd3 100644
--- a/packages/swap/src/types/index.ts
+++ b/packages/swap/src/types/index.ts
@@ -135,6 +135,7 @@ export enum TransactionStatus {
   pending = "pending",
   failed = "failed",
   success = "success",
+  dropped = "dropped",
 }
 
 export interface getQuoteOptions {
@@ -220,9 +221,17 @@ export interface ProviderQuoteResponse {
   quote: SwapQuote;
   minMax: MinMaxResponse;
 }
+
+export type StatusOptionTransaction = {
+  /** Transaction hash */
+  hash: string;
+  /** Unix epoch milliseconds `Date.now()` */
+  sentAt: number;
+};
+
 export interface StatusOptions {
   [key: string]: any;
-  transactionHashes: string[];
+  transactions: StatusOptionTransaction[];
 }
 
 export interface StatusOptionsResponse {
diff --git a/packages/swap/src/utils/solana.ts b/packages/swap/src/utils/solana.ts
index e0e43aa3f..863d22671 100644
--- a/packages/swap/src/utils/solana.ts
+++ b/packages/swap/src/utils/solana.ts
@@ -118,6 +118,58 @@ export function extractComputeBudget(
   );
 }
 
+/**
+ * @see https://solana.com/docs/core/fees#prioritization-fees
+ */
+export function extractComputeUnitPriceMicroLamports(
+  tx: VersionedTransaction,
+): undefined | number | bigint {
+  /** Compute unit price */
+  let computeUnitPriceMicroLamports: undefined | number | bigint;
+
+  // eslint-disable-next-line no-restricted-syntax, no-labels
+  instructionLoop: for (
+    let i = 0, len = tx.message.compiledInstructions.length;
+    i < len;
+    i++
+  ) {
+    const instr = tx.message.compiledInstructions[i];
+    const program = tx.message.staticAccountKeys[instr.programIdIndex];
+    if (!ComputeBudgetProgram.programId.equals(program)) continue;
+
+    const keys = instr.accountKeyIndexes.map(
+      (accountKeyIndex): AccountMeta => ({
+        pubkey: tx.message.staticAccountKeys[accountKeyIndex],
+        isSigner: tx.message.isAccountSigner(accountKeyIndex),
+        isWritable: tx.message.isAccountWritable(accountKeyIndex),
+      }),
+    );
+
+    // Decompile the instruction
+    const instruction = new TransactionInstruction({
+      keys,
+      programId: program,
+      data: Buffer.from(instr.data),
+    });
+
+    const type = ComputeBudgetInstruction.decodeInstructionType(instruction);
+    switch (type) {
+      case "SetComputeUnitPrice": {
+        // Compute limit
+        const command =
+          ComputeBudgetInstruction.decodeSetComputeUnitPrice(instruction);
+        computeUnitPriceMicroLamports = command.microLamports;
+        // eslint-disable-next-line no-labels
+        break instructionLoop;
+      }
+      default: /** noop */
+        break;
+    }
+  }
+
+  return computeUnitPriceMicroLamports;
+}
+
 /**
  * Insert new instructions at the start of a transaction, after compute budget and compute limit instructions
  */
diff --git a/packages/swap/tests/changelly.test.ts b/packages/swap/tests/changelly.test.ts
index 474325017..3f9708c42 100644
--- a/packages/swap/tests/changelly.test.ts
+++ b/packages/swap/tests/changelly.test.ts
@@ -51,7 +51,9 @@ describe("Changelly Provider", () => {
       (swap?.transactions[0] as EVMTransaction).data.startsWith("0xa9059cbb"),
     ).to.be.eq(true);
     const status = await changelly.getStatus(
-      (await swap!.getStatusObject({ transactionHashes: [] })).options,
+      (
+        await swap!.getStatusObject({ transactions: [] })
+      ).options,
     );
     expect(status).to.be.eq("pending");
   });
diff --git a/packages/utils/src/debug-logger.ts b/packages/utils/src/debug-logger.ts
new file mode 100644
index 000000000..b8b846a0d
--- /dev/null
+++ b/packages/utils/src/debug-logger.ts
@@ -0,0 +1,393 @@
+// Tiny, configurable debug logging
+
+function ymdhms(timestamp: Date) {
+  return (
+    timestamp.getFullYear().toString().padStart(4, "0") +
+    ":" +
+    (timestamp.getMonth() + 1).toString().padStart(2, "0") +
+    ":" +
+    timestamp.getDate().toString().padStart(2, "0") +
+    " " +
+    timestamp.getHours().toString().padStart(2, "0") +
+    ":" +
+    timestamp.getMinutes().toString().padStart(2, "0") +
+    ":" +
+    timestamp.getSeconds().toString().padStart(2, "0") +
+    "." +
+    timestamp.getMilliseconds().toString().padStart(3, "0")
+  );
+}
+
+const LogLevel = {
+  DISABLED: -1,
+  SILENT: 0,
+  TRACE: 1,
+  DEBUG: 2,
+  INFO: 3,
+  WARN: 4,
+  ERROR: 5,
+} as const;
+
+function levelToNumber(level: string | number): number {
+  if (typeof level === "number") return level;
+  switch (level?.toLowerCase()) {
+    case "trace":
+      return LogLevel.TRACE;
+    case "debug":
+      return LogLevel.DEBUG;
+    case "info":
+      return LogLevel.INFO;
+    case "warn":
+      return LogLevel.WARN;
+    case "error":
+      return LogLevel.ERROR;
+  }
+  return LogLevel.INFO;
+}
+
+type WildcardSearchConfig = {
+  prefix: string;
+  forceAllow: boolean;
+  forceDisallow: boolean;
+  level?: number;
+};
+
+type ExactSearchConfig = {
+  forceAllow: boolean;
+  forceDisallow: boolean;
+  level?: number;
+};
+
+type ParsedConfig = {
+  defaultLevel: number;
+  defaultAllow: boolean;
+  wildcards: WildcardSearchConfig[];
+  exacts: Map<string, ExactSearchConfig>;
+};
+
+function parseConfig(string: string): ParsedConfig {
+  const wildcards = new Map<string, WildcardSearchConfig>();
+  const exacts = new Map<string, ExactSearchConfig>();
+
+  let defaultAllow = false;
+  let defaultLevel = "info";
+  const lines = string
+    .replaceAll("\n", "")
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  const lineCount = lines.length;
+
+  for (let linei = 0; linei < lineCount; linei++) {
+    const line = lines[linei].trim();
+    if (line === "*") {
+      defaultAllow = true;
+    } else if (/^\([a-zA-Z]\)$/i.test(line)) {
+      defaultLevel = line.slice(1, -1).trim().toLowerCase() || defaultLevel;
+    } else {
+      let lineWithoutLevel: string;
+      const levelmatch = line.match(/\([a-zA-Z]+\)/i);
+      let level: undefined | string;
+      if (levelmatch) {
+        const levelRaw = levelmatch[0];
+        const leveli = line.indexOf(levelRaw);
+        lineWithoutLevel = (
+          line.slice(0, leveli) + line.slice(leveli + levelRaw.length)
+        ).trim();
+        level = levelRaw.slice(1, -1).trim().toLowerCase() || undefined;
+      } else {
+        lineWithoutLevel = defaultLevel;
+      }
+
+      let prefixi = 0;
+      let forceDisallow = false;
+      let forceAllow = false;
+      if (lineWithoutLevel.startsWith("-")) {
+        forceDisallow = true;
+        prefixi = 1;
+      }
+      if (lineWithoutLevel.startsWith("+")) {
+        forceAllow = true;
+        prefixi = 1;
+      }
+
+      const lineWithoutPrefix = line.slice(prefixi).trim();
+
+      const wildcardi = lineWithoutPrefix.indexOf("*");
+      let lineWithoutWildcard: string;
+      if (wildcardi === -1) {
+        lineWithoutWildcard = lineWithoutPrefix;
+      } else {
+        lineWithoutWildcard = lineWithoutPrefix.slice(0, wildcardi);
+      }
+
+      if (wildcardi === -1) {
+        exacts.set(lineWithoutWildcard, {
+          forceAllow,
+          forceDisallow,
+          level: levelToNumber(level),
+        });
+      } else {
+        wildcards.set(lineWithoutWildcard, {
+          prefix: lineWithoutWildcard,
+          forceAllow,
+          forceDisallow,
+          level: levelToNumber(level),
+        });
+      }
+    }
+  }
+
+  return {
+    defaultAllow: defaultAllow,
+    wildcards: Array.from(wildcards.values()),
+    exacts,
+    defaultLevel: levelToNumber(defaultLevel),
+  };
+}
+
+const defaultParsedConfig: ParsedConfig = {
+  defaultLevel: LogLevel.INFO,
+  defaultAllow: false,
+  wildcards: [],
+  exacts: new Map(),
+};
+
+function getDebugConfigString(): undefined | string {
+  // Load from global
+  if (typeof globalThis !== "undefined") {
+    const confString = globalThis?.__ENKRYPT_DEBUG_LOG_CONF__;
+    if (typeof confString === "string") return confString;
+  }
+  return undefined;
+}
+
+class DebugLogEnabler {
+  _cache: Map<string, number>;
+  _config: Readonly<ParsedConfig>;
+
+  constructor() {
+    this._cache = new Map();
+    this._config = parseConfig(getDebugConfigString() ?? "");
+  }
+
+  clear() {
+    this._cache.clear();
+    this._cache = new Map();
+    this._config = defaultParsedConfig;
+  }
+
+  refresh() {
+    this._cache.clear();
+    this._config = parseConfig(getDebugConfigString() ?? "");
+  }
+
+  level(name: string): number {
+    const cached = this._cache.get(name);
+    if (cached !== undefined) return cached;
+    const exact = this._config.exacts.get(name);
+    if (exact) {
+      let level: number;
+      if (exact.forceAllow) level = exact.level ?? this._config.defaultLevel;
+      else if (exact.forceDisallow) level = LogLevel.DISABLED;
+      else level = this._config.defaultLevel;
+      this._cache.set(name, level);
+      return level;
+    }
+    for (const wildcard of this._config.wildcards) {
+      if (name.startsWith(wildcard.prefix)) {
+        let level: number;
+        if (wildcard.forceAllow)
+          level = wildcard.level ?? this._config.defaultLevel;
+        else if (wildcard.forceDisallow) level = LogLevel.DISABLED;
+        else level = this._config.defaultLevel;
+        this._cache.set(name, level);
+        return level;
+      }
+    }
+    let level: number;
+    if (this._config.defaultAllow) level = this._config.defaultLevel;
+    else level = LogLevel.DISABLED;
+    this._cache.set(name, level);
+    return level;
+  }
+}
+
+// Initialise this before creating a DebugLogEnabler instance
+let currentConfString = globalThis.__ENKRYPT_DEBUG_LOG_CONF__;
+Object.defineProperty(globalThis, "__ENKRYPT_DEBUG_LOG_CONF__", {
+  get() {
+    return currentConfString;
+  },
+  set(value) {
+    currentConfString = value;
+    (globalThis.__ENKRYPT_DEBUG_LOG_ENABLER__ as DebugLogEnabler)?.refresh?.();
+  },
+});
+
+// Parses the debug logger configuration string, provides
+// log levels and caches results
+globalThis.__ENKRYPT_DEBUG_LOG_ENABLER__ = new DebugLogEnabler();
+globalThis.__ENKRYPT_DEBUG_LOG_ENABLER__.refresh();
+
+function getEnabler(): DebugLogEnabler {
+  return globalThis.__ENKRYPT_DEBUG_LOG_ENABLER__;
+}
+
+/**
+ * Configurable debug logging
+ *
+ * ## Usage
+ *
+ * Envfile:
+ * ```.env
+ * VITE_DEBUG_LOG= # Log nothing
+ * VITE_DEBUG_LOG='*'                                 # Log everything
+ * VITE_DEBUG_LOG='swap:jupiter'                      # Log only contexts name "swap:jupiter"
+ * VITE_DEBUG_LOG='swap:*'                            # Log contexts starting with "swap:*"
+ * VITE_DEBUG_LOG='(warn)'                            # Set the log level to trace
+ * VITE_DEBUG_LOG='(warn),swap:jupiter(trace)'        # Set the log level to warn but jupiter contexts to trace
+ * VITE_DEBUG_LOG='(warn),swap:jupiter(trace),swap:*'
+ * VITE_DEBUG_LOG='-swap:jupiter,swap:*'              # Log swap: context's except jupiter
+ * ```
+ *
+ * TypeScript files:
+ * ```ts
+ * // jupiter/index.ts
+ * import { DebugLogger } from '@enkryptcom/utils'
+ * cosnt logger = new DebugLogger('swap:jupiter')
+ *
+ * // Logging at different levels
+ * logger.silent('Hello!') // (Always dropped)
+ * logger.trace('Hello!')  // 2024-11-25T04:22:16Z [swap:jupiter] TRACE: Hello!
+ * logger.trace('Hello!')  // 2024-11-25T04:22:16Z [swap:jupiter] DEBUG: Hello!
+ * logger.info('Hello!')   // 2024-11-25T04:22:16Z [swap:jupiter] INFO: Hello!
+ * logger.warn('Hello!')   // 2024-11-25T04:22:16Z [swap:jupiter] WARN: Hello!
+ * logger.error('Hello!')  // 2024-11-25T04:22:16Z [swap:jupiter] ERROR: Hello!
+ *
+ * // Execute heavy conditional logic only when logging is enabled
+ * if (logger.enabled()) {
+ *   logger.info('Hi!', heavyCalculation())
+ * }
+ * ```
+ *
+ * Browser developer console:
+ * ```
+ * // Configure logging
+ * __ENKRYPT_DEBUG_LOG_CONF__ = 'swap:jupiter'
+ * __ENKRYPT_DEBUG_LOG_CONF__ = 'swap:*'
+ * // ...etc. Same as envfiles
+ * ```
+ */
+export class DebugLogger {
+  _name: string;
+  _color: boolean;
+  _level?: number;
+
+  constructor(name: string, opts?: { level?: string | number }) {
+    this._name = name;
+    this._color = true;
+    this._level =
+      typeof opts?.level === "string" ? levelToNumber(opts.level) : opts?.level;
+  }
+
+  enabled(): boolean {
+    return this.level() > LogLevel.DISABLED;
+  }
+
+  level(): number {
+    if (this._level !== undefined) return this._level;
+    return getEnabler().level(this._name);
+  }
+
+  _formatHeader(levelNumber: number): string {
+    const timestamp = new Date();
+    let timestampStr = ymdhms(timestamp);
+    if (this._color) timestampStr = `\x1b[90m${timestampStr}\x1b[0m`;
+
+    let levelStr: string;
+    switch (levelNumber) {
+      case LogLevel.DISABLED:
+        levelStr = "DISABLED";
+        if (this._color) levelStr = `\x1b[90m${levelStr}\x1b[0m`;
+        break;
+      case LogLevel.SILENT:
+        levelStr = "SILENT";
+        if (this._color) levelStr = `\x1b[90m${levelStr}\x1b[0m`;
+        break;
+      case LogLevel.TRACE:
+        levelStr = "TRACE";
+        if (this._color) levelStr = `\x1b[90m${levelStr}\x1b[0m`;
+        break;
+      case LogLevel.DEBUG:
+        levelStr = "DEBUG";
+        if (this._color) levelStr = `\x1b[36m${levelStr}\x1b[0m`;
+        break;
+      case LogLevel.INFO:
+        levelStr = "INFO";
+        if (this._color) levelStr = `\x1b[32m${levelStr}\x1b[0m`;
+        break;
+      case LogLevel.WARN:
+        levelStr = "WARN";
+        if (this._color) levelStr = `\x1b[33m${levelStr}\x1b[0m`;
+        break;
+      case LogLevel.ERROR:
+        levelStr = "ERROR";
+        if (this._color) levelStr = `\x1b[31m${levelStr}\x1b[0m`;
+        break;
+      default:
+        levelStr = "UNKNOWN";
+        if (this._color) levelStr = `\x1b[35m${levelStr}\x1b[0m`;
+    }
+
+    let msgHeader = `${timestampStr}`;
+
+    let contextStr = "";
+    if (this._name) {
+      let nameStr = this._name;
+      if (this._color && nameStr) nameStr = `\x1b[90m${nameStr}\x1b[0m`;
+      contextStr += nameStr;
+    }
+    if (contextStr) {
+      msgHeader += ` [${contextStr}]`;
+    }
+
+    msgHeader += ` ${levelStr}:`;
+
+    return msgHeader;
+  }
+
+  silent(..._args: any[]): void {
+    // Drop
+  }
+
+  trace(...args: any[]): void {
+    const level = this.level();
+    if (level < LogLevel.TRACE) return;
+    console.debug(this._formatHeader(LogLevel.TRACE), ...args);
+  }
+
+  debug(...args: any[]): void {
+    const level = this.level();
+    if (level < LogLevel.DEBUG) return;
+    console.debug(this._formatHeader(LogLevel.DEBUG), ...args);
+  }
+
+  info(...args: any[]): void {
+    const level = this.level();
+    if (level < LogLevel.INFO) return;
+    console.info(this._formatHeader(LogLevel.INFO), ...args);
+  }
+
+  warn(...args: any[]): void {
+    const level = this.level();
+    if (level < LogLevel.WARN) return;
+    console.warn(this._formatHeader(LogLevel.WARN), ...args);
+  }
+
+  error(...args: any[]): void {
+    const level = this.level();
+    if (level < LogLevel.ERROR) return;
+    console.error(this._formatHeader(LogLevel.ERROR), ...args);
+  }
+}
diff --git a/packages/utils/src/index.ts b/packages/utils/src/index.ts
index e1cfb5e68..0a68c2efd 100644
--- a/packages/utils/src/index.ts
+++ b/packages/utils/src/index.ts
@@ -10,6 +10,7 @@ import { encodeAddress as polkadotEncodeAddress } from "@polkadot/util-crypto";
 import { encrypt, decrypt } from "./encrypt";
 import MemoryStorage from "./memory-storage";
 import { fromBase, toBase, isValidDecimals } from "./units";
+import { DebugLogger } from "./debug-logger";
 
 const bufferToHex = (buf: Buffer | Uint8Array, nozerox = false): string =>
   nozerox
@@ -40,4 +41,5 @@ export {
   fromBase,
   toBase,
   isValidDecimals,
+  DebugLogger,
 };