diff --git a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/gossiping/KeyShareTests.kt b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/gossiping/KeyShareTests.kt
index 8c3917adc1..7d17b07c28 100644
--- a/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/gossiping/KeyShareTests.kt
+++ b/matrix-sdk-android/src/androidTest/java/org/matrix/android/sdk/internal/crypto/gossiping/KeyShareTests.kt
@@ -66,139 +66,6 @@ class KeyShareTests : InstrumentedTest {
     private val mTestHelper = CommonTestHelper(context())
     private val mCryptoTestHelper = CryptoTestHelper(mTestHelper)
 
-    @Test
-    fun test_DoNotSelfShareIfNotTrusted() {
-        val aliceSession = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true))
-
-        // Create an encrypted room and add a message
-        val roomId = mTestHelper.doSync<String> {
-            aliceSession.createRoom(
-                    CreateRoomParams().apply {
-                        visibility = RoomDirectoryVisibility.PRIVATE
-                        enableEncryption()
-                    },
-                    it
-            )
-        }
-        val room = aliceSession.getRoom(roomId)
-        assertNotNull(room)
-        Thread.sleep(4_000)
-        assertTrue(room?.isEncrypted() == true)
-        val sentEventId = mTestHelper.sendTextMessage(room!!, "My Message", 1).first().eventId
-
-        // Open a new sessionx
-
-        val aliceSession2 = mTestHelper.logIntoAccount(aliceSession.myUserId, SessionTestParams(true))
-
-        val roomSecondSessionPOV = aliceSession2.getRoom(roomId)
-
-        val receivedEvent = roomSecondSessionPOV?.getTimeLineEvent(sentEventId)
-        assertNotNull(receivedEvent)
-        assert(receivedEvent!!.isEncrypted())
-
-        try {
-            aliceSession2.cryptoService().decryptEvent(receivedEvent.root, "foo")
-            fail("should fail")
-        } catch (failure: Throwable) {
-        }
-
-        val outgoingRequestsBefore = aliceSession2.cryptoService().getOutgoingRoomKeyRequests()
-        // Try to request
-        aliceSession2.cryptoService().requestRoomKeyForEvent(receivedEvent.root)
-
-        val waitLatch = CountDownLatch(1)
-        val eventMegolmSessionId = receivedEvent.root.content.toModel<EncryptedEventContent>()?.sessionId
-
-        var outGoingRequestId: String? = null
-
-        mTestHelper.retryPeriodicallyWithLatch(waitLatch) {
-            aliceSession2.cryptoService().getOutgoingRoomKeyRequests()
-                    .filter { req ->
-                        // filter out request that was known before
-                        !outgoingRequestsBefore.any { req.requestId == it.requestId }
-                    }
-                    .let {
-                        val outgoing = it.firstOrNull { it.sessionId == eventMegolmSessionId }
-                        outGoingRequestId = outgoing?.requestId
-                        outgoing != null
-                    }
-        }
-        mTestHelper.await(waitLatch)
-
-        Log.v("TEST", "=======> Outgoing requet Id is $outGoingRequestId")
-
-        val outgoingRequestAfter = aliceSession2.cryptoService().getOutgoingRoomKeyRequests()
-
-        // We should have a new request
-        Assert.assertTrue(outgoingRequestAfter.size > outgoingRequestsBefore.size)
-        Assert.assertNotNull(outgoingRequestAfter.first { it.sessionId == eventMegolmSessionId })
-
-        // The first session should see an incoming request
-        // the request should be refused, because the device is not trusted
-        mTestHelper.waitWithLatch { latch ->
-            mTestHelper.retryPeriodicallyWithLatch(latch) {
-                // DEBUG LOGS
-                aliceSession.cryptoService().getIncomingRoomKeyRequests().let {
-                    Log.v("TEST", "Incoming request Session 1 (looking for $outGoingRequestId)")
-                    Log.v("TEST", "=========================")
-                    it.forEach { keyRequest ->
-                        Log.v("TEST", "[ts${keyRequest.localCreationTimestamp}] requestId ${keyRequest.requestId}, for sessionId ${keyRequest.requestBody?.sessionId} is ${keyRequest.state}")
-                    }
-                    Log.v("TEST", "=========================")
-                }
-
-                val incoming = aliceSession.cryptoService().getIncomingRoomKeyRequests().firstOrNull { it.requestId == outGoingRequestId }
-                incoming?.state == GossipingRequestState.REJECTED
-            }
-        }
-
-        try {
-            aliceSession2.cryptoService().decryptEvent(receivedEvent.root, "foo")
-            fail("should fail")
-        } catch (failure: Throwable) {
-        }
-
-        // Mark the device as trusted
-        aliceSession.cryptoService().setDeviceVerification(DeviceTrustLevel(crossSigningVerified = false, locallyVerified = true), aliceSession.myUserId,
-                aliceSession2.sessionParams.deviceId ?: "")
-
-        // Re request
-        aliceSession2.cryptoService().reRequestRoomKeyForEvent(receivedEvent.root)
-
-        mTestHelper.waitWithLatch { latch ->
-            mTestHelper.retryPeriodicallyWithLatch(latch) {
-                aliceSession.cryptoService().getIncomingRoomKeyRequests().let {
-                    Log.v("TEST", "Incoming request Session 1")
-                    Log.v("TEST", "=========================")
-                    it.forEach {
-                        Log.v("TEST", "requestId ${it.requestId}, for sessionId ${it.requestBody?.sessionId} is ${it.state}")
-                    }
-                    Log.v("TEST", "=========================")
-
-                    it.any { it.requestBody?.sessionId == eventMegolmSessionId && it.state == GossipingRequestState.ACCEPTED }
-                }
-            }
-        }
-
-        Thread.sleep(6_000)
-        mTestHelper.waitWithLatch { latch ->
-            mTestHelper.retryPeriodicallyWithLatch(latch) {
-                aliceSession2.cryptoService().getOutgoingRoomKeyRequests().let {
-                    it.any { it.requestBody?.sessionId == eventMegolmSessionId && it.state == OutgoingGossipingRequestState.CANCELLED }
-                }
-            }
-        }
-
-        try {
-            aliceSession2.cryptoService().decryptEvent(receivedEvent.root, "foo")
-        } catch (failure: Throwable) {
-            fail("should have been able to decrypt")
-        }
-
-        mTestHelper.signOutAndClose(aliceSession)
-        mTestHelper.signOutAndClose(aliceSession2)
-    }
-
     @Test
     fun test_ShareSSSSSecret() {
         val aliceSession1 = mTestHelper.createAccount(TestConstants.USER_ALICE, SessionTestParams(true))
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/CryptoService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/CryptoService.kt
index fa5ea359e8..595d38f704 100644
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/CryptoService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/crypto/CryptoService.kt
@@ -92,8 +92,6 @@ interface CryptoService {
 
     fun getDeviceInfo(userId: String, deviceId: String?): CryptoDeviceInfo?
 
-    fun requestRoomKeyForEvent(event: Event)
-
     fun reRequestRoomKeyForEvent(event: Event)
 
     fun cancelRoomKeyRequest(requestBody: RoomKeyRequestBody)
diff --git a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/DefaultCryptoService.kt b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/DefaultCryptoService.kt
index 9f3c5845a9..54ae6e43bc 100755
--- a/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/DefaultCryptoService.kt
+++ b/matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/crypto/DefaultCryptoService.kt
@@ -1191,24 +1191,6 @@ internal class DefaultCryptoService @Inject constructor(
         outgoingGossipingRequestManager.resendRoomKeyRequest(requestBody)
     }
 
-    override fun requestRoomKeyForEvent(event: Event) {
-        val wireContent = event.content.toModel<EncryptedEventContent>() ?: return Unit.also {
-            Timber.e("## CRYPTO | requestRoomKeyForEvent Failed to request key, null content eventId: ${event.eventId}")
-        }
-
-        cryptoCoroutineScope.launch(coroutineDispatchers.crypto) {
-//            if (!isStarted()) {
-//                Timber.v("## CRYPTO | requestRoomKeyForEvent() : wait after e2e init")
-//                internalStart(false)
-//            }
-            roomDecryptorProvider
-                    .getOrCreateRoomDecryptor(event.roomId, wireContent.algorithm)
-                    ?.requestKeysForEvent(event, false) ?: run {
-                Timber.v("## CRYPTO | requestRoomKeyForEvent() : No room decryptor for roomId:${event.roomId} algorithm:${wireContent.algorithm}")
-            }
-        }
-    }
-
     /**
      * Add a GossipingRequestListener listener.
      *