diff --git a/docs/stdlib.json b/docs/stdlib.json
index 801701e..e67086b 100644
--- a/docs/stdlib.json
+++ b/docs/stdlib.json
@@ -104,6 +104,174 @@
     "output_type": "()",
     "description": "Assert that two `bool` values are equal.\n\n## Panics\nThe assertion fails."
   },
+  {
+    "simplicityhl_name": "get_explicit_amount",
+    "section": "Amount getters",
+    "input_type": "u32, bool",
+    "output_type": "u64",
+    "description": "Returns the explicit amount at the specified input or output index.\n\n## Panics\nPanics if the specified input or output does not exist or if its amount is confidential."
+  },
+  {
+    "simplicityhl_name": "get_confidential_amount",
+    "section": "Amount getters",
+    "input_type": "u32, bool",
+    "output_type": "Confidential1",
+    "description": "Returns the confidential amount at the specified input or output index.\n\n## Panics\nPanics if the specified input or output does not exist or if its amount is explicit."
+  },
+  {
+    "simplicityhl_name": "get_explicit_input_amount",
+    "section": "Amount getters",
+    "input_type": "u32",
+    "output_type": "u64",
+    "description": "Returns the explicit amount at the specified input index.\n\n## Panics\nPanics if the specified input does not exist or if its amount is confidential."
+  },
+  {
+    "simplicityhl_name": "get_confidential_input_amount",
+    "section": "Amount getters",
+    "input_type": "u32",
+    "output_type": "Confidential1",
+    "description": "Returns the confidential amount at the specified input index.\n\n## Panics\nPanics if the specified input does not exist or if its amount is explicit."
+  },
+  {
+    "simplicityhl_name": "get_explicit_output_amount",
+    "section": "Amount getters",
+    "input_type": "u32",
+    "output_type": "u64",
+    "description": "Returns the explicit amount at the specified output index.\n\n## Panics\nPanics if the specified output does not exist or if its amount is confidential."
+  },
+  {
+    "simplicityhl_name": "get_confidential_output_amount",
+    "section": "Amount getters",
+    "input_type": "u32",
+    "output_type": "Confidential1",
+    "description": "Returns the confidential amount at the specified output index.\n\n## Panics\nPanics if the specified output does not exist or if its amount is explicit."
+  },
+  {
+    "simplicityhl_name": "get_explicit_current_amount",
+    "section": "Amount getters",
+    "input_type": "()",
+    "output_type": "u64",
+    "description": "Returns the explicit input amount at the current_index.\n\n## Panics\nPanics if amount is confidential."
+  },
+  {
+    "simplicityhl_name": "get_confidential_current_amount",
+    "section": "Amount getters",
+    "input_type": "()",
+    "output_type": "Confidential1",
+    "description": "Returns the confidential input amount at the current_index.\n\n## Panics\nPanics if amount is explicit."
+  },
+  {
+    "simplicityhl_name": "get_explicit_asset_id_with_amount",
+    "section": "AssetId and Amount getters",
+    "input_type": "u32, bool",
+    "output_type": "(u256, u64)",
+    "description": "Returns explicit asset_id and amount at the specified input or output index.\n\n## Panics\nPanics if the specified input or output does not exist or if its asset_id and amount are confidential."
+  },
+  {
+    "simplicityhl_name": "get_confidential_asset_id_with_amount",
+    "section": "AssetId and Amount getters",
+    "input_type": "u32, bool",
+    "output_type": "(Confidential1, Confidential1)",
+    "description": "Returns confidential asset_id and amount at the specified input or output index.\n\n## Panics\nPanics if the specified input or output does not exist or if its asset_id and amount are explicit."
+  },
+  {
+    "simplicityhl_name": "get_explicit_input_asset_id_with_amount",
+    "section": "AssetId and Amount getters",
+    "input_type": "u32",
+    "output_type": "(u256, u64)",
+    "description": "Returns explicit asset_id and amount at the specified input index.\n\n## Panics\nPanics if the specified input does not exist or if its asset_id and amount are confidential."
+  },
+  {
+    "simplicityhl_name": "get_confidential_input_asset_id_with_amount",
+    "section": "AssetId and Amount getters",
+    "input_type": "u32",
+    "output_type": "(Confidential1, Confidential1)",
+    "description": "Returns confidential asset_id and amount at the specified input index.\n\n## Panics\nPanics if the specified input does not exist or if its asset_id and amount are explicit."
+  },
+  {
+    "simplicityhl_name": "get_explicit_output_asset_id_with_amount",
+    "section": "AssetId and Amount getters",
+    "input_type": "u32",
+    "output_type": "(u256, u64)",
+    "description": "Returns explicit asset_id and amount at the specified output index.\n\n## Panics\nPanics if the specified output does not exist or if its asset_id and amount are confidential."
+  },
+  {
+    "simplicityhl_name": "get_confidential_output_asset_id_with_amount",
+    "section": "AssetId and Amount getters",
+    "input_type": "u32",
+    "output_type": "(Confidential1, Confidential1)",
+    "description": "Returns confidential asset_id and amount at the specified output index.\n\n## Panics\nPanics if the specified output does not exist or if its asset_id and amount are explicit."
+  },
+  {
+    "simplicityhl_name": "get_explicit_current_asset_id_with_amount",
+    "section": "AssetId and Amount getters",
+    "input_type": "()",
+    "output_type": "(u256, u64)",
+    "description": "Returns explicit input asset_id and amount at the current_index.\n\n## Panics\nPanics if asset_id and amount are confidential."
+  },
+  {
+    "simplicityhl_name": "get_confidential_current_asset_id_with_amount",
+    "section": "AssetId and Amount getters",
+    "input_type": "()",
+    "output_type": "(Confidential1, Confidential1)",
+    "description": "Returns confidential input asset_id and amount at the current_index.\n\n## Panics\nPanics if asset_id and amount are explicit."
+  },
+  {
+    "simplicityhl_name": "get_explicit_asset_id",
+    "section": "AssetId getters",
+    "input_type": "u32, bool",
+    "output_type": "u256",
+    "description": "Returns the explicit asset_id at the specified input or output index.\n\n## Panics\nPanics if the specified input or output does not exist or if its asset_id is confidential."
+  },
+  {
+    "simplicityhl_name": "get_confidential_asset_id",
+    "section": "AssetId getters",
+    "input_type": "u32, bool",
+    "output_type": "Confidential1",
+    "description": "Returns the confidential asset_id at the specified input or output index.\n\n## Panics\nPanics if the specified input or output does not exist or if its asset_id is explicit."
+  },
+  {
+    "simplicityhl_name": "get_explicit_input_asset_id",
+    "section": "AssetId getters",
+    "input_type": "u32",
+    "output_type": "u256",
+    "description": "Returns the explicit asset_id at the specified input index.\n\n## Panics\nPanics if the specified input does not exist or if its asset_id is confidential."
+  },
+  {
+    "simplicityhl_name": "get_confidential_input_asset_id",
+    "section": "AssetId getters",
+    "input_type": "u32",
+    "output_type": "Confidential1",
+    "description": "Returns the confidential asset_id at the specified input index.\n\n## Panics\nPanics if the specified input does not exist or if its asset_id is explicit."
+  },
+  {
+    "simplicityhl_name": "get_explicit_output_asset_id",
+    "section": "AssetId getters",
+    "input_type": "u32",
+    "output_type": "u256",
+    "description": "Returns the explicit asset_id at the specified output index.\n\n## Panics\nPanics if the specified output does not exist or if its asset_id is confidential."
+  },
+  {
+    "simplicityhl_name": "get_confidential_output_asset_id",
+    "section": "AssetId getters",
+    "input_type": "u32",
+    "output_type": "Confidential1",
+    "description": "Returns the confidential asset_id at the specified output index.\n\n## Panics\nPanics if the specified output does not exist or if its asset_id is explicit."
+  },
+  {
+    "simplicityhl_name": "get_explicit_current_asset_id",
+    "section": "AssetId getters",
+    "input_type": "()",
+    "output_type": "u256",
+    "description": "Returns the explicit input asset_id at the current_index.\n\n## Panics\nPanics if asset_id is confidential."
+  },
+  {
+    "simplicityhl_name": "get_confidential_current_asset_id",
+    "section": "AssetId getters",
+    "input_type": "()",
+    "output_type": "Confidential1",
+    "description": "Returns the confidential input asset_id at the current_index.\n\n## Panics\nPanics if asset_id is explicit."
+  },
   {
     "simplicityhl_name": "not",
     "section": "Binary logic",
diff --git a/simf/lib/utxo/getters/amount.simf b/simf/lib/utxo/getters/amount.simf
new file mode 100644
index 0000000..55c2f75
--- /dev/null
+++ b/simf/lib/utxo/getters/amount.simf
@@ -0,0 +1,80 @@
+/// Functions for retrieving Amount
+///
+/// If you need both `Amount` and `AssetId`, it is recommended to use the corresponding
+/// function from the `asset_id_with_amount` file, because all `get_amount` functions
+/// also return the `AssetId`. Using `get_amount` and `get_asset_id` together results
+/// in unnecessary overhead.
+
+/// Returns the explicit amount at the specified input or output.
+/// 
+/// Warning: using this incurs the overhead, and should be used only when the input/output selection
+/// needs to be determined at runtime; otherwise, use the input- or output- specific getter directly.
+pub fn get_explicit_amount(index: u32, is_input_index: bool) -> u64 {
+    let (
+        _,
+        amount
+    ): (Asset1, Amount1) = match is_input_index {
+        true => unwrap(jet::input_amount(index)),
+        false => unwrap(jet::output_amount(index)),
+    };
+
+    unwrap_right::<(u1, u256)>(amount)
+}
+
+/// Returns the confidential amount at the specified input or output
+/// 
+/// Warning: using this incurs the overhead, and should be used only when the input/output selection
+/// needs to be determined at runtime; otherwise, use the input- or output- specific getter directly.
+pub fn get_confidential_amount(index: u32, is_input_index: bool) -> Confidential1 {
+    let (
+        _,
+        amount
+    ): (Asset1, Amount1) = match is_input_index {
+        true => unwrap(jet::input_amount(index)),
+        false => unwrap(jet::output_amount(index)),
+    };
+
+    unwrap_left::<u64>(amount)
+}
+
+/// Returns the explicit amount at the specified input
+pub fn get_explicit_input_amount(index: u32) -> u64 {
+    let (_, amount): (Asset1, Amount1) = unwrap(jet::input_amount(index));
+
+    unwrap_right::<(u1, u256)>(amount)
+}
+
+/// Returns the confidential amount at the specified input
+pub fn get_confidential_input_amount(index: u32) -> Confidential1 {
+    let (_, amount): (Asset1, Amount1) = unwrap(jet::input_amount(index));
+
+    unwrap_left::<u64>(amount)
+}
+
+/// Returns the explicit amount at the specified output
+pub fn get_explicit_output_amount(index: u32) -> u64 {
+    let (_, amount): (Asset1, Amount1) = unwrap(jet::output_amount(index));
+
+    unwrap_right::<(u1, u256)>(amount)
+}
+
+/// Returns the confidential amount at the specified output
+pub fn get_confidential_output_amount(index: u32) -> Confidential1 {
+    let (_, amount): (Asset1, Amount1) = unwrap(jet::output_amount(index));
+
+    unwrap_left::<u64>(amount)
+}
+
+/// Returns the explicit input amount at the current_index
+pub fn get_explicit_current_amount() -> u64 {
+    let (_, amount): (Asset1, Amount1) = jet::current_amount();
+
+    unwrap_right::<(u1, u256)>(amount)
+}
+
+/// Returns the confidential input amount at the current_index
+pub fn get_confidential_current_amount() -> Confidential1 {
+    let (_, amount): (Asset1, Amount1) = jet::current_amount();
+
+    unwrap_left::<u64>(amount)
+}
diff --git a/simf/lib/utxo/getters/asset_id.simf b/simf/lib/utxo/getters/asset_id.simf
new file mode 100644
index 0000000..3e2b8f1
--- /dev/null
+++ b/simf/lib/utxo/getters/asset_id.simf
@@ -0,0 +1,69 @@
+/// Functions for retrieving AssetId
+
+/// Returns the explicit asset_id at the specified input or output
+/// 
+/// Warning: using this incurs the overhead, and should be used only when the input/output selection
+/// needs to be determined at runtime; otherwise, use the input- or output- specific getter directly.
+pub fn get_explicit_asset_id(index: u32, is_input_index: bool) -> u256 {
+    let asset: Asset1 = match is_input_index {
+        true => unwrap(jet::input_asset(index)),
+        false => unwrap(jet::output_asset(index)),
+    };
+
+    unwrap_right::<(u1, u256)>(asset)
+}
+
+/// Returns the confidential asset_id at the specified input or output
+/// 
+/// Warning: using this incurs the overhead, and should be used only when the input/output selection
+/// needs to be determined at runtime; otherwise, use the input- or output- specific getter directly.
+pub fn get_confidential_asset_id(index: u32, is_input_index: bool) -> Confidential1 {
+    let asset: Asset1 = match is_input_index {
+        true => unwrap(jet::input_asset(index)),
+        false => unwrap(jet::output_asset(index)),
+    };
+
+    unwrap_left::<u256>(asset)
+}
+
+/// Returns the explicit asset_id at the specified input
+pub fn get_explicit_input_asset_id(index: u32) -> u256 {
+    let asset: Asset1 = unwrap(jet::input_asset(index));
+
+    unwrap_right::<(u1, u256)>(asset)
+}
+
+/// Returns the confidential asset_id at the specified input
+pub fn get_confidential_input_asset_id(index: u32) -> Confidential1 {
+    let asset: Asset1 = unwrap(jet::input_asset(index));
+
+    unwrap_left::<u256>(asset)
+}
+
+/// Returns the explicit asset_id at the specified output
+pub fn get_explicit_output_asset_id(index: u32) -> u256 {
+    let asset: Asset1 = unwrap(jet::output_asset(index));
+
+    unwrap_right::<(u1, u256)>(asset)
+}
+
+/// Returns the confidential asset_id at the specified output
+pub fn get_confidential_output_asset_id(index: u32) -> Confidential1 {
+    let asset: Asset1 = unwrap(jet::output_asset(index));
+
+    unwrap_left::<u256>(asset)
+}
+
+/// Returns the explicit input asset_id at the current_index
+pub fn get_explicit_current_asset_id() -> u256 {
+    let asset: Asset1 = jet::current_asset();
+
+    unwrap_right::<(u1, u256)>(asset)
+}
+
+/// Returns the confidential input asset_id at the current_index
+pub fn get_confidential_current_asset_id() -> Confidential1 {
+    let asset: Asset1 = jet::current_asset();
+
+    unwrap_left::<u256>(asset)
+}
diff --git a/simf/lib/utxo/getters/asset_id_with_amount.simf b/simf/lib/utxo/getters/asset_id_with_amount.simf
new file mode 100644
index 0000000..d555e6d
--- /dev/null
+++ b/simf/lib/utxo/getters/asset_id_with_amount.simf
@@ -0,0 +1,78 @@
+/// Functions for retrieving an `AssetId` along with an `Amount`
+
+/// Returns explicit asset_id and amount at the specified input or output.
+/// 
+/// Warning: using this incurs the overhead, and should be used only when the input/output selection
+/// needs to be determined at runtime; otherwise, use the input- or output- specific getter directly.
+pub fn get_explicit_asset_id_with_amount(index: u32, is_input_index: bool) -> (u256, u64) {
+    let (
+        asset,
+        amount
+    ): (Asset1, Amount1) = match is_input_index {
+        true => unwrap(jet::input_amount(index)),
+        false => unwrap(jet::output_amount(index)),
+    };
+
+    (unwrap_right::<(u1, u256)>(asset), unwrap_right::<(u1, u256)>(amount))
+}
+
+/// Returns confidential asset_id and amount at the specified input or output
+/// 
+/// Warning: using this incurs the overhead, and should be used only when the input/output selection
+/// needs to be determined at runtime; otherwise, use the input- or output- specific getter directly.
+pub fn get_confidential_asset_id_with_amount(
+    index: u32,
+    is_input_index: bool
+) -> (Confidential1, Confidential1) {
+    let (
+        asset,
+        amount
+    ): (Asset1, Amount1) = match is_input_index {
+        true => unwrap(jet::input_amount(index)),
+        false => unwrap(jet::output_amount(index)),
+    };
+
+    (unwrap_left::<u256>(asset), unwrap_left::<u64>(amount))
+}
+
+/// Returns explicit asset_id and amount at the specified input
+pub fn get_explicit_input_asset_id_with_amount(index: u32) -> (u256, u64) {
+    let (asset, amount): (Asset1, Amount1) = unwrap(jet::input_amount(index));
+
+    (unwrap_right::<(u1, u256)>(asset), unwrap_right::<(u1, u256)>(amount))
+}
+
+/// Returns confidential asset_id and amount at the specified input
+pub fn get_confidential_input_asset_id_with_amount(index: u32) -> (Confidential1, Confidential1) {
+    let (asset, amount): (Asset1, Amount1) = unwrap(jet::input_amount(index));
+
+    (unwrap_left::<u256>(asset), unwrap_left::<u64>(amount))
+}
+
+/// Returns explicit asset_id and amount at the specified output
+pub fn get_explicit_output_asset_id_with_amount(index: u32) -> (u256, u64) {
+    let (asset, amount): (Asset1, Amount1) = unwrap(jet::output_amount(index));
+
+    (unwrap_right::<(u1, u256)>(asset), unwrap_right::<(u1, u256)>(amount))
+}
+
+/// Returns confidential asset_id and amount at the specified output
+pub fn get_confidential_output_asset_id_with_amount(index: u32) -> (Confidential1, Confidential1) {
+    let (asset, amount): (Asset1, Amount1) = unwrap(jet::output_amount(index));
+
+    (unwrap_left::<u256>(asset), unwrap_left::<u64>(amount))
+}
+
+/// Returns explicit input asset_id and amount at the current_index
+pub fn get_explicit_current_asset_id_with_amount() -> (u256, u64) {
+    let (asset, amount): (Asset1, Amount1) = jet::current_amount();
+
+    (unwrap_right::<(u1, u256)>(asset), unwrap_right::<(u1, u256)>(amount))
+}
+
+/// Returns confidential input asset_id and amount at the current_index
+pub fn get_confidential_current_asset_id_with_amount() -> (Confidential1, Confidential1) {
+    let (asset, amount): (Asset1, Amount1) = jet::current_amount();
+
+    (unwrap_left::<u256>(asset), unwrap_left::<u64>(amount))
+}
diff --git a/simf/tests/utxo/getters/amount.simf b/simf/tests/utxo/getters/amount.simf
new file mode 100644
index 0000000..08b6b0a
--- /dev/null
+++ b/simf/tests/utxo/getters/amount.simf
@@ -0,0 +1,104 @@
+use crate::lib::utxo::getters::amount::{
+    get_explicit_amount,
+    get_confidential_amount,
+    get_explicit_input_amount,
+    get_confidential_input_amount,
+    get_explicit_output_amount,
+    get_confidential_output_amount,
+    get_explicit_current_amount,
+    get_confidential_current_amount
+};
+use crate::lib::asserts::{assert_eq_1, assert_eq_64, assert_eq_256};
+
+use crate::tests::support::dispatch::is_selected;
+
+fn main() {
+    let fn_idx: u8 = witness::FUNCTION_INDEX;
+
+    let index: u32 = witness::INDEX;
+    let is_input_index: bool = witness::IS_INPUT_INDEX;
+
+    let expected_amount: u64 = witness::EXPECTED;
+    let expected_parity: u1 = witness::EXPECTED_PARITY;
+    let expected_confidential_amount: u256 = witness::EXPECTED_CONF;
+
+    match is_selected(0, fn_idx) {
+        true => {
+            assert_eq_64(get_explicit_amount(index, is_input_index), expected_amount);
+        },
+        false => (),
+    };
+
+    match is_selected(1, fn_idx) {
+        true => {
+            let (
+                parity_bit,
+                confidential_amount
+            ): Confidential1 = get_confidential_amount(index, is_input_index);
+
+            assert_eq_1(parity_bit,expected_parity);
+            assert_eq_256(confidential_amount, expected_confidential_amount);
+        },
+        false => (),
+    };
+
+    match is_selected(2, fn_idx) {
+        true => {
+            assert_eq_64(get_explicit_input_amount(index), expected_amount);
+        },
+        false => (),
+    };
+
+    match is_selected(3, fn_idx) {
+        true => {
+            let (
+                parity_bit,
+                confidential_amount
+            ): Confidential1 = get_confidential_input_amount(index);
+
+            assert_eq_1(parity_bit,expected_parity);
+            assert_eq_256(confidential_amount, expected_confidential_amount);
+        },
+        false => (),
+    };
+
+    match is_selected(4, fn_idx) {
+        true => {
+            assert_eq_64(get_explicit_output_amount(index), expected_amount);
+        },
+        false => (),
+    };
+
+    match is_selected(5, fn_idx) {
+        true => {
+            let (
+                parity_bit,
+                confidential_amount
+            ): Confidential1 = get_confidential_output_amount(index);
+
+            assert_eq_1(parity_bit,expected_parity);
+            assert_eq_256(confidential_amount, expected_confidential_amount);
+        },
+        false => (),
+    };
+
+    match is_selected(6, fn_idx) {
+        true => {
+            assert_eq_64(get_explicit_current_amount(), expected_amount);
+        },
+        false => (),
+    };
+
+    match is_selected(7, fn_idx) {
+        true => {
+            let (
+                parity_bit,
+                confidential_amount
+            ): Confidential1 = get_confidential_current_amount();
+
+            assert_eq_1(parity_bit,expected_parity);
+            assert_eq_256(confidential_amount, expected_confidential_amount);
+        },
+        false => (),
+    };
+}
diff --git a/simf/tests/utxo/getters/asset_id.simf b/simf/tests/utxo/getters/asset_id.simf
new file mode 100644
index 0000000..1655758
--- /dev/null
+++ b/simf/tests/utxo/getters/asset_id.simf
@@ -0,0 +1,104 @@
+use crate::lib::utxo::getters::asset_id::{
+    get_explicit_asset_id,
+    get_confidential_asset_id,
+    get_explicit_input_asset_id,
+    get_confidential_input_asset_id,
+    get_explicit_output_asset_id,
+    get_confidential_output_asset_id,
+    get_explicit_current_asset_id,
+    get_confidential_current_asset_id
+};
+use crate::lib::asserts::{assert_eq_1, assert_eq_256};
+
+use crate::tests::support::dispatch::is_selected;
+
+fn main() {
+    let fn_idx: u8 = witness::FUNCTION_INDEX;
+
+    let index: u32 = witness::INDEX;
+    let is_input_index: bool = witness::IS_INPUT_INDEX;
+
+    let expected_asset_id: u256 = witness::EXPECTED;
+    let expected_parity: u1 = witness::EXPECTED_PARITY;
+    let expected_confidential_asset_id: u256 = witness::EXPECTED_CONF;
+
+    match is_selected(0, fn_idx) {
+        true => {
+            assert_eq_256(get_explicit_asset_id(index, is_input_index), expected_asset_id);
+        },
+        false => (),
+    };
+
+    match is_selected(1, fn_idx) {
+        true => {
+            let (
+                parity_bit,
+                confidential_asset_id
+            ): Confidential1 = get_confidential_asset_id(index, is_input_index);
+
+            assert_eq_1(parity_bit, expected_parity);
+            assert_eq_256(confidential_asset_id, expected_confidential_asset_id);
+        },
+        false => (),
+    };
+
+    match is_selected(2, fn_idx) {
+        true => {
+            assert_eq_256(get_explicit_input_asset_id(index), expected_asset_id);
+        },
+        false => (),
+    };
+
+    match is_selected(3, fn_idx) {
+        true => {
+            let (
+                parity_bit,
+                confidential_asset_id
+            ): Confidential1 = get_confidential_input_asset_id(index);
+
+            assert_eq_1(parity_bit, expected_parity);
+            assert_eq_256(confidential_asset_id, expected_confidential_asset_id);
+        },
+        false => (),
+    };
+
+    match is_selected(4, fn_idx) {
+        true => {
+            assert_eq_256(get_explicit_output_asset_id(index), expected_asset_id);
+        },
+        false => (),
+    };
+
+    match is_selected(5, fn_idx) {
+        true => {
+            let (
+                parity_bit,
+                confidential_asset_id
+            ): Confidential1 = get_confidential_output_asset_id(index);
+
+            assert_eq_1(parity_bit, expected_parity);
+            assert_eq_256(confidential_asset_id, expected_confidential_asset_id);
+        },
+        false => (),
+    };
+
+    match is_selected(6, fn_idx) {
+        true => {
+            assert_eq_256(get_explicit_current_asset_id(), expected_asset_id);
+        },
+        false => (),
+    };
+
+    match is_selected(7, fn_idx) {
+        true => {
+            let (
+                parity_bit,
+                confidential_asset_id
+            ): Confidential1 = get_confidential_current_asset_id();
+
+            assert_eq_1(parity_bit, expected_parity);
+            assert_eq_256(confidential_asset_id, expected_confidential_asset_id);
+        },
+        false => (),
+    };
+}
diff --git a/simf/tests/utxo/getters/asset_id_with_amount.simf b/simf/tests/utxo/getters/asset_id_with_amount.simf
new file mode 100644
index 0000000..298b265
--- /dev/null
+++ b/simf/tests/utxo/getters/asset_id_with_amount.simf
@@ -0,0 +1,162 @@
+use crate::lib::utxo::getters::asset_id_with_amount::{
+    get_explicit_asset_id_with_amount,
+    get_confidential_asset_id_with_amount,
+    get_explicit_input_asset_id_with_amount,
+    get_confidential_input_asset_id_with_amount,
+    get_explicit_output_asset_id_with_amount,
+    get_confidential_output_asset_id_with_amount,
+    get_explicit_current_asset_id_with_amount,
+    get_confidential_current_asset_id_with_amount
+};
+use crate::lib::asserts::{assert_eq_1, assert_eq_64, assert_eq_256};
+
+use crate::tests::support::dispatch::is_selected;
+
+fn main() {
+    let fn_idx: u8 = witness::FUNCTION_INDEX;
+
+    let index: u32 = witness::INDEX;
+    let is_input_index: bool = witness::IS_INPUT_INDEX;
+
+    let expected_asset_id: u256 = witness::EXPECTED_ASSET;
+    let expected_asset_parity: u1 = witness::EXPECTED_ASSET_PARITY;
+    let expected_confidential_asset_id: u256 = witness::EXPECTED_CONF_ASSET;
+
+    let expected_amount: u64 = witness::EXPECTED_AMOUNT;
+    let expected_amount_parity: u1 = witness::EXPECTED_AMOUNT_PARITY;
+    let expected_confidential_amount: u256 = witness::EXPECTED_CONF_AMOUNT;
+
+    match is_selected(0, fn_idx) {
+        true => {
+            let (
+                asset_id,
+                amount
+            ): (u256, u64) = get_explicit_asset_id_with_amount(index, is_input_index);
+
+            assert_eq_256(asset_id, expected_asset_id);
+            assert_eq_64(amount, expected_amount);
+        },
+        false => (),
+    };
+
+    match is_selected(1, fn_idx) {
+        true => {
+            let (
+                (
+                    parity_bit_asset_id,
+                    confidential_asset_id
+                ),
+                (
+                    parity_bit_amount,
+                    confidential_amount
+                )
+            ): (Confidential1, Confidential1) = get_confidential_asset_id_with_amount(
+                index,
+                is_input_index
+            );
+
+            assert_eq_1(parity_bit_asset_id, expected_asset_parity);
+            assert_eq_256(confidential_asset_id, expected_confidential_asset_id);
+
+            assert_eq_1(parity_bit_amount, expected_amount_parity);
+            assert_eq_256(confidential_amount, expected_confidential_amount);
+        },
+        false => (),
+    };
+
+    match is_selected(2, fn_idx) {
+        true => {
+            let (asset_id, amount): (u256, u64) = get_explicit_input_asset_id_with_amount(index);
+
+            assert_eq_256(asset_id, expected_asset_id);
+            assert_eq_64(amount, expected_amount);
+        },
+        false => (),
+    };
+
+    match is_selected(3, fn_idx) {
+        true => {
+            let (
+                (
+                    parity_bit_asset_id,
+                    confidential_asset_id
+                ),
+                (
+                    parity_bit_amount,
+                    confidential_amount
+                )
+            ): (Confidential1, Confidential1) = get_confidential_input_asset_id_with_amount(index);
+
+            assert_eq_1(parity_bit_asset_id, expected_asset_parity);
+            assert_eq_256(confidential_asset_id, expected_confidential_asset_id);
+
+            assert_eq_1(parity_bit_amount, expected_amount_parity);
+            assert_eq_256(confidential_amount, expected_confidential_amount);
+        },
+        false => (),
+    };
+
+    match is_selected(4, fn_idx) {
+        true => {
+            let (asset_id, amount): (u256, u64) = get_explicit_output_asset_id_with_amount(index);
+
+            assert_eq_256(asset_id, expected_asset_id);
+            assert_eq_64(amount, expected_amount);
+        },
+        false => (),
+    };
+
+    match is_selected(5, fn_idx) {
+        true => {
+            let (
+                (
+                    parity_bit_asset_id,
+                    confidential_asset_id
+                ),
+                (
+                    parity_bit_amount,
+                    confidential_amount
+                )
+            ): (Confidential1, Confidential1) = get_confidential_output_asset_id_with_amount(index);
+
+            assert_eq_1(parity_bit_asset_id, expected_asset_parity);
+            assert_eq_256(confidential_asset_id, expected_confidential_asset_id);
+
+            assert_eq_1(parity_bit_amount, expected_amount_parity);
+            assert_eq_256(confidential_amount, expected_confidential_amount);
+        },
+        false => (),
+    };
+
+    match is_selected(6, fn_idx) {
+        true => {
+            let (asset_id, amount): (u256, u64) = get_explicit_current_asset_id_with_amount();
+
+            assert_eq_256(asset_id, expected_asset_id);
+            assert_eq_64(amount, expected_amount);
+        },
+        false => (),
+    };
+
+    match is_selected(7, fn_idx) {
+        true => {
+            let (
+                (
+                    parity_bit_asset_id,
+                    confidential_asset_id
+                ),
+                (
+                    parity_bit_amount,
+                    confidential_amount
+                )
+            ): (Confidential1, Confidential1) = get_confidential_current_asset_id_with_amount();
+
+            assert_eq_1(parity_bit_asset_id, expected_asset_parity);
+            assert_eq_256(confidential_asset_id, expected_confidential_asset_id);
+
+            assert_eq_1(parity_bit_amount, expected_amount_parity);
+            assert_eq_256(confidential_amount, expected_confidential_amount);
+        },
+        false => (),
+    };
+}
diff --git a/tests/stdlib/common/core.rs b/tests/stdlib/common/core.rs
index ada5e42..9569c14 100644
--- a/tests/stdlib/common/core.rs
+++ b/tests/stdlib/common/core.rs
@@ -2,12 +2,17 @@
 // part of it, so per-crate dead-code analysis would warn about the rest.
 #![allow(dead_code)]
 
+use secp256k1_zkp::Secp256k1;
 use simplex::program::{Program, WitnessTrait};
-use simplex::simplicityhl::elements::Script;
+use simplex::signer::Signer;
+use simplex::simplicityhl::elements::{AssetId, Script, Txid};
+use simplex::transaction::partial_input::IssuanceInput;
 use simplex::transaction::{
-    FinalTransaction, PartialInput, PartialOutput, ProgramInput, RequiredSignature,
+    FinalTransaction, PartialInput, PartialOutput, ProgramInput, RequiredSignature, UTXO,
 };
 
+use crate::common::utxo_helper::{DEFAULT_SEND_AMOUNT, search_utxo_by_txid};
+
 #[derive(Clone, Copy)]
 pub enum Expect {
     /// The spend succeeds.
@@ -35,14 +40,66 @@ impl Expect {
 pub fn fund(
     context: &simplex::TestContext,
     program: &impl AsRef<Program>,
+    amount_to_send: u64,
 ) -> anyhow::Result<Script> {
     let script = program.as_ref().get_script_pubkey(context.get_network());
 
-    context.get_default_signer().send(script.clone(), 50)?;
+    send_explicit(context.get_default_signer(), &script, amount_to_send)?;
 
     Ok(script)
 }
 
+/// Send sats to the specified script so it has a UTXO to spend.
+pub fn send_explicit(signer: &Signer, to: &Script, amount_to_send: u64) -> anyhow::Result<Txid> {
+    Ok(signer.send(to.clone(), amount_to_send)?.txid())
+}
+
+pub fn send_blinded(
+    signer: &Signer,
+    to: &Script,
+    amount_to_send: u64,
+    asset: AssetId,
+) -> anyhow::Result<Txid> {
+    let mut ft = FinalTransaction::new();
+
+    ft.add_output(
+        PartialOutput::new(to.clone(), amount_to_send, asset)
+            .with_blinding_key(signer.get_blinding_public_key()),
+    );
+
+    Ok(signer.broadcast(&ft)?.txid())
+}
+
+/// Issue `amount_to_send` of a new asset to the specified script, so the UTXO holds an asset that
+/// nothing else in the wallet has. Returns the funding txid and the new asset id.
+pub fn send_issued(
+    context: &simplex::TestContext,
+    to: &Script,
+    amount_to_send: u64,
+) -> anyhow::Result<(Txid, AssetId)> {
+    let signer = context.get_default_signer();
+    // The largest UTXO, so the issuance never spends one of the small UTXOs a test created.
+    let funding = signer
+        .get_utxos_asset(context.get_network().policy_asset())?
+        .into_iter()
+        .max_by_key(UTXO::amount)
+        .ok_or_else(|| anyhow::anyhow!("no policy asset UTXO to attach the issuance to"))?;
+
+    let mut ft = FinalTransaction::new();
+    let issued = ft.add_issuance_input(
+        PartialInput::new(funding),
+        IssuanceInput::new_issuance(amount_to_send, 0, rand::random()),
+        RequiredSignature::NativeEcdsa,
+    );
+    ft.add_output(PartialOutput::new(
+        to.clone(),
+        amount_to_send,
+        issued.asset_id,
+    ));
+
+    Ok((signer.broadcast(&ft)?.txid(), issued.asset_id))
+}
+
 /// Construct the funded UTXO with `witness`.
 pub fn construct_final_tx<W>(
     context: &simplex::TestContext,
@@ -50,21 +107,105 @@ pub fn construct_final_tx<W>(
     script: &Script,
     witness: W,
     data: Option<&[u8]>,
+    txids: Vec<Txid>,
 ) -> anyhow::Result<FinalTransaction>
 where
     W: WitnessTrait + 'static,
 {
+    let signer = context.get_default_signer();
+    let script_to_send_to = signer.get_address().script_pubkey();
+    let policy_asset = context.get_network().policy_asset();
+
+    // Every output amount is one less than the corresponding input amount.
+    // The signer handles leftovers for the policy asset, but for other assets, we need to handle it here.
+    let mut leftover_asset = policy_asset;
+
     let utxos = context
         .get_default_provider()
         .fetch_scripthash_utxos(script)?;
 
+    let mut program_utxo = if txids.is_empty() {
+        utxos[0].clone()
+    } else {
+        search_utxo_by_txid(&txids[0], &utxos)?
+    };
+
+    let first_input_confidential = program_utxo.txout.value.is_confidential();
+
+    if first_input_confidential {
+        program_utxo = unblind(signer, program_utxo)?;
+    }
+
     let mut ft = FinalTransaction::new();
+
     ft.add_program_input(
-        PartialInput::new(utxos[0].clone()),
+        PartialInput::new(program_utxo.clone()),
         ProgramInput::new(Box::new(program.as_ref().clone()), Box::new(witness)),
         RequiredSignature::None,
     );
 
+    // it is not an op_return path
+    if data.unwrap_or_default().is_empty() {
+        let mut output = PartialOutput::new(
+            script_to_send_to.clone(),
+            // amounts in input and output on the same index should be different for the test purposes
+            program_utxo.amount() - 1,
+            program_utxo.asset(),
+        );
+
+        if first_input_confidential {
+            output = output.with_blinding_key(signer.get_blinding_public_key())
+        }
+
+        ft.add_output(output);
+
+        if program_utxo.asset() != policy_asset {
+            leftover_asset = program_utxo.asset();
+        }
+    }
+
+    if txids.len() > 1 {
+        let unblinded_utxos = signer.get_utxos()?;
+
+        for txid in txids.iter().skip(1) {
+            let utxo = search_utxo_by_txid(txid, &unblinded_utxos)?;
+
+            if !utxo.txout.value.is_confidential() {
+                ft.add_input(PartialInput::new(utxo.clone()), RequiredSignature::None);
+
+                ft.add_output(PartialOutput::new(
+                    script_to_send_to.clone(),
+                    utxo.explicit_amount() - 1,
+                    utxo.explicit_asset(),
+                ));
+
+                if utxo.explicit_asset() != policy_asset {
+                    leftover_asset = utxo.asset();
+                }
+                // filtering out fund transaction
+            } else {
+                ft.add_input(PartialInput::new(utxo.clone()), RequiredSignature::None);
+
+                ft.add_output(
+                    PartialOutput::new(
+                        script_to_send_to.clone(),
+                        utxo.unblinded_amount() - 1,
+                        utxo.unblinded_asset(),
+                    )
+                    .with_blinding_key(signer.get_blinding_public_key()),
+                );
+            }
+        }
+    }
+
+    if leftover_asset != policy_asset {
+        ft.add_output(PartialOutput::new(
+            script_to_send_to.clone(),
+            1,
+            leftover_asset,
+        ));
+    }
+
     if let Some(data) = data {
         ft.add_output(PartialOutput::new_metadata(data))
     };
@@ -72,6 +213,15 @@ where
     Ok(ft)
 }
 
+fn unblind(signer: &Signer, mut utxo: UTXO) -> anyhow::Result<UTXO> {
+    let secp = Secp256k1::new();
+    let secrets = utxo
+        .txout
+        .unblind(&secp, signer.get_blinding_private_key().inner)?;
+    utxo.secrets = Some(secrets);
+    Ok(utxo)
+}
+
 /// Spend the funded UTXO with `witness`. Return the broadcast result.
 pub fn spend<W>(
     context: &simplex::TestContext,
@@ -79,11 +229,12 @@ pub fn spend<W>(
     script: &Script,
     witness: W,
     data: Option<&[u8]>,
+    txids: Vec<Txid>,
 ) -> anyhow::Result<String>
 where
     W: WitnessTrait + 'static,
 {
-    let ft = construct_final_tx(context, program, script, witness, data)?;
+    let ft = construct_final_tx(context, program, script, witness, data, txids)?;
 
     Ok(context.get_default_signer().broadcast(&ft)?.to_string())
 }
@@ -118,8 +269,8 @@ pub fn run<W>(
 where
     W: WitnessTrait + 'static,
 {
-    let script = fund(context, &program)?;
-    let result = spend(context, &program, &script, witness, None);
+    let script = fund(context, &program, DEFAULT_SEND_AMOUNT)?;
+    let result = spend(context, &program, &script, witness, None, Vec::new());
 
     assert_error_msg(result, expect)
 }
@@ -136,8 +287,26 @@ pub fn run_with_op_return<W>(
 where
     W: WitnessTrait + 'static,
 {
-    let script = fund(context, &program)?;
-    let result = spend(context, &program, &script, witness, Some(data));
+    let script = fund(context, &program, DEFAULT_SEND_AMOUNT)?;
+    let result = spend(context, &program, &script, witness, Some(data), Vec::new());
+
+    assert_error_msg(result, expect)
+}
+
+/// Spend with additional inputs and outputs + assert the outcome.
+pub fn run_with_inputs_outputs<W>(
+    context: &simplex::TestContext,
+    program: impl AsRef<Program>,
+    witness: W,
+    expect: Expect,
+    txids: Vec<Txid>,
+) -> anyhow::Result<()>
+where
+    W: WitnessTrait + 'static,
+{
+    let script = program.as_ref().get_script_pubkey(context.get_network());
+
+    let result = spend(context, &program, &script, witness, None, txids);
 
     assert_error_msg(result, expect)
 }
diff --git a/tests/stdlib/common/mod.rs b/tests/stdlib/common/mod.rs
index e8669e2..16f0294 100644
--- a/tests/stdlib/common/mod.rs
+++ b/tests/stdlib/common/mod.rs
@@ -2,3 +2,4 @@ pub mod core;
 pub mod helper;
 pub mod u256_wrapper;
 pub mod uint;
+pub mod utxo_helper;
diff --git a/tests/stdlib/common/utxo_helper.rs b/tests/stdlib/common/utxo_helper.rs
new file mode 100644
index 0000000..ac94a6d
--- /dev/null
+++ b/tests/stdlib/common/utxo_helper.rs
@@ -0,0 +1,165 @@
+use rand::Rng;
+use simplex::program::Program;
+use simplex::simplicityhl::elements::AssetId;
+use simplex::simplicityhl::elements::OutPoint;
+use simplex::simplicityhl::elements::Txid;
+use simplex::simplicityhl::elements::pset::serialize::Serialize;
+use simplex::transaction::UTXO;
+
+use crate::common::core::{send_blinded, send_explicit, send_issued};
+pub const DEFAULT_SEND_AMOUNT: u64 = 50;
+
+/// The funding transaction holds around 10^16 satoshis, so 10_000 is used
+/// as the limit to ensure there are enough satoshis for all the inputs and outputs.
+pub fn random_expected_amount() -> u64 {
+    rand::thread_rng().gen_range(100..=10_000)
+}
+
+pub struct ConfidentialAssetId {
+    pub parity_bit: u8,
+    pub asset_id: [u8; 32],
+}
+pub struct ConfidentialAmount {
+    pub parity_bit: u8,
+    pub amount: [u8; 32],
+}
+
+pub type ConfidentialAsset = (ConfidentialAssetId, ConfidentialAmount);
+
+pub fn create_utxos(
+    context: &simplex::TestContext,
+    index: u32,
+    is_explicit: bool,
+    is_input: bool,
+    expected_amount: u64,
+    program: impl AsRef<Program>,
+) -> anyhow::Result<(Option<ConfidentialAsset>, Vec<Txid>)> {
+    let signer = context.get_default_signer();
+    let pubkey_script = &signer.get_address().script_pubkey();
+    let program_script = &program.as_ref().get_script_pubkey(context.get_network());
+
+    let mut txids = Vec::new();
+
+    for i in 0..=index {
+        let script = match i == 0 {
+            true => program_script,
+            false => pubkey_script,
+        };
+        let mut amount_to_send = match index == i {
+            true => expected_amount,
+            false => DEFAULT_SEND_AMOUNT,
+        };
+        // while testing an input amount, input utxo has `amount` and output has `amount - 1`;
+        // if an output amount is tested, input utxo has `amount + 1` and output has `amount`.
+        if !is_input {
+            amount_to_send += 1;
+        }
+
+        if index == i && !is_explicit {
+            txids.push(send_blinded(
+                signer,
+                script,
+                amount_to_send,
+                context.get_network().policy_asset(),
+            )?)
+        } else {
+            txids.push(send_explicit(signer, script, amount_to_send)?);
+        }
+    }
+
+    if !is_explicit {
+        let script = match index == 0 {
+            true => program_script,
+            false => pubkey_script,
+        };
+
+        let utxos = context
+            .get_default_provider()
+            .fetch_scripthash_utxos(script)?;
+
+        let conf_utxo = search_utxo_by_txid(txids.last().unwrap(), &utxos)?;
+
+        Ok((Some(get_asset_id_amount_from_conf_utxo(conf_utxo)?), txids))
+    } else {
+        Ok((None, txids))
+    }
+}
+
+pub fn create_utxos_with_new_asset(
+    context: &simplex::TestContext,
+    index: u32,
+    is_input: bool,
+    expected_amount: u64,
+    program: impl AsRef<Program>,
+) -> anyhow::Result<([u8; 32], Vec<Txid>)> {
+    let signer = context.get_default_signer();
+    let pubkey_script = &signer.get_address().script_pubkey();
+    let program_script = &program.as_ref().get_script_pubkey(context.get_network());
+
+    let mut txids = Vec::new();
+    let mut new_asset = None::<AssetId>;
+
+    for i in 0..=index {
+        let script = match i == 0 {
+            true => program_script,
+            false => pubkey_script,
+        };
+        let mut amount_to_send = match index == i {
+            true => expected_amount,
+            false => DEFAULT_SEND_AMOUNT,
+        };
+        // same convention as in `create_utxos`
+        if !is_input {
+            amount_to_send += 1;
+        }
+
+        if index == i {
+            let (txid, asset) = send_issued(context, script, amount_to_send)?;
+            txids.push(txid);
+            new_asset = Some(asset);
+        } else {
+            txids.push(send_explicit(signer, script, amount_to_send)?);
+        }
+    }
+
+    Ok((new_asset.unwrap().into_inner().0, txids))
+}
+
+fn get_asset_id_amount_from_conf_utxo(conf_utxo: UTXO) -> anyhow::Result<ConfidentialAsset> {
+    let confidential_asset = conf_utxo.txout.asset.serialize(); // 0x0a | 0x0b
+    let confidential_amount = conf_utxo.txout.value.serialize(); // 0x08 | 0x09
+
+    // 0x0a = 00001010 & 1 = 0
+    // 0x0b = 00001011 & 1 = 1
+    // 0x08 = 00001000 & 1 = 0
+    // 0x09 = 00001001 & 1 = 1
+    let asset_parity_bit = confidential_asset[0] & 1;
+    let amount_parity_bit = confidential_amount[0] & 1;
+
+    let asset_id: [u8; 32] = confidential_asset[1..33].try_into()?;
+    let amount: [u8; 32] = confidential_amount[1..33].try_into()?;
+
+    Ok((
+        ConfidentialAssetId {
+            parity_bit: asset_parity_bit,
+            asset_id,
+        },
+        ConfidentialAmount {
+            parity_bit: amount_parity_bit,
+            amount,
+        },
+    ))
+}
+
+pub fn search_utxo_by_txid(txid: &Txid, utxos: &[UTXO]) -> anyhow::Result<UTXO> {
+    let outpoint = OutPoint {
+        txid: *txid,
+        vout: 0,
+    };
+
+    utxos
+        .iter()
+        .find(|utxo| utxo.outpoint == outpoint)
+        .cloned()
+        .ok_or_else(|| anyhow::anyhow!("Missing utxo with id: {txid}"))
+}
diff --git a/tests/stdlib/main.rs b/tests/stdlib/main.rs
index 8698e0e..04a23cb 100644
--- a/tests/stdlib/main.rs
+++ b/tests/stdlib/main.rs
@@ -11,3 +11,4 @@ mod u256;
 mod u32;
 mod u64;
 mod u8;
+mod utxo;
diff --git a/tests/stdlib/utxo/getters/amount.rs b/tests/stdlib/utxo/getters/amount.rs
new file mode 100644
index 0000000..855235b
--- /dev/null
+++ b/tests/stdlib/utxo/getters/amount.rs
@@ -0,0 +1,462 @@
+use anyhow::Context;
+use rand::Rng;
+use simplex::simplicityhl::elements::Txid;
+
+use crate::common::core::Expect;
+use crate::common::core::run_with_inputs_outputs;
+use crate::common::utxo_helper::ConfidentialAmount;
+use crate::common::utxo_helper::{create_utxos, random_expected_amount};
+
+use simplicityhl_std::artifacts::tests::utxo::getters::amount::AmountProgram as TestAmountProgram;
+use simplicityhl_std::artifacts::tests::utxo::getters::amount::derived_amount::{
+    AmountArguments as TestAmountArguments, AmountWitness as TestAmountWitness,
+};
+
+use FunctionToTest::*;
+
+enum FunctionToTest {
+    Explicit,
+    Confidential,
+    ExplicitInput,
+    ConfidentialInput,
+    ExplicitOutput,
+    // Currently, the getters happy path for the confidential amount of an output index cannot be tested
+    ConfidentialOutput,
+    CurrentExplicit,
+    CurrentConfidential,
+}
+
+#[derive(PartialEq, Eq)]
+enum IndexType {
+    Input,
+    Output,
+}
+
+fn is_input(o: IndexType) -> bool {
+    o == IndexType::Input
+}
+
+fn program() -> TestAmountProgram {
+    TestAmountProgram::new(&TestAmountArguments {})
+}
+
+/// One dispatch arm of the contract, plus the witness it reads.
+struct Case {
+    witness: TestAmountWitness,
+}
+
+fn case(function: FunctionToTest) -> Case {
+    Case {
+        witness: TestAmountWitness {
+            function_index: function as u8,
+            index: 0,
+            is_input_index: false,
+            expected: 0,
+            expected_parity: 0,
+            expected_conf: [0; 32],
+        },
+    }
+}
+
+impl Case {
+    /// `index`: the input/output the arm inspects.
+    fn index(mut self, index: u32) -> Self {
+        self.witness.index = index;
+        self
+    }
+
+    /// `is_input`: whether the arm inspects an input.
+    fn index_type(mut self, index_type: IndexType) -> Self {
+        self.witness.is_input_index = is_input(index_type);
+        self
+    }
+
+    /// `expected`: value the arm should produce.
+    fn expect(mut self, expected: u64) -> Self {
+        self.witness.expected = expected;
+        self
+    }
+
+    /// `expected_parity`: value the arm should produce.
+    fn expected_parity(mut self, expected_parity: u8) -> Self {
+        self.witness.expected_parity = expected_parity;
+        self
+    }
+
+    /// `expected_confidential`: the arm's confidential result.
+    fn confidential_amount(mut self, expected_confidential: [u8; 32]) -> Self {
+        self.witness.expected_conf = expected_confidential;
+        self
+    }
+
+    /// Fund, spend, and expect the spend to succeed.
+    fn run(self, context: &simplex::TestContext, txids: Vec<Txid>) -> anyhow::Result<()> {
+        self.expecting(context, Expect::Ok, txids)
+    }
+
+    /// Fund, spend, and expect `expect`.
+    fn expecting(
+        self,
+        context: &simplex::TestContext,
+        expect: Expect,
+        txids: Vec<Txid>,
+    ) -> anyhow::Result<()> {
+        run_with_inputs_outputs(context, program(), self.witness, expect, txids)
+    }
+}
+
+/// Missing input or output also returns `Expect::PrunedBranch` error,
+/// so this approach ensures that the program has the expected input or output.
+/// A failed spend is not broadcasted, so both cases can use the same UTXOs.
+fn fail_and_pass_cases(
+    context: &simplex::TestContext,
+    failing: Case,
+    passing: Case,
+    txids: Vec<Txid>,
+) -> anyhow::Result<()> {
+    failing.expecting(context, Expect::PrunedBranch, txids.clone())?;
+    passing.run(context, txids)
+}
+
+fn create_utxos_wrapper(
+    context: &simplex::TestContext,
+    index: u32,
+    is_explicit: bool,
+    is_input: bool,
+    expected_amount: u64,
+) -> anyhow::Result<(Option<ConfidentialAmount>, Vec<Txid>)> {
+    let (result, txids) = create_utxos(
+        context,
+        index,
+        is_explicit,
+        is_input,
+        expected_amount,
+        program(),
+    )?;
+
+    let confidential_amount = match is_explicit {
+        true => None,
+        false => {
+            let (_, conf_amount) =
+                result.context("confidential UTXO creation returned no commitment")?;
+
+            Some(conf_amount)
+        }
+    };
+
+    Ok((confidential_amount, txids))
+}
+
+#[simplex::test]
+fn get_explicit_amount_for_input(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 0;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = true;
+
+    let (_, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Input),
+        expected_amount,
+    )?;
+
+    let failing = case(Confidential).index(index).index_type(IndexType::Input);
+    let passing = case(Explicit)
+        .index(index)
+        .index_type(IndexType::Input)
+        .expect(expected_amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_amount_for_random_input(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = rand::thread_rng().gen_range(0..=20) as u32; // not a big value to not to slow down tests
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = true;
+
+    let (_, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Input),
+        expected_amount,
+    )?;
+
+    case(Explicit)
+        .index(index)
+        .index_type(IndexType::Input)
+        .expect(expected_amount)
+        .run(&context, txids)
+}
+
+#[simplex::test]
+fn get_explicit_amount_for_output(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 1;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = true;
+
+    let (_, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Output),
+        expected_amount,
+    )?;
+
+    let failing = case(Confidential)
+        .index(index)
+        .index_type(IndexType::Output);
+    let passing = case(Explicit)
+        .index(index)
+        .index_type(IndexType::Output)
+        .expect(expected_amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_amount_for_random_output(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = rand::thread_rng().gen_range(0..=20) as u32;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = true;
+
+    let (_, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Output),
+        expected_amount,
+    )?;
+
+    case(Explicit)
+        .index(index)
+        .index_type(IndexType::Output)
+        .expect(expected_amount)
+        .run(&context, txids)
+}
+
+#[simplex::test]
+fn get_explicit_amount_for_confidential_output_fail(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let index = 0;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = false;
+
+    let (conf, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Output),
+        expected_amount,
+    )?;
+    let conf = conf.unwrap();
+
+    let failing = case(Explicit).index(index).index_type(IndexType::Output);
+    // Output `index` is blinded because input `index` is confidential, and its commitment
+    // is only made when the spend is blinded, so check the input instead.
+    let passing = case(Confidential)
+        .index(index)
+        .index_type(IndexType::Input)
+        .expected_parity(conf.parity_bit)
+        .confidential_amount(conf.amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_confidential_amount_for_input(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 3;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = false;
+
+    let (conf, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Input),
+        expected_amount,
+    )?;
+    let conf = conf.unwrap();
+
+    let failing = case(Explicit).index(index).index_type(IndexType::Input);
+    let passing = case(Confidential)
+        .index(index)
+        .index_type(IndexType::Input)
+        .expected_parity(conf.parity_bit)
+        .confidential_amount(conf.amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_input_amount(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 1;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = true;
+
+    let (_, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Input),
+        expected_amount,
+    )?;
+
+    let failing = case(ConfidentialInput).index(index);
+    let passing = case(ExplicitInput).index(index).expect(expected_amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_confidential_input_amount(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 0;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = false;
+
+    let (conf, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Input),
+        expected_amount,
+    )?;
+    let conf = conf.unwrap();
+
+    let failing = case(ExplicitInput).index(index);
+    let passing = case(ConfidentialInput)
+        .index(index)
+        .expected_parity(conf.parity_bit)
+        .confidential_amount(conf.amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_output_amount(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 2;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = true;
+
+    let (_, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Output),
+        expected_amount,
+    )?;
+
+    let failing = case(ConfidentialOutput).index(index);
+    let passing = case(ExplicitOutput).index(index).expect(expected_amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_output_amount_for_confidential_fail(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let index = 2;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = false;
+
+    let (conf, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Output),
+        expected_amount,
+    )?;
+    let conf = conf.unwrap();
+
+    let failing = case(ExplicitOutput).index(index);
+    // Output `index` is blinded because input `index` is confidential, and its commitment
+    // is only made when the spend is blinded, so check the input instead.
+    let passing = case(ConfidentialInput)
+        .index(index)
+        .expected_parity(conf.parity_bit)
+        .confidential_amount(conf.amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_current_amount(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 0;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = true;
+
+    let (_, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Input),
+        expected_amount,
+    )?;
+
+    let failing = case(CurrentConfidential).index(index);
+    let passing = case(CurrentExplicit).index(index).expect(expected_amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_confidential_current_amount(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 0;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = false;
+
+    let (conf, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Input),
+        expected_amount,
+    )?;
+    let conf = conf.unwrap();
+
+    let failing = case(CurrentExplicit).index(index);
+    let passing = case(CurrentConfidential)
+        .index(index)
+        .expected_parity(conf.parity_bit)
+        .confidential_amount(conf.amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_input_amount_for_missing_input_fail(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let (_, txids) = create_utxos_wrapper(
+        &context,
+        0,
+        true,
+        is_input(IndexType::Input),
+        random_expected_amount(),
+    )?;
+
+    case(ExplicitInput)
+        .index(u32::MAX)
+        .expecting(&context, Expect::PrunedBranch, txids)
+}
+
+#[simplex::test]
+fn get_explicit_output_amount_for_missing_output_fail(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let (_, txids) = create_utxos_wrapper(
+        &context,
+        0,
+        true,
+        is_input(IndexType::Input),
+        random_expected_amount(),
+    )?;
+
+    case(ExplicitOutput)
+        .index(u32::MAX)
+        .expecting(&context, Expect::PrunedBranch, txids)
+}
diff --git a/tests/stdlib/utxo/getters/asset_id.rs b/tests/stdlib/utxo/getters/asset_id.rs
new file mode 100644
index 0000000..728ffbe
--- /dev/null
+++ b/tests/stdlib/utxo/getters/asset_id.rs
@@ -0,0 +1,355 @@
+use anyhow::Context;
+use rand::Rng;
+use simplex::simplicityhl::elements::Txid;
+
+use crate::common::core::Expect;
+use crate::common::core::run_with_inputs_outputs;
+use crate::common::utxo_helper::ConfidentialAssetId;
+use crate::common::utxo_helper::DEFAULT_SEND_AMOUNT;
+use crate::common::utxo_helper::{create_utxos, create_utxos_with_new_asset};
+
+use simplicityhl_std::artifacts::tests::utxo::getters::asset_id::AssetIdProgram as TestAssetIdProgram;
+use simplicityhl_std::artifacts::tests::utxo::getters::asset_id::derived_asset_id::{
+    AssetIdArguments as TestAssetIdArguments, AssetIdWitness as TestAssetIdWitness,
+};
+
+use FunctionToTest::*;
+
+enum FunctionToTest {
+    Explicit,
+    Confidential,
+    ExplicitInput,
+    ConfidentialInput,
+    ExplicitOutput,
+    // Currently, the getters happy path for the confidential asset_id of an output index cannot be tested
+    ConfidentialOutput,
+    CurrentExplicit,
+    CurrentConfidential,
+}
+
+#[derive(PartialEq, Eq)]
+enum IndexType {
+    Input,
+    Output,
+}
+
+fn is_input(o: IndexType) -> bool {
+    o == IndexType::Input
+}
+
+const DEFAULT_EXPECTED: [u8; 32] = [0; 32];
+
+fn program() -> TestAssetIdProgram {
+    TestAssetIdProgram::new(&TestAssetIdArguments {})
+}
+
+/// One dispatch arm of the contract, plus the witness it reads.
+struct Case {
+    witness: TestAssetIdWitness,
+}
+
+fn case(function: FunctionToTest) -> Case {
+    Case {
+        witness: TestAssetIdWitness {
+            function_index: function as u8,
+            index: 0,
+            is_input_index: false,
+            expected: DEFAULT_EXPECTED,
+            expected_parity: 0,
+            expected_conf: DEFAULT_EXPECTED,
+        },
+    }
+}
+
+impl Case {
+    /// `index`: the input/output the arm inspects.
+    fn index(mut self, index: u32) -> Self {
+        self.witness.index = index;
+        self
+    }
+
+    /// `is_input`: whether the arm inspects an input.
+    fn index_type(mut self, index_type: IndexType) -> Self {
+        self.witness.is_input_index = is_input(index_type);
+        self
+    }
+
+    /// `expected`: value the arm should produce.
+    fn expect(mut self, expected: [u8; 32]) -> Self {
+        self.witness.expected = expected;
+        self
+    }
+
+    /// `expected_parity`: value the arm should produce.
+    fn expected_parity(mut self, expected_parity: u8) -> Self {
+        self.witness.expected_parity = expected_parity;
+        self
+    }
+
+    /// `expected_confidential`: the arm's confidential result.
+    fn confidential_asset_id(mut self, expected_confidential: [u8; 32]) -> Self {
+        self.witness.expected_conf = expected_confidential;
+        self
+    }
+
+    /// Fund, spend, and expect the spend to succeed.
+    fn run(self, context: &simplex::TestContext, txids: Vec<Txid>) -> anyhow::Result<()> {
+        self.expecting(context, Expect::Ok, txids)
+    }
+
+    /// Fund, spend, and expect `expect`.
+    fn expecting(
+        self,
+        context: &simplex::TestContext,
+        expect: Expect,
+        txids: Vec<Txid>,
+    ) -> anyhow::Result<()> {
+        run_with_inputs_outputs(context, program(), self.witness, expect, txids)
+    }
+}
+
+/// Missing input or output also returns `Expect::PrunedBranch` error,
+/// so this approach ensures that the program has the expected input or output.
+/// A failed spend is not broadcasted, so both cases can use the same UTXOs.
+fn fail_and_pass_cases(
+    context: &simplex::TestContext,
+    failing: Case,
+    passing: Case,
+    txids: Vec<Txid>,
+) -> anyhow::Result<()> {
+    failing.expecting(context, Expect::PrunedBranch, txids.clone())?;
+    passing.run(context, txids)
+}
+
+fn create_utxos_wrapper(
+    context: &simplex::TestContext,
+    index: u32,
+    is_explicit: bool,
+) -> anyhow::Result<(Option<ConfidentialAssetId>, Vec<Txid>)> {
+    let (result, txids) = create_utxos(
+        context,
+        index,
+        is_explicit,
+        true, // is_input is always true, because this parameter affects only tested amount
+        DEFAULT_SEND_AMOUNT,
+        program(),
+    )?;
+
+    let confidential_asset = match is_explicit {
+        true => None,
+        false => {
+            let (conf_asset, _) =
+                result.context("confidential UTXO creation returned no commitment")?;
+
+            Some(conf_asset)
+        }
+    };
+
+    Ok((confidential_asset, txids))
+}
+
+#[simplex::test]
+fn get_explicit_asset_id_for_input(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 1;
+    let (expected_asset_id, txids) =
+        create_utxos_with_new_asset(&context, index, true, DEFAULT_SEND_AMOUNT, program())?;
+
+    let failing = case(Confidential).index(index).index_type(IndexType::Input);
+    let passing = case(Explicit)
+        .index(index)
+        .index_type(IndexType::Input)
+        .expect(expected_asset_id);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_asset_id_for_random_input(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = rand::thread_rng().gen_range(0..=20) as u32; // not a big value to not to slow down tests
+    let (expected_asset_id, txids) =
+        create_utxos_with_new_asset(&context, index, true, DEFAULT_SEND_AMOUNT, program())?;
+
+    case(Explicit)
+        .index(index)
+        .index_type(IndexType::Input)
+        .expect(expected_asset_id)
+        .run(&context, txids)
+}
+
+#[simplex::test]
+fn get_explicit_asset_id_for_output(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 0;
+    let (expected_asset_id, txids) =
+        create_utxos_with_new_asset(&context, index, true, DEFAULT_SEND_AMOUNT, program())?;
+
+    let failing = case(Confidential).index(index);
+    let passing = case(Explicit).index(index).expect(expected_asset_id);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_asset_id_for_random_output(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = rand::thread_rng().gen_range(0..=20) as u32;
+    let (expected_asset_id, txids) =
+        create_utxos_with_new_asset(&context, index, true, DEFAULT_SEND_AMOUNT, program())?;
+
+    case(Explicit)
+        .index(index)
+        .index_type(IndexType::Output)
+        .expect(expected_asset_id)
+        .run(&context, txids)
+}
+
+#[simplex::test]
+fn get_explicit_asset_id_for_confidential_output_fail(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let index = 0;
+    let is_explicit = false;
+
+    let (conf, txids) = create_utxos_wrapper(&context, index, is_explicit)?;
+    let conf = conf.unwrap();
+
+    let failing = case(Explicit).index(index).index_type(IndexType::Output);
+    // Output `index` is blinded because input `index` is confidential, and its commitment
+    // is only made when the spend is blinded, so check the input instead.
+    let passing = case(Confidential)
+        .index(index)
+        .index_type(IndexType::Input)
+        .expected_parity(conf.parity_bit)
+        .confidential_asset_id(conf.asset_id);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_confidential_asset_id_for_input(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 2;
+    let is_explicit = false;
+
+    let (conf_asset, txids) = create_utxos_wrapper(&context, index, is_explicit)?;
+    let expected = conf_asset.unwrap();
+
+    let failing = case(Explicit).index(index).index_type(IndexType::Input);
+    let passing = case(Confidential)
+        .index(index)
+        .index_type(IndexType::Input)
+        .expected_parity(expected.parity_bit)
+        .confidential_asset_id(expected.asset_id);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_input_asset_id(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 0;
+    let (expected_asset_id, txids) =
+        create_utxos_with_new_asset(&context, index, true, DEFAULT_SEND_AMOUNT, program())?;
+
+    let failing = case(ConfidentialInput).index(index);
+    let passing = case(ExplicitInput).index(index).expect(expected_asset_id);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_confidential_input_asset_id(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 1;
+    let is_explicit = false;
+
+    let (conf_asset, txids) = create_utxos_wrapper(&context, index, is_explicit)?;
+    let expected = conf_asset.unwrap();
+
+    let failing = case(ExplicitInput).index(index);
+    let passing = case(ConfidentialInput)
+        .index(index)
+        .expected_parity(expected.parity_bit)
+        .confidential_asset_id(expected.asset_id);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_output_asset_id(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 2;
+    let (expected_asset_id, txids) =
+        create_utxos_with_new_asset(&context, index, true, DEFAULT_SEND_AMOUNT, program())?;
+
+    let failing = case(ConfidentialOutput).index(index);
+    let passing = case(ExplicitOutput).index(index).expect(expected_asset_id);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_output_asset_id_for_confidential_fail(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let index = 2;
+    let is_explicit = false;
+
+    let (conf, txids) = create_utxos_wrapper(&context, index, is_explicit)?;
+    let conf = conf.unwrap();
+
+    let failing = case(ExplicitOutput).index(index);
+    // Output `index` is blinded because input `index` is confidential, and its commitment
+    // is only made when the spend is blinded, so check the input instead.
+    let passing = case(ConfidentialInput)
+        .index(index)
+        .expected_parity(conf.parity_bit)
+        .confidential_asset_id(conf.asset_id);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_current_asset_id(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 0;
+    let (expected_asset_id, txids) =
+        create_utxos_with_new_asset(&context, index, true, DEFAULT_SEND_AMOUNT, program())?;
+
+    let failing = case(CurrentConfidential).index(index);
+    let passing = case(CurrentExplicit).index(index).expect(expected_asset_id);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_confidential_current_asset_id(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 0;
+    let is_explicit = false;
+
+    let (conf_asset, txids) = create_utxos_wrapper(&context, index, is_explicit)?;
+    let expected = conf_asset.unwrap();
+
+    let failing = case(CurrentExplicit).index(index);
+    let passing = case(CurrentConfidential)
+        .index(index)
+        .expected_parity(expected.parity_bit)
+        .confidential_asset_id(expected.asset_id);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_input_asset_id_for_missing_input_fail(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let (_, txids) = create_utxos_wrapper(&context, 0, true)?;
+
+    case(ExplicitInput)
+        .index(u32::MAX)
+        .expecting(&context, Expect::PrunedBranch, txids)
+}
+
+#[simplex::test]
+fn get_explicit_output_asset_id_for_missing_output_fail(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let (_, txids) = create_utxos_wrapper(&context, 0, true)?;
+
+    case(ExplicitOutput)
+        .index(u32::MAX)
+        .expecting(&context, Expect::PrunedBranch, txids)
+}
diff --git a/tests/stdlib/utxo/getters/asset_id_with_amount.rs b/tests/stdlib/utxo/getters/asset_id_with_amount.rs
new file mode 100644
index 0000000..af2f9db
--- /dev/null
+++ b/tests/stdlib/utxo/getters/asset_id_with_amount.rs
@@ -0,0 +1,475 @@
+use rand::Rng;
+use simplex::simplicityhl::elements::Txid;
+
+use crate::common::core::Expect;
+use crate::common::core::run_with_inputs_outputs;
+use crate::common::utxo_helper::ConfidentialAsset;
+use crate::common::utxo_helper::{
+    create_utxos, create_utxos_with_new_asset, random_expected_amount,
+};
+
+use simplicityhl_std::artifacts::tests::utxo::getters::asset_id_with_amount::AssetIdWithAmountProgram as TestAssetIdWithAmountProgram;
+use simplicityhl_std::artifacts::tests::utxo::getters::asset_id_with_amount::derived_asset_id_with_amount::{
+    AssetIdWithAmountArguments as TestAssetIdWithAmountArguments, AssetIdWithAmountWitness as TestAssetIdWithAmountWitness,
+};
+
+use FunctionToTest::*;
+
+enum FunctionToTest {
+    Explicit,
+    Confidential,
+    ExplicitInput,
+    ConfidentialInput,
+    ExplicitOutput,
+    // Currently, the getters happy path for the confidential amount and asset_id of an output index cannot be tested
+    ConfidentialOutput,
+    CurrentExplicit,
+    CurrentConfidential,
+}
+
+#[derive(PartialEq, Eq)]
+enum IndexType {
+    Input,
+    Output,
+}
+
+fn is_input(o: IndexType) -> bool {
+    o == IndexType::Input
+}
+
+fn program() -> TestAssetIdWithAmountProgram {
+    TestAssetIdWithAmountProgram::new(&TestAssetIdWithAmountArguments {})
+}
+
+/// One dispatch arm of the contract, plus the witness it reads.
+struct Case {
+    witness: TestAssetIdWithAmountWitness,
+}
+
+fn case(function: FunctionToTest) -> Case {
+    Case {
+        witness: TestAssetIdWithAmountWitness {
+            function_index: function as u8,
+            index: 0,
+            is_input_index: false,
+            expected_asset: [0; 32],
+            expected_asset_parity: 0,
+            expected_conf_asset: [0; 32],
+            expected_amount: 0,
+            expected_amount_parity: 0,
+            expected_conf_amount: [0; 32],
+        },
+    }
+}
+
+impl Case {
+    /// `index`: the input/output the arm inspects.
+    fn index(mut self, index: u32) -> Self {
+        self.witness.index = index;
+        self
+    }
+
+    /// `is_input`: whether the arm inspects an input.
+    fn index_type(mut self, index_type: IndexType) -> Self {
+        self.witness.is_input_index = is_input(index_type);
+        self
+    }
+
+    /// `expected`: value the arm should produce.
+    fn expect(mut self, expected_asset: [u8; 32], expected_amount: u64) -> Self {
+        self.witness.expected_asset = expected_asset;
+        self.witness.expected_amount = expected_amount;
+        self
+    }
+
+    /// `expected_parity`: value the arm should produce.
+    fn expected_parity(mut self, expected_asset_parity: u8, expected_amount_parity: u8) -> Self {
+        self.witness.expected_asset_parity = expected_asset_parity;
+        self.witness.expected_amount_parity = expected_amount_parity;
+        self
+    }
+
+    /// `expected_conf_asset` and `expected_conf_amount`.
+    fn confidentials(
+        mut self,
+        expected_conf_asset: [u8; 32],
+        expected_conf_amount: [u8; 32],
+    ) -> Self {
+        self.witness.expected_conf_asset = expected_conf_asset;
+        self.witness.expected_conf_amount = expected_conf_amount;
+        self
+    }
+
+    /// Fund, spend, and expect the spend to succeed.
+    fn run(self, context: &simplex::TestContext, txids: Vec<Txid>) -> anyhow::Result<()> {
+        self.expecting(context, Expect::Ok, txids)
+    }
+
+    /// Fund, spend, and expect `expect`.
+    fn expecting(
+        self,
+        context: &simplex::TestContext,
+        expect: Expect,
+        txids: Vec<Txid>,
+    ) -> anyhow::Result<()> {
+        run_with_inputs_outputs(context, program(), self.witness, expect, txids)
+    }
+}
+
+/// Missing input or output also returns `Expect::PrunedBranch` error,
+/// so this approach ensures that the program has the expected input or output.
+/// A failed spend is not broadcasted, so both cases can use the same UTXOs.
+fn fail_and_pass_cases(
+    context: &simplex::TestContext,
+    failing: Case,
+    passing: Case,
+    txids: Vec<Txid>,
+) -> anyhow::Result<()> {
+    failing.expecting(context, Expect::PrunedBranch, txids.clone())?;
+    passing.run(context, txids)
+}
+
+fn create_utxos_wrapper(
+    context: &simplex::TestContext,
+    index: u32,
+    is_explicit: bool,
+    is_input: bool,
+    expected_amount: u64,
+) -> anyhow::Result<(Option<ConfidentialAsset>, Vec<Txid>)> {
+    create_utxos(
+        context,
+        index,
+        is_explicit,
+        is_input,
+        expected_amount,
+        program(),
+    )
+}
+
+#[simplex::test]
+fn get_explicit_asset_id_with_amount_for_input(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let index = 0;
+    let expected_amount = random_expected_amount();
+    let (expected_asset_id, txids) = create_utxos_with_new_asset(
+        &context,
+        index,
+        is_input(IndexType::Input),
+        expected_amount,
+        program(),
+    )?;
+
+    let failing = case(Confidential).index(index).index_type(IndexType::Input);
+    let passing = case(Explicit)
+        .index(index)
+        .index_type(IndexType::Input)
+        .expect(expected_asset_id, expected_amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_asset_id_with_amount_for_random_input(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let index = rand::thread_rng().gen_range(0..=20) as u32;
+    let expected_amount = random_expected_amount();
+    let (expected_asset_id, txids) = create_utxos_with_new_asset(
+        &context,
+        index,
+        is_input(IndexType::Input),
+        expected_amount,
+        program(),
+    )?;
+
+    case(Explicit)
+        .index(index)
+        .index_type(IndexType::Input)
+        .expect(expected_asset_id, expected_amount)
+        .run(&context, txids)
+}
+
+#[simplex::test]
+fn get_explicit_asset_id_with_amount_for_output(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let index = 1;
+    let expected_amount: u64 = random_expected_amount();
+    let (expected_asset_id, txids) = create_utxos_with_new_asset(
+        &context,
+        index,
+        is_input(IndexType::Output),
+        expected_amount,
+        program(),
+    )?;
+
+    let failing = case(Confidential)
+        .index(index)
+        .index_type(IndexType::Output);
+    let passing = case(Explicit)
+        .index(index)
+        .index_type(IndexType::Output)
+        .expect(expected_asset_id, expected_amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_asset_id_with_amount_for_random_output(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let index = rand::thread_rng().gen_range(0..=20) as u32;
+    let expected_amount = random_expected_amount();
+    let (expected_asset_id, txids) = create_utxos_with_new_asset(
+        &context,
+        index,
+        is_input(IndexType::Output),
+        expected_amount,
+        program(),
+    )?;
+
+    case(Explicit)
+        .index(index)
+        .index_type(IndexType::Output)
+        .expect(expected_asset_id, expected_amount)
+        .run(&context, txids)
+}
+
+#[simplex::test]
+fn get_explicit_asset_id_with_amount_for_confidential_output_fail(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let index = 1;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = false;
+
+    let (conf, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Output),
+        expected_amount,
+    )?;
+    let (asset, amount) = conf.unwrap();
+
+    let failing = case(Explicit).index(index).index_type(IndexType::Output);
+    // Output `index` is blinded because input `index` is confidential, and its commitment
+    // is only made when the spend is blinded, so check the input instead.
+    let passing = case(Confidential)
+        .index(index)
+        .index_type(IndexType::Input)
+        .expected_parity(asset.parity_bit, amount.parity_bit)
+        .confidentials(asset.asset_id, amount.amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_confidential_asset_id_with_amount_for_input(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let index = 2;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = false;
+
+    let (expected, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Input),
+        expected_amount,
+    )?;
+    let (asset, amount) = expected.unwrap();
+
+    let failing = case(Explicit).index(index).index_type(IndexType::Input);
+    let passing = case(Confidential)
+        .index(index)
+        .index_type(IndexType::Input)
+        .expected_parity(asset.parity_bit, amount.parity_bit)
+        .confidentials(asset.asset_id, amount.amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_input_asset_id_with_amount(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 0;
+    let expected_amount = random_expected_amount();
+    let (expected_asset_id, txids) = create_utxos_with_new_asset(
+        &context,
+        index,
+        is_input(IndexType::Input),
+        expected_amount,
+        program(),
+    )?;
+
+    let failing = case(ConfidentialInput).index(index);
+    let passing = case(ExplicitInput)
+        .index(index)
+        .expect(expected_asset_id, expected_amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_confidential_input_asset_id_with_amount(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let index = 1;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = false;
+
+    let (expected, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Input),
+        expected_amount,
+    )?;
+
+    let (conf_asset, conf_amount) = expected.unwrap();
+
+    let (asset_parity_bit, asset_conf_amount) = (conf_asset.parity_bit, conf_asset.asset_id);
+    let (amount_parity_bit, amount_conf_amount) = (conf_amount.parity_bit, conf_amount.amount);
+
+    let failing = case(ExplicitInput).index(index);
+    let passing = case(ConfidentialInput)
+        .index(index)
+        .expected_parity(asset_parity_bit, amount_parity_bit)
+        .confidentials(asset_conf_amount, amount_conf_amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_output_asset_id_with_amount(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 1;
+    let expected_amount = random_expected_amount();
+    let (expected_asset_id, txids) = create_utxos_with_new_asset(
+        &context,
+        index,
+        is_input(IndexType::Output),
+        expected_amount,
+        program(),
+    )?;
+
+    let failing = case(ConfidentialOutput).index(index);
+    let passing = case(ExplicitOutput)
+        .index(index)
+        .expect(expected_asset_id, expected_amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_output_asset_id_with_amount_for_confidential_fail(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let index = 1;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = false;
+
+    let (conf, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Output),
+        expected_amount,
+    )?;
+    let (asset, amount) = conf.unwrap();
+
+    let failing = case(ExplicitOutput).index(index);
+    // Output `index` is blinded because input `index` is confidential, and its commitment
+    // is only made when the spend is blinded, so check the input instead.
+    let passing = case(ConfidentialInput)
+        .index(index)
+        .expected_parity(asset.parity_bit, amount.parity_bit)
+        .confidentials(asset.asset_id, amount.amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_current_asset_id_with_amount(context: simplex::TestContext) -> anyhow::Result<()> {
+    let index = 0;
+    let expected_amount = random_expected_amount();
+    let (expected_asset_id, txids) = create_utxos_with_new_asset(
+        &context,
+        index,
+        is_input(IndexType::Input),
+        expected_amount,
+        program(),
+    )?;
+
+    let failing = case(CurrentConfidential).index(index);
+    let passing = case(CurrentExplicit)
+        .index(index)
+        .expect(expected_asset_id, expected_amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_confidential_current_asset_id_with_amount(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let index = 0;
+    let expected_amount: u64 = random_expected_amount();
+    let is_explicit = false;
+
+    let (expected, txids) = create_utxos_wrapper(
+        &context,
+        index,
+        is_explicit,
+        is_input(IndexType::Input),
+        expected_amount,
+    )?;
+
+    let (conf_asset, conf_amount) = expected.unwrap();
+
+    let (asset_parity_bit, asset_conf_amount) = (conf_asset.parity_bit, conf_asset.asset_id);
+    let (amount_parity_bit, amount_conf_amount) = (conf_amount.parity_bit, conf_amount.amount);
+
+    let failing = case(CurrentExplicit).index(index);
+    let passing = case(CurrentConfidential)
+        .index(index)
+        .expected_parity(asset_parity_bit, amount_parity_bit)
+        .confidentials(asset_conf_amount, amount_conf_amount);
+
+    fail_and_pass_cases(&context, failing, passing, txids)
+}
+
+#[simplex::test]
+fn get_explicit_input_asset_id_with_amount_for_missing_input_fail(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let (_, txids) = create_utxos_wrapper(
+        &context,
+        0,
+        true,
+        is_input(IndexType::Input),
+        random_expected_amount(),
+    )?;
+
+    case(ExplicitInput)
+        .index(u32::MAX)
+        .expecting(&context, Expect::PrunedBranch, txids)
+}
+
+#[simplex::test]
+fn get_explicit_output_asset_id_with_amount_for_missing_output_fail(
+    context: simplex::TestContext,
+) -> anyhow::Result<()> {
+    let (_, txids) = create_utxos_wrapper(
+        &context,
+        0,
+        true,
+        is_input(IndexType::Input),
+        random_expected_amount(),
+    )?;
+
+    case(ExplicitOutput)
+        .index(u32::MAX)
+        .expecting(&context, Expect::PrunedBranch, txids)
+}
diff --git a/tests/stdlib/utxo/getters/mod.rs b/tests/stdlib/utxo/getters/mod.rs
new file mode 100644
index 0000000..6cbabb2
--- /dev/null
+++ b/tests/stdlib/utxo/getters/mod.rs
@@ -0,0 +1,3 @@
+mod amount;
+mod asset_id;
+mod asset_id_with_amount;
diff --git a/tests/stdlib/utxo/mod.rs b/tests/stdlib/utxo/mod.rs
new file mode 100644
index 0000000..518a791
--- /dev/null
+++ b/tests/stdlib/utxo/mod.rs
@@ -0,0 +1 @@
+mod getters;