在不使用Corda的FinalityFlow的情况下，您可以自己实现交易的最终化逻辑。下面是一个基本的示例代码，展示了如何手动实现交易的最终化。

import net.corda.core.contracts.Command
import net.corda.core.contracts.StateRef
import net.corda.core.contracts.requireThat
import net.corda.core.flows.FlowLogic
import net.corda.core.flows.InitiatingFlow
import net.corda.core.flows.StartableByRPC
import net.corda.core.identity.Party
import net.corda.core.transactions.SignedTransaction
import net.corda.core.transactions.TransactionBuilder
import net.corda.core.utilities.ProgressTracker

@InitiatingFlow
@StartableByRPC
class CustomFinalityFlow(private val transactionId: String) : FlowLogic() {

    companion object {
        object BUILDING : ProgressTracker.Step("Building transaction.")
        object SIGNING : ProgressTracker.Step("Signing transaction.")
        object FINALIZING : ProgressTracker.Step("Finalizing transaction.") {
            override fun childProgressTracker() = FinalityFlow.tracker()
        }

        fun tracker() = ProgressTracker(BUILDING, SIGNING, FINALIZING)
    }

    override val progressTracker = tracker()

    override fun call(): SignedTransaction {
        progressTracker.currentStep = BUILDING

        // 查询未最终化的交易
        val stx = serviceHub.validatedTransactions.getTransactionById(SecureHash.parse(transactionId))
            ?: throw IllegalArgumentException("Transaction with id $transactionId not found.")

        // 构建一个新的交易
        val notary = stx.notary ?: throw IllegalArgumentException("Transaction notarization missing.")
        val builder = TransactionBuilder(notary)
        builder.addInputState(stx.tx.outRefsOfType().single())

        // 添加自定义逻辑和验证规则
        val outputState = YourState(/* state properties */)
        builder.addOutputState(outputState, YourContract.ID)
        val command = Command(YourContract.Commands.SomeCommand(), listOf(ourIdentity.owningKey))
        builder.addCommand(command)

        // 签署交易
        progressTracker.currentStep = SIGNING
        val signedTransaction = serviceHub.signInitialTransaction(builder)

        // 最终化交易
        progressTracker.currentStep = FINALIZING
        val finalityFlow = subFlow(FinalityFlow(signedTransaction, FINALIZING.childProgressTracker()))
        val finalTx = finalityFlow.single()

        // 确保交易已最终化
        requireThat {
            "The transaction has been finalized." using (finalTx.id == signedTransaction.id)
        }

        return finalTx
    }
}

在这个示例代码中，我们首先查询了要最终化的交易，并使用它的输出状态来构建一个新的交易。然后，我们添加了自定义的交易逻辑和验证规则，并在交易中签署了我们的节点。最后，我们使用自定义的FinalityFlow来最终化交易，并确保它已成功最终化。

请注意，这只是一个基本示例，并没有处理所有可能的情况。在实际应用中，您可能需要根据您的具体需求进行一些修改和调整。