1. Corda's support for "on ledger libraries" as we call them is not 100% complete. Tudor Malene is working on this and can comment further. Be aware that for now your code will end up fat-jarred/statically linked into the apps that use it, and this will mean you can't easily combine different apps that use the same base types together. So your potential for truly generic code will be somewhat limited.
   
   This matters to us a lot and we've put a lot of infrastructure in place over the years to allow this scenario, but we're not 100% there yet. Make sure you understand the limitations.
   
   
2. You mention "autowiring". Corda doesn't have any kind of DI framework and doesn't use anything like Spring out of the box. Even if you add it, and it works today, it won't work in the DJVM in future. That will be an opt-in change but DJVM compatibility will be important for scaling to larger networks and more apps, so please bear that in mind.
   
   
3. Creating an abstract base class then overriding it and using supercalls should work. This is all just normal OOP. I'm not sure why it didn't for you.
   
   The model is simple enough - a state specifies which contract class it "belongs to". If not explicitly annotated this is implied to be the outer class, if compatible. That contract class must implement the Contract interface and have the verify method as a result, but can otherwise be any normal class that can be constructed by the platform with a no-args constructor. Therefore your contract cannot be abstract. That won't work. Perhaps we have a misleading error message in this case.

abstract class IXContract : Contract {

    // A transaction is valid if the verify() function of the contract of all the transaction's input and output states
    // does not throw an exception.
    override fun verify(tx: LedgerTransaction) {
        // Verification logic goes here.
        val command = tx.commands.requireSingleCommand<Commands>()
        val signers = command.signers.toSet()

        when (command.value) {
            is Commands.TestXState -> testXState(tx, signers)
            else -> throw IllegalArgumentException("Unrecognised command.")
        }
    }

    private fun testXState(tx: LedgerTransaction, signers: Set<PublicKey>) = requireThat {
        "Transaction should have 1 inputs" using (tx.inputStates.size == 1)
    }

    // Used to indicate the transaction's intent.
    interface Commands : CommandData {
        class TestXState : Commands
    }
}

open class XContract : IXContract() {
    companion object {
        // Used to identify our contract when building a transaction.
        const val ID = "com.interswitch.contracts.XContract"
    }

    override fun verify(tx: LedgerTransaction) {
        super.verify(tx)

        //custom verification
        val command = tx.commands.requireSingleCommand<Commands>()
        val signers = command.signers.toSet()

        when (command.value) {
            is Commands.TestBaseXState -> testBaseXState(tx, signers)
            else -> throw IllegalArgumentException("Unrecognised command.")
        }
    }

    private fun testBaseXState(tx: LedgerTransaction, signers: Set<PublicKey>) = requireThat {
        "Transaction should have 1 output" using (tx.outputStates.size==1)
    }

    interface Commands : CommandData {
        class TestBaseXState : Commands
    }

}