Transactional macro cross pallet transaction

Question

Suppose I have the following cross pallet function call

// Pallet A : method that sets a storage variable
pub fn try_set_value_in_pallet_a(value: u64) -> DispatchResult {
    ensure!(!value.is_zero(), Error::<T>::CannotSetZeroValue);
    ValueA::<T>::set(value);
    Ok(())
}

// Pallet B : extrinsic leveraging functionality in pallet A
#[weights(...)]
pub fn foo(value_a: u64, value_b: u64) -> DispatchResult {
    ensure!(!b.is_zero(), Error::<T>::CannotSetZeroValue);
    ValueB::<T>::set(value_b);
    PalletA::<T>::try_set_value_in_pallet_a(value_a)?;
}

In this case if the following behavior is desired: Either foo in Pallet B succeeds or it leaves PalletA and PalletB states invariate. Where should I put the #[transactional] macro? Should I put it above foo only?

Answer 1

Putting it above fn foo only should be fine in this case. Basically the transactional macro needs to wrap all logic that should be reverted if it fails.

Since the logic in pallet A is inside of fn foo, you only need a transactional layer around fn foo, and that will also take care of any reverting of storage changes in pallet A from that call aswell.