diff --git a/lib/balance-tx/lib/Cardano/Wallet/Shelley/Compatibility/Ledger.hs b/lib/balance-tx/lib/Cardano/Wallet/Shelley/Compatibility/Ledger.hs
index 21253a7fd28..ef99c759abe 100644
--- a/lib/balance-tx/lib/Cardano/Wallet/Shelley/Compatibility/Ledger.hs
+++ b/lib/balance-tx/lib/Cardano/Wallet/Shelley/Compatibility/Ledger.hs
@@ -15,7 +15,8 @@
 module Cardano.Wallet.Shelley.Compatibility.Ledger
     (
       -- * Conversions from wallet types to ledger specification types
-      toLedgerCoin
+      toLedgerAddress
+    , toLedgerCoin
     , toLedgerTokenBundle
     , toLedgerTokenPolicyId
     , toLedgerTokenName
@@ -23,6 +24,7 @@ module Cardano.Wallet.Shelley.Compatibility.Ledger
     , toLedgerTimelockScript
 
       -- * Conversions from ledger specification types to wallet types
+    , toWalletAddress
     , toWalletCoin
     , toWalletTokenBundle
     , toWalletTokenPolicyId
@@ -289,13 +291,19 @@ instance Convert TxIn (Ledger.TxIn StandardCrypto) where
 --------------------------------------------------------------------------------
 
 instance Convert Address (Ledger.Addr StandardCrypto) where
-    toLedger (Address bytes ) = case Ledger.deserialiseAddr bytes of
-        Just addr -> addr
-        Nothing -> error $ unwords
-            [ "toLedger @Address: Invalid address:"
-            , pretty (Address bytes)
-            ]
-    toWallet = Address . Ledger.serialiseAddr
+    toLedger = toLedgerAddress
+    toWallet = toWalletAddress
+
+toLedgerAddress :: Address -> Ledger.Addr StandardCrypto
+toLedgerAddress (Address bytes) = case Ledger.deserialiseAddr bytes of
+    Just addr -> addr
+    Nothing -> error $ unwords
+        [ "toLedger @Address: Invalid address:"
+        , pretty (Address bytes)
+        ]
+
+toWalletAddress :: Ledger.Addr StandardCrypto -> Address
+toWalletAddress = Address . Ledger.serialiseAddr
 
 --------------------------------------------------------------------------------
 -- Conversions for 'TxOut'
diff --git a/lib/balance-tx/lib/Cardano/Wallet/Write/Tx.hs b/lib/balance-tx/lib/Cardano/Wallet/Write/Tx.hs
index 2267d091420..1a9b01f22f6 100644
--- a/lib/balance-tx/lib/Cardano/Wallet/Write/Tx.hs
+++ b/lib/balance-tx/lib/Cardano/Wallet/Write/Tx.hs
@@ -538,7 +538,7 @@ type TxOutInBabbage = Babbage.BabbageTxOut (Babbage.BabbageEra StandardCrypto)
 type Address = Ledger.Addr StandardCrypto
 
 type Script = AlonzoScript
-type Value = MaryValue
+type Value = MaryValue StandardCrypto
 
 unsafeAddressFromBytes :: ByteString -> Address
 unsafeAddressFromBytes bytes = case Ledger.deserialiseAddr bytes of
diff --git a/lib/balance-tx/lib/Cardano/Wallet/Write/Tx/Balance.hs b/lib/balance-tx/lib/Cardano/Wallet/Write/Tx/Balance.hs
index 7e3fbd65f6d..b1b11e5f3bf 100644
--- a/lib/balance-tx/lib/Cardano/Wallet/Write/Tx/Balance.hs
+++ b/lib/balance-tx/lib/Cardano/Wallet/Write/Tx/Balance.hs
@@ -119,7 +119,8 @@ import Cardano.Wallet.Primitive.Types.Tx.Constraints
 import Cardano.Wallet.Write.ProtocolParameters
     ( ProtocolParameters (..) )
 import Cardano.Wallet.Write.Tx
-    ( Coin (..)
+    ( Address
+    , Coin (..)
     , FeePerByte (..)
     , IsRecentEra (..)
     , KeyWitnessCount (..)
@@ -130,6 +131,7 @@ import Cardano.Wallet.Write.Tx
     , TxIn
     , TxOut
     , UTxO (..)
+    , Value
     , computeMinimumCoinForTxOut
     , evaluateMinimumFee
     , evaluateTransactionBalance
@@ -301,11 +303,11 @@ data ErrBalanceTxUnableToCreateChangeError =
 -- that would be necessary to balance the transaction.
 --
 data ErrBalanceTxAssetsInsufficientError = ErrBalanceTxAssetsInsufficientError
-    { available :: W.TokenBundle
+    { available :: Value
         -- ^ The total sum of all assets available.
-    , required :: W.TokenBundle
+    , required :: Value
         -- ^ The total sum of all assets required.
-    , shortfall :: W.TokenBundle
+    , shortfall :: Value
         -- ^ The total shortfall between available and required assets.
     }
     deriving (Eq, Generic, Show)
@@ -956,7 +958,7 @@ selectAssets era (ProtocolParameters pp) utxoAssumptions outs redeemers
     , minimumCollateralPercentage =
         withConstraints era $ pp ^. ppCollateralPercentageL
     , maximumLengthChangeAddress =
-        maxLengthChangeAddress changeGen
+        W.toWalletAddress $ maxLengthChangeAddress changeGen
     }
 
     selectionParams = SelectionParams
@@ -1038,7 +1040,7 @@ selectAssets era (ProtocolParameters pp) utxoAssumptions outs redeemers
         extraBytes = 8
 
 data ChangeAddressGen s = ChangeAddressGen
-    { getChangeAddressGen :: s -> (W.Address, s)
+    { getChangeAddressGen :: s -> (Address, s)
 
     -- | Returns the longest address that the wallet can generate for a given
     --   key.
@@ -1052,7 +1054,7 @@ data ChangeAddressGen s = ChangeAddressGen
     --  - never be used for anything besides its length and validity properties.
     --  - never be used as a payment target within a real transaction.
     --
-    , maxLengthChangeAddress :: W.Address
+    , maxLengthChangeAddress :: Address
     }
 
 -- | Augments the given outputs with new outputs. These new outputs correspond
@@ -1066,7 +1068,7 @@ assignChangeAddresses
 assignChangeAddresses (ChangeAddressGen genChange _) sel = runState $ do
     changeOuts <- forM (view #change sel) $ \bundle -> do
         addr <- state genChange
-        pure $ W.TxOut addr bundle
+        pure $ W.TxOut (W.toWalletAddress addr) bundle
     pure $ (sel :: SelectionOf W.TokenBundle) { change = changeOuts }
 
 -- | Convert a 'Cardano.Value' into a positive and negative component. Useful
@@ -1450,9 +1452,9 @@ coinSelectionErrorToBalanceTxError = \case
             BalanceInsufficient e ->
                 ErrBalanceTxAssetsInsufficient $
                 ErrBalanceTxAssetsInsufficientError
-                    { available = view #utxoBalanceAvailable e
-                    , required = view #utxoBalanceRequired e
-                    , shortfall = view #utxoBalanceShortfall e
+                    { available = W.toLedger (view #utxoBalanceAvailable e)
+                    , required = W.toLedger (view #utxoBalanceRequired e)
+                    , shortfall = W.toLedger (view #utxoBalanceShortfall e)
                     }
             UnableToConstructChange
                 UnableToConstructChangeError {shortfall, requiredCost} ->
@@ -1500,20 +1502,20 @@ data ErrBalanceTxOutputErrorInfo
 
 data ErrBalanceTxOutputAdaQuantityInsufficientError =
     ErrBalanceTxOutputAdaQuantityInsufficientError
-    { minimumExpectedCoin :: W.Coin
-    , output :: (W.Address, W.TokenBundle)
+    { minimumExpectedCoin :: Coin
+    , output :: (Address, Value)
     }
     deriving (Eq, Generic, Show)
 
 newtype ErrBalanceTxOutputSizeExceedsLimitError =
     ErrBalanceTxOutputSizeExceedsLimitError
-    { outputThatExceedsLimit :: (W.Address, W.TokenBundle)
+    { outputThatExceedsLimit :: (Address, Value)
     }
     deriving (Eq, Generic, Show)
 
 data ErrBalanceTxOutputTokenQuantityExceedsLimitError =
     ErrBalanceTxOutputTokenQuantityExceedsLimitError
-    { address :: W.Address
+    { address :: Address
       -- ^ The address to which this token quantity was to be sent.
     , asset :: W.AssetId
       -- ^ The asset identifier to which this token quantity corresponds.
@@ -1557,11 +1559,13 @@ validateTxOutputSize
     :: SelectionConstraints
     -> (W.Address, W.TokenBundle)
     -> Maybe ErrBalanceTxOutputSizeExceedsLimitError
-validateTxOutputSize cs out = case sizeAssessment of
+validateTxOutputSize cs out@(address, bundle) = case sizeAssessment of
     TokenBundleSizeWithinLimit ->
         Nothing
     TokenBundleSizeExceedsLimit ->
-        Just $ ErrBalanceTxOutputSizeExceedsLimitError out
+        Just $
+        ErrBalanceTxOutputSizeExceedsLimitError
+            (W.toLedger address, W.toLedger bundle)
   where
     sizeAssessment :: TokenBundleSizeAssessment
     sizeAssessment =
@@ -1578,7 +1582,7 @@ validateTxOutputTokenQuantities
 validateTxOutputTokenQuantities out =
     [ ErrBalanceTxOutputTokenQuantityExceedsLimitError
         {address, asset, quantity, quantityMaxBound = txOutMaxTokenQuantity}
-    | let address = fst out
+    | let address = W.toLedgerAddress $ fst out
     , (asset, quantity) <- W.TokenMap.toFlatList $ (snd out) ^. #tokens
     , quantity > txOutMaxTokenQuantity
     ]
@@ -1592,18 +1596,20 @@ validateTxOutputAdaQuantity
     :: SelectionConstraints
     -> (W.Address, W.TokenBundle)
     -> Maybe ErrBalanceTxOutputAdaQuantityInsufficientError
-validateTxOutputAdaQuantity constraints output
+validateTxOutputAdaQuantity constraints output@(address, bundle)
     | isBelowMinimum =
         Just ErrBalanceTxOutputAdaQuantityInsufficientError
-            {minimumExpectedCoin, output}
+            { minimumExpectedCoin
+            , output = (W.toLedger address, W.toLedger bundle)
+            }
     | otherwise =
         Nothing
   where
     isBelowMinimum :: Bool
     isBelowMinimum = uncurry (constraints ^. #isBelowMinimumAdaQuantity) output
 
-    minimumExpectedCoin :: W.Coin
-    minimumExpectedCoin =
+    minimumExpectedCoin :: Coin
+    minimumExpectedCoin = W.toLedgerCoin $
         (constraints ^. #computeMinimumAdaQuantity)
         (fst output)
         (snd output ^. #tokens)
diff --git a/lib/balance-tx/lib/Cardano/Wallet/Write/Tx/Balance/TokenBundleSize.hs b/lib/balance-tx/lib/Cardano/Wallet/Write/Tx/Balance/TokenBundleSize.hs
index b8b6683226e..05f2f9e7565 100644
--- a/lib/balance-tx/lib/Cardano/Wallet/Write/Tx/Balance/TokenBundleSize.hs
+++ b/lib/balance-tx/lib/Cardano/Wallet/Write/Tx/Balance/TokenBundleSize.hs
@@ -11,7 +11,7 @@ import Prelude
 import Cardano.CoinSelection.Size
     ( TokenBundleSizeAssessment (..), TokenBundleSizeAssessor (..) )
 import Cardano.Ledger.Api
-    ( StandardCrypto, ppMaxValSizeL, ppProtocolVersionL )
+    ( ppMaxValSizeL, ppProtocolVersionL )
 import Cardano.Ledger.BaseTypes
     ( ProtVer (pvMajor) )
 import Cardano.Ledger.Binary
@@ -56,7 +56,7 @@ computeTokenBundleSerializedLengthBytes
     -> TxSize
 computeTokenBundleSerializedLengthBytes tb ver = serSize (toLedger tb)
   where
-    serSize :: Value StandardCrypto -> TxSize
+    serSize :: Value -> TxSize
     serSize v = maybe err TxSize
         . intCastMaybe
         . BL.length
diff --git a/lib/wallet/api/http/Cardano/Wallet/Api/Http/Server/Error.hs b/lib/wallet/api/http/Cardano/Wallet/Api/Http/Server/Error.hs
index d39eac8eba0..10358800984 100644
--- a/lib/wallet/api/http/Cardano/Wallet/Api/Http/Server/Error.hs
+++ b/lib/wallet/api/http/Cardano/Wallet/Api/Http/Server/Error.hs
@@ -101,7 +101,7 @@ import Cardano.Wallet.Primitive.Types.TokenMap
 import Cardano.Wallet.Primitive.Types.Tx.SealedTx
     ( serialisedTx )
 import Cardano.Wallet.Shelley.Compatibility.Ledger
-    ( toWalletCoin )
+    ( Convert (toWallet), toWalletAddress, toWalletCoin, toWalletTokenBundle )
 import Cardano.Wallet.Transaction
     ( ErrSignTx (..) )
 import Cardano.Wallet.Write.Tx.Balance
@@ -503,7 +503,8 @@ instance IsServerError ErrBalanceTx where
             apiError err403 NotEnoughMoney $ mconcat
                 [ "I can't process this payment as there are not "
                 , "enough funds available in the wallet. I am "
-                , "missing: ", pretty . Flat $ e ^. #shortfall
+                , "missing: "
+                , pretty . Flat . toWalletTokenBundle $ e ^. #shortfall
                 ]
         ErrBalanceTxAssignRedeemers err -> toServerError err
         ErrBalanceTxConflictingNetworks ->
@@ -924,9 +925,13 @@ instance IsServerError ErrBalanceTxOutputError where
                             , show index
                             ]
                 , txOutputLovelaceSpecified =
-                    Coin.toQuantity $ TokenBundle.getCoin $ snd $ view #output e
+                    Coin.toQuantity
+                        $ TokenBundle.getCoin
+                        $ toWallet
+                        $ snd
+                        $ view #output e
                 , txOutputLovelaceRequiredMinimum =
-                    Coin.toQuantity $ view #minimumExpectedCoin e
+                    Coin.toQuantity $ toWalletCoin $ view #minimumExpectedCoin e
                 }
         ErrBalanceTxOutputSizeExceedsLimit e ->
             toServerError e
@@ -948,9 +953,9 @@ instance IsServerError ErrBalanceTxOutputSizeExceedsLimitError
         [ "One of the outputs you've specified contains too many assets. "
         , "Try splitting these assets across two or more outputs. "
         , "Destination address: "
-        , pretty (fst output)
+        , pretty (toWalletAddress (fst output))
         , ". Asset count: "
-        , pretty (TokenMap.size $ snd output ^. #tokens)
+        , pretty (TokenMap.size $ toWalletTokenBundle (snd output) ^. #tokens)
         , "."
         ]
       where
@@ -963,7 +968,7 @@ instance IsServerError ErrBalanceTxOutputTokenQuantityExceedsLimitError
         , "maximum quantity allowed in a single transaction output. Try "
         , "splitting this quantity across two or more outputs. "
         , "Destination address: "
-        , pretty (view #address e)
+        , pretty (toWalletAddress (view #address e))
         , ". Token policy identifier: "
         , pretty (view (#asset . #tokenPolicyId) e)
         , ". Asset name: "
diff --git a/lib/wallet/src/Cardano/Wallet.hs b/lib/wallet/src/Cardano/Wallet.hs
index e782a0bb083..45a2509ab35 100644
--- a/lib/wallet/src/Cardano/Wallet.hs
+++ b/lib/wallet/src/Cardano/Wallet.hs
@@ -487,7 +487,7 @@ import Cardano.Wallet.Shelley.Compatibility
     , fromCardanoWdrls
     )
 import Cardano.Wallet.Shelley.Compatibility.Ledger
-    ( toWallet, toWalletCoin )
+    ( toLedgerAddress, toWallet, toWalletCoin )
 import Cardano.Wallet.Shelley.Transaction
     ( txWitnessTagForKey )
 import Cardano.Wallet.Transaction
@@ -555,6 +555,8 @@ import Control.Tracer
     ( Tracer, contramap, traceWith )
 import Crypto.Hash
     ( Blake2b_256, hash )
+import Data.Bifunctor
+    ( first )
 import Data.ByteString
     ( ByteString )
 import Data.DBVar
@@ -3712,16 +3714,16 @@ defaultChangeAddressGen
     -> ChangeAddressGen s
 defaultChangeAddressGen arg =
     ChangeAddressGen
-        (genChange arg)
-        (maxLengthAddressFor (keyFlavorFromState @s))
+        (first toLedgerAddress <$> genChange arg)
+        (toLedgerAddress $ maxLengthAddressFor (keyFlavorFromState @s))
 
 -- WARNING: Must never be used to create real transactions for submission to the
 -- blockchain as funds sent to a dummy change address would be irrecoverable.
 dummyChangeAddressGen :: forall s. WalletFlavor s => ChangeAddressGen s
 dummyChangeAddressGen =
     ChangeAddressGen
-        (maxLengthAddressFor (keyFlavorFromState @s),)
-        (maxLengthAddressFor (keyFlavorFromState @s))
+        (toLedgerAddress $ maxLengthAddressFor (keyFlavorFromState @s),)
+        (toLedgerAddress $ maxLengthAddressFor (keyFlavorFromState @s))
 
 utxoAssumptionsForWallet
     :: forall s
diff --git a/lib/wallet/test/data/balanceTx/1ada-payment/golden b/lib/wallet/test/data/balanceTx/1ada-payment/golden
index 9efffe90e27..ca8990b703e 100644
--- a/lib/wallet/test/data/balanceTx/1ada-payment/golden
+++ b/lib/wallet/test/data/balanceTx/1ada-payment/golden
@@ -1,23 +1,23 @@
- 0.000000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 0, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}})
- 0.050000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 50000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 950000, tokens = TokenMap (fromList [])}})
- 0.100000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 100000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 900000, tokens = TokenMap (fromList [])}})
- 0.150000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 150000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 850000, tokens = TokenMap (fromList [])}})
- 0.200000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 200000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 800000, tokens = TokenMap (fromList [])}})
- 0.250000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 250000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 750000, tokens = TokenMap (fromList [])}})
- 0.300000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 300000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 700000, tokens = TokenMap (fromList [])}})
- 0.350000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 350000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 650000, tokens = TokenMap (fromList [])}})
- 0.400000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 400000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 600000, tokens = TokenMap (fromList [])}})
- 0.450000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 450000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 550000, tokens = TokenMap (fromList [])}})
- 0.500000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 500000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 500000, tokens = TokenMap (fromList [])}})
- 0.550000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 550000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 450000, tokens = TokenMap (fromList [])}})
- 0.600000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 600000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 400000, tokens = TokenMap (fromList [])}})
- 0.650000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 650000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 350000, tokens = TokenMap (fromList [])}})
- 0.700000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 700000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 300000, tokens = TokenMap (fromList [])}})
- 0.750000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 750000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 250000, tokens = TokenMap (fromList [])}})
- 0.800000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 800000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 200000, tokens = TokenMap (fromList [])}})
- 0.850000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 850000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 150000, tokens = TokenMap (fromList [])}})
- 0.900000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 900000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 100000, tokens = TokenMap (fromList [])}})
- 0.950000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 950000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 50000, tokens = TokenMap (fromList [])}})
+ 0.000000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 0 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 1000000 (MultiAsset (fromList []))})
+ 0.050000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 50000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 950000 (MultiAsset (fromList []))})
+ 0.100000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 100000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 900000 (MultiAsset (fromList []))})
+ 0.150000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 150000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 850000 (MultiAsset (fromList []))})
+ 0.200000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 200000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 800000 (MultiAsset (fromList []))})
+ 0.250000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 250000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 750000 (MultiAsset (fromList []))})
+ 0.300000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 300000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 700000 (MultiAsset (fromList []))})
+ 0.350000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 350000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 650000 (MultiAsset (fromList []))})
+ 0.400000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 400000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 600000 (MultiAsset (fromList []))})
+ 0.450000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 450000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 550000 (MultiAsset (fromList []))})
+ 0.500000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 500000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 500000 (MultiAsset (fromList []))})
+ 0.550000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 550000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 450000 (MultiAsset (fromList []))})
+ 0.600000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 600000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 400000 (MultiAsset (fromList []))})
+ 0.650000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 650000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 350000 (MultiAsset (fromList []))})
+ 0.700000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 700000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 300000 (MultiAsset (fromList []))})
+ 0.750000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 750000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 250000 (MultiAsset (fromList []))})
+ 0.800000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 800000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 200000 (MultiAsset (fromList []))})
+ 0.850000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 850000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 150000 (MultiAsset (fromList []))})
+ 0.900000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 900000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 100000 (MultiAsset (fromList []))})
+ 0.950000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 950000 (MultiAsset (fromList [])), required = MaryValue 1000000 (MultiAsset (fromList [])), shortfall = MaryValue 50000 (MultiAsset (fromList []))})
  1.000000,ErrBalanceTxUnableToCreateChange (ErrBalanceTxUnableToCreateChangeError {requiredCost = Coin 168933, shortfall = Coin 168933})
  1.050000,ErrBalanceTxUnableToCreateChange (ErrBalanceTxUnableToCreateChangeError {requiredCost = Coin 168933, shortfall = Coin 118933})
  1.100000,ErrBalanceTxUnableToCreateChange (ErrBalanceTxUnableToCreateChangeError {requiredCost = Coin 168933, shortfall = Coin 68933})
