diff --git a/bindings/core/src/method/secret_manager.rs b/bindings/core/src/method/secret_manager.rs
index d8e9150b31..2a13acbca0 100644
--- a/bindings/core/src/method/secret_manager.rs
+++ b/bindings/core/src/method/secret_manager.rs
@@ -79,6 +79,27 @@ pub enum SecretManagerMethod {
         #[derivative(Debug(format_with = "OmittedDebug::omitted_fmt"))]
         mnemonic: String,
     },
+    /// Set the stronghold password.
+    /// Expected response: [`Ok`](crate::Response::Ok)
+    #[cfg(feature = "stronghold")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "stronghold")))]
+    SetStrongholdPassword {
+        #[derivative(Debug(format_with = "OmittedDebug::omitted_fmt"))]
+        password: String,
+    },
+    /// Change the stronghold password.
+    /// Expected response: [`Ok`](crate::Response::Ok)
+    #[cfg(feature = "stronghold")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "stronghold")))]
+    ChangeStrongholdPassword {
+        #[derivative(Debug(format_with = "OmittedDebug::omitted_fmt"))]
+        password: String,
+    },
+    /// Clear the stronghold password.
+    /// Expected response: [`Ok`](crate::Response::Ok)
+    #[cfg(feature = "stronghold")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "stronghold")))]
+    ClearStrongholdPassword,
 }
 
 #[cfg(test)]
diff --git a/bindings/core/src/method_handler/secret_manager.rs b/bindings/core/src/method_handler/secret_manager.rs
index d766194ee1..19f4806d31 100644
--- a/bindings/core/src/method_handler/secret_manager.rs
+++ b/bindings/core/src/method_handler/secret_manager.rs
@@ -135,6 +135,42 @@ where
                 return Err(iota_sdk::client::Error::SecretManagerMismatch.into());
             }
         }
+        #[cfg(feature = "stronghold")]
+        SecretManagerMethod::SetStrongholdPassword { password } => {
+            let stronghold = if let Some(secret_manager) = secret_manager.downcast::<StrongholdSecretManager>() {
+                secret_manager
+            } else if let Some(SecretManager::Stronghold(secret_manager)) = secret_manager.downcast::<SecretManager>() {
+                secret_manager
+            } else {
+                return Err(iota_sdk::client::Error::SecretManagerMismatch.into());
+            };
+            stronghold.set_password(password).await?;
+            Response::Ok
+        }
+        #[cfg(feature = "stronghold")]
+        SecretManagerMethod::ChangeStrongholdPassword { password } => {
+            let stronghold = if let Some(secret_manager) = secret_manager.downcast::<StrongholdSecretManager>() {
+                secret_manager
+            } else if let Some(SecretManager::Stronghold(secret_manager)) = secret_manager.downcast::<SecretManager>() {
+                secret_manager
+            } else {
+                return Err(iota_sdk::client::Error::SecretManagerMismatch.into());
+            };
+            stronghold.change_password(password).await?;
+            Response::Ok
+        }
+        #[cfg(feature = "stronghold")]
+        SecretManagerMethod::ClearStrongholdPassword => {
+            let stronghold = if let Some(secret_manager) = secret_manager.downcast::<StrongholdSecretManager>() {
+                secret_manager
+            } else if let Some(SecretManager::Stronghold(secret_manager)) = secret_manager.downcast::<SecretManager>() {
+                secret_manager
+            } else {
+                return Err(iota_sdk::client::Error::SecretManagerMismatch.into());
+            };
+            stronghold.clear_key().await;
+            Response::Ok
+        }
     };
     Ok(response)
 }
diff --git a/bindings/nodejs/lib/secret_manager/secret-manager.ts b/bindings/nodejs/lib/secret_manager/secret-manager.ts
index c1f4366b7c..82196bd6c5 100644
--- a/bindings/nodejs/lib/secret_manager/secret-manager.ts
+++ b/bindings/nodejs/lib/secret_manager/secret-manager.ts
@@ -216,4 +216,33 @@ export class SecretManager {
 
         return JSON.parse(response).payload;
     }
+
+    /**
+     * Set the Stronghold password.
+     */
+    async setStrongholdPassword(password: string): Promise<void> {
+        await this.methodHandler.callMethod({
+            name: 'setStrongholdPassword',
+            data: { password },
+        });
+    }
+
+    /**
+     * Change the Stronghold password.
+     */
+    async changeStrongholdPassword(password: string): Promise<void> {
+        await this.methodHandler.callMethod({
+            name: 'changeStrongholdPassword',
+            data: { password },
+        });
+    }
+
+    /**
+     * Clear the Stronghold password.
+     */
+    async clearStrongholdPassword(): Promise<void> {
+        await this.methodHandler.callMethod({
+            name: 'clearStrongholdPassword',
+        });
+    }
 }
