I have a Fragment which is made up of 3 components. It is mounted using this Adapter.
I need help with a filter in RecyclerView. Currently the filter is working for the first time, but when I delete the search the RecyclerView items remain filtered. Could you please point out to me what my logic error is?

`class TransactionsAdapter(
    var summary: Summary = object : Summary {
        override val previousBalance = 0.bd
        override val credits = 0.bd
        override val payments = 0.bd
        override val balance = 0.bd
    },
    private val isOpened: Boolean,
    private val container: View,
    private val userName: String = "",
    private val cardId: String = "",
    private val cfi: Boolean = true,
    transactions: List<Transaction> = emptyList(),
    realTimeTransactions: List<Transaction> = emptyList(),
    private val onTryAgain: () -> Unit,
    private val onSearchBoxClicked: () -> Unit
) : DynamicListAdapter<Transaction, ComponentTransactionsHeaderBinding, ComponentSummaryFooterBinding,    
ComposeViewBinding, TransactionsAdapter.ItemViewHolder>(
    realTimeTransactions,
    transactions,
    showHeader = true,
    showFooter = true
), Filterable {

    var realTimeTransactions: List<Transaction>
        get() = getGroup(0)
        set(value) = submitGroup(0, value, true)
    
    var transactions: List<Transaction>
        get() = getGroup(1)
        set(value) = submitGroup(1, value, true)
    
    private var transactionsFiltered: List<Transaction> = transactions
    
    var taxes: CardTaxes = CardTaxes()
    var footerPadding: Int = 0
        set(value) {
            field = value
            notifyUpdateFooter()
        }
    
    var error: StatementError? = null
        set(value) {
            field = value
            showWarning = value != null
            notifyUpdateWarning()
        }
    
    override fun createItemViewHolder(parent: ViewGroup, groupIndex: Int): ItemViewHolder {
        val context = if (groupIndex == 0) ContextThemeWrapper(parent.context, R.style.RealTime)
        else ContextThemeWrapper(parent.context, R.style.NonRealTime)
        return ItemViewHolder(
            ComponentTransactionBinding.inflate(
                LayoutInflater.from(context),
                parent,
                false
            )
        )
    }
    
    override fun onBindItem(
        holder: ItemViewHolder,
        group: List<Transaction>,
        groupIndex: Int,
        itemIndex: Int
    ) {
        val item = group[itemIndex]
        holder.binding.apply {
            this.transaction = item
            installmentsString = if (item.installments > 1)
                root.resources.getString(R.string.transaction_installments, item.installments)
            else ""
            isLastTransaction = group.getOrNull(itemIndex + 1)?.dayMonth != item.dayMonth
            isFirstTransaction = group.getOrNull(itemIndex - 1)?.dayMonth != item.dayMonth
            if (!isLastTransaction || !isFirstTransaction) {
                transactionGroupCircle.updateLayoutParams<ConstraintLayout.LayoutParams> {
                    baselineToBaseline = transactionName.id
                    transactionGroupCircle.baselineAlignBottom = true
                    baselineMargin = -3
                }
            }
            if (groupIndex == 0) {
                transactionGroupCircle.apply {
                    backgroundTintList = null
                    background = root.resources.getDrawableCompat(R.drawable.shape_outlined_circle)
                }
                usdText.setTextColor(root.resources.getColorCompat(R.color.statement_real_time_tint))
                val d = root.resources.getDrawableCompat(R.color.statement_light_gray)
                dividerDown.background = d
                dividerUp.background = d
            }
        }
    }
    
    override fun createHeaderBinding(parent: ViewGroup): ComponentTransactionsHeaderBinding =
        ComponentTransactionsHeaderBinding.inflate(
            LayoutInflater.from(parent.context),
            parent,
            false
        )
    
    override fun onBindHeader(binding: ComponentTransactionsHeaderBinding) {
        binding.username = userName
        binding.cardDigits = cardId
        setupSearchBox(binding)
        binding.searchBearer.setOnClickListener { onSearchBoxClicked() }
    }
    
    private fun setupSearchBox(binding: ComponentTransactionsHeaderBinding) {
        binding.searchBearer.addTextChangedListener(object : TextWatcher {
            override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
            override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
                filter.filter(s)
            }
            override fun afterTextChanged(s: Editable?) {}
        })
    }
    
    override fun createFooterBinding(parent: ViewGroup): ComponentSummaryFooterBinding =
        ComponentSummaryFooterBinding.inflate(
            LayoutInflater.from(parent.context),
            parent,
            false
        )
    
    override fun onBindFooter(binding: ComponentSummaryFooterBinding) = with(binding) {
        if (cfi) {
            previousBalance.setCurrency(summary.previousBalance)
            credits.setCurrency(summary.credits)
            payments.setCurrency(summary.payments)
            currentBalance.setCurrency(summary.balance)
        } else summaryFooterContainer.visibility = View.GONE
        root.setPadding(root.paddingLeft, root.paddingTop, root.paddingRight, footerPadding)
        root.fillRemainderOfScreen(container)
        checkTaxLink.setOnClickListener {
            val context = root.context
            val intent = Intent(context, TaxesActivity::class.java).apply {
                putExtra(TaxesActivity.TAXES_KEY, taxes)
            }
            context.startActivity(intent)
        }
    }
    
    override fun areItemsTheSame(oldItem: Transaction, newItem: Transaction): Boolean =
        oldItem.dayMonth == newItem.dayMonth && oldItem.name == newItem.name
    
    override fun isItemContentTheSame(oldItem: Transaction, newItem: Transaction): Boolean =
        oldItem == newItem
    
    override fun createWarningBinding(parent: ViewGroup): ComposeViewBinding =
        ComposeViewBinding.inflate(
            LayoutInflater.from(parent.context),
            parent,
            false
        )
    
    override fun onBindWarning(binding: ComposeViewBinding) {
        binding.composeView.setContent {
            when (error) {
                StatementError.REALTIME -> Box(
                    modifier = Modifier
                        .padding(horizontal = dimensionResource(id = R.dimen.liquid_medium_margin_24))
                        .padding(bottom = 8.dp)
                ) {
                    NoFutureReleases(onClick = onTryAgain)
                }
                StatementError.NORMAL -> Box(
                    modifier = Modifier
                        .padding(horizontal = dimensionResource(id = R.dimen.liquid_medium_margin_24))
                        .padding(bottom = 8.dp)
                ) {
                    NoReleases(onClick = onTryAgain)
                }
                else -> Box(
                    modifier = Modifier
                        .padding(horizontal = dimensionResource(id = R.dimen.liquid_medium_margin_24))
                ) {
                    NoTransactions(openedStatement = isOpened)
                }
            }
        }
    }
    
    override fun getFilter(): Filter = object : Filter() {
        override fun performFiltering(constraint: CharSequence?): FilterResults {
            val charString = constraint?.toString() ?: ""
            transactionsFiltered = if (charString.isEmpty()) {
                transactions
            } else {
                val filteredList = ArrayList<Transaction>()
                transactions.filter {
                    it.name.contains(charString, true) || it.value.toString().contains(charString)
                }.forEach { filteredList.add(it) }
                filteredList
            }
            return FilterResults().apply { values = transactionsFiltered }
        }
    
        override fun publishResults(constraint: CharSequence?, results: FilterResults?) {
            transactionsFiltered = results?.values as? List<Transaction> ?: listOf()
            submitGroup(1, transactionsFiltered, true)
            notifyDataSetChanged()
        }
    }
    
    class ItemViewHolder(internal val binding: ComponentTransactionBinding) :              
    RecyclerView.ViewHolder(binding.root)

}`

`