diff --git a/lib/wallet/test/data/balanceTx/delegate/golden b/lib/wallet/test/data/balanceTx/delegate/golden
index 726385310fa..bf026a9437c 100644
--- a/lib/wallet/test/data/balanceTx/delegate/golden
+++ b/lib/wallet/test/data/balanceTx/delegate/golden
@@ -1,43 +1,43 @@
- 0.000000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 0, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}})
- 0.050000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 50000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1950000, tokens = TokenMap (fromList [])}})
- 0.100000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 100000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1900000, tokens = TokenMap (fromList [])}})
- 0.150000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 150000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1850000, tokens = TokenMap (fromList [])}})
- 0.200000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 200000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1800000, tokens = TokenMap (fromList [])}})
- 0.250000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 250000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1750000, tokens = TokenMap (fromList [])}})
- 0.300000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 300000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1700000, tokens = TokenMap (fromList [])}})
- 0.350000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 350000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1650000, tokens = TokenMap (fromList [])}})
- 0.400000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 400000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1600000, tokens = TokenMap (fromList [])}})
- 0.450000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 450000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1550000, tokens = TokenMap (fromList [])}})
- 0.500000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 500000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1500000, tokens = TokenMap (fromList [])}})
- 0.550000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 550000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1450000, tokens = TokenMap (fromList [])}})
- 0.600000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 600000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1400000, tokens = TokenMap (fromList [])}})
- 0.650000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 650000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1350000, tokens = TokenMap (fromList [])}})
- 0.700000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 700000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1300000, tokens = TokenMap (fromList [])}})
- 0.750000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 750000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1250000, tokens = TokenMap (fromList [])}})
- 0.800000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 800000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1200000, tokens = TokenMap (fromList [])}})
- 0.850000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 850000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1150000, tokens = TokenMap (fromList [])}})
- 0.900000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 900000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1100000, tokens = TokenMap (fromList [])}})
- 0.950000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 950000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1050000, tokens = TokenMap (fromList [])}})
- 1.000000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}})
- 1.050000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1050000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 950000, tokens = TokenMap (fromList [])}})
- 1.100000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1100000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 900000, tokens = TokenMap (fromList [])}})
- 1.150000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1150000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 850000, tokens = TokenMap (fromList [])}})
- 1.200000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1200000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 800000, tokens = TokenMap (fromList [])}})
- 1.250000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1250000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 750000, tokens = TokenMap (fromList [])}})
- 1.300000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1300000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 700000, tokens = TokenMap (fromList [])}})
- 1.350000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1350000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 650000, tokens = TokenMap (fromList [])}})
- 1.400000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1400000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 600000, tokens = TokenMap (fromList [])}})
- 1.450000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1450000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 550000, tokens = TokenMap (fromList [])}})
- 1.500000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1500000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 500000, tokens = TokenMap (fromList [])}})
- 1.550000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1550000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 450000, tokens = TokenMap (fromList [])}})
- 1.600000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1600000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 400000, tokens = TokenMap (fromList [])}})
- 1.650000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1650000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 350000, tokens = TokenMap (fromList [])}})
- 1.700000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1700000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 300000, tokens = TokenMap (fromList [])}})
- 1.750000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1750000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 250000, tokens = TokenMap (fromList [])}})
- 1.800000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1800000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 200000, tokens = TokenMap (fromList [])}})
- 1.850000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1850000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 150000, tokens = TokenMap (fromList [])}})
- 1.900000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1900000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 100000, tokens = TokenMap (fromList [])}})
- 1.950000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1950000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 50000, tokens = TokenMap (fromList [])}})
+ 0.000000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 0 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 2000000 (MultiAsset (fromList []))})
+ 0.050000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 50000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1950000 (MultiAsset (fromList []))})
+ 0.100000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 100000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1900000 (MultiAsset (fromList []))})
+ 0.150000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 150000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1850000 (MultiAsset (fromList []))})
+ 0.200000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 200000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1800000 (MultiAsset (fromList []))})
+ 0.250000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 250000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1750000 (MultiAsset (fromList []))})
+ 0.300000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 300000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1700000 (MultiAsset (fromList []))})
+ 0.350000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 350000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1650000 (MultiAsset (fromList []))})
+ 0.400000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 400000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1600000 (MultiAsset (fromList []))})
+ 0.450000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 450000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1550000 (MultiAsset (fromList []))})
+ 0.500000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 500000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1500000 (MultiAsset (fromList []))})
+ 0.550000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 550000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1450000 (MultiAsset (fromList []))})
+ 0.600000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 600000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1400000 (MultiAsset (fromList []))})
+ 0.650000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 650000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1350000 (MultiAsset (fromList []))})
+ 0.700000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 700000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1300000 (MultiAsset (fromList []))})
+ 0.750000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 750000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1250000 (MultiAsset (fromList []))})
+ 0.800000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 800000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1200000 (MultiAsset (fromList []))})
+ 0.850000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 850000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1150000 (MultiAsset (fromList []))})
+ 0.900000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 900000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1100000 (MultiAsset (fromList []))})
+ 0.950000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 950000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1050000 (MultiAsset (fromList []))})
+ 1.000000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1000000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1000000 (MultiAsset (fromList []))})
+ 1.050000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1050000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 950000 (MultiAsset (fromList []))})
+ 1.100000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1100000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 900000 (MultiAsset (fromList []))})
+ 1.150000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1150000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 850000 (MultiAsset (fromList []))})
+ 1.200000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1200000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 800000 (MultiAsset (fromList []))})
+ 1.250000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1250000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 750000 (MultiAsset (fromList []))})
+ 1.300000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1300000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 700000 (MultiAsset (fromList []))})
+ 1.350000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1350000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 650000 (MultiAsset (fromList []))})
+ 1.400000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1400000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 600000 (MultiAsset (fromList []))})
+ 1.450000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1450000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 550000 (MultiAsset (fromList []))})
+ 1.500000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1500000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 500000 (MultiAsset (fromList []))})
+ 1.550000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1550000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 450000 (MultiAsset (fromList []))})
+ 1.600000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1600000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 400000 (MultiAsset (fromList []))})
+ 1.650000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1650000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 350000 (MultiAsset (fromList []))})
+ 1.700000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1700000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 300000 (MultiAsset (fromList []))})
+ 1.750000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1750000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 250000 (MultiAsset (fromList []))})
+ 1.800000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1800000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 200000 (MultiAsset (fromList []))})
+ 1.850000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1850000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 150000 (MultiAsset (fromList []))})
+ 1.900000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1900000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 100000 (MultiAsset (fromList []))})
+ 1.950000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1950000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 50000 (MultiAsset (fromList []))})
  2.000000,ErrBalanceTxUnableToCreateChange (ErrBalanceTxUnableToCreateChangeError {requiredCost = Coin 176457, shortfall = Coin 176457})
  2.050000,ErrBalanceTxUnableToCreateChange (ErrBalanceTxUnableToCreateChangeError {requiredCost = Coin 176457, shortfall = Coin 126457})
  2.100000,ErrBalanceTxUnableToCreateChange (ErrBalanceTxUnableToCreateChangeError {requiredCost = Coin 176457, shortfall = Coin 76457})