diff --git a/bindings/nodejs/lib/types/block/output/feature.ts b/bindings/nodejs/lib/types/block/output/feature.ts
index 0ea713e422..a9fefdd2be 100644
--- a/bindings/nodejs/lib/types/block/output/feature.ts
+++ b/bindings/nodejs/lib/types/block/output/feature.ts
@@ -163,9 +163,9 @@ class BlockIssuerFeature extends Feature {
     @Type(() => BlockIssuerKey, {
         discriminator: BlockIssuerKeyDiscriminator,
     })
-    readonly blockIssuerKeys: Set<BlockIssuerKey>;
+    readonly blockIssuerKeys: BlockIssuerKey[];
 
-    constructor(expirySlot: SlotIndex, blockIssuerKeys: Set<BlockIssuerKey>) {
+    constructor(expirySlot: SlotIndex, blockIssuerKeys: BlockIssuerKey[]) {
         super(FeatureType.BlockIssuer);
         this.expirySlot = expirySlot;
         this.blockIssuerKeys = blockIssuerKeys;
diff --git a/bindings/nodejs/lib/types/secret_manager/bridge/index.ts b/bindings/nodejs/lib/types/secret_manager/bridge/index.ts
index c9901c3440..c7027781ae 100644
--- a/bindings/nodejs/lib/types/secret_manager/bridge/index.ts
+++ b/bindings/nodejs/lib/types/secret_manager/bridge/index.ts
@@ -8,6 +8,9 @@ import type {
     __SignatureUnlockMethod__,
     __SignEd25519Method__,
     __SignSecp256k1EcdsaMethod__,
+    __SetStrongholdPasswordMethod__,
+    __ChangeStrongholdPasswordMethod__,
+    __ClearStrongholdPasswordMethod__,
 } from './secret-manager';
 
 export type __SecretManagerMethods__ =
@@ -19,4 +22,7 @@ export type __SecretManagerMethods__ =
     | __SignatureUnlockMethod__
     | __StoreMnemonicMethod__
     | __SignEd25519Method__
-    | __SignSecp256k1EcdsaMethod__;
+    | __SignSecp256k1EcdsaMethod__
+    | __SetStrongholdPasswordMethod__
+    | __ChangeStrongholdPasswordMethod__
+    | __ClearStrongholdPasswordMethod__;
diff --git a/bindings/nodejs/lib/types/secret_manager/bridge/secret-manager.ts b/bindings/nodejs/lib/types/secret_manager/bridge/secret-manager.ts
index 31bca06493..2e1390d34b 100644
--- a/bindings/nodejs/lib/types/secret_manager/bridge/secret-manager.ts
+++ b/bindings/nodejs/lib/types/secret_manager/bridge/secret-manager.ts
@@ -70,3 +70,17 @@ export interface __SignSecp256k1EcdsaMethod__ {
 export interface __GetLedgerNanoStatusMethod__ {
     name: 'getLedgerNanoStatus';
 }
+
+export interface __SetStrongholdPasswordMethod__ {
+    name: 'setStrongholdPassword';
+    data: { password: string };
+}
+
+export interface __ChangeStrongholdPasswordMethod__ {
+    name: 'changeStrongholdPassword';
+    data: { password: string };
+}
+
+export interface __ClearStrongholdPasswordMethod__ {
+    name: 'clearStrongholdPassword';
+}
diff --git a/bindings/python/iota_sdk/__init__.py b/bindings/python/iota_sdk/__init__.py
index 2b58358006..69bc5522d3 100644
--- a/bindings/python/iota_sdk/__init__.py
+++ b/bindings/python/iota_sdk/__init__.py
@@ -3,7 +3,9 @@
 
 from .external import *
 
-from .client.client import Client, NodeIndexerAPI, ClientError
+from .common import custom_encoder
+from .client.client import Client, NodeIndexerAPI
+from .client.common import ClientError
 from .client._high_level_api import GenerateAddressesOptions, GenerateAddressOptions
 from .utils import Utils
 from .wallet.wallet import Wallet, WalletOptions
diff --git a/bindings/python/iota_sdk/client/_node_core_api.py b/bindings/python/iota_sdk/client/_node_core_api.py
index 079c7395dd..f149e8c961 100644
--- a/bindings/python/iota_sdk/client/_node_core_api.py
+++ b/bindings/python/iota_sdk/client/_node_core_api.py
@@ -80,7 +80,7 @@ def post_block(self, block: Block) -> HexStr:
             The block id of the posted block.
         """
         return self._call_method('postBlock', {
-            'block': block.to_dict()
+            'block': block
         })
 
     def get_block(self, block_id: HexStr) -> Block:
diff --git a/bindings/python/iota_sdk/client/_node_indexer_api.py b/bindings/python/iota_sdk/client/_node_indexer_api.py
index cdc24277a5..db684098d4 100644
--- a/bindings/python/iota_sdk/client/_node_indexer_api.py
+++ b/bindings/python/iota_sdk/client/_node_indexer_api.py
@@ -261,10 +261,8 @@ def output_ids(
             The corresponding output IDs of the outputs.
         """
 
-        query_parameters_camelized = query_parameters.to_dict()
-
         response = self._call_method('outputIds', {
-            'queryParameters': query_parameters_camelized,
+            'queryParameters': query_parameters,
         })
         return OutputIdsResponse(response)
 
@@ -276,10 +274,8 @@ def basic_output_ids(
             The corresponding output IDs of the basic outputs.
         """
 
-        query_parameters_camelized = query_parameters.to_dict()
-
         response = self._call_method('basicOutputIds', {
-            'queryParameters': query_parameters_camelized,
+            'queryParameters': query_parameters,
         })
         return OutputIdsResponse(response)
 
@@ -291,10 +287,8 @@ def account_output_ids(
             The corresponding output IDs of the account outputs.
         """
 
-        query_parameters_camelized = query_parameters.to_dict()
-
         response = self._call_method('accountOutputIds', {
-            'queryParameters': query_parameters_camelized,
+            'queryParameters': query_parameters,
         })
         return OutputIdsResponse(response)
 
@@ -316,10 +310,8 @@ def anchor_output_ids(
             The corresponding output IDs of the anchor outputs.
         """
 
-        query_parameters_camelized = query_parameters.to_dict()
-
         response = self._call_method('anchorOutputIds', {
-            'queryParameters': query_parameters_camelized,
+            'queryParameters': query_parameters,
         })
         return OutputIdsResponse(response)
 
@@ -341,10 +333,8 @@ def delegation_output_ids(
             The corresponding output IDs of the delegation outputs.
         """
 
-        query_parameters_camelized = query_parameters.to_dict()
-
         response = self._call_method('delegationOutputIds', {
-            'queryParameters': query_parameters_camelized,
+            'queryParameters': query_parameters,
         })
         return OutputIdsResponse(response)
 
@@ -366,10 +356,8 @@ def foundry_output_ids(
             The corresponding output IDs of the foundry outputs.
         """
 
-        query_parameters_camelized = query_parameters.to_dict()
-
         response = self._call_method('foundryOutputIds', {
-            'queryParameters': query_parameters_camelized,
+            'queryParameters': query_parameters,
         })
         return OutputIdsResponse(response)
 
@@ -391,10 +379,8 @@ def nft_output_ids(
             The corresponding output IDs of the NFT outputs.
         """
 
-        query_parameters_camelized = query_parameters.to_dict()
-
         response = self._call_method('nftOutputIds', {
-            'queryParameters': query_parameters_camelized,
+            'queryParameters': query_parameters,
         })
         return OutputIdsResponse(response)
 
diff --git a/bindings/python/iota_sdk/client/client.py b/bindings/python/iota_sdk/client/client.py
index fdc26d3287..c17ae7550e 100644
--- a/bindings/python/iota_sdk/client/client.py
+++ b/bindings/python/iota_sdk/client/client.py
@@ -1,16 +1,17 @@
 # Copyright 2023 IOTA Stiftung
 # SPDX-License-Identifier: Apache-2.0
 
-from json import dumps, loads
+from json import dumps
 from datetime import timedelta
 from typing import Any, Dict, List, Optional, Union
 import humps
 
-from iota_sdk.external import create_client, call_client_method, listen_mqtt
+from iota_sdk.external import create_client, listen_mqtt
 from iota_sdk.client._node_core_api import NodeCoreAPI
 from iota_sdk.client._node_indexer_api import NodeIndexerAPI
 from iota_sdk.client._high_level_api import HighLevelAPI
 from iota_sdk.client._utils import ClientUtils
+from iota_sdk.client.common import _call_client_method_routine
 from iota_sdk.types.block.block import UnsignedBlock
 from iota_sdk.types.common import HexStr, Node
 from iota_sdk.types.feature import Feature
@@ -21,10 +22,6 @@
 from iota_sdk.types.unlock_condition import UnlockCondition
 
 
-class ClientError(Exception):
-    """Represents a client error."""
-
-
 class Client(NodeCoreAPI, NodeIndexerAPI, HighLevelAPI, ClientUtils):
     """Represents an IOTA client.
 
@@ -117,6 +114,7 @@ def get_remaining_nano_seconds(duration: timedelta):
         else:
             self.handle = client_handle
 
+    @_call_client_method_routine
     def _call_method(self, name, data=None):
         """Dumps json string and calls `call_client_method()`
         """
@@ -125,20 +123,7 @@ def _call_method(self, name, data=None):
         }
         if data:
             message['data'] = data
-        message = dumps(message)
-
-        # Send message to the Rust library
-        response = call_client_method(self.handle, message)
-
-        json_response = loads(response)
-
-        if "type" in json_response:
-            if json_response["type"] == "error":
-                raise ClientError(json_response['payload'])
-
-        if "payload" in json_response:
-            return json_response['payload']
-        return response
+        return message
 
     def get_handle(self):
         """Get the client handle.
@@ -171,26 +156,11 @@ def build_account_output(self,
             The account output as dict.
         """
 
-        unlock_conditions = [unlock_condition.to_dict()
-                             for unlock_condition in unlock_conditions]
-
-        if features:
-            features = [feature.to_dict() for feature in features]
-        if immutable_features:
-            immutable_features = [immutable_feature.to_dict()
-                                  for immutable_feature in immutable_features]
-
-        if amount:
-            amount = str(amount)
-
-        if mana:
-            mana = str(mana)
-
         return deserialize_output(self._call_method('buildAccountOutput', {
             'accountId': account_id,
             'unlockConditions': unlock_conditions,
-            'amount': amount,
-            'mana': mana,
+            'amount': None if amount is None else str(amount),
+            'mana': None if mana is None else str(mana),
             'foundryCounter': foundry_counter,
             'features': features,
             'immutableFeatures': immutable_features
@@ -213,22 +183,10 @@ def build_basic_output(self,
             The basic output as dict.
         """
 
-        unlock_conditions = [unlock_condition.to_dict()
-                             for unlock_condition in unlock_conditions]
-
-        if features:
-            features = [feature.to_dict() for feature in features]
-
-        if amount:
-            amount = str(amount)
-
-        if mana:
-            mana = str(mana)
-
         return deserialize_output(self._call_method('buildBasicOutput', {
             'unlockConditions': unlock_conditions,
-            'amount': amount,
-            'mana': mana,
+            'amount': None if amount is None else str(amount),
+            'mana': None if mana is None else str(mana),
             'features': features,
         }))
 
@@ -253,23 +211,11 @@ def build_foundry_output(self,
             The foundry output as dict.
         """
 
-        unlock_conditions = [unlock_condition.to_dict()
-                             for unlock_condition in unlock_conditions]
-
-        if features:
-            features = [feature.to_dict() for feature in features]
-        if immutable_features:
-            immutable_features = [immutable_feature.to_dict()
-                                  for immutable_feature in immutable_features]
-
-        if amount:
-            amount = str(amount)
-
         return deserialize_output(self._call_method('buildFoundryOutput', {
             'serialNumber': serial_number,
-            'tokenScheme': token_scheme.to_dict(),
+            'tokenScheme': token_scheme,
             'unlockConditions': unlock_conditions,
-            'amount': amount,
+            'amount': None if amount is None else str(amount),
             'features': features,
             'immutableFeatures': immutable_features
         }))
@@ -295,26 +241,11 @@ def build_nft_output(self,
             The NFT output as dict.
         """
 
-        unlock_conditions = [unlock_condition.to_dict()
-                             for unlock_condition in unlock_conditions]
-
-        if features:
-            features = [feature.to_dict() for feature in features]
-        if immutable_features:
-            immutable_features = [immutable_feature.to_dict()
-                                  for immutable_feature in immutable_features]
-
-        if amount:
-            amount = str(amount)
-
-        if mana:
-            mana = str(mana)
-
         return deserialize_output(self._call_method('buildNftOutput', {
             'nftId': nft_id,
             'unlockConditions': unlock_conditions,
-            'amount': amount,
-            'mana': mana,
+            'amount': None if amount is None else str(amount),
+            'mana': None if mana is None else str(mana),
             'features': features,
             'immutableFeatures': immutable_features
         }))
@@ -358,8 +289,6 @@ def build_basic_block(
         Returns:
             An unsigned block.
         """
-        if payload is not None:
-            payload = payload.to_dict()
         result = self._call_method('buildBasicBlock', {
             'issuerId': issuer_id,
             'payload': payload,
diff --git a/bindings/python/iota_sdk/client/common.py b/bindings/python/iota_sdk/client/common.py
new file mode 100644
index 0000000000..ba12cdf348
--- /dev/null
+++ b/bindings/python/iota_sdk/client/common.py
@@ -0,0 +1,30 @@
+# Copyright 2024 IOTA Stiftung
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from iota_sdk import call_client_method
+from iota_sdk.common import custom_encoder
+
+
+def _call_client_method_routine(func):
+    """The routine of dump json string and call call_client_method().
+    """
+    def wrapper(*args, **kwargs):
+        message = custom_encoder(func, *args, **kwargs)
+        # Send message to the Rust library
+        response = call_client_method(args[0].handle, message)
+
+        json_response = json.loads(response)
+
+        if "type" in json_response:
+            if json_response["type"] == "error" or json_response["type"] == "panic":
+                raise ClientError(json_response['payload'])
+
+        if "payload" in json_response:
+            return json_response['payload']
+        return response
+    return wrapper
+
+
+class ClientError(Exception):
+    """A client error."""
diff --git a/bindings/python/iota_sdk/common.py b/bindings/python/iota_sdk/common.py
new file mode 100644
index 0000000000..0b624d6ea2
--- /dev/null
+++ b/bindings/python/iota_sdk/common.py
@@ -0,0 +1,51 @@
+# Copyright 2024 IOTA Stiftung
+# SPDX-License-Identifier: Apache-2.0
+
+import json
+from json import dumps, JSONEncoder
+from enum import Enum
+import humps
+
+
+def custom_encoder(func, *args, **kwargs):
+    """Converts the parameters to a JSON string and removes None values.
+    """
+    class MyEncoder(JSONEncoder):
+        """Custom encoder
+        """
+        # pylint: disable=too-many-return-statements
+
+        def default(self, o):
+            to_dict_method = getattr(o, "to_dict", None)
+            if callable(to_dict_method):
+                return o.to_dict()
+            if isinstance(o, str):
+                return o
+            if isinstance(o, Enum):
+                return o.__dict__
+            if isinstance(o, dict):
+                return o
+            if hasattr(o, "__dict__"):
+                obj_dict = o.__dict__
+                items_method = getattr(self, "items", None)
+                if callable(items_method):
+                    for k, v in obj_dict.items():
+                        obj_dict[k] = dumps(v, cls=MyEncoder)
+                return obj_dict
+            return o
+    message = func(*args, **kwargs)
+    for k, v in message.items():
+        if not isinstance(v, str):
+            message[k] = json.loads(dumps(v, cls=MyEncoder))
+
+    def remove_none(obj):
+        if isinstance(obj, (list, tuple, set)):
+            return type(obj)(remove_none(x) for x in obj if x is not None)
+        if isinstance(obj, dict):
+            return type(obj)((remove_none(k), remove_none(v))
+                             for k, v in obj.items() if k is not None and v is not None)
+        return obj
+
+    message_null_filtered = remove_none(message)
+    message = dumps(humps.camelize(message_null_filtered))
+    return message
diff --git a/bindings/python/iota_sdk/types/output.py b/bindings/python/iota_sdk/types/output.py
index 37adc08d30..005ed65c54 100644
--- a/bindings/python/iota_sdk/types/output.py
+++ b/bindings/python/iota_sdk/types/output.py
@@ -301,7 +301,7 @@ def deserialize_output(d: Dict[str, Any]) -> Output:
     Arguments:
     * `d`: A dictionary that is expected to have a key called 'type' which specifies the type of the returned value.
     """
-    output_type = dict['type']
+    output_type = d['type']
     if output_type == OutputType.Basic:
         return BasicOutput.from_dict(d)
     if output_type == OutputType.Account:
diff --git a/bindings/python/iota_sdk/types/output_id.py b/bindings/python/iota_sdk/types/output_id.py
index 2a2742aef6..0a824cfd47 100644
--- a/bindings/python/iota_sdk/types/output_id.py
+++ b/bindings/python/iota_sdk/types/output_id.py
@@ -24,9 +24,7 @@ def __init__(self, transaction_id: HexStr, output_index: int):
             raise ValueError('transaction_id must start with 0x')
         # Validate that it has only valid hex characters
         int(transaction_id[2:], 16)
-        if output_index not in range(0, 129):
-            raise ValueError('output_index must be a value from 0 to 128')
-        output_index_hex = (output_index).to_bytes(2, "little").hex()
+        output_index_hex = (output_index).to_bytes(4, "little").hex()
         self.output_id = transaction_id + output_index_hex
         self.transaction_id = transaction_id
         self.output_index = output_index
@@ -43,9 +41,9 @@ def from_string(cls, output_id: HexStr):
         """
         obj = cls.__new__(cls)
         super(OutputId, obj).__init__()
-        if len(output_id) != 70:
+        if len(output_id) != 78:
             raise ValueError(
-                'output_id length must be 70 characters with 0x prefix')
+                'output_id length must be 78 characters with 0x prefix')
         if not output_id.startswith('0x'):
             raise ValueError('transaction_id must start with 0x')
         # Validate that it has only valid hex characters
diff --git a/bindings/python/iota_sdk/wallet/common.py b/bindings/python/iota_sdk/wallet/common.py
index 131591917e..e91168bf01 100644
--- a/bindings/python/iota_sdk/wallet/common.py
+++ b/bindings/python/iota_sdk/wallet/common.py
@@ -2,57 +2,15 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import json
-from json import dumps, JSONEncoder
-from enum import Enum
-import humps
 from iota_sdk import call_wallet_method
+from iota_sdk.common import custom_encoder
 
 
-def _call_method_routine(func):
+def _call_wallet_method_routine(func):
     """The routine of dump json string and call call_wallet_method().
     """
     def wrapper(*args, **kwargs):
-        class MyEncoder(JSONEncoder):
-            """Custom encoder
-            """
-
-            # pylint: disable=too-many-return-statements
-            def default(self, o):
-                to_dict_method = getattr(o, "to_dict", None)
-                if callable(to_dict_method):
-                    return o.to_dict()
-                if isinstance(o, str):
-                    return o
-                if isinstance(o, Enum):
-                    return o.__dict__
-                if isinstance(o, dict):
-                    return o
-                if hasattr(o, "__dict__"):
-                    obj_dict = o.__dict__
-
-                    items_method = getattr(self, "items", None)
-                    if callable(items_method):
-                        for k, v in obj_dict.items():
-                            obj_dict[k] = dumps(v, cls=MyEncoder)
-                            return obj_dict
-                    return obj_dict
-                return o
-        message = func(*args, **kwargs)
-
-        for k, v in message.items():
-            if not isinstance(v, str):
-                message[k] = json.loads(dumps(v, cls=MyEncoder))
-
-        def remove_none(obj):
-            if isinstance(obj, (list, tuple, set)):
-                return type(obj)(remove_none(x) for x in obj if x is not None)
-            if isinstance(obj, dict):
-                return type(obj)((remove_none(k), remove_none(v))
-                                 for k, v in obj.items() if k is not None and v is not None)
-            return obj
-
-        message_null_filtered = remove_none(message)
-        message = dumps(humps.camelize(message_null_filtered))
+        message = custom_encoder(func, *args, **kwargs)
         # Send message to the Rust library
         response = call_wallet_method(args[0].handle, message)
 
diff --git a/bindings/python/iota_sdk/wallet/wallet.py b/bindings/python/iota_sdk/wallet/wallet.py
index eb57979fa0..bc52528bdf 100644
--- a/bindings/python/iota_sdk/wallet/wallet.py
+++ b/bindings/python/iota_sdk/wallet/wallet.py
@@ -8,7 +8,7 @@
 from iota_sdk import destroy_wallet, create_wallet, listen_wallet, get_client_from_wallet, get_secret_manager_from_wallet, Client
 from iota_sdk.secret_manager.secret_manager import LedgerNanoSecretManager, MnemonicSecretManager, StrongholdSecretManager, SeedSecretManager, SecretManager
 
-from iota_sdk.wallet.common import _call_method_routine
+from iota_sdk.wallet.common import _call_wallet_method_routine
 from iota_sdk.wallet.prepared_transaction import PreparedTransaction, PreparedCreateTokenTransaction
 from iota_sdk.wallet.sync_options import SyncOptions
 from iota_sdk.types.balance import Balance
@@ -63,7 +63,7 @@ def get_handle(self):
         """
         return self.handle
 
-    @_call_method_routine
+    @_call_wallet_method_routine
     def _call_method(self, name: str, data=None):
         message = {
             'name': name
diff --git a/bindings/python/tests/test_offline.py b/bindings/python/tests/test_offline.py
index e827558113..8a4a892a8c 100644
--- a/bindings/python/tests/test_offline.py
+++ b/bindings/python/tests/test_offline.py
@@ -61,12 +61,12 @@ def test_output_id(self):
         output_index = 42
         output_id = OutputId(transaction_id, output_index)
         assert repr(
-            output_id) == '0x52fdfc072182654f163f5f0f9a621d729566c74d10037c4d7bbb0407d1e2c6492a00'
+            output_id) == '0x52fdfc072182654f163f5f0f9a621d729566c74d10037c4d7bbb0407d1e2c6492a000000'
 
         new_output_id = OutputId.from_string(
-            '0x52fdfc072182654f163f5f0f9a621d729566c74d10037c4d7bbb0407d1e2c6492a00')
+            '0x52fdfc072182654f163f5f0f9a621d729566c74d10037c4d7bbb0407d1e2c6492a0000000000')
         assert repr(
-            new_output_id) == '0x52fdfc072182654f163f5f0f9a621d729566c74d10037c4d7bbb0407d1e2c6492a00'
+            new_output_id) == '0x52fdfc072182654f163f5f0f9a621d729566c74d10037c4d7bbb0407d1e2c6492a0000000000'
         assert new_output_id.transaction_id == transaction_id
         assert new_output_id.output_index == output_index
 
@@ -79,16 +79,13 @@ def test_output_id(self):
         transaction_id_invalid_hex_char = '0xz2fdfc072182654f163f5f0f9a621d729566c74d10037c4d7bbb0407d1e2c649'
         with self.assertRaises(ValueError):
             OutputId(transaction_id_invalid_hex_char, output_index)
-        invalid_output_index = 129
-        with self.assertRaises(ValueError):
-            OutputId(transaction_id, invalid_output_index)
-        output_id_missing_0x_prefix = '52fdfc072182654f163f5f0f9a621d729566c74d10037c4d7bbb0407d1e2c6492a00'
+        output_id_missing_0x_prefix = '52fdfc072182654f163f5f0f9a621d729566c74d10037c4d7bbb0407d1e2c6492a00000000'
         with self.assertRaises(ValueError):
             OutputId.from_string(output_id_missing_0x_prefix)
-        output_id_invalid_hex_char = '0xz2fdfc072182654f163f5f0f9a621d729566c74d10037c4d7bbb0407d1e2c6492a00'
+        output_id_invalid_hex_char = '0xz2fdfc072182654f163f5f0f9a621d729566c74d10037c4d7bbb0407d1e2c6492a00000000'
         with self.assertRaises(ValueError):
             OutputId.from_string(output_id_invalid_hex_char)
-        output_id_invalid_hex_prefix = '0052fdfc072182654f163f5f0f9a621d729566c74d10037c4d7bbb0407d1e2c6492a00'
+        output_id_invalid_hex_prefix = '0052fdfc072182654f163f5f0f9a621d729566c74d10037c4d7bbb0407d1e2c6492a00000000'
         with self.assertRaises(ValueError):
             OutputId.from_string(output_id_invalid_hex_prefix)
 
diff --git a/cli/src/wallet_cli/mod.rs b/cli/src/wallet_cli/mod.rs
index 88616d9bb4..0ff7bda314 100644
--- a/cli/src/wallet_cli/mod.rs
+++ b/cli/src/wallet_cli/mod.rs
@@ -181,6 +181,8 @@ pub enum WalletCommand {
         /// Selector for output.
         /// Either by ID (e.g. 0xbce525324af12eda02bf7927e92cea3a8e8322d0f41966271443e6c3b245a4400000) or index.
         selector: OutputSelector,
+        #[arg(short, long)]
+        metadata: bool,
     },
     /// List all outputs.
     Outputs,
@@ -803,7 +805,7 @@ pub async fn node_info_command(wallet: &Wallet) -> Result<(), Error> {
 }
 
 /// `output` command
-pub async fn output_command(wallet: &Wallet, selector: OutputSelector) -> Result<(), Error> {
+pub async fn output_command(wallet: &Wallet, selector: OutputSelector, metadata: bool) -> Result<(), Error> {
     let wallet_data = wallet.data().await;
     let output = match selector {
         OutputSelector::Id(id) => wallet_data.get_output(&id),
@@ -815,7 +817,11 @@ pub async fn output_command(wallet: &Wallet, selector: OutputSelector) -> Result
     };
 
     if let Some(output) = output {
-        println_log_info!("{output:#?}");
+        if metadata {
+            println_log_info!("{output:#?}");
+        } else {
+            println_log_info!("{:#?}", output.output);
+        }
     } else {
         println_log_info!("Output not found");
     }
@@ -1286,7 +1292,9 @@ pub async fn prompt_internal(
                             .await
                         }
                         WalletCommand::NodeInfo => node_info_command(wallet).await,
-                        WalletCommand::Output { selector } => output_command(wallet, selector).await,
+                        WalletCommand::Output { selector, metadata } => {
+                            output_command(wallet, selector, metadata).await
+                        }
                         WalletCommand::Outputs => outputs_command(wallet).await,
                         WalletCommand::Send {
                             address,
diff --git a/sdk/src/types/block/error.rs b/sdk/src/types/block/error.rs
index 6e293465ad..672be985dc 100644
--- a/sdk/src/types/block/error.rs
+++ b/sdk/src/types/block/error.rs
@@ -196,7 +196,7 @@ pub enum Error {
     DuplicateOutputChain(ChainId),
     InvalidField(&'static str),
     NullDelegationValidatorId,
-    InvalidEpochDelta {
+    InvalidEpochDiff {
         created: EpochIndex,
         target: EpochIndex,
     },
@@ -429,8 +429,8 @@ impl fmt::Display for Error {
             Self::DuplicateOutputChain(chain_id) => write!(f, "duplicate output chain {chain_id}"),
             Self::InvalidField(field) => write!(f, "invalid field: {field}"),
             Self::NullDelegationValidatorId => write!(f, "null delegation validator ID"),
-            Self::InvalidEpochDelta { created, target } => {
-                write!(f, "invalid epoch delta: created {created}, target {target}")
+            Self::InvalidEpochDiff { created, target } => {
+                write!(f, "invalid epoch diff: created {created}, target {target}")
             }
             Self::TrailingCapabilityBytes => write!(f, "capability bytes have trailing zeroes"),
             Self::RestrictedAddressCapability(cap) => write!(f, "restricted address capability: {cap:?}"),
diff --git a/sdk/src/types/block/mana/parameters.rs b/sdk/src/types/block/mana/parameters.rs
index e6d68aa698..e9e8469489 100644
--- a/sdk/src/types/block/mana/parameters.rs
+++ b/sdk/src/types/block/mana/parameters.rs
@@ -53,18 +53,23 @@ impl ManaParameters {
         self.decay_factors.get(*epoch_index.into() as usize).copied()
     }
 
+    /// Returns the annual decay factor.
+    pub fn annual_decay_factor(&self) -> f64 {
+        self.annual_decay_factor_percentage() as f64 / 100.0
+    }
+
     /// Returns the max mana that can exist with the mana bits defined.
     pub fn max_mana(&self) -> u64 {
         (1 << self.bits_count) - 1
     }
 
-    fn decay(&self, mut mana: u64, epoch_delta: u32) -> u64 {
-        if mana == 0 || epoch_delta == 0 || self.decay_factors().is_empty() {
+    fn decay(&self, mut mana: u64, epoch_diff: u32) -> u64 {
+        if mana == 0 || epoch_diff == 0 || self.decay_factors().is_empty() {
             return mana;
         }
 
         // we keep applying the lookup table factors as long as n epochs are left
-        let mut remaining_epochs = epoch_delta;
+        let mut remaining_epochs = epoch_diff;
 
         while remaining_epochs > 0 {
             let epochs_to_decay = remaining_epochs.min(self.decay_factors().len() as u32);
@@ -80,13 +85,14 @@ impl ManaParameters {
         mana
     }
 
-    fn generate_mana(&self, amount: u64, slot_delta: u32) -> u64 {
-        if self.generation_rate() == 0 || slot_delta == 0 {
+    fn generate_mana(&self, amount: u64, slot_diff: u32) -> u64 {
+        if self.generation_rate() == 0 || slot_diff == 0 {
             return 0;
         }
+
         fixed_point_multiply(
             amount,
-            slot_delta * self.generation_rate() as u32,
+            slot_diff * self.generation_rate() as u32,
             self.generation_rate_exponent(),
         )
     }
@@ -116,17 +122,18 @@ impl ProtocolParameters {
         slot_index_created: impl Into<SlotIndex>,
         slot_index_target: impl Into<SlotIndex>,
     ) -> Result<u64, Error> {
-        let (slot_index_created, slot_index_target) = (slot_index_created.into(), slot_index_target.into());
         let (epoch_index_created, epoch_index_target) = (
             self.epoch_index_of(slot_index_created),
             self.epoch_index_of(slot_index_target),
         );
+
         if epoch_index_created > epoch_index_target {
-            return Err(Error::InvalidEpochDelta {
+            return Err(Error::InvalidEpochDiff {
                 created: epoch_index_created,
                 target: epoch_index_target,
             });
         }
+
         Ok(self
             .mana_parameters()
             .decay(mana, epoch_index_target.0 - epoch_index_created.0))
@@ -140,18 +147,20 @@ impl ProtocolParameters {
         claimed_epoch: impl Into<EpochIndex>,
     ) -> Result<u64, Error> {
         let (reward_epoch, claimed_epoch) = (reward_epoch.into(), claimed_epoch.into());
+
         if reward_epoch > claimed_epoch {
-            return Err(Error::InvalidEpochDelta {
+            return Err(Error::InvalidEpochDiff {
                 created: reward_epoch,
                 target: claimed_epoch,
             });
         }
+
         Ok(self.mana_parameters().decay(reward, claimed_epoch.0 - reward_epoch.0))
     }
 
     /// Calculates the potential mana that is generated by holding `amount` tokens from `slot_index_created` to
     /// `slot_index_target` and applies the decay to the result
-    pub fn potential_mana(
+    pub fn generate_mana_with_decay(
         &self,
         amount: u64,
         slot_index_created: impl Into<SlotIndex>,
@@ -162,8 +171,9 @@ impl ProtocolParameters {
             self.epoch_index_of(slot_index_created),
             self.epoch_index_of(slot_index_target),
         );
+
         if epoch_index_created > epoch_index_target {
-            return Err(Error::InvalidEpochDelta {
+            return Err(Error::InvalidEpochDiff {
                 created: epoch_index_created,
                 target: epoch_index_target,
             });
@@ -171,35 +181,35 @@ impl ProtocolParameters {
         if slot_index_created >= slot_index_target {
             return Ok(0);
         }
+
         let mana_parameters = self.mana_parameters();
 
         Ok(if epoch_index_created == epoch_index_target {
             mana_parameters.generate_mana(amount, slot_index_target.0 - slot_index_created.0)
         } else if epoch_index_target == epoch_index_created + 1 {
-            let slots_before_next_epoch = self.first_slot_of(epoch_index_created + 1) - slot_index_created;
-            let slots_since_epoch_start = slot_index_target - self.first_slot_of(epoch_index_target);
-            let mana_decayed =
-                mana_parameters.decay(mana_parameters.generate_mana(amount, slots_before_next_epoch.0), 1);
-            let mana_generated = mana_parameters.generate_mana(amount, slots_since_epoch_start.0);
-            mana_decayed + mana_generated
+            let mana_generated_first_epoch =
+                mana_parameters.generate_mana(amount, self.slots_before_next_epoch(slot_index_created));
+            let mana_decayed_first_epoch = mana_parameters.decay(mana_generated_first_epoch, 1);
+            let mana_generated_second_epoch =
+                mana_parameters.generate_mana(amount, self.slots_since_epoch_start(slot_index_target));
+            mana_decayed_first_epoch + mana_generated_second_epoch
         } else {
+            let mana_generated_first_epoch =
+                mana_parameters.generate_mana(amount, self.slots_before_next_epoch(slot_index_created));
+            let mana_decayed_first_epoch =
+                mana_parameters.decay(mana_generated_first_epoch, epoch_index_target.0 - epoch_index_created.0);
             let c = fixed_point_multiply(
                 amount,
                 mana_parameters.decay_factor_epochs_sum() * mana_parameters.generation_rate() as u32,
                 mana_parameters.decay_factor_epochs_sum_exponent() + mana_parameters.generation_rate_exponent()
                     - self.slots_per_epoch_exponent(),
             );
-            let epoch_delta = epoch_index_target.0 - epoch_index_created.0;
-            let slots_before_next_epoch = self.first_slot_of(epoch_index_created + 1) - slot_index_created;
-            let slots_since_epoch_start = slot_index_target - self.first_slot_of(epoch_index_target);
-            let potential_mana_n = mana_parameters.decay(
-                mana_parameters.generate_mana(amount, slots_before_next_epoch.0),
-                epoch_delta,
-            );
-            let potential_mana_n_1 = mana_parameters.decay(c, epoch_delta - 1);
-            let potential_mana_0 = c + mana_parameters.generate_mana(amount, slots_since_epoch_start.0)
-                - (c >> mana_parameters.decay_factors_exponent());
-            potential_mana_0 - potential_mana_n_1 + potential_mana_n
+            let mana_decayed_intermediate_epochs =
+                c - mana_parameters.decay(c, epoch_index_target.0 - epoch_index_created.0 - 1);
+            let mana_generated_last_epoch =
+                mana_parameters.generate_mana(amount, self.slots_since_epoch_start(slot_index_target));
+            mana_decayed_intermediate_epochs + mana_generated_last_epoch + mana_decayed_first_epoch
+                - (c >> mana_parameters.decay_factors_exponent())
         })
     }
 }
@@ -217,32 +227,33 @@ mod test {
 
     // Tests from https://github.com/iotaledger/iota.go/blob/develop/mana_decay_provider_test.go
 
-    const BETA_PER_YEAR: f64 = 1. / 3.;
-
     fn params() -> &'static ProtocolParameters {
         use once_cell::sync::Lazy;
         static PARAMS: Lazy<ProtocolParameters> = Lazy::new(|| {
             let mut params = ProtocolParameters {
+                genesis_slot: 0,
+                genesis_unix_timestamp: time::OffsetDateTime::now_utc().unix_timestamp() as _,
                 slots_per_epoch_exponent: 13,
                 slot_duration_in_seconds: 10,
+                token_supply: 1813620509061365,
                 mana_parameters: ManaParameters {
                     bits_count: 63,
                     generation_rate: 1,
-                    generation_rate_exponent: 27,
+                    generation_rate_exponent: 17,
                     decay_factors_exponent: 32,
-                    decay_factor_epochs_sum_exponent: 20,
+                    decay_factor_epochs_sum_exponent: 21,
+                    annual_decay_factor_percentage: 70,
                     ..Default::default()
                 },
                 ..Default::default()
             };
             params.mana_parameters.decay_factors = {
-                let epochs_per_year = ((365_u64 * 24 * 60 * 60) as f64 / params.slot_duration_in_seconds() as f64)
-                    / params.slots_per_epoch() as f64;
-                let beta_per_epoch_index = BETA_PER_YEAR / epochs_per_year;
-                (1..=epochs_per_year.floor() as usize)
+                let epochs_in_table = (u16::MAX as usize).min(params.epochs_per_year().floor() as usize);
+                let decay_per_epoch = params.decay_per_epoch();
+                (1..=epochs_in_table)
                     .map(|epoch| {
-                        ((-beta_per_epoch_index * epoch as f64).exp()
-                            * (params.mana_parameters().decay_factors_exponent() as f64).exp2())
+                        (decay_per_epoch.powi(epoch as _)
+                            * 2f64.powi(params.mana_parameters().decay_factors_exponent() as _))
                         .floor() as u32
                     })
                     .collect::<Box<[_]>>()
@@ -250,11 +261,11 @@ mod test {
             .try_into()
             .unwrap();
             params.mana_parameters.decay_factor_epochs_sum = {
-                let delta = params.slots_per_epoch() as f64 * params.slot_duration_in_seconds() as f64
-                    / (365_u64 * 24 * 60 * 60) as f64;
-                (((-BETA_PER_YEAR * delta).exp() / (1. - (-BETA_PER_YEAR * delta).exp()))
-                    * (params.mana_parameters().decay_factor_epochs_sum_exponent() as f64).exp2())
-                .floor() as u32
+                let delta = params.epochs_per_year().recip();
+                let annual_decay_factor = params.mana_parameters().annual_decay_factor();
+                (annual_decay_factor.powf(delta) / (1.0 - annual_decay_factor.powf(delta))
+                    * (2f64.powi(params.mana_parameters().decay_factor_epochs_sum_exponent() as _)))
+                .floor() as _
             };
             params
         });
@@ -270,145 +281,271 @@ mod test {
         assert_eq!(mana_parameters.decay(100, 100), 100);
     }
 
-    #[test]
-    fn mana_decay_no_delta() {
-        assert_eq!(
-            params().mana_with_decay(100, params().first_slot_of(1), params().first_slot_of(1)),
-            Ok(100)
-        );
-    }
-
-    #[test]
-    fn mana_decay_no_mana() {
-        assert_eq!(
-            params().mana_with_decay(0, params().first_slot_of(1), params().first_slot_of(400)),
-            Ok(0)
-        );
-    }
-
-    #[test]
-    fn mana_decay_negative_delta() {
-        assert_eq!(
-            params().mana_with_decay(100, params().first_slot_of(2), params().first_slot_of(1)),
-            Err(Error::InvalidEpochDelta {
-                created: 2.into(),
-                target: 1.into()
-            })
-        );
-    }
-
-    #[test]
-    fn mana_decay_lookup_len_delta() {
-        assert_eq!(
-            params().mana_with_decay(
-                u64::MAX,
-                params().first_slot_of(1),
-                params().first_slot_of(params().mana_parameters().decay_factors().len() as u32 + 1)
-            ),
-            Ok(13228672242897911807)
-        );
-    }
-
-    #[test]
-    fn mana_decay_lookup_len_delta_multiple() {
-        assert_eq!(
-            params().mana_with_decay(
-                u64::MAX,
-                params().first_slot_of(1),
-                params().first_slot_of(3 * params().mana_parameters().decay_factors().len() as u32 + 1)
-            ),
-            Ok(6803138682699798504)
-        );
-    }
-
-    #[test]
-    fn mana_decay_max_mana() {
-        assert_eq!(
-            params().mana_with_decay(u64::MAX, params().first_slot_of(1), params().first_slot_of(401)),
-            Ok(13046663022640287317)
-        );
+    struct ManaDecayTest {
+        name: &'static str,
+        stored_mana: u64,
+        created_slot: SlotIndex,
+        target_slot: SlotIndex,
+        err: Option<Error>,
     }
 
     #[test]
-    fn potential_mana_no_delta() {
-        assert_eq!(
-            params().potential_mana(100, params().first_slot_of(1), params().first_slot_of(1)),
-            Ok(0)
-        );
+    fn mana_decay() {
+        let tests = [
+            ManaDecayTest {
+                name: "check if mana decay works for 0 mana values",
+                stored_mana: 0,
+                created_slot: params().first_slot_of(1),
+                target_slot: params().first_slot_of(400),
+                err: None,
+            },
+            ManaDecayTest {
+                name: "check if mana decay works for 0 slot index diffs",
+                stored_mana: u64::MAX,
+                created_slot: params().first_slot_of(1),
+                target_slot: params().first_slot_of(1),
+                err: None,
+            },
+            ManaDecayTest {
+                name: "check for error if target index is lower than created index",
+                stored_mana: 0,
+                created_slot: params().first_slot_of(2),
+                target_slot: params().first_slot_of(1),
+                err: Some(Error::InvalidEpochDiff {
+                    created: 2.into(),
+                    target: 1.into(),
+                }),
+            },
+            ManaDecayTest {
+                name: "check if mana decay works for exactly the amount of epochs in the lookup table",
+                stored_mana: u64::MAX,
+                created_slot: params().first_slot_of(1),
+                target_slot: params().first_slot_of(params().mana_parameters().decay_factors().len() as u32 + 1),
+                err: None,
+            },
+            ManaDecayTest {
+                name: "check if mana decay works for multiples of the available epochs in the lookup table",
+                stored_mana: u64::MAX,
+                created_slot: params().first_slot_of(1),
+                target_slot: params().first_slot_of(3 * params().mana_parameters().decay_factors().len() as u32 + 1),
+                err: None,
+            },
+            ManaDecayTest {
+                name: "even with the highest possible uint64 number, the calculation should not overflow",
+                stored_mana: u64::MAX,
+                created_slot: params().first_slot_of(1),
+                target_slot: params().first_slot_of(401),
+                err: None,
+            },
+        ];
+
+        for ManaDecayTest {
+            name,
+            stored_mana,
+            created_slot,
+            target_slot,
+            err,
+        } in tests
+        {
+            let result = params().mana_with_decay(stored_mana, created_slot, target_slot);
+            if let Some(err) = err {
+                assert_eq!(result, Err(err), "{name}");
+            } else {
+                let result = result.map_err(|e| format!("{name}: {e}")).unwrap();
+                let upper_bound = upper_bound_mana_decay(stored_mana, created_slot, target_slot);
+                let lower_bound = lower_bound_mana_decay(stored_mana, created_slot, target_slot);
+
+                assert!(
+                    result as f64 <= upper_bound,
+                    "{name}: result {result} above upper bound {upper_bound}",
+                );
+                assert!(
+                    result as f64 >= lower_bound,
+                    "{name}: result {result} below lower bound {upper_bound}",
+                );
+            }
+        }
     }
 
-    #[test]
-    fn potential_mana_no_mana() {
-        assert_eq!(
-            params().potential_mana(0, params().first_slot_of(1), params().first_slot_of(400)),
-            Ok(0)
-        );
+    struct ManaGenerationTest {
+        name: &'static str,
+        amount: u64,
+        created_slot: SlotIndex,
+        target_slot: SlotIndex,
+        err: Option<Error>,
     }
 
     #[test]
-    fn potential_mana_negative_delta() {
-        assert_eq!(
-            params().potential_mana(100, params().first_slot_of(2), params().first_slot_of(1)),
-            Err(Error::InvalidEpochDelta {
-                created: 2.into(),
-                target: 1.into()
-            })
-        );
+    fn mana_generation() {
+        let tests = [
+            ManaGenerationTest {
+                name: "check if mana generation works for 0 mana values",
+                amount: 0,
+                created_slot: params().first_slot_of(1),
+                target_slot: params().first_slot_of(400),
+                err: None,
+            },
+            ManaGenerationTest {
+                name: "check if mana generation works for 0 slot index diffs",
+                amount: i64::MAX as _,
+                created_slot: params().first_slot_of(1),
+                target_slot: params().first_slot_of(1),
+                err: None,
+            },
+            ManaGenerationTest {
+                name: "check for error if target index is lower than created index",
+                amount: 0,
+                created_slot: params().first_slot_of(2),
+                target_slot: params().first_slot_of(1),
+                err: Some(Error::InvalidEpochDiff {
+                    created: 2.into(),
+                    target: 1.into(),
+                }),
+            },
+            ManaGenerationTest {
+                name: "check if mana generation works for exactly the amount of epochs in the lookup table",
+                amount: params().token_supply(),
+                created_slot: params().first_slot_of(1),
+                target_slot: params().first_slot_of(params().mana_parameters().decay_factors().len() as u32 + 1),
+                err: None,
+            },
+            ManaGenerationTest {
+                name: "check if mana generation works for multiples of the available epochs in the lookup table",
+                amount: params().token_supply(),
+                created_slot: params().first_slot_of(1),
+                target_slot: params().first_slot_of(3 * params().mana_parameters().decay_factors().len() as u32 + 1),
+                err: None,
+            },
+            ManaGenerationTest {
+                name: "check if mana generation works for 0 epoch diffs",
+                amount: params().token_supply(),
+                created_slot: params().first_slot_of(1),
+                target_slot: params().last_slot_of(1),
+                err: None,
+            },
+            ManaGenerationTest {
+                name: "check if mana generation works for 1 epoch diffs",
+                amount: params().token_supply(),
+                created_slot: params().first_slot_of(1),
+                target_slot: params().last_slot_of(2),
+                err: None,
+            },
+            ManaGenerationTest {
+                name: "check if mana generation works for >=2 epoch diffs",
+                amount: params().token_supply(),
+                created_slot: params().first_slot_of(1),
+                target_slot: params().last_slot_of(3),
+                err: None,
+            },
+        ];
+
+        for ManaGenerationTest {
+            name,
+            amount,
+            created_slot,
+            target_slot,
+            err,
+        } in tests
+        {
+            let result = params().generate_mana_with_decay(amount, created_slot, target_slot);
+            if let Some(err) = err {
+                assert_eq!(result, Err(err), "{name}");
+            } else {
+                let result = result.map_err(|e| format!("{name}: {e}")).unwrap();
+                let upper_bound = upper_bound_mana_generation(amount, created_slot, target_slot);
+                let lower_bound = lower_bound_mana_generation(amount, created_slot, target_slot);
+
+                assert!(
+                    result as f64 <= upper_bound,
+                    "{name}: result {result} above upper bound {upper_bound}",
+                );
+                assert!(
+                    result as f64 >= lower_bound,
+                    "{name}: result {result} below lower bound {upper_bound}",
+                );
+
+                if result != 0 {
+                    let float_res = mana_generation_with_decay_float(amount as _, created_slot, target_slot);
+                    let epsilon = 0.001;
+                    let allowed_delta = float_res.abs().min(result as f64) * epsilon;
+                    let dt = float_res - result as f64;
+                    assert!(
+                        dt >= -allowed_delta && dt <= allowed_delta,
+                        "{name}: fixed point result varies too greatly from float result"
+                    );
+                }
+            }
+        }
     }
 
-    #[test]
-    fn potential_mana_lookup_len_delta() {
-        assert_eq!(
-            params().potential_mana(
-                i64::MAX as u64,
-                params().first_slot_of(1),
-                params().first_slot_of(params().mana_parameters().decay_factors().len() as u32 + 1)
-            ),
-            Ok(183827295065703076)
+    fn mana_decay_float(mana: f64, creation_slot: SlotIndex, target_slot: SlotIndex) -> f64 {
+        let (creation_epoch, target_epoch) = (
+            params().epoch_index_of(creation_slot),
+            params().epoch_index_of(target_slot),
         );
+        mana * params()
+            .decay_per_epoch()
+            .powi((target_epoch.0 - creation_epoch.0) as _)
     }
 
-    #[test]
-    fn potential_mana_lookup_len_delta_multiple() {
-        assert_eq!(
-            params().potential_mana(
-                i64::MAX as u64,
-                params().first_slot_of(1),
-                params().first_slot_of(3 * params().mana_parameters().decay_factors().len() as u32 + 1)
-            ),
-            Ok(410192223115924783)
+    fn mana_generation_with_decay_float(amount: f64, creation_slot: SlotIndex, target_slot: SlotIndex) -> f64 {
+        let (creation_epoch, target_epoch) = (
+            params().epoch_index_of(creation_slot),
+            params().epoch_index_of(target_slot),
         );
+        let decay_per_epoch = params().decay_per_epoch();
+        let generation_rate = params().mana_parameters().generation_rate() as f64
+            * 2f64.powi(-(params().mana_parameters().generation_rate_exponent() as i32));
+
+        if creation_epoch == target_epoch {
+            (target_slot.0 - creation_slot.0) as f64 * amount * generation_rate
+        } else if target_epoch == creation_epoch + 1 {
+            let slots_before_next_epoch = params().slots_before_next_epoch(creation_slot);
+            let slots_since_epoch_start = params().slots_since_epoch_start(target_slot);
+            let mana_decayed = slots_before_next_epoch as f64 * amount * generation_rate * decay_per_epoch;
+            let mana_generated = slots_since_epoch_start as f64 * amount * generation_rate;
+            mana_decayed + mana_generated
+        } else {
+            let slots_before_next_epoch = params().slots_before_next_epoch(creation_slot);
+            let slots_since_epoch_start = params().slots_since_epoch_start(target_slot);
+            let c = decay_per_epoch * (1.0 - decay_per_epoch.powi((target_epoch.0 - creation_epoch.0) as i32 - 1))
+                / (1.0 - decay_per_epoch);
+            let potential_mana_n = slots_before_next_epoch as f64
+                * amount
+                * generation_rate
+                * decay_per_epoch.powi((target_epoch.0 - creation_epoch.0) as i32);
+            let potential_mana_n_1 = c * amount * generation_rate * params().slots_per_epoch() as f64;
+            let potential_mana_0 = slots_since_epoch_start as f64 * amount * generation_rate;
+            potential_mana_n + potential_mana_n_1 + potential_mana_0
+        }
     }
 
-    #[test]
-    fn potential_mana_same_epoch() {
-        assert_eq!(
-            params().potential_mana(i64::MAX as u64, params().first_slot_of(1), params().last_slot_of(1)),
-            Ok(562881233944575)
-        );
+    fn upper_bound_mana_decay(mana: u64, creation_slot: SlotIndex, target_slot: SlotIndex) -> f64 {
+        mana_decay_float(mana as _, creation_slot, target_slot)
     }
 
-    #[test]
-    fn potential_mana_one_epoch() {
-        assert_eq!(
-            params().potential_mana(i64::MAX as u64, params().first_slot_of(1), params().last_slot_of(2)),
-            Ok(1125343946211326)
-        );
+    fn lower_bound_mana_decay(mana: u64, creation_slot: SlotIndex, target_slot: SlotIndex) -> f64 {
+        mana_decay_float(mana as _, creation_slot, target_slot)
+            - (mana as f64 * 2f64.powi(-(params().mana_parameters().decay_factors_exponent() as i32)) + 1.0)
     }
 
-    #[test]
-    fn potential_mana_several_epochs() {
-        assert_eq!(
-            params().potential_mana(i64::MAX as u64, params().first_slot_of(1), params().last_slot_of(3)),
-            Ok(1687319824887185)
-        );
+    fn upper_bound_mana_generation(amount: u64, creation_slot: SlotIndex, target_slot: SlotIndex) -> f64 {
+        mana_generation_with_decay_float(amount as _, creation_slot, target_slot) + 2.0
+            - 2f64.powi(-(params().mana_parameters().decay_factors_exponent() as i32) - 1)
     }
 
-    #[test]
-    fn potential_mana_max_mana() {
-        assert_eq!(
-            params().potential_mana(i64::MAX as u64, params().first_slot_of(1), params().first_slot_of(401)),
-            Ok(190239292388858706)
-        );
+    fn lower_bound_mana_generation(amount: u64, creation_slot: SlotIndex, target_slot: SlotIndex) -> f64 {
+        let decay_per_epoch = params().decay_per_epoch();
+        let c = decay_per_epoch / (1.0 - decay_per_epoch);
+
+        mana_generation_with_decay_float(amount as _, creation_slot, target_slot)
+            - (4.0
+                + amount as f64
+                    * params().mana_parameters().generation_rate() as f64
+                    * 2f64.powi(
+                        params().slots_per_epoch_exponent() as i32
+                            - params().mana_parameters().generation_rate_exponent() as i32,
+                    )
+                    * (1.0 + c * 2f64.powi(-(params().mana_parameters().decay_factors_exponent() as i32))))
     }
 }
diff --git a/sdk/src/types/block/output/unlock_condition/timelock.rs b/sdk/src/types/block/output/unlock_condition/timelock.rs
index 2b3f50ccd9..b9ac9aef90 100644
--- a/sdk/src/types/block/output/unlock_condition/timelock.rs
+++ b/sdk/src/types/block/output/unlock_condition/timelock.rs
@@ -55,6 +55,7 @@ pub(crate) mod dto {
     use crate::types::block::Error;
 
     #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
+    #[serde(rename_all = "camelCase")]
     struct TimelockUnlockConditionDto {
         #[serde(rename = "type")]
         kind: u8,
diff --git a/sdk/src/types/block/protocol/mod.rs b/sdk/src/types/block/protocol/mod.rs
index adc9b1e9c7..d2ee4ca4b5 100644
--- a/sdk/src/types/block/protocol/mod.rs
+++ b/sdk/src/types/block/protocol/mod.rs
@@ -202,11 +202,51 @@ impl ProtocolParameters {
         epoch_index.into().last_slot_index(self.slots_per_epoch_exponent())
     }
 
+    /// Calculates the number of slots before the next epoch.
+    pub fn slots_before_next_epoch(&self, slot_index: impl Into<SlotIndex>) -> u32 {
+        let slot_index = slot_index.into();
+
+        if slot_index.0 < self.genesis_slot() {
+            0
+        } else {
+            self.genesis_slot() + self.first_slot_of(self.epoch_index_of(slot_index) + 1).0 - slot_index.0
+        }
+    }
+
+    /// Calculates the number of slots since the start of the epoch.
+    pub fn slots_since_epoch_start(&self, slot_index: impl Into<SlotIndex>) -> u32 {
+        let slot_index = slot_index.into();
+
+        if slot_index.0 < self.genesis_slot() {
+            0
+        } else {
+            self.genesis_slot() + slot_index.0 - self.first_slot_of(self.epoch_index_of(slot_index)).0
+        }
+    }
+
     /// Gets the [`EpochIndex`] of a given [`SlotIndex`].
     pub fn epoch_index_of(&self, slot_index: impl Into<SlotIndex>) -> EpochIndex {
         EpochIndex::from_slot_index(slot_index.into(), self.slots_per_epoch_exponent())
     }
 
+    /// Calculates the duration of an epoch in seconds.
+    pub fn epoch_duration_in_seconds(&self) -> u64 {
+        self.slot_duration_in_seconds() as u64 * self.slots_per_epoch() as u64
+    }
+
+    /// Calculates the number of epochs per year.
+    pub fn epochs_per_year(&self) -> f64 {
+        (365_u64 * 24 * 60 * 60) as f64 / self.epoch_duration_in_seconds() as f64
+    }
+
+    /// Calculates the decay per epoch based on the annual decay factor and number of epochs in a year.
+    #[cfg(feature = "std")]
+    pub fn decay_per_epoch(&self) -> f64 {
+        self.mana_parameters()
+            .annual_decay_factor()
+            .powf(self.epochs_per_year().recip())
+    }
+
     /// Returns the hash of the [`ProtocolParameters`].
     pub fn hash(&self) -> ProtocolParametersHash {
         ProtocolParametersHash::new(Blake2b256::digest(self.pack_to_vec()).into())
diff --git a/sdk/src/types/block/rand/transaction.rs b/sdk/src/types/block/rand/transaction.rs
index 20036d143b..5a12cdcac1 100644
--- a/sdk/src/types/block/rand/transaction.rs
+++ b/sdk/src/types/block/rand/transaction.rs
@@ -1,9 +1,18 @@
 // Copyright 2020-2021 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::types::block::{payload::signed_transaction::TransactionId, rand::bytes::rand_bytes_array};
+use crate::types::block::{
+    payload::signed_transaction::{TransactionHash, TransactionId},
+    rand::{bytes::rand_bytes_array, number::rand_number},
+    slot::SlotIndex,
+};
+
+/// Generates a random transaction id with a given slot index.
+pub fn rand_transaction_id_with_slot_index(slot_index: impl Into<SlotIndex>) -> TransactionId {
+    TransactionHash::new(rand_bytes_array()).into_transaction_id(slot_index.into())
+}
 
 /// Generates a random transaction id.
 pub fn rand_transaction_id() -> TransactionId {
-    TransactionId::new(rand_bytes_array())
+    rand_transaction_id_with_slot_index(rand_number::<u32>())
 }
diff --git a/sdk/src/types/block/semantic/mod.rs b/sdk/src/types/block/semantic/mod.rs
index 109915b869..0c7a7e8c11 100644
--- a/sdk/src/types/block/semantic/mod.rs
+++ b/sdk/src/types/block/semantic/mod.rs
@@ -16,7 +16,9 @@ pub use self::{
 };
 use crate::types::block::{
     address::Address,
-    output::{AccountId, AnchorOutput, ChainId, FoundryId, NativeTokens, Output, OutputId, TokenId},
+    output::{
+        AccountId, AnchorOutput, ChainId, FoundryId, MinimumOutputAmount, NativeTokens, Output, OutputId, TokenId,
+    },
     payload::signed_transaction::{Transaction, TransactionCapabilityFlag, TransactionSigningHash},
     protocol::ProtocolParameters,
     unlock::Unlock,
@@ -160,7 +162,37 @@ impl<'a> SemanticValidationContext<'a> {
                 .checked_add(amount)
                 .ok_or(Error::ConsumedAmountOverflow)?;
 
-            self.input_mana = self.input_mana.checked_add(mana).ok_or(Error::ConsumedManaOverflow)?;
+            let potential_mana = {
+                // Deposit amount doesn't generate mana
+                let min_deposit = consumed_output.minimum_amount(self.protocol_parameters.storage_score_parameters());
+                let generation_amount = consumed_output.amount().saturating_sub(min_deposit);
+
+                self.protocol_parameters.generate_mana_with_decay(
+                    generation_amount,
+                    output_id.transaction_id().slot_index(),
+                    self.transaction.creation_slot(),
+                )
+            }?;
+
+            // Add potential mana
+            self.input_mana = self
+                .input_mana
+                .checked_add(potential_mana)
+                .ok_or(Error::ConsumedManaOverflow)?;
+
+            let stored_mana = self.protocol_parameters.mana_with_decay(
+                mana,
+                output_id.transaction_id().slot_index(),
+                self.transaction.creation_slot(),
+            )?;
+
+            // Add stored mana
+            self.input_mana = self
+                .input_mana
+                .checked_add(stored_mana)
+                .ok_or(Error::ConsumedManaOverflow)?;
+
+            // TODO: Add reward mana https://github.com/iotaledger/iota-sdk/issues/1310
 
             if let Some(consumed_native_token) = consumed_native_token {
                 let native_token_amount = self
@@ -221,8 +253,17 @@ impl<'a> SemanticValidationContext<'a> {
                 .checked_add(amount)
                 .ok_or(Error::CreatedAmountOverflow)?;
 
+            // Add stored mana
             self.output_mana = self.output_mana.checked_add(mana).ok_or(Error::CreatedManaOverflow)?;
 
+            // Add allotted mana
+            for mana_allotment in self.transaction.allotments() {
+                self.output_mana = self
+                    .output_mana
+                    .checked_add(mana_allotment.mana())
+                    .ok_or(Error::CreatedManaOverflow)?;
+            }
+
             if let Some(created_native_token) = created_native_token {
                 let native_token_amount = self
                     .output_native_tokens
@@ -251,11 +292,17 @@ impl<'a> SemanticValidationContext<'a> {
             return Ok(Some(TransactionFailureReason::SumInputsOutputsAmountMismatch));
         }
 
-        // TODO re-enable with https://github.com/iotaledger/iota-sdk/issues/1692
-        // if self.input_mana > self.output_mana &&
-        // !self.transaction.has_capability(TransactionCapabilityFlag::BurnMana) {     // TODO: add a variant https://github.com/iotaledger/iota-sdk/issues/1430
-        //     return Ok(Some(TransactionFailureReason::SemanticValidationFailed));
-        // }
+        if self.input_mana != self.output_mana {
+            if self.input_mana > self.output_mana {
+                if !self.transaction.has_capability(TransactionCapabilityFlag::BurnMana) {
+                    return Ok(Some(
+                        TransactionFailureReason::TransactionCapabilityManaBurningNotAllowed,
+                    ));
+                }
+            } else {
+                return Ok(Some(TransactionFailureReason::InvalidManaAmount));
+            }
+        }
 
         // Validation of input native tokens.
         let mut native_token_ids = self.input_native_tokens.keys().collect::<HashSet<_>>();
diff --git a/sdk/src/wallet/core/builder.rs b/sdk/src/wallet/core/builder.rs
index c9aa3e7e23..23eca5fe22 100644
--- a/sdk/src/wallet/core/builder.rs
+++ b/sdk/src/wallet/core/builder.rs
@@ -3,7 +3,7 @@
 
 #[cfg(feature = "storage")]
 use std::collections::HashSet;
-use std::sync::{atomic::AtomicUsize, Arc};
+use std::sync::Arc;
 
 use serde::Serialize;
 use tokio::sync::{Mutex, RwLock};
@@ -19,7 +19,7 @@ use crate::{
     client::secret::{GenerateAddressOptions, SecretManage, SecretManager},
     types::block::address::{Address, Bech32Address},
     wallet::{
-        core::{Bip44, WalletData, WalletInner},
+        core::{operations::background_syncing::BackgroundSyncStatus, Bip44, WalletData, WalletInner},
         operations::syncing::SyncOptions,
         ClientOptions, Wallet,
     },
@@ -242,11 +242,14 @@ where
             .finish()
             .await?;
 
+        let background_syncing_status = tokio::sync::watch::channel(BackgroundSyncStatus::Stopped);
+        let background_syncing_status = (Arc::new(background_syncing_status.0), background_syncing_status.1);
+
         // Build the wallet.
         let wallet_inner = WalletInner {
             default_sync_options: Mutex::new(SyncOptions::default()),
             last_synced: Mutex::new(0),
-            background_syncing_status: AtomicUsize::new(0),
+            background_syncing_status,
             client,
             secret_manager: self.secret_manager.expect("make WalletInner::secret_manager optional?"),
             #[cfg(feature = "events")]
diff --git a/sdk/src/wallet/core/mod.rs b/sdk/src/wallet/core/mod.rs
index 88f0e3bc2a..16db6cdf27 100644
--- a/sdk/src/wallet/core/mod.rs
+++ b/sdk/src/wallet/core/mod.rs
@@ -6,7 +6,7 @@ pub(crate) mod operations;
 
 use std::{
     collections::{HashMap, HashSet},
-    sync::{atomic::AtomicUsize, Arc},
+    sync::Arc,
 };
 
 use crypto::keys::{
@@ -17,6 +17,7 @@ use serde::{Deserialize, Serialize};
 use tokio::sync::{Mutex, RwLock};
 
 pub use self::builder::WalletBuilder;
+use self::operations::background_syncing::BackgroundSyncStatus;
 use super::types::{TransactionWithMetadata, TransactionWithMetadataDto};
 #[cfg(feature = "events")]
 use crate::wallet::events::{
@@ -84,8 +85,10 @@ pub struct WalletInner<S: SecretManage = SecretManager> {
     // again, because sending transactions can change that
     pub(crate) last_synced: Mutex<u128>,
     pub(crate) default_sync_options: Mutex<SyncOptions>,
-    // 0 = not running, 1 = running, 2 = stopping
-    pub(crate) background_syncing_status: AtomicUsize,
+    pub(crate) background_syncing_status: (
+        Arc<tokio::sync::watch::Sender<BackgroundSyncStatus>>,
+        tokio::sync::watch::Receiver<BackgroundSyncStatus>,
+    ),
     pub(crate) client: Client,
     // TODO: make this optional?
     pub(crate) secret_manager: Arc<RwLock<S>>,
diff --git a/sdk/src/wallet/core/operations/background_syncing.rs b/sdk/src/wallet/core/operations/background_syncing.rs
index 9bea901acc..7328441fef 100644
--- a/sdk/src/wallet/core/operations/background_syncing.rs
+++ b/sdk/src/wallet/core/operations/background_syncing.rs
@@ -1,18 +1,25 @@
 // Copyright 2021 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
-use std::{sync::atomic::Ordering, time::Duration};
+use std::time::Duration;
 
-use tokio::time::sleep;
+use tokio::time::timeout;
 
 use crate::{
     client::secret::SecretManage,
-    wallet::{operations::syncing::SyncOptions, Wallet},
+    wallet::{operations::syncing::SyncOptions, task, Wallet},
 };
 
 /// The default interval for background syncing
 pub(crate) const DEFAULT_BACKGROUNDSYNCING_INTERVAL: Duration = Duration::from_secs(7);
 
+#[derive(Clone, PartialEq, Debug)]
+pub(crate) enum BackgroundSyncStatus {
+    Stopped,
+    Running,
+    Stopping,
+}
+
 impl<S: 'static + SecretManage> Wallet<S>
 where
     crate::wallet::Error: From<S::Error>,
@@ -25,49 +32,49 @@ where
         interval: Option<Duration>,
     ) -> crate::wallet::Result<()> {
         log::debug!("[start_background_syncing]");
+
+        let (tx_background_sync, mut rx_background_sync) = self.background_syncing_status.clone();
+
         // stop existing process if running
-        if self.background_syncing_status.load(Ordering::Relaxed) == 1 {
-            self.background_syncing_status.store(2, Ordering::Relaxed);
-        };
-        while self.background_syncing_status.load(Ordering::Relaxed) == 2 {
-            log::debug!("[background_syncing]: waiting for the old process to stop");
-            sleep(Duration::from_secs(1)).await;
+        if *rx_background_sync.borrow() == BackgroundSyncStatus::Running {
+            tx_background_sync.send(BackgroundSyncStatus::Stopping).ok();
         }
 
-        self.background_syncing_status.store(1, Ordering::Relaxed);
+        log::debug!("[background_syncing]: waiting for the old process to stop");
+        rx_background_sync
+            .wait_for(|status| *status != BackgroundSyncStatus::Stopping)
+            .await
+            .ok();
+
+        tx_background_sync.send(BackgroundSyncStatus::Running).ok();
+
         let wallet = self.clone();
-        let _background_syncing = std::thread::spawn(move || {
-            #[cfg(not(target_family = "wasm"))]
-            let runtime = tokio::runtime::Builder::new_multi_thread()
-                .enable_all()
-                .build()
-                .unwrap();
-            #[cfg(target_family = "wasm")]
-            let runtime = tokio::runtime::Builder::new_current_thread()
-                .enable_all()
-                .build()
-                .unwrap();
-            runtime.block_on(async {
-                'outer: loop {
-                    log::debug!("[background_syncing]: syncing wallet");
-
-                    if let Err(err) = wallet.sync(options.clone()).await {
-                        log::debug!("[background_syncing] error: {}", err)
-                    }
-
-                    // split interval syncing to seconds so stopping the process doesn't have to wait long
-                    let seconds = interval.unwrap_or(DEFAULT_BACKGROUNDSYNCING_INTERVAL).as_secs();
-                    for _ in 0..seconds {
-                        if wallet.background_syncing_status.load(Ordering::Relaxed) == 2 {
-                            log::debug!("[background_syncing]: stopping");
-                            break 'outer;
-                        }
-                        sleep(Duration::from_secs(1)).await;
-                    }
+        let interval_seconds = interval.unwrap_or(DEFAULT_BACKGROUNDSYNCING_INTERVAL);
+
+        task::spawn(async move {
+            loop {
+                log::debug!("[background_syncing]: syncing wallet");
+
+                if let Err(err) = wallet.sync(options.clone()).await {
+                    log::debug!("[background_syncing] error: {}", err)
                 }
-                wallet.background_syncing_status.store(0, Ordering::Relaxed);
-                log::debug!("[background_syncing]: stopped");
-            });
+
+                let res = timeout(interval_seconds, async {
+                    rx_background_sync
+                        .wait_for(|status| *status == BackgroundSyncStatus::Stopping)
+                        .await
+                        .is_ok()
+                })
+                .await;
+
+                // If true it means rx_background_sync changed to BackgroundSyncStatus::Stopping
+                if Ok(true) == res {
+                    log::debug!("[background_syncing]: stopping");
+                    break;
+                }
+            }
+            tx_background_sync.send(BackgroundSyncStatus::Stopped).ok();
+            log::debug!("[background_syncing]: stopped");
         });
         Ok(())
     }
@@ -75,25 +82,32 @@ where
     /// Request to stop the background syncing of the wallet
     pub fn request_stop_background_syncing(&self) {
         log::debug!("[request_stop_background_syncing]");
-        self.background_syncing_status.store(2, Ordering::Relaxed);
+        self.background_syncing_status
+            .0
+            .send(BackgroundSyncStatus::Stopping)
+            .ok();
     }
 
     /// Stop the background syncing of the wallet
     pub async fn stop_background_syncing(&self) -> crate::wallet::Result<()> {
         log::debug!("[stop_background_syncing]");
-        // immediately return if not running
-        if self.background_syncing_status.load(Ordering::Relaxed) == 0 {
+
+        let mut rx_background_sync = self.background_syncing_status.1.clone();
+
+        // immediately return if is stopped
+        if *rx_background_sync.borrow() == BackgroundSyncStatus::Stopped {
             return Ok(());
         }
+
         // send stop request
         self.request_stop_background_syncing();
-        // wait until it stopped
-        while self.background_syncing_status.load(Ordering::Relaxed) != 0 {
-            #[cfg(target_family = "wasm")]
-            gloo_timers::future::TimeoutFuture::new(10).await;
-            #[cfg(not(target_family = "wasm"))]
-            tokio::time::sleep(std::time::Duration::from_millis(10)).await;
-        }
+
+        // wait until it has stopped
+        rx_background_sync
+            .wait_for(|status| *status == BackgroundSyncStatus::Stopped)
+            .await
+            .ok();
+
         Ok(())
     }
 }
diff --git a/sdk/tests/client/input_selection/account_outputs.rs b/sdk/tests/client/input_selection/account_outputs.rs
index a350d1a584..ade83ef47a 100644
--- a/sdk/tests/client/input_selection/account_outputs.rs
+++ b/sdk/tests/client/input_selection/account_outputs.rs
@@ -25,14 +25,17 @@ fn input_account_eq_output_account() {
     let protocol_parameters = protocol_parameters();
     let account_id_2 = AccountId::from_str(ACCOUNT_ID_2).unwrap();
 
-    let inputs = build_inputs([Account(
-        1_000_000,
-        account_id_2,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Account(
+            1_000_000,
+            account_id_2,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_2,
@@ -60,14 +63,17 @@ fn transition_account_id_zero() {
     let protocol_parameters = protocol_parameters();
     let account_id_0 = AccountId::from_str(ACCOUNT_ID_0).unwrap();
 
-    let inputs = build_inputs([Account(
-        1_000_000,
-        account_id_0,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Account(
+            1_000_000,
+            account_id_0,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let account_id = AccountId::from(inputs[0].output_id());
     let outputs = build_outputs([Account(
         1_000_000,
@@ -230,16 +236,19 @@ fn create_account() {
     let protocol_parameters = protocol_parameters();
     let account_id_0 = AccountId::from_str(ACCOUNT_ID_0).unwrap();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_0,
@@ -276,14 +285,17 @@ fn burn_account() {
     let protocol_parameters = protocol_parameters();
     let account_id_2 = AccountId::from_str(ACCOUNT_ID_2).unwrap();
 
-    let inputs = build_inputs([Account(
-        2_000_000,
-        account_id_2,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Account(
+            2_000_000,
+            account_id_2,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -359,16 +371,19 @@ fn missing_input_for_account_output() {
     let protocol_parameters = protocol_parameters();
     let account_id_2 = AccountId::from_str(ACCOUNT_ID_2).unwrap();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_2,
@@ -398,26 +413,29 @@ fn missing_input_for_account_output_2() {
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
     let account_id_2 = AccountId::from_str(ACCOUNT_ID_2).unwrap();
 
-    let inputs = build_inputs([
-        Account(
-            2_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Account(
+                2_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_2,
@@ -446,16 +464,19 @@ fn missing_input_for_account_output_but_created() {
     let protocol_parameters = protocol_parameters();
     let account_id_0 = AccountId::from_str(ACCOUNT_ID_0).unwrap();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_0,
@@ -481,26 +502,29 @@ fn account_in_output_and_sender() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Account(
-            1_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Account(
+                1_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let account_output = AccountOutputBuilder::from(inputs[0].output.as_account())
         .finish_output()
         .unwrap();
@@ -534,14 +558,17 @@ fn missing_ed25519_sender() {
     let protocol_parameters = protocol_parameters();
     let account_id_2 = AccountId::from_str(ACCOUNT_ID_2).unwrap();
 
-    let inputs = build_inputs([Account(
-        1_000_000,
-        account_id_2,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Account(
+            1_000_000,
+            account_id_2,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_2,
@@ -570,16 +597,19 @@ fn missing_ed25519_issuer_created() {
     let protocol_parameters = protocol_parameters();
     let account_id_0 = AccountId::from_str(ACCOUNT_ID_0).unwrap();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_0,
@@ -608,14 +638,17 @@ fn missing_ed25519_issuer_transition() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([Account(
-        1_000_000,
-        account_id_1,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        Some(Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap()),
+    let inputs = build_inputs(
+        [Account(
+            1_000_000,
+            account_id_1,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            Some(Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap()),
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_1,
@@ -641,14 +674,17 @@ fn missing_account_sender() {
     let protocol_parameters = protocol_parameters();
     let account_id_2 = AccountId::from_str(ACCOUNT_ID_2).unwrap();
 
-    let inputs = build_inputs([Account(
-        1_000_000,
-        account_id_2,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Account(
+            1_000_000,
+            account_id_2,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_2,
@@ -677,16 +713,19 @@ fn missing_account_issuer_created() {
     let protocol_parameters = protocol_parameters();
     let account_id_0 = AccountId::from_str(ACCOUNT_ID_0).unwrap();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_0,
@@ -715,14 +754,17 @@ fn missing_account_issuer_transition() {
     let protocol_parameters = protocol_parameters();
     let account_id_2 = AccountId::from_str(ACCOUNT_ID_2).unwrap();
 
-    let inputs = build_inputs([Account(
-        1_000_000,
-        account_id_2,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        Some(Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap()),
+    let inputs = build_inputs(
+        [Account(
+            1_000_000,
+            account_id_2,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            Some(Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap()),
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_2,
@@ -748,14 +790,17 @@ fn missing_nft_sender() {
     let protocol_parameters = protocol_parameters();
     let account_id_2 = AccountId::from_str(ACCOUNT_ID_2).unwrap();
 
-    let inputs = build_inputs([Account(
-        1_000_000,
-        account_id_2,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Account(
+            1_000_000,
+            account_id_2,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_2,
@@ -784,16 +829,19 @@ fn missing_nft_issuer_created() {
     let protocol_parameters = protocol_parameters();
     let account_id_0 = AccountId::from_str(ACCOUNT_ID_0).unwrap();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_0,
@@ -822,14 +870,17 @@ fn missing_nft_issuer_transition() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([Account(
-        1_000_000,
-        account_id_1,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        Some(Address::try_from_bech32(BECH32_ADDRESS_NFT_1).unwrap()),
+    let inputs = build_inputs(
+        [Account(
+            1_000_000,
+            account_id_1,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            Some(Address::try_from_bech32(BECH32_ADDRESS_NFT_1).unwrap()),
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_1,
@@ -855,26 +906,29 @@ fn increase_account_amount() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Account(
-            2_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Account(
+                2_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Account(
         3_000_000,
         account_id_1,
@@ -902,26 +956,29 @@ fn decrease_account_amount() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Account(
-            2_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Account(
+                2_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_1,
@@ -961,26 +1018,29 @@ fn prefer_basic_to_account() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Account(
-            1_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Account(
+                1_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1011,26 +1071,29 @@ fn take_amount_from_account_to_fund_basic() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Account(
-            2_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Account(
+                2_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_200_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1075,26 +1138,29 @@ fn account_burn_should_validate_account_sender() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Account(
-            1_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Account(
+                1_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1137,26 +1203,29 @@ fn account_burn_should_validate_account_address() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Account(
-            1_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Account(
+                1_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1199,14 +1268,17 @@ fn transitioned_zero_account_id_no_longer_is_zero() {
     let protocol_parameters = protocol_parameters();
     let account_id_0 = AccountId::from_str(ACCOUNT_ID_0).unwrap();
 
-    let inputs = build_inputs([Account(
-        2_000_000,
-        account_id_0,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Account(
+            2_000_000,
+            account_id_0,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1252,24 +1324,27 @@ fn two_accounts_required() {
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
     let account_id_2 = AccountId::from_str(ACCOUNT_ID_2).unwrap();
 
-    let inputs = build_inputs([
-        Account(
-            2_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-        Account(
-            2_000_000,
-            account_id_2,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Account(
+                2_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+            Account(
+                2_000_000,
+                account_id_2,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         3_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1320,14 +1395,17 @@ fn state_controller_sender_required() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([Account(
-        2_000_000,
-        account_id_1,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Account(
+            2_000_000,
+            account_id_1,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1358,14 +1436,17 @@ fn state_controller_sender_required_already_selected() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([Account(
-        2_000_000,
-        account_id_1,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Account(
+            2_000_000,
+            account_id_1,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([
         Account(
             1_000_000,
@@ -1406,14 +1487,17 @@ fn state_transition_and_required() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([Account(
-        2_000_000,
-        account_id_1,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Account(
+            2_000_000,
+            account_id_1,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Account(
         2_000_000,
         account_id_1,
@@ -1442,14 +1526,17 @@ fn remainder_address_in_state_controller() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([Account(
-        2_000_000,
-        account_id_1,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Account(
+            2_000_000,
+            account_id_1,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Account(
         1_000_000,
         account_id_1,
diff --git a/sdk/tests/client/input_selection/basic_outputs.rs b/sdk/tests/client/input_selection/basic_outputs.rs
index 7b190eeb3c..f20d862c8b 100644
--- a/sdk/tests/client/input_selection/basic_outputs.rs
+++ b/sdk/tests/client/input_selection/basic_outputs.rs
@@ -6,10 +6,7 @@ use std::str::FromStr;
 use iota_sdk::{
     client::api::input_selection::{Error, InputSelection, Requirement},
     types::block::{
-        address::{
-            Address, AddressCapabilities, ImplicitAccountCreationAddress, MultiAddress, RestrictedAddress,
-            WeightedAddress,
-        },
+        address::{Address, AddressCapabilities, MultiAddress, RestrictedAddress, WeightedAddress},
         output::{AccountId, NftId},
         protocol::protocol_parameters,
     },
@@ -27,16 +24,19 @@ use crate::client::{
 fn input_amount_equal_output_amount() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -65,16 +65,19 @@ fn input_amount_equal_output_amount() {
 fn input_amount_lower_than_output_amount() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -107,28 +110,31 @@ fn input_amount_lower_than_output_amount() {
 fn input_amount_lower_than_output_amount_2() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         3_500_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -161,16 +167,19 @@ fn input_amount_lower_than_output_amount_2() {
 fn input_amount_greater_than_output_amount() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         500_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -212,16 +221,19 @@ fn input_amount_greater_than_output_amount_with_remainder_address() {
     let protocol_parameters = protocol_parameters();
     let remainder_address = Address::try_from_bech32(BECH32_ADDRESS_REMAINDER).unwrap();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         500_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -263,28 +275,31 @@ fn input_amount_greater_than_output_amount_with_remainder_address() {
 fn two_same_inputs_one_needed() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         500_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -326,28 +341,31 @@ fn two_same_inputs_one_needed() {
 fn two_inputs_one_needed() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -376,28 +394,31 @@ fn two_inputs_one_needed() {
 fn two_inputs_one_needed_reversed() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -426,28 +447,31 @@ fn two_inputs_one_needed_reversed() {
 fn two_inputs_both_needed() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         3_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -476,28 +500,31 @@ fn two_inputs_both_needed() {
 fn two_inputs_remainder() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_500_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -581,58 +608,61 @@ fn ed25519_sender() {
     let protocol_parameters = protocol_parameters();
     let sender = Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -672,16 +702,19 @@ fn ed25519_sender() {
 fn missing_ed25519_sender() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        5_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            5_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -712,57 +745,59 @@ fn account_sender() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Account(
-            1_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
-
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Account(
+                1_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -801,26 +836,29 @@ fn account_sender_zero_id() {
     let protocol_parameters = protocol_parameters();
     let account_id_0 = AccountId::from_str(ACCOUNT_ID_0).unwrap();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Account(
-            1_000_000,
-            account_id_0,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Account(
+                1_000_000,
+                account_id_0,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let account_id = AccountId::from(inputs[1].output_id());
     let outputs = build_outputs([Basic(
         2_000_000,
@@ -856,16 +894,19 @@ fn account_sender_zero_id() {
 fn missing_account_sender() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        5_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            5_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -896,58 +937,61 @@ fn nft_sender() {
     let protocol_parameters = protocol_parameters();
     let nft_id_1 = NftId::from_str(NFT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Nft(
-            1_000_000,
-            nft_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Nft(
+                1_000_000,
+                nft_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -987,28 +1031,31 @@ fn nft_sender_zero_id() {
     let protocol_parameters = protocol_parameters();
     let nft_id_0 = NftId::from_str(NFT_ID_0).unwrap();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Nft(
-            1_000_000,
-            nft_id_0,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Nft(
+                1_000_000,
+                nft_id_0,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let nft_id = NftId::from(inputs[1].output_id());
     let outputs = build_outputs([Basic(
         2_000_000,
@@ -1044,16 +1091,19 @@ fn nft_sender_zero_id() {
 fn missing_nft_sender() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        5_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            5_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1083,16 +1133,19 @@ fn missing_nft_sender() {
 fn simple_remainder() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         500_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1212,16 +1265,19 @@ fn simple_remainder() {
 fn one_provided_one_needed() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1250,16 +1306,19 @@ fn one_provided_one_needed() {
 fn insufficient_amount() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_250_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1292,28 +1351,31 @@ fn insufficient_amount() {
 fn two_inputs_remainder_2() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         500_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1354,28 +1416,31 @@ fn two_inputs_remainder_2() {
 fn two_inputs_remainder_3() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_750_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1455,16 +1520,19 @@ fn two_inputs_remainder_3() {
 fn sender_already_selected() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1497,16 +1565,19 @@ fn sender_already_selected() {
 fn single_mandatory_input() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1554,8 +1625,8 @@ fn too_many_inputs() {
             )
         })
         .take(129),
+        None,
     );
-
     let outputs = build_outputs([Basic(
         129_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1600,18 +1671,22 @@ fn more_than_max_inputs_only_one_needed() {
             )
         })
         .take(1000),
+        None,
     );
     // Add the needed input
-    let needed_input = build_inputs([Basic(
-        129_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let needed_input = build_inputs(
+        [Basic(
+            129_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     inputs.push(needed_input[0].clone());
 
     let outputs = build_outputs([Basic(
@@ -1642,17 +1717,19 @@ fn more_than_max_inputs_only_one_needed() {
 fn too_many_outputs() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
-
+    );
     let outputs = build_outputs(
         std::iter::repeat_with(|| {
             Basic(
@@ -1687,16 +1764,19 @@ fn too_many_outputs() {
 fn too_many_outputs_with_remainder() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
 
     let outputs = build_outputs(
         std::iter::repeat_with(|| {
@@ -1735,49 +1815,52 @@ fn restricted_ed25519() {
     let address = Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap();
     let restricted = Address::from(RestrictedAddress::new(address.clone()).unwrap());
 
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(1_000_000, restricted, None, None, None, None, None, None),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(1_000_000, restricted, None, None, None, None, None, None),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1810,19 +1893,22 @@ fn restricted_nft() {
     let nft_address = Address::from(nft_id_1);
     let restricted = Address::from(RestrictedAddress::new(nft_address.clone()).unwrap());
 
-    let inputs = build_inputs([
-        Basic(2_000_000, restricted, None, None, None, None, None, None),
-        Nft(
-            2_000_000,
-            nft_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(2_000_000, restricted, None, None, None, None, None, None),
+            Nft(
+                2_000_000,
+                nft_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         3_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1855,18 +1941,20 @@ fn restricted_account() {
     let account_address = Address::from(account_id_1);
     let restricted = Address::from(RestrictedAddress::new(account_address.clone()).unwrap());
 
-    let inputs = build_inputs([
-        Basic(3_000_000, restricted, None, None, None, None, None, None),
-        Account(
-            2_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-    ]);
-
+    let inputs = build_inputs(
+        [
+            Basic(3_000_000, restricted, None, None, None, None, None, None),
+            Account(
+                2_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         3_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1898,58 +1986,61 @@ fn restricted_ed25519_sender() {
     let sender = Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap();
     let restricted_sender = Address::from(RestrictedAddress::new(sender.clone()).unwrap());
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -2003,38 +2094,41 @@ fn multi_address_sender_already_fulfilled() {
         .unwrap(),
     );
 
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         3_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -2074,19 +2168,22 @@ fn ed25519_backed_available_address() {
             .with_allowed_capabilities(AddressCapabilities::all()),
     );
 
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            restricted_address.clone(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(1_000_000, ed25519.clone(), None, None, None, None, None, None),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                restricted_address.clone(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(1_000_000, ed25519.clone(), None, None, None, None, None, None),
+        ],
+        None,
+    );
     let outputs = build_outputs([
         Basic(
             1_000_000,
diff --git a/sdk/tests/client/input_selection/expiration.rs b/sdk/tests/client/input_selection/expiration.rs
index 08852b876f..8dc60c5696 100644
--- a/sdk/tests/client/input_selection/expiration.rs
+++ b/sdk/tests/client/input_selection/expiration.rs
@@ -24,16 +24,19 @@ use crate::client::{
 fn one_output_expiration_not_expired() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 200)),
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 200)),
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -61,16 +64,19 @@ fn one_output_expiration_not_expired() {
 fn expiration_equal_timestamp() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 200)),
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 200)),
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -100,16 +106,19 @@ fn expiration_equal_timestamp() {
 fn one_output_expiration_expired() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -139,28 +148,31 @@ fn one_output_expiration_expired() {
 fn two_outputs_one_expiration_expired() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 200)),
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 200)),
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
@@ -191,28 +203,31 @@ fn two_outputs_one_expiration_expired() {
 fn two_outputs_one_unexpired_one_missing() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 200)),
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 200)),
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
@@ -243,38 +258,41 @@ fn two_outputs_one_unexpired_one_missing() {
 fn two_outputs_two_expired() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 100)),
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(), 100)),
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 100)),
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(), 100)),
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
@@ -305,28 +323,31 @@ fn two_outputs_two_expired() {
 fn two_outputs_two_expired_2() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 100)),
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(), 100)),
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 100)),
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(), 100)),
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         4_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
@@ -359,16 +380,19 @@ fn two_outputs_two_expired_2() {
 fn expiration_expired_with_sdr() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
@@ -398,16 +422,19 @@ fn expiration_expired_with_sdr() {
 fn expiration_expired_with_sdr_2() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -437,16 +464,19 @@ fn expiration_expired_with_sdr_2() {
 fn expiration_expired_with_sdr_and_timelock() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 1_000_000)),
-        Some(50),
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 1_000_000)),
+            Some(50),
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
@@ -476,16 +506,19 @@ fn expiration_expired_with_sdr_and_timelock() {
 fn expiration_expired_with_sdr_and_timelock_2() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
-        Some(50),
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
+            Some(50),
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
@@ -515,58 +548,61 @@ fn expiration_expired_with_sdr_and_timelock_2() {
 fn sender_in_expiration() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 50)),
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 50)),
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -600,16 +636,19 @@ fn sender_in_expiration() {
 fn sender_in_expiration_already_selected() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 50)),
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 50)),
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -643,16 +682,19 @@ fn sender_in_expiration_already_selected() {
 fn remainder_in_expiration() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 50)),
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 50)),
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -696,16 +738,19 @@ fn remainder_in_expiration() {
 fn expiration_expired_non_ed25519_in_address_unlock_condition() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -736,26 +781,29 @@ fn expiration_expired_only_account_addresses() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(), 50)),
-            None,
-        ),
-        Account(
-            1_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(), 50)),
+                None,
+            ),
+            Account(
+                1_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
 
     let outputs = build_outputs([Basic(
         2_000_000,
@@ -787,16 +835,19 @@ fn one_nft_output_expiration_unexpired() {
     let protocol_parameters = protocol_parameters();
     let nft_id_1 = NftId::from_str(NFT_ID_1).unwrap();
 
-    let inputs = build_inputs([Nft(
-        2_000_000,
-        nft_id_1,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-        None,
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 150)),
+    let inputs = build_inputs(
+        [Nft(
+            2_000_000,
+            nft_id_1,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+            None,
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 150)),
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Nft(
         2_000_000,
         nft_id_1,
@@ -827,16 +878,19 @@ fn one_nft_output_expiration_expired() {
     let protocol_parameters = protocol_parameters();
     let nft_id_1 = NftId::from_str(NFT_ID_1).unwrap();
 
-    let inputs = build_inputs([Nft(
-        2_000_000,
-        nft_id_1,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-        None,
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
+    let inputs = build_inputs(
+        [Nft(
+            2_000_000,
+            nft_id_1,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+            None,
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(), 50)),
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Nft(
         2_000_000,
         nft_id_1,
diff --git a/sdk/tests/client/input_selection/foundry_outputs.rs b/sdk/tests/client/input_selection/foundry_outputs.rs
index 52c510b70c..bf8fe83707 100644
--- a/sdk/tests/client/input_selection/foundry_outputs.rs
+++ b/sdk/tests/client/input_selection/foundry_outputs.rs
@@ -31,16 +31,19 @@ fn missing_input_account_for_foundry() {
     let protocol_parameters = protocol_parameters();
     let account_id_2 = AccountId::from_str(ACCOUNT_ID_2).unwrap();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Foundry(
         1_000_000,
         account_id_2,
@@ -106,26 +109,29 @@ fn minted_native_tokens_in_new_remainder() {
     let protocol_parameters = protocol_parameters();
     let account_id_2 = AccountId::from_str(ACCOUNT_ID_2).unwrap();
 
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Account(
-            1_000_000,
-            account_id_2,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Account(
+                1_000_000,
+                account_id_2,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Foundry(
         1_000_000,
         account_id_2,
@@ -162,26 +168,29 @@ fn minted_native_tokens_in_provided_output() {
     let foundry_id = FoundryId::build(&AccountAddress::from(account_id_2), 1, SimpleTokenScheme::KIND);
     let token_id = TokenId::from(foundry_id);
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Account(
-            1_000_000,
-            account_id_2,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Account(
+                1_000_000,
+                account_id_2,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([
         Foundry(
             1_000_000,
@@ -223,28 +232,31 @@ fn melt_native_tokens() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let mut inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Foundry(
-            1_000_000,
-            account_id_1,
-            1,
-            SimpleTokenScheme::new(10, 0, 10).unwrap(),
-            Some((
-                "0x0811111111111111111111111111111111111111111111111111111111111111110100000000",
-                10,
-            )),
-        ),
-    ]);
+    let mut inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Foundry(
+                1_000_000,
+                account_id_1,
+                1,
+                SimpleTokenScheme::new(10, 0, 10).unwrap(),
+                Some((
+                    "0x0811111111111111111111111111111111111111111111111111111111111111110100000000",
+                    10,
+                )),
+            ),
+        ],
+        None,
+    );
     let account_output = AccountOutputBuilder::new_with_amount(1_000_000, account_id_1)
         .add_unlock_condition(AddressUnlockCondition::new(
             Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -292,23 +304,26 @@ fn destroy_foundry_with_account_state_transition() {
     let protocol_parameters = protocol_parameters();
     let account_id_2 = AccountId::from_str(ACCOUNT_ID_2).unwrap();
 
-    let inputs = build_inputs([
-        Account(
-            50_300,
-            account_id_2,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-        Foundry(
-            52_800,
-            account_id_2,
-            1,
-            SimpleTokenScheme::new(10, 10, 10).unwrap(),
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Account(
+                50_300,
+                account_id_2,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+            Foundry(
+                52_800,
+                account_id_2,
+                1,
+                SimpleTokenScheme::new(10, 10, 10).unwrap(),
+                None,
+            ),
+        ],
+        None,
+    );
     let account_output = AccountOutputBuilder::from(inputs[0].output.as_account())
         .with_amount(103_100)
         .finish_output()
@@ -336,23 +351,26 @@ fn destroy_foundry_with_account_burn() {
     let protocol_parameters = protocol_parameters();
     let account_id_2 = AccountId::from_str(ACCOUNT_ID_2).unwrap();
 
-    let inputs = build_inputs([
-        Account(
-            1_000_000,
-            account_id_2,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-        Foundry(
-            1_000_000,
-            account_id_2,
-            1,
-            SimpleTokenScheme::new(10, 10, 10).unwrap(),
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Account(
+                1_000_000,
+                account_id_2,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+            Foundry(
+                1_000_000,
+                account_id_2,
+                1,
+                SimpleTokenScheme::new(10, 10, 10).unwrap(),
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -398,33 +416,36 @@ fn prefer_basic_to_foundry() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Account(
-            1_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-        Foundry(
-            1_000_000,
-            account_id_1,
-            1,
-            SimpleTokenScheme::new(10, 10, 10).unwrap(),
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Account(
+                1_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+            Foundry(
+                1_000_000,
+                account_id_1,
+                1,
+                SimpleTokenScheme::new(10, 10, 10).unwrap(),
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -455,25 +476,28 @@ fn simple_foundry_transition_basic_not_needed() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let mut inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Foundry(
-            1_000_000,
-            account_id_1,
-            1,
-            SimpleTokenScheme::new(10, 10, 10).unwrap(),
-            None,
-        ),
-    ]);
+    let mut inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Foundry(
+                1_000_000,
+                account_id_1,
+                1,
+                SimpleTokenScheme::new(10, 10, 10).unwrap(),
+                None,
+            ),
+        ],
+        None,
+    );
     let account_output = AccountOutputBuilder::new_with_amount(2_000_000, account_id_1)
         .add_unlock_condition(AddressUnlockCondition::new(
             Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -530,25 +554,28 @@ fn simple_foundry_transition_basic_not_needed_with_remainder() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let mut inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Foundry(
-            2_000_000,
-            account_id_1,
-            1,
-            SimpleTokenScheme::new(10, 10, 10).unwrap(),
-            None,
-        ),
-    ]);
+    let mut inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Foundry(
+                2_000_000,
+                account_id_1,
+                1,
+                SimpleTokenScheme::new(10, 10, 10).unwrap(),
+                None,
+            ),
+        ],
+        None,
+    );
     let account_output = AccountOutputBuilder::new_with_amount(2_000_000, account_id_1)
         .add_unlock_condition(AddressUnlockCondition::new(
             Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -683,13 +710,16 @@ fn mint_and_burn_at_the_same_time() {
     let foundry_id = FoundryId::build(&AccountAddress::from(account_id_1), 1, SimpleTokenScheme::KIND);
     let token_id = TokenId::from(foundry_id);
 
-    let mut inputs = build_inputs([Foundry(
-        1_000_000,
-        account_id_1,
-        1,
-        SimpleTokenScheme::new(100, 0, 200).unwrap(),
-        Some((&token_id.to_string(), 100)),
-    )]);
+    let mut inputs = build_inputs(
+        [Foundry(
+            1_000_000,
+            account_id_1,
+            1,
+            SimpleTokenScheme::new(100, 0, 200).unwrap(),
+            Some((&token_id.to_string(), 100)),
+        )],
+        None,
+    );
     let account_output = AccountOutputBuilder::new_with_amount(2_000_000, account_id_1)
         .add_unlock_condition(AddressUnlockCondition::new(
             Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -733,25 +763,28 @@ fn take_amount_from_account_and_foundry_to_fund_basic() {
     let foundry_id = FoundryId::build(&AccountAddress::from(account_id_1), 0, SimpleTokenScheme::KIND);
     let token_id = TokenId::from(foundry_id);
 
-    let mut inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Foundry(
-            1_000_000,
-            account_id_1,
-            1,
-            SimpleTokenScheme::new(100, 0, 200).unwrap(),
-            Some((&token_id.to_string(), 100)),
-        ),
-    ]);
+    let mut inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Foundry(
+                1_000_000,
+                account_id_1,
+                1,
+                SimpleTokenScheme::new(100, 0, 200).unwrap(),
+                Some((&token_id.to_string(), 100)),
+            ),
+        ],
+        None,
+    );
     let account_output = AccountOutputBuilder::new_with_amount(2_000_000, account_id_1)
         .add_unlock_condition(AddressUnlockCondition::new(
             Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -802,23 +835,26 @@ fn create_native_token_but_burn_account() {
     let foundry_id = FoundryId::build(&AccountAddress::from(account_id_1), 1, SimpleTokenScheme::KIND);
     let token_id = TokenId::from(foundry_id);
 
-    let inputs = build_inputs([
-        Account(
-            2_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-        Foundry(
-            1_000_000,
-            account_id_1,
-            1,
-            SimpleTokenScheme::new(0, 0, 100).unwrap(),
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Account(
+                2_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+            Foundry(
+                1_000_000,
+                account_id_1,
+                1,
+                SimpleTokenScheme::new(0, 0, 100).unwrap(),
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Foundry(
         1_000_000,
         account_id_1,
@@ -860,23 +896,26 @@ fn melted_tokens_not_provided() {
     let foundry_id = FoundryId::build(&AccountAddress::from(account_id_1), 1, SimpleTokenScheme::KIND);
     let token_id_1 = TokenId::from(foundry_id);
 
-    let inputs = build_inputs([
-        Account(
-            2_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-        Foundry(
-            1_000_000,
-            account_id_1,
-            1,
-            SimpleTokenScheme::new(100, 0, 100).unwrap(),
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Account(
+                2_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+            Foundry(
+                1_000_000,
+                account_id_1,
+                1,
+                SimpleTokenScheme::new(100, 0, 100).unwrap(),
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Foundry(
         1_000_000,
         account_id_1,
@@ -909,23 +948,26 @@ fn burned_tokens_not_provided() {
     let foundry_id = FoundryId::build(&AccountAddress::from(account_id_1), 0, SimpleTokenScheme::KIND);
     let token_id_1 = TokenId::from(foundry_id);
 
-    let inputs = build_inputs([
-        Account(
-            2_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-        Foundry(
-            1_000_000,
-            account_id_1,
-            1,
-            SimpleTokenScheme::new(100, 0, 100).unwrap(),
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Account(
+                2_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+            Foundry(
+                1_000_000,
+                account_id_1,
+                1,
+                SimpleTokenScheme::new(100, 0, 100).unwrap(),
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Foundry(
         1_000_000,
         account_id_1,
@@ -957,13 +999,16 @@ fn foundry_in_outputs_and_required() {
     let protocol_parameters = protocol_parameters();
     let account_id_2 = AccountId::from_str(ACCOUNT_ID_2).unwrap();
 
-    let mut inputs = build_inputs([Foundry(
-        1_000_000,
-        account_id_2,
-        1,
-        SimpleTokenScheme::new(0, 0, 10).unwrap(),
+    let mut inputs = build_inputs(
+        [Foundry(
+            1_000_000,
+            account_id_2,
+            1,
+            SimpleTokenScheme::new(0, 0, 10).unwrap(),
+            None,
+        )],
         None,
-    )]);
+    );
     let account_output = AccountOutputBuilder::new_with_amount(1_251_500, account_id_2)
         .add_unlock_condition(AddressUnlockCondition::new(
             Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1011,25 +1056,28 @@ fn melt_and_burn_native_tokens() {
     let foundry_id = FoundryId::build(&AccountAddress::from(account_id), 1, SimpleTokenScheme::KIND);
     let token_id = TokenId::from(foundry_id);
 
-    let mut inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Foundry(
-            1_000_000,
-            account_id,
-            1,
-            SimpleTokenScheme::new(1000, 0, 1000).unwrap(),
-            Some((&token_id.to_string(), 1000)),
-        ),
-    ]);
+    let mut inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Foundry(
+                1_000_000,
+                account_id,
+                1,
+                SimpleTokenScheme::new(1000, 0, 1000).unwrap(),
+                Some((&token_id.to_string(), 1000)),
+            ),
+        ],
+        None,
+    );
     let account_output = AccountOutputBuilder::new_with_amount(1_000_000, account_id)
         .add_unlock_condition(AddressUnlockCondition::new(
             Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
diff --git a/sdk/tests/client/input_selection/nft_outputs.rs b/sdk/tests/client/input_selection/nft_outputs.rs
index 33ddf7c960..ad3d40db1e 100644
--- a/sdk/tests/client/input_selection/nft_outputs.rs
+++ b/sdk/tests/client/input_selection/nft_outputs.rs
@@ -29,16 +29,19 @@ fn input_nft_eq_output_nft() {
     let protocol_parameters = protocol_parameters();
     let nft_id_2 = NftId::from_str(NFT_ID_2).unwrap();
 
-    let inputs = build_inputs([Nft(
-        1_000_000,
-        nft_id_2,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Nft(
+            1_000_000,
+            nft_id_2,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Nft(
         1_000_000,
         nft_id_2,
@@ -68,16 +71,19 @@ fn transition_nft_id_zero() {
     let protocol_parameters = protocol_parameters();
     let nft_id_0 = NftId::from_str(NFT_ID_0).unwrap();
 
-    let inputs = build_inputs([Nft(
-        1_000_000,
-        nft_id_0,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Nft(
+            1_000_000,
+            nft_id_0,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let nft_id = NftId::from(inputs[0].output_id());
     let outputs = build_outputs([Nft(
         1_000_000,
@@ -196,16 +202,19 @@ fn mint_nft() {
     let protocol_parameters = protocol_parameters();
     let nft_id_0 = NftId::from_str(NFT_ID_0).unwrap();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Nft(
         1_000_000,
         nft_id_0,
@@ -244,16 +253,19 @@ fn burn_nft() {
     let protocol_parameters = protocol_parameters();
     let nft_id_2 = NftId::from_str(NFT_ID_2).unwrap();
 
-    let inputs = build_inputs([Nft(
-        2_000_000,
-        nft_id_2,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Nft(
+            2_000_000,
+            nft_id_2,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -329,16 +341,19 @@ fn missing_input_for_nft_output() {
     let protocol_parameters = protocol_parameters();
     let nft_id_2 = NftId::from_str(NFT_ID_2).unwrap();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Nft(
         1_000_000,
         nft_id_2,
@@ -369,16 +384,19 @@ fn missing_input_for_nft_output_but_created() {
     let protocol_parameters = protocol_parameters();
     let nft_id_0 = NftId::from_str(NFT_ID_0).unwrap();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Nft(
         1_000_000,
         nft_id_0,
@@ -406,28 +424,31 @@ fn nft_in_output_and_sender() {
     let protocol_parameters = protocol_parameters();
     let nft_id_1 = NftId::from_str(NFT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Nft(
-            1_000_000,
-            nft_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Nft(
+                1_000_000,
+                nft_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([
         Nft(
             1_000_000,
@@ -477,16 +498,19 @@ fn missing_ed25519_sender() {
     let protocol_parameters = protocol_parameters();
     let nft_id_2 = NftId::from_str(NFT_ID_2).unwrap();
 
-    let inputs = build_inputs([Nft(
-        1_000_000,
-        nft_id_2,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Nft(
+            1_000_000,
+            nft_id_2,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Nft(
         1_000_000,
         nft_id_2,
@@ -517,16 +541,19 @@ fn missing_ed25519_issuer_created() {
     let protocol_parameters = protocol_parameters();
     let nft_id_0 = NftId::from_str(NFT_ID_0).unwrap();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Nft(
         1_000_000,
         nft_id_0,
@@ -557,16 +584,19 @@ fn missing_ed25519_issuer_transition() {
     let protocol_parameters = protocol_parameters();
     let nft_id_1 = NftId::from_str(NFT_ID_1).unwrap();
 
-    let inputs = build_inputs([Nft(
-        1_000_000,
-        nft_id_1,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        Some(Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap()),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Nft(
+            1_000_000,
+            nft_id_1,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            Some(Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap()),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Nft(
         1_000_000,
         nft_id_1,
@@ -594,16 +624,19 @@ fn missing_account_sender() {
     let protocol_parameters = protocol_parameters();
     let nft_id_2 = NftId::from_str(NFT_ID_2).unwrap();
 
-    let inputs = build_inputs([Nft(
-        1_000_000,
-        nft_id_2,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Nft(
+            1_000_000,
+            nft_id_2,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Nft(
         1_000_000,
         nft_id_2,
@@ -634,16 +667,19 @@ fn missing_account_issuer_created() {
     let protocol_parameters = protocol_parameters();
     let nft_id_0 = NftId::from_str(NFT_ID_0).unwrap();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Nft(
         1_000_000,
         nft_id_0,
@@ -674,16 +710,19 @@ fn missing_account_issuer_transition() {
     let protocol_parameters = protocol_parameters();
     let nft_id_2 = NftId::from_str(NFT_ID_2).unwrap();
 
-    let inputs = build_inputs([Nft(
-        1_000_000,
-        nft_id_2,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        Some(Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap()),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Nft(
+            1_000_000,
+            nft_id_2,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            Some(Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap()),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Nft(
         1_000_000,
         nft_id_2,
@@ -711,16 +750,19 @@ fn missing_nft_sender() {
     let protocol_parameters = protocol_parameters();
     let nft_id_2 = NftId::from_str(NFT_ID_2).unwrap();
 
-    let inputs = build_inputs([Nft(
-        1_000_000,
-        nft_id_2,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Nft(
+            1_000_000,
+            nft_id_2,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Nft(
         1_000_000,
         nft_id_2,
@@ -751,16 +793,19 @@ fn missing_nft_issuer_created() {
     let protocol_parameters = protocol_parameters();
     let nft_id_0 = NftId::from_str(NFT_ID_0).unwrap();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Nft(
         1_000_000,
         nft_id_0,
@@ -791,16 +836,19 @@ fn missing_nft_issuer_transition() {
     let protocol_parameters = protocol_parameters();
     let nft_id_2 = NftId::from_str(NFT_ID_2).unwrap();
 
-    let inputs = build_inputs([Nft(
-        1_000_000,
-        nft_id_2,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        Some(Address::try_from_bech32(BECH32_ADDRESS_NFT_1).unwrap()),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Nft(
+            1_000_000,
+            nft_id_2,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            Some(Address::try_from_bech32(BECH32_ADDRESS_NFT_1).unwrap()),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Nft(
         1_000_000,
         nft_id_2,
@@ -828,28 +876,31 @@ fn increase_nft_amount() {
     let protocol_parameters = protocol_parameters();
     let nft_id_1 = NftId::from_str(NFT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Nft(
-            2_000_000,
-            nft_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Nft(
+                2_000_000,
+                nft_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Nft(
         3_000_000,
         nft_id_1,
@@ -879,28 +930,31 @@ fn decrease_nft_amount() {
     let protocol_parameters = protocol_parameters();
     let nft_id_1 = NftId::from_str(NFT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Nft(
-            2_000_000,
-            nft_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Nft(
+                2_000_000,
+                nft_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Nft(
         1_000_000,
         nft_id_1,
@@ -942,28 +996,31 @@ fn prefer_basic_to_nft() {
     let protocol_parameters = protocol_parameters();
     let nft_id_1 = NftId::from_str(NFT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Nft(
-            2_000_000,
-            nft_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Nft(
+                2_000_000,
+                nft_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -994,28 +1051,31 @@ fn take_amount_from_nft_to_fund_basic() {
     let protocol_parameters = protocol_parameters();
     let nft_id_1 = NftId::from_str(NFT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Nft(
-            2_000_000,
-            nft_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Nft(
+                2_000_000,
+                nft_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_200_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1058,28 +1118,31 @@ fn nft_burn_should_validate_nft_sender() {
     let protocol_parameters = protocol_parameters();
     let nft_id_1 = NftId::from_str(NFT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Nft(
-            1_000_000,
-            nft_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Nft(
+                1_000_000,
+                nft_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         3_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1110,28 +1173,31 @@ fn nft_burn_should_validate_nft_address() {
     let protocol_parameters = protocol_parameters();
     let nft_id_1 = NftId::from_str(NFT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_NFT_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Nft(
-            1_000_000,
-            nft_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_NFT_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Nft(
+                1_000_000,
+                nft_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         3_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -1162,16 +1228,19 @@ fn transitioned_zero_nft_id_no_longer_is_zero() {
     let protocol_parameters = protocol_parameters();
     let nft_id_0 = NftId::from_str(NFT_ID_0).unwrap();
 
-    let inputs = build_inputs([Nft(
-        2_000_000,
-        nft_id_0,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Nft(
+            2_000_000,
+            nft_id_0,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
diff --git a/sdk/tests/client/input_selection/outputs.rs b/sdk/tests/client/input_selection/outputs.rs
index 7fae73e9c5..98551690e9 100644
--- a/sdk/tests/client/input_selection/outputs.rs
+++ b/sdk/tests/client/input_selection/outputs.rs
@@ -46,16 +46,19 @@ fn no_inputs() {
 fn no_outputs() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = Vec::new();
 
     let selected = InputSelection::new(
@@ -74,14 +77,17 @@ fn no_outputs_but_burn() {
     let protocol_parameters = protocol_parameters();
     let account_id_2 = AccountId::from_str(ACCOUNT_ID_2).unwrap();
 
-    let inputs = build_inputs([Account(
-        2_000_000,
-        account_id_2,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Account(
+            2_000_000,
+            account_id_2,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = Vec::new();
 
     let selected = InputSelection::new(
@@ -108,16 +114,19 @@ fn no_outputs_but_burn() {
 fn no_address_provided() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -138,16 +147,19 @@ fn no_address_provided() {
 fn no_matching_address_provided() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -174,28 +186,31 @@ fn no_matching_address_provided() {
 fn two_addresses_one_missing() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -228,28 +243,31 @@ fn two_addresses_one_missing() {
 fn two_addresses() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
diff --git a/sdk/tests/client/input_selection/storage_deposit_return.rs b/sdk/tests/client/input_selection/storage_deposit_return.rs
index 5c7ba2b633..1ccec61b40 100644
--- a/sdk/tests/client/input_selection/storage_deposit_return.rs
+++ b/sdk/tests/client/input_selection/storage_deposit_return.rs
@@ -20,16 +20,19 @@ use crate::client::{
 fn sdruc_output_not_provided_no_remainder() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -69,16 +72,19 @@ fn sdruc_output_not_provided_no_remainder() {
 fn sdruc_output_provided_no_remainder() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([
         Basic(
             1_000_000,
@@ -119,16 +125,19 @@ fn sdruc_output_provided_no_remainder() {
 fn sdruc_output_provided_remainder() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
@@ -168,28 +177,31 @@ fn sdruc_output_provided_remainder() {
 fn two_sdrucs_to_the_same_address_both_needed() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -229,28 +241,31 @@ fn two_sdrucs_to_the_same_address_both_needed() {
 fn two_sdrucs_to_the_same_address_one_needed() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -291,28 +306,31 @@ fn two_sdrucs_to_the_same_address_one_needed() {
 fn two_sdrucs_to_different_addresses_both_needed() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(), 1_000_000)),
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(), 1_000_000)),
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -358,28 +376,31 @@ fn two_sdrucs_to_different_addresses_both_needed() {
 fn two_sdrucs_to_different_addresses_one_needed() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(), 1_000_000)),
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(), 1_000_000)),
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -420,16 +441,19 @@ fn two_sdrucs_to_different_addresses_one_needed() {
 fn insufficient_amount_because_of_sdruc() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
-        None,
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(), 1_000_000)),
+            None,
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -462,28 +486,31 @@ fn insufficient_amount_because_of_sdruc() {
 fn useless_sdruc_required_for_sender_feature() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(), 1_000_000)),
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(), 1_000_000)),
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
@@ -527,26 +554,29 @@ fn sdruc_required_non_ed25519_in_address_unlock() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(),
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(), 1_000_000)),
-            None,
-            None,
-            None,
-        ),
-        Account(
-            1_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(),
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(), 1_000_000)),
+                None,
+                None,
+                None,
+            ),
+            Account(
+                1_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(),
@@ -587,36 +617,39 @@ fn useless_sdruc_non_ed25519_in_address_unlock() {
     let protocol_parameters = protocol_parameters();
     let account_id_1 = AccountId::from_str(ACCOUNT_ID_1).unwrap();
 
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(),
-            None,
-            None,
-            Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(), 1_000_000)),
-            None,
-            None,
-            None,
-        ),
-        Basic(
-            1_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-        Account(
-            1_000_000,
-            account_id_1,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(),
+                None,
+                None,
+                Some((Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(), 1_000_000)),
+                None,
+                None,
+                None,
+            ),
+            Basic(
+                1_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ACCOUNT_1).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+            Account(
+                1_000_000,
+                account_id_1,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_2).unwrap(),
diff --git a/sdk/tests/client/input_selection/timelock.rs b/sdk/tests/client/input_selection/timelock.rs
index 7c27a9bad9..d5a100cf6d 100644
--- a/sdk/tests/client/input_selection/timelock.rs
+++ b/sdk/tests/client/input_selection/timelock.rs
@@ -15,16 +15,19 @@ use crate::client::{
 fn one_output_timelock_not_expired() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        Some(200),
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            Some(200),
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         1_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
@@ -52,16 +55,19 @@ fn one_output_timelock_not_expired() {
 fn timelock_equal_timestamp() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        Some(200),
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            Some(200),
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
@@ -91,28 +97,31 @@ fn timelock_equal_timestamp() {
 fn two_outputs_one_timelock_expired() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            Some(200),
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            Some(50),
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                Some(200),
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                Some(50),
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
@@ -143,28 +152,31 @@ fn two_outputs_one_timelock_expired() {
 fn two_outputs_one_timelocked_one_missing() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            Some(200),
-            None,
-            None,
-        ),
-        Basic(
-            2_000_000,
-            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-        ),
-    ]);
+    let inputs = build_inputs(
+        [
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                Some(200),
+                None,
+                None,
+            ),
+            Basic(
+                2_000_000,
+                Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                None,
+            ),
+        ],
+        None,
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
@@ -195,16 +207,19 @@ fn two_outputs_one_timelocked_one_missing() {
 fn one_output_timelock_expired() {
     let protocol_parameters = protocol_parameters();
 
-    let inputs = build_inputs([Basic(
-        2_000_000,
-        Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
-        None,
-        None,
-        None,
-        Some(50),
-        None,
+    let inputs = build_inputs(
+        [Basic(
+            2_000_000,
+            Address::try_from_bech32(BECH32_ADDRESS_ED25519_0).unwrap(),
+            None,
+            None,
+            None,
+            Some(50),
+            None,
+            None,
+        )],
         None,
-    )]);
+    );
     let outputs = build_outputs([Basic(
         2_000_000,
         Address::try_from_bech32(BECH32_ADDRESS_ED25519_1).unwrap(),
diff --git a/sdk/tests/client/mod.rs b/sdk/tests/client/mod.rs
index 987ef89ea8..e65ca490d2 100644
--- a/sdk/tests/client/mod.rs
+++ b/sdk/tests/client/mod.rs
@@ -31,7 +31,11 @@ use iota_sdk::{
             AccountId, AccountOutputBuilder, BasicOutputBuilder, FoundryOutputBuilder, NativeToken, NftId,
             NftOutputBuilder, Output, OutputId, SimpleTokenScheme, TokenId, TokenScheme,
         },
-        rand::{output::rand_output_metadata_with_id, transaction::rand_transaction_id},
+        rand::{
+            output::rand_output_metadata_with_id,
+            transaction::{rand_transaction_id, rand_transaction_id_with_slot_index},
+        },
+        slot::SlotIndex,
     },
 };
 
@@ -208,15 +212,22 @@ fn build_output_inner(build: Build) -> (Output, Option<Bip44>) {
     }
 }
 
-fn build_inputs<'a>(outputs: impl IntoIterator<Item = Build<'a>>) -> Vec<InputSigningData> {
+fn build_inputs<'a>(
+    outputs: impl IntoIterator<Item = Build<'a>>,
+    slot_index: Option<SlotIndex>,
+) -> Vec<InputSigningData> {
     outputs
         .into_iter()
         .map(|build| {
             let (output, chain) = build_output_inner(build);
+            let transaction_id = slot_index.map_or_else(
+                || rand_transaction_id(),
+                |index| rand_transaction_id_with_slot_index(index),
+            );
 
             InputSigningData {
                 output,
-                output_metadata: rand_output_metadata_with_id(OutputId::new(rand_transaction_id(), 0)),
+                output_metadata: rand_output_metadata_with_id(OutputId::new(transaction_id, 0)),
                 chain,
             }
         })
diff --git a/sdk/tests/client/signing/account.rs b/sdk/tests/client/signing/account.rs
index 30eafbb97c..a97ed6d29e 100644
--- a/sdk/tests/client/signing/account.rs
+++ b/sdk/tests/client/signing/account.rs
@@ -20,7 +20,7 @@ use iota_sdk::{
         output::AccountId,
         payload::{signed_transaction::Transaction, SignedTransactionPayload},
         protocol::protocol_parameters,
-        rand::mana::rand_mana_allotment,
+        slot::SlotIndex,
         unlock::{SignatureUnlock, Unlock},
     },
 };
@@ -48,15 +48,19 @@ async fn sign_account_state_transition() -> Result<()> {
 
     let protocol_parameters = protocol_parameters();
     let account_id = AccountId::from_str(ACCOUNT_ID_1)?;
+    let slot_index = SlotIndex::from(10);
 
-    let inputs = build_inputs([Account(
-        1_000_000,
-        account_id,
-        address.clone(),
-        None,
-        None,
-        Some(Bip44::new(SHIMMER_COIN_TYPE)),
-    )]);
+    let inputs = build_inputs(
+        [Account(
+            1_000_000,
+            account_id,
+            address.clone(),
+            None,
+            None,
+            Some(Bip44::new(SHIMMER_COIN_TYPE)),
+        )],
+        Some(slot_index),
+    );
 
     let outputs = build_outputs([Account(1_000_000, account_id, address.clone(), None, None, None)]);
 
@@ -68,7 +72,7 @@ async fn sign_account_state_transition() -> Result<()> {
                 .collect::<Vec<_>>(),
         )
         .with_outputs(outputs)
-        .add_mana_allotment(rand_mana_allotment(&protocol_parameters))
+        .with_creation_slot(slot_index + 1)
         .finish_with_params(&protocol_parameters)?;
 
     let prepared_transaction_data = PreparedTransactionData {
@@ -114,19 +118,23 @@ async fn account_reference_unlocks() -> Result<()> {
     let protocol_parameters = protocol_parameters();
     let account_id = AccountId::from_str(ACCOUNT_ID_1)?;
     let account_address = Address::Account(AccountAddress::new(account_id));
-
-    let inputs = build_inputs([
-        Account(
-            1_000_000,
-            account_id,
-            address.clone(),
-            None,
-            None,
-            Some(Bip44::new(SHIMMER_COIN_TYPE)),
-        ),
-        Basic(1_000_000, account_address.clone(), None, None, None, None, None, None),
-        Basic(1_000_000, account_address.clone(), None, None, None, None, None, None),
-    ]);
+    let slot_index = SlotIndex::from(10);
+
+    let inputs = build_inputs(
+        [
+            Account(
+                1_000_000,
+                account_id,
+                address.clone(),
+                None,
+                None,
+                Some(Bip44::new(SHIMMER_COIN_TYPE)),
+            ),
+            Basic(1_000_000, account_address.clone(), None, None, None, None, None, None),
+            Basic(1_000_000, account_address.clone(), None, None, None, None, None, None),
+        ],
+        Some(slot_index),
+    );
 
     let outputs = build_outputs([
         Account(1_000_000, account_id, address, None, None, None),
@@ -141,7 +149,7 @@ async fn account_reference_unlocks() -> Result<()> {
                 .collect::<Vec<_>>(),
         )
         .with_outputs(outputs)
-        .add_mana_allotment(rand_mana_allotment(&protocol_parameters))
+        .with_creation_slot(slot_index + 1)
         .finish_with_params(&protocol_parameters)?;
 
     let prepared_transaction_data = PreparedTransactionData {
diff --git a/sdk/tests/client/signing/basic.rs b/sdk/tests/client/signing/basic.rs
index ba9a2eb5b0..07b7a4144d 100644
--- a/sdk/tests/client/signing/basic.rs
+++ b/sdk/tests/client/signing/basic.rs
@@ -16,7 +16,7 @@ use iota_sdk::{
         input::{Input, UtxoInput},
         payload::{signed_transaction::Transaction, SignedTransactionPayload},
         protocol::protocol_parameters,
-        rand::mana::rand_mana_allotment,
+        slot::SlotIndex,
         unlock::{SignatureUnlock, Unlock},
     },
 };
@@ -39,17 +39,21 @@ async fn single_ed25519_unlock() -> Result<()> {
         .into_inner();
 
     let protocol_parameters = protocol_parameters();
+    let slot_index = SlotIndex::from(10);
 
-    let inputs = build_inputs([Basic(
-        1_000_000,
-        address_0.clone(),
-        None,
-        None,
-        None,
-        None,
-        None,
-        Some(Bip44::new(SHIMMER_COIN_TYPE)),
-    )]);
+    let inputs = build_inputs(
+        [Basic(
+            1_000_000,
+            address_0.clone(),
+            None,
+            None,
+            None,
+            None,
+            None,
+            Some(Bip44::new(SHIMMER_COIN_TYPE)),
+        )],
+        Some(slot_index),
+    );
 
     let outputs = build_outputs([Basic(
         1_000_000,
@@ -70,7 +74,7 @@ async fn single_ed25519_unlock() -> Result<()> {
                 .collect::<Vec<_>>(),
         )
         .with_outputs(outputs)
-        .add_mana_allotment(rand_mana_allotment(&protocol_parameters))
+        .with_creation_slot(slot_index + 1)
         .finish_with_params(&protocol_parameters)?;
 
     let prepared_transaction_data = PreparedTransactionData {
@@ -114,39 +118,43 @@ async fn ed25519_reference_unlocks() -> Result<()> {
         .into_inner();
 
     let protocol_parameters = protocol_parameters();
-
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            address_0.clone(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            Some(Bip44::new(SHIMMER_COIN_TYPE)),
-        ),
-        Basic(
-            1_000_000,
-            address_0.clone(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            Some(Bip44::new(SHIMMER_COIN_TYPE)),
-        ),
-        Basic(
-            1_000_000,
-            address_0.clone(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            Some(Bip44::new(SHIMMER_COIN_TYPE)),
-        ),
-    ]);
+    let slot_index = SlotIndex::from(10);
+
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                address_0.clone(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                Some(Bip44::new(SHIMMER_COIN_TYPE)),
+            ),
+            Basic(
+                1_000_000,
+                address_0.clone(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                Some(Bip44::new(SHIMMER_COIN_TYPE)),
+            ),
+            Basic(
+                1_000_000,
+                address_0.clone(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                Some(Bip44::new(SHIMMER_COIN_TYPE)),
+            ),
+        ],
+        Some(slot_index),
+    );
 
     let outputs = build_outputs([Basic(
         3_000_000,
@@ -167,7 +175,7 @@ async fn ed25519_reference_unlocks() -> Result<()> {
                 .collect::<Vec<_>>(),
         )
         .with_outputs(outputs)
-        .add_mana_allotment(rand_mana_allotment(&protocol_parameters))
+        .with_creation_slot(slot_index + 1)
         .finish_with_params(&protocol_parameters)?;
 
     let prepared_transaction_data = PreparedTransactionData {
@@ -232,29 +240,33 @@ async fn two_signature_unlocks() -> Result<()> {
         .into_inner();
 
     let protocol_parameters = protocol_parameters();
-
-    let inputs = build_inputs([
-        Basic(
-            1_000_000,
-            address_0.clone(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            Some(Bip44::new(SHIMMER_COIN_TYPE)),
-        ),
-        Basic(
-            1_000_000,
-            address_1,
-            None,
-            None,
-            None,
-            None,
-            None,
-            Some(Bip44::new(SHIMMER_COIN_TYPE).with_address_index(1)),
-        ),
-    ]);
+    let slot_index = SlotIndex::from(10);
+
+    let inputs = build_inputs(
+        [
+            Basic(
+                1_000_000,
+                address_0.clone(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                Some(Bip44::new(SHIMMER_COIN_TYPE)),
+            ),
+            Basic(
+                1_000_000,
+                address_1,
+                None,
+                None,
+                None,
+                None,
+                None,
+                Some(Bip44::new(SHIMMER_COIN_TYPE).with_address_index(1)),
+            ),
+        ],
+        Some(slot_index),
+    );
 
     let outputs = build_outputs([Basic(
         2_000_000,
@@ -275,7 +287,7 @@ async fn two_signature_unlocks() -> Result<()> {
                 .collect::<Vec<_>>(),
         )
         .with_outputs(outputs)
-        .add_mana_allotment(rand_mana_allotment(&protocol_parameters))
+        .with_creation_slot(slot_index + 1)
         .finish_with_params(&protocol_parameters)?;
 
     let prepared_transaction_data = PreparedTransactionData {
diff --git a/sdk/tests/client/signing/mod.rs b/sdk/tests/client/signing/mod.rs
index a5149ec73a..dc38b1fd3d 100644
--- a/sdk/tests/client/signing/mod.rs
+++ b/sdk/tests/client/signing/mod.rs
@@ -19,13 +19,12 @@ use iota_sdk::{
         Result,
     },
     types::block::{
-        address::{AccountAddress, Address, NftAddress, ToBech32Ext},
+        address::{AccountAddress, Address, NftAddress},
         context_input::{CommitmentContextInput, ContextInput},
         input::{Input, UtxoInput},
         output::{AccountId, NftId},
         payload::{signed_transaction::Transaction, SignedTransactionPayload},
         protocol::protocol_parameters,
-        rand::mana::rand_mana_allotment,
         slot::{SlotCommitmentId, SlotIndex},
         unlock::{SignatureUnlock, Unlock},
     },
@@ -72,125 +71,130 @@ async fn all_combined() -> Result<()> {
     let nft_3 = Address::Nft(NftAddress::new(nft_id_3));
     let nft_4 = Address::Nft(NftAddress::new(nft_id_4));
 
-    let inputs = build_inputs([
-        Account(1_000_000, account_id_1, nft_1.clone(), None, None, None),
-        Account(
-            1_000_000,
-            account_id_2,
-            ed25519_0.clone(),
-            None,
-            None,
-            Some(Bip44::new(SHIMMER_COIN_TYPE)),
-        ),
-        Basic(1_000_000, account_1.clone(), None, None, None, None, None, None),
-        Basic(1_000_000, account_2.clone(), None, None, None, None, None, None),
-        Basic(1_000_000, account_2, None, None, None, None, None, None),
-        Basic(1_000_000, nft_2.clone(), None, None, None, None, None, None),
-        Basic(1_000_000, nft_2, None, None, None, None, None, None),
-        Basic(1_000_000, nft_4.clone(), None, None, None, None, None, None),
-        Basic(
-            1_000_000,
-            ed25519_0.clone(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            Some(Bip44::new(SHIMMER_COIN_TYPE)),
-        ),
-        Basic(
-            1_000_000,
-            ed25519_1.clone(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            Some(Bip44::new(SHIMMER_COIN_TYPE).with_address_index(1)),
-        ),
-        Basic(
-            1_000_000,
-            ed25519_2.clone(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            Some(Bip44::new(SHIMMER_COIN_TYPE).with_address_index(2)),
-        ),
-        Basic(
-            1_000_000,
-            ed25519_2.clone(),
-            None,
-            None,
-            None,
-            None,
-            None,
-            Some(Bip44::new(SHIMMER_COIN_TYPE).with_address_index(2)),
-        ),
-        Nft(
-            1_000_000,
-            nft_id_1,
-            ed25519_0.clone(),
-            None,
-            None,
-            None,
-            None,
-            Some(Bip44::new(SHIMMER_COIN_TYPE)),
-        ),
-        Nft(1_000_000, nft_id_2, account_1.clone(), None, None, None, None, None),
-        // Expirations
-        Basic(
-            2_000_000,
-            ed25519_0.clone(),
-            None,
-            None,
-            None,
-            None,
-            Some((account_1.clone(), 50)),
-            None,
-        ),
-        Basic(
-            2_000_000,
-            ed25519_0.clone(),
-            None,
-            None,
-            None,
-            None,
-            Some((nft_3.clone(), 50)),
-            None,
-        ),
-        Basic(
-            2_000_000,
-            ed25519_0.clone(),
-            None,
-            None,
-            None,
-            None,
-            Some((nft_3.clone(), 150)),
-            Some(Bip44::new(SHIMMER_COIN_TYPE)),
-        ),
-        Nft(
-            1_000_000,
-            nft_id_3,
-            account_1.clone(),
-            None,
-            None,
-            None,
-            Some((nft_4, 50)),
-            None,
-        ),
-        Nft(
-            1_000_000,
-            nft_id_4,
-            account_1,
-            None,
-            None,
-            None,
-            Some((nft_3, 150)),
-            None,
-        ),
-    ]);
+    let slot_index = SlotIndex::from(90);
+
+    let inputs = build_inputs(
+        [
+            Account(1_000_000, account_id_1, nft_1.clone(), None, None, None),
+            Account(
+                1_000_000,
+                account_id_2,
+                ed25519_0.clone(),
+                None,
+                None,
+                Some(Bip44::new(SHIMMER_COIN_TYPE)),
+            ),
+            Basic(1_000_000, account_1.clone(), None, None, None, None, None, None),
+            Basic(1_000_000, account_2.clone(), None, None, None, None, None, None),
+            Basic(1_000_000, account_2, None, None, None, None, None, None),
+            Basic(1_000_000, nft_2.clone(), None, None, None, None, None, None),
+            Basic(1_000_000, nft_2, None, None, None, None, None, None),
+            Basic(1_000_000, nft_4.clone(), None, None, None, None, None, None),
+            Basic(
+                1_000_000,
+                ed25519_0.clone(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                Some(Bip44::new(SHIMMER_COIN_TYPE)),
+            ),
+            Basic(
+                1_000_000,
+                ed25519_1.clone(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                Some(Bip44::new(SHIMMER_COIN_TYPE).with_address_index(1)),
+            ),
+            Basic(
+                1_000_000,
+                ed25519_2.clone(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                Some(Bip44::new(SHIMMER_COIN_TYPE).with_address_index(2)),
+            ),
+            Basic(
+                1_000_000,
+                ed25519_2.clone(),
+                None,
+                None,
+                None,
+                None,
+                None,
+                Some(Bip44::new(SHIMMER_COIN_TYPE).with_address_index(2)),
+            ),
+            Nft(
+                1_000_000,
+                nft_id_1,
+                ed25519_0.clone(),
+                None,
+                None,
+                None,
+                None,
+                Some(Bip44::new(SHIMMER_COIN_TYPE)),
+            ),
+            Nft(1_000_000, nft_id_2, account_1.clone(), None, None, None, None, None),
+            // Expirations
+            Basic(
+                2_000_000,
+                ed25519_0.clone(),
+                None,
+                None,
+                None,
+                None,
+                Some((account_1.clone(), 50)),
+                None,
+            ),
+            Basic(
+                2_000_000,
+                ed25519_0.clone(),
+                None,
+                None,
+                None,
+                None,
+                Some((nft_3.clone(), 50)),
+                None,
+            ),
+            Basic(
+                2_000_000,
+                ed25519_0.clone(),
+                None,
+                None,
+                None,
+                None,
+                Some((nft_3.clone(), 150)),
+                Some(Bip44::new(SHIMMER_COIN_TYPE)),
+            ),
+            Nft(
+                1_000_000,
+                nft_id_3,
+                account_1.clone(),
+                None,
+                None,
+                None,
+                Some((nft_4, 50)),
+                None,
+            ),
+            Nft(
+                1_000_000,
+                nft_id_4,
+                account_1,
+                None,
+                None,
+                None,
+                Some((nft_3, 150)),
+                None,
+            ),
+        ],
+        Some(slot_index),
+    );
 
     let outputs = build_outputs([
         Account(1_000_000, account_id_1, nft_1, None, None, None),
@@ -202,8 +206,6 @@ async fn all_combined() -> Result<()> {
         Nft(1_000_000, nft_id_4, ed25519_0.clone(), None, None, None, None, None),
     ]);
 
-    let slot_index = SlotIndex::from(90);
-
     let selected = InputSelection::new(
         inputs.clone(),
         outputs.clone(),
@@ -227,7 +229,6 @@ async fn all_combined() -> Result<()> {
         )
         .with_outputs(outputs)
         .with_creation_slot(slot_index)
-        .add_mana_allotment(rand_mana_allotment(&protocol_parameters))
         .finish_with_params(&protocol_parameters)?;
 
     let prepared_transaction_data = PreparedTransactionData {
diff --git a/sdk/tests/client/signing/nft.rs b/sdk/tests/client/signing/nft.rs
index 65e0470d18..72b4c4d374 100644
--- a/sdk/tests/client/signing/nft.rs
+++ b/sdk/tests/client/signing/nft.rs
@@ -20,7 +20,7 @@ use iota_sdk::{
         output::NftId,
         payload::{signed_transaction::Transaction, SignedTransactionPayload},
         protocol::protocol_parameters,
-        rand::mana::rand_mana_allotment,
+        slot::SlotIndex,
         unlock::{SignatureUnlock, Unlock},
     },
 };
@@ -49,21 +49,25 @@ async fn nft_reference_unlocks() -> Result<()> {
     let protocol_parameters = protocol_parameters();
     let nft_id = NftId::from_str(NFT_ID_1)?;
     let nft_address = Address::Nft(NftAddress::new(nft_id));
-
-    let inputs = build_inputs([
-        Nft(
-            1_000_000,
-            nft_id,
-            address_0.clone(),
-            None,
-            None,
-            None,
-            None,
-            Some(Bip44::new(SHIMMER_COIN_TYPE)),
-        ),
-        Basic(1_000_000, nft_address.clone(), None, None, None, None, None, None),
-        Basic(1_000_000, nft_address.clone(), None, None, None, None, None, None),
-    ]);
+    let slot_index = SlotIndex::from(10);
+
+    let inputs = build_inputs(
+        [
+            Nft(
+                1_000_000,
+                nft_id,
+                address_0.clone(),
+                None,
+                None,
+                None,
+                None,
+                Some(Bip44::new(SHIMMER_COIN_TYPE)),
+            ),
+            Basic(1_000_000, nft_address.clone(), None, None, None, None, None, None),
+            Basic(1_000_000, nft_address.clone(), None, None, None, None, None, None),
+        ],
+        Some(slot_index),
+    );
 
     let outputs = build_outputs([
         Nft(1_000_000, nft_id, address_0, None, None, None, None, None),
@@ -78,7 +82,7 @@ async fn nft_reference_unlocks() -> Result<()> {
                 .collect::<Vec<_>>(),
         )
         .with_outputs(outputs)
-        .add_mana_allotment(rand_mana_allotment(&protocol_parameters))
+        .with_creation_slot(slot_index + 1)
         .finish_with_params(&protocol_parameters)?;
 
     let prepared_transaction_data = PreparedTransactionData {