diff --git a/core/src/main/java/bisq/core/btc/wallet/BsqWalletService.java b/core/src/main/java/bisq/core/btc/wallet/BsqWalletService.java
index b8ccad5aba0..aec48649658 100644
--- a/core/src/main/java/bisq/core/btc/wallet/BsqWalletService.java
+++ b/core/src/main/java/bisq/core/btc/wallet/BsqWalletService.java
@@ -82,11 +82,13 @@
 @Slf4j
 public class BsqWalletService extends WalletService implements DaoStateListener {
 
+
     public interface WalletTransactionsChangeListener {
 
         void onWalletTransactionsChange();
     }
 
+    private final DaoKillSwitch daoKillSwitch;
     private final BsqCoinSelector bsqCoinSelector;
     private final NonBsqCoinSelector nonBsqCoinSelector;
     private final DaoStateService daoStateService;
@@ -124,7 +126,8 @@ public BsqWalletService(WalletsSetup walletsSetup,
                             DaoStateService daoStateService,
                             UnconfirmedBsqChangeOutputListService unconfirmedBsqChangeOutputListService,
                             Preferences preferences,
-                            FeeService feeService) {
+                            FeeService feeService,
+                            DaoKillSwitch daoKillSwitch) {
         super(walletsSetup,
                 preferences,
                 feeService);
@@ -133,73 +136,75 @@ public BsqWalletService(WalletsSetup walletsSetup,
         this.nonBsqCoinSelector = nonBsqCoinSelector;
         this.daoStateService = daoStateService;
         this.unconfirmedBsqChangeOutputListService = unconfirmedBsqChangeOutputListService;
+        this.daoKillSwitch = daoKillSwitch;
 
-        walletsSetup.addSetupCompletedHandler(() -> {
-            wallet = walletsSetup.getBsqWallet();
-            if (wallet != null) {
-                wallet.setCoinSelector(bsqCoinSelector);
-                wallet.addEventListener(walletEventListener);
+        walletsSetup.addSetupCompletedHandler(this::setupComplete);
 
-                //noinspection deprecation
-                wallet.addEventListener(new AbstractWalletEventListener() {
-                    @Override
-                    public void onCoinsReceived(Wallet wallet, Transaction tx, Coin prevBalance, Coin newBalance) {
-                        updateBsqWalletTransactions();
-                    }
+        daoStateService.addDaoStateListener(this);
+    }
 
-                    @Override
-                    public void onCoinsSent(Wallet wallet, Transaction tx, Coin prevBalance, Coin newBalance) {
-                        updateBsqWalletTransactions();
-                    }
+    void setupComplete() {
+        wallet = walletsSetup.getBsqWallet();
+        if (wallet != null) {
+            wallet.setCoinSelector(bsqCoinSelector);
+            wallet.addEventListener(walletEventListener);
 
-                    @Override
-                    public void onReorganize(Wallet wallet) {
-                        log.warn("onReorganize ");
-                        updateBsqWalletTransactions();
-                        unconfirmedBsqChangeOutputListService.onReorganize();
-                    }
+            //noinspection deprecation
+            wallet.addEventListener(new AbstractWalletEventListener() {
+                @Override
+                public void onCoinsReceived(Wallet wallet, Transaction tx, Coin prevBalance, Coin newBalance) {
+                    updateBsqWalletTransactions();
+                }
 
-                    @Override
-                    public void onTransactionConfidenceChanged(Wallet wallet, Transaction tx) {
-                        // We are only interested in updates from unconfirmed txs and confirmed txs at the
-                        // time when it gets into a block. Otherwise we would get called
-                        // updateBsqWalletTransactions for each tx as the block depth changes for all.
-                        if (tx.getConfidence().getDepthInBlocks() <= 1 &&
-                                daoStateService.isParseBlockChainComplete()) {
-                            updateBsqWalletTransactions();
-                        }
-                        unconfirmedBsqChangeOutputListService.onTransactionConfidenceChanged(tx);
-                    }
+                @Override
+                public void onCoinsSent(Wallet wallet, Transaction tx, Coin prevBalance, Coin newBalance) {
+                    updateBsqWalletTransactions();
+                }
 
-                    @Override
-                    public void onKeysAdded(List<ECKey> keys) {
-                        updateBsqWalletTransactions();
-                    }
+                @Override
+                public void onReorganize(Wallet wallet) {
+                    log.warn("onReorganize ");
+                    updateBsqWalletTransactions();
+                    unconfirmedBsqChangeOutputListService.onReorganize();
+                }
 
-                    @Override
-                    public void onScriptsChanged(Wallet wallet, List<Script> scripts, boolean isAddingScripts) {
+                @Override
+                public void onTransactionConfidenceChanged(Wallet wallet, Transaction tx) {
+                    // We are only interested in updates from unconfirmed txs and confirmed txs at the
+                    // time when it gets into a block. Otherwise we would get called
+                    // updateBsqWalletTransactions for each tx as the block depth changes for all.
+                    if (tx.getConfidence().getDepthInBlocks() <= 1 &&
+                            daoStateService.isParseBlockChainComplete()) {
                         updateBsqWalletTransactions();
                     }
+                    unconfirmedBsqChangeOutputListService.onTransactionConfidenceChanged(tx);
+                }
 
-                    @Override
-                    public void onWalletChanged(Wallet wallet) {
-                        updateBsqWalletTransactions();
-                    }
+                @Override
+                public void onKeysAdded(List<ECKey> keys) {
+                    updateBsqWalletTransactions();
+                }
 
-                });
-            }
+                @Override
+                public void onScriptsChanged(Wallet wallet, List<Script> scripts, boolean isAddingScripts) {
+                    updateBsqWalletTransactions();
+                }
 
-            BlockChain chain = walletsSetup.getChain();
-            if (chain != null) {
-                chain.addNewBestBlockListener(block -> chainHeightProperty.set(block.getHeight()));
-                chainHeightProperty.set(chain.getBestChainHeight());
-            }
-        });
+                @Override
+                public void onWalletChanged(Wallet wallet) {
+                    updateBsqWalletTransactions();
+                }
 
-        daoStateService.addDaoStateListener(this);
-    }
+            });
+        }
 
+        BlockChain chain = walletsSetup.getChain();
+        if (chain != null) {
+            chain.addNewBestBlockListener(block -> chainHeightProperty.set(block.getHeight()));
+            chainHeightProperty.set(chain.getBestChainHeight());
+        }
 
+    }
     ///////////////////////////////////////////////////////////////////////////////////////////
     // DaoStateListener
     ///////////////////////////////////////////////////////////////////////////////////////////
@@ -528,7 +533,7 @@ public Transaction getPreparedSendBtcTx(String receiverAddress, Coin receiverAmo
 
     private Transaction getPreparedSendTx(String receiverAddress, Coin receiverAmount, CoinSelector coinSelector)
             throws AddressFormatException, InsufficientBsqException, WalletException, TransactionVerificationException, BsqChangeBelowDustException {
-        DaoKillSwitch.assertDaoIsNotDisabled();
+        daoKillSwitch.assertDaoIsNotDisabled();
         Transaction tx = new Transaction(params);
         checkArgument(Restrictions.isAboveDust(receiverAmount),
                 "The amount is too low (dust limit).");
@@ -583,7 +588,7 @@ public Transaction getPreparedBurnFeeTx(Coin fee) throws InsufficientBsqExceptio
     }
 
     private Transaction getPreparedBurnFeeTx(Coin fee, boolean requireChangeOutput) throws InsufficientBsqException {
-        DaoKillSwitch.assertDaoIsNotDisabled();
+        daoKillSwitch.assertDaoIsNotDisabled();
         final Transaction tx = new Transaction(params);
         addInputsAndChangeOutputForTx(tx, fee, bsqCoinSelector, requireChangeOutput);
         // printTx("getPreparedFeeTx", tx);
@@ -635,7 +640,7 @@ private void addInputsAndChangeOutputForTx(Transaction tx,
     // We create a tx with Bsq inputs for the fee, one output for the stake and optional one BSQ change output.
     // As the fee amount will be missing in the output those BSQ fees are burned.
     public Transaction getPreparedBlindVoteTx(Coin fee, Coin stake) throws InsufficientBsqException {
-        DaoKillSwitch.assertDaoIsNotDisabled();
+        daoKillSwitch.assertDaoIsNotDisabled();
         Transaction tx = new Transaction(params);
         tx.addOutput(new TransactionOutput(params, tx, stake, getUnusedAddress()));
         addInputsAndChangeOutputForTx(tx, fee.add(stake), bsqCoinSelector, false);
@@ -649,7 +654,7 @@ public Transaction getPreparedBlindVoteTx(Coin fee, Coin stake) throws Insuffici
     ///////////////////////////////////////////////////////////////////////////////////////////
 
     public Transaction getPreparedVoteRevealTx(TxOutput stakeTxOutput) {
-        DaoKillSwitch.assertDaoIsNotDisabled();
+        daoKillSwitch.assertDaoIsNotDisabled();
         Transaction tx = new Transaction(params);
         final Coin stake = Coin.valueOf(stakeTxOutput.getValue());
         Transaction blindVoteTx = getTransaction(stakeTxOutput.getTxId());
@@ -668,7 +673,7 @@ public Transaction getPreparedVoteRevealTx(TxOutput stakeTxOutput) {
     ///////////////////////////////////////////////////////////////////////////////////////////
 
     public Transaction getPreparedLockupTx(Coin lockupAmount) throws AddressFormatException, InsufficientBsqException {
-        DaoKillSwitch.assertDaoIsNotDisabled();
+        daoKillSwitch.assertDaoIsNotDisabled();
         Transaction tx = new Transaction(params);
         checkArgument(Restrictions.isAboveDust(lockupAmount), "The amount is too low (dust limit).");
         tx.addOutput(new TransactionOutput(params, tx, lockupAmount, getUnusedAddress()));
@@ -682,7 +687,7 @@ public Transaction getPreparedLockupTx(Coin lockupAmount) throws AddressFormatEx
     ///////////////////////////////////////////////////////////////////////////////////////////
 
     public Transaction getPreparedUnlockTx(TxOutput lockupTxOutput) throws AddressFormatException {
-        DaoKillSwitch.assertDaoIsNotDisabled();
+        daoKillSwitch.assertDaoIsNotDisabled();
         Transaction tx = new Transaction(params);
         // Unlocking means spending the full value of the locked txOutput to another txOutput with the same value
         Coin amountToUnlock = Coin.valueOf(lockupTxOutput.getValue());
diff --git a/core/src/main/java/bisq/core/dao/DaoKillSwitch.java b/core/src/main/java/bisq/core/dao/DaoKillSwitch.java
index af72fb3dea6..2dbf54c53cb 100644
--- a/core/src/main/java/bisq/core/dao/DaoKillSwitch.java
+++ b/core/src/main/java/bisq/core/dao/DaoKillSwitch.java
@@ -32,7 +32,6 @@
 
 @Slf4j
 public class DaoKillSwitch implements DaoSetupService {
-    private static DaoKillSwitch INSTANCE;
     private final FilterManager filterManager;
 
     @Getter
@@ -41,8 +40,6 @@ public class DaoKillSwitch implements DaoSetupService {
     @Inject
     public DaoKillSwitch(FilterManager filterManager) {
         this.filterManager = filterManager;
-
-        DaoKillSwitch.INSTANCE = this;
     }
 
     @Override
@@ -70,8 +67,8 @@ private void applyFilter(@Nullable Filter filter) {
         daoDisabled = requireUpdateToNewVersion || filter.isDisableDao();
     }
 
-    public static void assertDaoIsNotDisabled() {
-        if (INSTANCE.isDaoDisabled()) {
+    public void assertDaoIsNotDisabled() {
+        if (isDaoDisabled()) {
             throw new DaoDisabledException("The DAO features have been disabled by the Bisq developers. " +
                     "Please check out the Bisq Forum for further information.");
         }
diff --git a/core/src/main/java/bisq/core/util/BsqFormatter.java b/core/src/main/java/bisq/core/util/BsqFormatter.java
index a1eb0debc4e..e64ef383495 100644
--- a/core/src/main/java/bisq/core/util/BsqFormatter.java
+++ b/core/src/main/java/bisq/core/util/BsqFormatter.java
@@ -26,7 +26,6 @@
 import bisq.core.util.validation.BtcAddressValidator;
 import bisq.core.util.validation.InputValidator;
 
-import bisq.common.app.DevEnv;
 import bisq.common.util.MathUtils;
 
 import org.bitcoinj.core.Address;
@@ -47,8 +46,7 @@
 @Slf4j
 @Singleton
 public class BsqFormatter extends BSFormatter {
-    @SuppressWarnings("PointlessBooleanExpression")
-    private static final boolean useBsqAddressFormat = true || !DevEnv.isDevMode();
+    private static final boolean useBsqAddressFormat = true;// || !DevEnv.isDevMode();
     private final String prefix = "B";
     private DecimalFormat amountFormat;
     private DecimalFormat marketCapFormat;
@@ -100,7 +98,7 @@ public String getBsqAddressStringFromAddress(Address address) {
 
     public Address getAddressFromBsqAddress(String encoded) {
         if (useBsqAddressFormat)
-            encoded = encoded.substring(prefix.length(), encoded.length());
+            encoded = encoded.substring(prefix.length());
 
         try {
             return Address.fromBase58(BisqEnvironment.getParameters(), encoded);
diff --git a/core/src/test/java/bisq/core/btc/wallet/BsqWalletServiceTest.java b/core/src/test/java/bisq/core/btc/wallet/BsqWalletServiceTest.java
new file mode 100644
index 00000000000..c95250b28c3
--- /dev/null
+++ b/core/src/test/java/bisq/core/btc/wallet/BsqWalletServiceTest.java
@@ -0,0 +1,44 @@
+package bisq.core.btc.wallet;
+
+import bisq.core.btc.exceptions.BsqChangeBelowDustException;
+import bisq.core.btc.exceptions.InsufficientBsqException;
+import bisq.core.btc.exceptions.TransactionVerificationException;
+import bisq.core.btc.exceptions.WalletException;
+import bisq.core.btc.setup.WalletsSetup;
+import bisq.core.dao.DaoKillSwitch;
+import bisq.core.dao.state.DaoStateService;
+import bisq.core.dao.state.unconfirmed.UnconfirmedBsqChangeOutputListService;
+import bisq.core.provider.fee.FeeService;
+import bisq.core.user.Preferences;
+import bisq.core.util.ParsingUtils;
+
+import org.bitcoinj.core.Coin;
+import org.bitcoinj.params.UnitTestParams;
+import org.bitcoinj.utils.MonetaryFormat;
+import org.bitcoinj.wallet.Wallet;
+
+import org.junit.Test;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class BsqWalletServiceTest {
+    @Test(expected = InsufficientBsqException.class)
+    public void throwsExceptionWhenFundsAreInsufficient() throws TransactionVerificationException, WalletException, BsqChangeBelowDustException, InsufficientBsqException {
+        WalletsSetup walletsSetup = mock(WalletsSetup.class);
+        UnitTestParams params = new UnitTestParams();
+        Wallet bsqWallet = new Wallet(params);
+        when(walletsSetup.getBsqWallet()).thenReturn(bsqWallet);
+        when(walletsSetup.getParams()).thenReturn(params);
+        FeeService feeService = mock(FeeService.class);
+        DaoStateService daoStateService = mock(DaoStateService.class);
+        BsqCoinSelector bsqSelector = new BsqCoinSelector(daoStateService, mock(UnconfirmedBsqChangeOutputListService.class));
+        BsqWalletService bsqWalletService = new BsqWalletService(walletsSetup, bsqSelector, mock(NonBsqCoinSelector.class), daoStateService, mock(UnconfirmedBsqChangeOutputListService.class), mock(Preferences.class), feeService, mock(DaoKillSwitch.class));
+        bsqWalletService.setupComplete();
+        Coin receiverAmount = ParsingUtils.parseToCoin("10", MonetaryFormat.BTC);
+
+
+        bsqWalletService.getPreparedSendBsqTx(bsqWallet.freshReceiveAddress().toString(), receiverAmount);
+    }
+
+}