diff --git a/lib/wallet/test/data/balanceTx/pingPong_1/golden b/lib/wallet/test/data/balanceTx/pingPong_1/golden
index 9fadbfbd69b..47de5996c69 100644
--- a/lib/wallet/test/data/balanceTx/pingPong_1/golden
+++ b/lib/wallet/test/data/balanceTx/pingPong_1/golden
@@ -1,43 +1,43 @@
- 0.000000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 0, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}})
- 0.050000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 50000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1950000, tokens = TokenMap (fromList [])}})
- 0.100000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 100000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1900000, tokens = TokenMap (fromList [])}})
- 0.150000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 150000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1850000, tokens = TokenMap (fromList [])}})
- 0.200000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 200000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1800000, tokens = TokenMap (fromList [])}})
- 0.250000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 250000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1750000, tokens = TokenMap (fromList [])}})
- 0.300000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 300000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1700000, tokens = TokenMap (fromList [])}})
- 0.350000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 350000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1650000, tokens = TokenMap (fromList [])}})
- 0.400000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 400000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1600000, tokens = TokenMap (fromList [])}})
- 0.450000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 450000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1550000, tokens = TokenMap (fromList [])}})
- 0.500000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 500000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1500000, tokens = TokenMap (fromList [])}})
- 0.550000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 550000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1450000, tokens = TokenMap (fromList [])}})
- 0.600000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 600000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1400000, tokens = TokenMap (fromList [])}})
- 0.650000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 650000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1350000, tokens = TokenMap (fromList [])}})
- 0.700000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 700000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1300000, tokens = TokenMap (fromList [])}})
- 0.750000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 750000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1250000, tokens = TokenMap (fromList [])}})
- 0.800000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 800000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1200000, tokens = TokenMap (fromList [])}})
- 0.850000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 850000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1150000, tokens = TokenMap (fromList [])}})
- 0.900000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 900000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1100000, tokens = TokenMap (fromList [])}})
- 0.950000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 950000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1050000, tokens = TokenMap (fromList [])}})
- 1.000000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 1000000, tokens = TokenMap (fromList [])}})
- 1.050000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1050000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 950000, tokens = TokenMap (fromList [])}})
- 1.100000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1100000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 900000, tokens = TokenMap (fromList [])}})
- 1.150000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1150000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 850000, tokens = TokenMap (fromList [])}})
- 1.200000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1200000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 800000, tokens = TokenMap (fromList [])}})
- 1.250000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1250000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 750000, tokens = TokenMap (fromList [])}})
- 1.300000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1300000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 700000, tokens = TokenMap (fromList [])}})
- 1.350000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1350000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 650000, tokens = TokenMap (fromList [])}})
- 1.400000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1400000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 600000, tokens = TokenMap (fromList [])}})
- 1.450000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1450000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 550000, tokens = TokenMap (fromList [])}})
- 1.500000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1500000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 500000, tokens = TokenMap (fromList [])}})
- 1.550000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1550000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 450000, tokens = TokenMap (fromList [])}})
- 1.600000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1600000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 400000, tokens = TokenMap (fromList [])}})
- 1.650000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1650000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 350000, tokens = TokenMap (fromList [])}})
- 1.700000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1700000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 300000, tokens = TokenMap (fromList [])}})
- 1.750000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1750000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 250000, tokens = TokenMap (fromList [])}})
- 1.800000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1800000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 200000, tokens = TokenMap (fromList [])}})
- 1.850000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1850000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 150000, tokens = TokenMap (fromList [])}})
- 1.900000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1900000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 100000, tokens = TokenMap (fromList [])}})
- 1.950000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = TokenBundle {coin = Coin 1950000, tokens = TokenMap (fromList [])}, required = TokenBundle {coin = Coin 2000000, tokens = TokenMap (fromList [])}, shortfall = TokenBundle {coin = Coin 50000, tokens = TokenMap (fromList [])}})
+ 0.000000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 0 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 2000000 (MultiAsset (fromList []))})
+ 0.050000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 50000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1950000 (MultiAsset (fromList []))})
+ 0.100000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 100000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1900000 (MultiAsset (fromList []))})
+ 0.150000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 150000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1850000 (MultiAsset (fromList []))})
+ 0.200000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 200000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1800000 (MultiAsset (fromList []))})
+ 0.250000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 250000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1750000 (MultiAsset (fromList []))})
+ 0.300000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 300000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1700000 (MultiAsset (fromList []))})
+ 0.350000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 350000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1650000 (MultiAsset (fromList []))})
+ 0.400000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 400000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1600000 (MultiAsset (fromList []))})
+ 0.450000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 450000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1550000 (MultiAsset (fromList []))})
+ 0.500000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 500000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1500000 (MultiAsset (fromList []))})
+ 0.550000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 550000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1450000 (MultiAsset (fromList []))})
+ 0.600000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 600000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1400000 (MultiAsset (fromList []))})
+ 0.650000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 650000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1350000 (MultiAsset (fromList []))})
+ 0.700000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 700000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1300000 (MultiAsset (fromList []))})
+ 0.750000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 750000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1250000 (MultiAsset (fromList []))})
+ 0.800000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 800000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1200000 (MultiAsset (fromList []))})
+ 0.850000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 850000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1150000 (MultiAsset (fromList []))})
+ 0.900000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 900000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1100000 (MultiAsset (fromList []))})
+ 0.950000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 950000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1050000 (MultiAsset (fromList []))})
+ 1.000000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1000000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 1000000 (MultiAsset (fromList []))})
+ 1.050000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1050000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 950000 (MultiAsset (fromList []))})
+ 1.100000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1100000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 900000 (MultiAsset (fromList []))})
+ 1.150000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1150000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 850000 (MultiAsset (fromList []))})
+ 1.200000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1200000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 800000 (MultiAsset (fromList []))})
+ 1.250000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1250000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 750000 (MultiAsset (fromList []))})
+ 1.300000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1300000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 700000 (MultiAsset (fromList []))})
+ 1.350000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1350000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 650000 (MultiAsset (fromList []))})
+ 1.400000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1400000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 600000 (MultiAsset (fromList []))})
+ 1.450000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1450000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 550000 (MultiAsset (fromList []))})
+ 1.500000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1500000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 500000 (MultiAsset (fromList []))})
+ 1.550000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1550000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 450000 (MultiAsset (fromList []))})
+ 1.600000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1600000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 400000 (MultiAsset (fromList []))})
+ 1.650000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1650000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 350000 (MultiAsset (fromList []))})
+ 1.700000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1700000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 300000 (MultiAsset (fromList []))})
+ 1.750000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1750000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 250000 (MultiAsset (fromList []))})
+ 1.800000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1800000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 200000 (MultiAsset (fromList []))})
+ 1.850000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1850000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 150000 (MultiAsset (fromList []))})
+ 1.900000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1900000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 100000 (MultiAsset (fromList []))})
+ 1.950000,ErrBalanceTxAssetsInsufficient (ErrBalanceTxAssetsInsufficientError {available = MaryValue 1950000 (MultiAsset (fromList [])), required = MaryValue 2000000 (MultiAsset (fromList [])), shortfall = MaryValue 50000 (MultiAsset (fromList []))})
  2.000000,ErrBalanceTxUnableToCreateChange (ErrBalanceTxUnableToCreateChangeError {requiredCost = Coin 170781, shortfall = Coin 170781})
  2.050000,ErrBalanceTxUnableToCreateChange (ErrBalanceTxUnableToCreateChangeError {requiredCost = Coin 170781, shortfall = Coin 120781})
  2.100000,ErrBalanceTxUnableToCreateChange (ErrBalanceTxUnableToCreateChangeError {requiredCost = Coin 170781, shortfall = Coin 70781})
diff --git a/lib/wallet/test/unit/Cardano/Wallet/Shelley/TransactionSpec.hs b/lib/wallet/test/unit/Cardano/Wallet/Shelley/TransactionSpec.hs
index fb675c18cc0..9cbf5e362a8 100644
--- a/lib/wallet/test/unit/Cardano/Wallet/Shelley/TransactionSpec.hs
+++ b/lib/wallet/test/unit/Cardano/Wallet/Shelley/TransactionSpec.hs
@@ -84,6 +84,7 @@ import Cardano.Ledger.Api
     , ppMaxTxSizeL
     , ppMinFeeAL
     , scriptTxWitsL
+    , serialiseAddr
     , witsTxL
     )
 import Cardano.Ledger.Era
@@ -202,7 +203,13 @@ import Cardano.Wallet.Shelley.Compatibility
     , toCardanoValue
     )
 import Cardano.Wallet.Shelley.Compatibility.Ledger
-    ( toBabbageTxOut, toLedger, toLedgerTokenBundle, toWallet, toWalletCoin )
+    ( toBabbageTxOut
+    , toLedgerAddress
+    , toLedgerTokenBundle
+    , toWallet
+    , toWalletAddress
+    , toWalletCoin
+    )
 import Cardano.Wallet.Shelley.Transaction
     ( EraConstraints
     , TxWitnessTag (..)
@@ -1784,7 +1791,7 @@ dummyShelleyChangeAddressGen = AnyChangeAddressGenWithState
 
 instance Show AnyChangeAddressGenWithState where
     show (AnyChangeAddressGenWithState (ChangeAddressGen gen _) s) =
-            show $ toLedger $ fst $ gen s
+            show $ fst $ gen s
 
 balanceTransactionSpec :: Spec
 balanceTransactionSpec = describe "balanceTransaction" $ do
@@ -1886,7 +1893,8 @@ balanceTransactionSpec = describe "balanceTransaction" $ do
         -- 'ErrBalanceTxMaxSizeLimitExceeded' or ErrMakeChange
         let nChange = max nPayments 1
         let s0 = DummyChangeState 0
-        let expectedChange = flip evalState s0
+        let expectedChange = fmap toWalletAddress <$>
+                flip evalState s0
                 $ replicateM nChange
                 $ state @Identity (getChangeAddressGen dummyChangeAddrGen)
 
@@ -2556,9 +2564,9 @@ instance Buildable AnyChangeAddressGenWithState where
     build (AnyChangeAddressGenWithState (ChangeAddressGen g maxLengthAddr) s0) =
         blockListF
             [ nameF "changeAddr0" $
-                build $ show $ toLedger $ fst $ g s0
+                build $ show $ fst $ g s0
             , nameF "max address length" $
-                build $ BS.length $ unAddress maxLengthAddr
+                build $ BS.length $ serialiseAddr maxLengthAddr
             ]
 
 instance Buildable Wallet' where
@@ -2881,8 +2889,9 @@ dummyChangeAddrGen = ChangeAddressGen
             :: Index
                 'Cardano.Wallet.Address.Derivation.Soft
                 'CredFromKeyK
-            -> Address
-        addressAtIx ix = paymentAddress @ShelleyKey @'CredFromKeyK SMainnet
+            -> Write.Address
+        addressAtIx ix = toLedgerAddress
+            $ paymentAddress @ShelleyKey @'CredFromKeyK SMainnet
             $ publicKey ShelleyKeyS
             $ Shelley.ShelleyKey
             $ Shelley.deriveAddressPrivateKeyShelley
@@ -3224,8 +3233,8 @@ prop_balanceTransactionValid
                         ]
             Left (ErrBalanceTxAssetsInsufficient err) -> do
                 let missing = view #shortfall err
-                let missingCoin = view #coin missing == Coin 0
-                let missingTokens = view #tokens missing == mempty
+                let missingCoin = Value.coin missing == mempty
+                let missingTokens = Value.isAdaOnly missing
                 case (missingCoin, missingTokens) of
                     (False, False) ->
                         label "missing coin and tokens" $
diff --git a/lib/wallet/test/unit/Cardano/WalletSpec.hs b/lib/wallet/test/unit/Cardano/WalletSpec.hs
index 3ef0cadabf6..80f7fd2f48c 100644
--- a/lib/wallet/test/unit/Cardano/WalletSpec.hs
+++ b/lib/wallet/test/unit/Cardano/WalletSpec.hs
@@ -660,9 +660,9 @@ prop_calculateFeePercentiles (NonEmpty coins) =
     genericError
         = ErrBalanceTxAssetsInsufficient
         $ ErrBalanceTxAssetsInsufficientError
-            TokenBundle.empty
-            TokenBundle.empty
-            TokenBundle.empty
+            mempty
+            mempty
+            mempty
 
     estimateFee :: ExceptT ErrBalanceTx (State Int) W.Fee
     estimateFee = do