@ledgerhq/device-transport-kit-react-native-hid 0.0.0-rn-hid-20250221112139 → 0.0.0-rnhid-transport-20250411151739

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/apdu/ApduBuilder.kt

@@ -0,0 +1,88 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.api.apdu
+
+import com.ledger.devicesdk.shared.api.utils.isHexadecimal
+import com.ledger.devicesdk.shared.internal.transport.framer.model.MINIMUM_APDU_SIZE
+import com.ledger.devicesdk.shared.internal.transport.utils.isHexadecimal
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+import kotlin.properties.Delegates
+
+@OptIn(ExperimentalContracts::class)
+public fun apdu(init: ApduBuilder.() -> Unit): Apdu {
+    contract { callsInPlace(init, InvocationKind.EXACTLY_ONCE) }
+    val builder = ApduBuilder()
+    init.invoke(builder)
+    return builder.build()
+}
+
+@OptIn(ExperimentalContracts::class)
+public fun rawApdu(init: ApduRawBuilder.() -> Unit): Apdu {
+    contract { callsInPlace(init, InvocationKind.EXACTLY_ONCE) }
+    val builder = ApduRawBuilder()
+    init.invoke(builder)
+    return builder.build()
+}
+
+public class ApduBuilder internal constructor() {
+    public var classInstruction: Byte by Delegates.notNull()
+    public var instructionMethod: Byte by Delegates.notNull()
+    public var parameter1: Byte by Delegates.notNull()
+    public var parameter2: Byte by Delegates.notNull()
+    public var data: ByteArray? = null
+
+    internal fun build(): Apdu {
+        check(classInstruction.isHexadecimal()) { "classInstruction must be a hexadecimal value" }
+        check(instructionMethod.isHexadecimal()) { "instructionMethod must be a hexadecimal value" }
+        check(parameter1.isHexadecimal()) { "parameter1 must be a hexadecimal value" }
+        check(parameter2.isHexadecimal()) { "parameter2 must be a hexadecimal value" }
+        if (data != null) {
+            val internalData = data!!
+            check(internalData.isHexadecimal()) { "data must be filled with a hexadecimal values" }
+        }
+
+        return Apdu(
+            classInstruction = classInstruction,
+            instructionMethod = instructionMethod,
+            parameter1 = parameter1,
+            parameter2 = parameter2,
+            data = data,
+            dataLength = data?.size ?: 0,
+        )
+    }
+}
+
+public class ApduRawBuilder internal constructor() {
+    public var rawApdu: ByteArray? = null
+
+    internal fun build(): Apdu {
+        check(rawApdu != null) { "RawAPDU must be filled" }
+        val apdu = rawApdu!!
+        check(apdu.isHexadecimal()) { "APDU must be filled with hexadecimal values" }
+        check(
+            apdu.size >= MINIMUM_APDU_SIZE,
+        ) {
+            "APDU size is not correct : current size = ${apdu.size} / " +
+                "minimum size must be = 4 (CLA / INS / P1 / P2)"
+        }
+        val data =
+            if (apdu.size == MINIMUM_APDU_SIZE) {
+                null
+            } else {
+                apdu.sliceArray(MINIMUM_APDU_SIZE..<apdu.size)
+            }
+        return Apdu(
+            classInstruction = apdu[0],
+            instructionMethod = apdu[1],
+            parameter1 = apdu[2],
+            parameter2 = apdu[3],
+            data = data,
+            dataLength = data?.size ?: 0,
+        )
+    }
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/apdu/ApduParser.kt

@@ -0,0 +1,37 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.api.apdu
+
+import com.ledger.devicesdk.shared.api.utils.extractField
+
+public class ApduParser(
+    private val response: ByteArray,
+) {
+    private var currentIndex = 0
+
+    public fun extractByteValue(): Byte = extract1BytesValue().first()
+
+    public fun extract1BytesValue(): ByteArray = extractBytesValue(nbrBytes = 1)
+
+    public fun extract2BytesValue(): ByteArray = extractBytesValue(nbrBytes = 2)
+
+    public fun extract3BytesValue(): ByteArray = extractBytesValue(nbrBytes = 3)
+
+    public fun extract4BytesValue(): ByteArray = extractBytesValue(nbrBytes = 4)
+
+    public fun extractValueString(nbrBytes: Int): String = extractBytesValue(nbrBytes = nbrBytes).decodeToString()
+
+    public fun extractRemainingBytesValue(): ByteArray = extractBytesValue(nbrBytes = response.size - currentIndex)
+
+    public fun extractBytesValue(nbrBytes: Int): ByteArray {
+        val index = currentIndex + nbrBytes
+        val result = response.extractField(from = currentIndex, to = index, toInclusive = false)
+        currentIndex += nbrBytes
+        return result
+    }
+
+    public fun getCurrentIndex(): Int = currentIndex
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/apdu/ApduUtils.kt

@@ -0,0 +1,37 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.api.apdu
+
+import com.ledger.devicesdk.shared.api.utils.isHexadecimal
+import com.ledger.devicesdk.shared.internal.transport.utils.isHexadecimal
+
+internal fun Apdu.toRawApdu(): ByteArray {
+    val dataLength = this.dataLength.toByte()
+    return byteArrayOf(
+        this.classInstruction,
+        this.instructionMethod,
+        this.parameter1,
+        this.parameter2,
+    ) + dataLength + (this.data ?: byteArrayOf())
+}
+
+public fun Apdu.isNotWellFormatted(): Boolean = !this.isWellFormatted()
+
+public fun Apdu.isWellFormatted(): Boolean = this.isHexadecimalFields()
+
+public fun Apdu.isHexadecimalFields(): Boolean =
+    try {
+        check(this.classInstruction.isHexadecimal())
+        check(this.instructionMethod.isHexadecimal())
+        check(this.parameter1.isHexadecimal())
+        check(this.parameter2.isHexadecimal())
+        if (this.data != null) {
+            check(this.data.isHexadecimal())
+        }
+        true
+    } catch (e: IllegalStateException) {
+        false
+    }

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/apdu/SendApduResult.kt

@@ -0,0 +1,47 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.api.apdu
+
+public sealed class SendApduResult {
+    public data class Success(
+        val apdu: ByteArray,
+    ) : SendApduResult() {
+        override fun equals(other: Any?): Boolean {
+            if (this === other) return true
+            if (other == null || this::class != other::class) return false
+
+            other as Success
+
+            return apdu.contentEquals(other.apdu)
+        }
+
+        override fun hashCode(): Int {
+            return apdu.contentHashCode()
+        }
+    }
+
+    public data class Failure(
+        val reason: SendApduFailureReason,
+    ) : SendApduResult()
+}
+
+public sealed class SendApduFailureReason {
+    public data object DeviceNotFound : SendApduFailureReason()
+
+    public data object NoUsbEndpointFound : SendApduFailureReason()
+
+    public data object ApduNotWellFormatted : SendApduFailureReason()
+
+    public data object DeviceLocked : SendApduFailureReason()
+
+    public data object DeviceBusy : SendApduFailureReason()
+
+    public data object NoResponse : SendApduFailureReason()
+
+    public data object DeviceDisconnected : SendApduFailureReason()
+
+    public data object Unknown : SendApduFailureReason()
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/connection/ConnectedDevice.kt

@@ -0,0 +1,25 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.api.connection
+
+import com.ledger.devicesdk.shared.api.device.LedgerDevice
+import com.ledger.devicesdk.shared.api.discovery.ConnectivityType
+import com.ledger.devicesdk.shared.internal.connection.InternalConnectedDevice
+
+public data class ConnectedDevice(
+    public val uid: String,
+    public val name: String,
+    public val ledgerDevice: LedgerDevice,
+    public val connectivityType: ConnectivityType,
+)
+
+internal fun InternalConnectedDevice.toConnectedDevice(): ConnectedDevice =
+    ConnectedDevice(
+        uid = this.id,
+        name = this.name,
+        ledgerDevice = this.ledgerDevice,
+        connectivityType = this.connectivity,
+    )

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/connection/ConnectionResult.kt

@@ -0,0 +1,45 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.api.connection
+
+public sealed class ConnectionResult {
+    public data class Connected(
+        val device: ConnectedDevice,
+    ) : ConnectionResult()
+
+    public data class Disconnected(
+        val failure: Failure,
+    ) : ConnectionResult()
+
+    // Most of these failures are mapped from the ble library but could be cleaned
+    public sealed class Failure {
+        public data object PairingFailed : Failure()
+
+        public data object ConnectionTimeout : Failure()
+
+        public data object DeviceNotFound : Failure()
+
+        public data object NoDeviceAddress : Failure()
+
+        public data object ServiceNotFound : Failure()
+
+        public data object InternalState : Failure()
+
+        public data object InitializingFailed : Failure()
+
+        public data object PermissionNotGranted : Failure()
+
+        public data object DeviceConnectivityBluetoothDisabled : Failure()
+
+        public data object DeviceConnectivityLocationDisabled : Failure()
+
+        public data object BleNotSupported : Failure()
+
+        public data class Unknown(
+            val msg: String?,
+        ) : Failure()
+    }
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/device/BleInformation.kt

@@ -0,0 +1,8 @@
+package com.ledger.devicesdk.shared.api.device
+
+public data class BleInformation(
+    val serviceUuid: String,
+    val notifyCharacteristicUuid: String,
+    val writeWithResponseCharacteristicUuid: String,
+    val writeWithoutResponseCharacteristicUuid: String,
+)

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/device/LedgerDevice.kt

@@ -0,0 +1,89 @@
+package com.ledger.devicesdk.shared.api.device
+
+public sealed class LedgerDevice(
+        public val name: String,
+        public val usbInfo: UsbInfo,
+        public val bleInformation: BleInformation? = null,
+) {
+    public data object Flex :
+            LedgerDevice(
+                    name = "Ledger Flex",
+                    usbInfo = UsbInfo(LEDGER_USB_VENDOR_ID, "0x70", "0x0007"),
+                    bleInformation =
+                            BleInformation(
+                                    serviceUuid = "13d63400-2c97-3004-0000-4c6564676572",
+                                    notifyCharacteristicUuid =
+                                            "13d63400-2c97-3004-0001-4c6564676572",
+                                    writeWithResponseCharacteristicUuid =
+                                            "13d63400-2c97-3004-0002-4c6564676572",
+                                    writeWithoutResponseCharacteristicUuid =
+                                            "13d63400-2c97-3004-0003-4c6564676572",
+                            ),
+            )
+
+    public data object Stax :
+            LedgerDevice(
+                    name = "Ledger Stax",
+                    usbInfo = UsbInfo(LEDGER_USB_VENDOR_ID, "0x60", "0x0006"),
+                    bleInformation =
+                            BleInformation(
+                                    serviceUuid = "13d63400-2c97-6004-0000-4c6564676572",
+                                    notifyCharacteristicUuid =
+                                            "13d63400-2c97-6004-0001-4c6564676572",
+                                    writeWithResponseCharacteristicUuid =
+                                            "13d63400-2c97-6004-0002-4c6564676572",
+                                    writeWithoutResponseCharacteristicUuid =
+                                            "13d63400-2c97-6004-0003-4c6564676572",
+                            ),
+            )
+
+    public data object NanoX :
+            LedgerDevice(
+                    name = "Nano X",
+                    usbInfo = UsbInfo(LEDGER_USB_VENDOR_ID, "0x40", "0x0004"),
+                    bleInformation =
+                            BleInformation(
+                                    serviceUuid = "13d63400-2c97-0004-0000-4c6564676572",
+                                    notifyCharacteristicUuid =
+                                            "13d63400-2c97-0004-0001-4c6564676572",
+                                    writeWithResponseCharacteristicUuid =
+                                            "13d63400-2c97-0004-0002-4c6564676572",
+                                    writeWithoutResponseCharacteristicUuid =
+                                            "13d63400-2c97-0004-0003-4c6564676572",
+                            ),
+            )
+
+    public data object NanoSPlus :
+            LedgerDevice(
+                    name = "Nano S Plus",
+                    usbInfo = UsbInfo(LEDGER_USB_VENDOR_ID, "0x50", "0x0005"),
+                    bleInformation = null,
+            )
+
+    public data object NanoS :
+            LedgerDevice(
+                    name = "Nano S",
+                    usbInfo = UsbInfo(LEDGER_USB_VENDOR_ID, "0x10", "0x0001"),
+                    bleInformation = null,
+            )
+
+    public companion object {
+        public const val LEDGER_USB_VENDOR_ID: String = "0x2c97"
+
+        // Cannot use reflexion here to get all subclasses as it depends of the JVM
+        private val subclasses = buildList {
+            add(Flex)
+            add(Stax)
+            add(NanoX)
+            add(NanoSPlus)
+            add(NanoS)
+        }
+
+        public fun getAllDevices(): List<LedgerDevice> {
+            return subclasses
+        }
+
+        public fun getAllDevicesWithBluetooth(): List<LedgerDevice> =
+                getAllDevices().filter { it.bleInformation != null }
+    }
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/device/UsbInfo.kt

@@ -0,0 +1,7 @@
+package com.ledger.devicesdk.shared.api.device
+
+public data class UsbInfo(
+        val vendorId: String,
+        val productIdMask: String,
+        val bootloaderProductId: String,
+)

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/disconnection/DisconnectionResult.kt

@@ -0,0 +1,10 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.api.disconnection
+
+public sealed class DisconnectionResult {
+    public data object Success : DisconnectionResult()
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/discovery/ConnectivityType.kt

@@ -0,0 +1,10 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.api.discovery
+
+public sealed class ConnectivityType {
+    public data object Usb : ConnectivityType()
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/discovery/DiscoveryDevice.kt

@@ -0,0 +1,18 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.api.discovery
+
+import com.ledger.devicesdk.shared.api.device.LedgerDevice
+import kotlinx.datetime.Clock
+
+public class DiscoveryDevice(
+    public val uid: String,
+    public val name: String,
+    public val ledgerDevice: LedgerDevice,
+    public val connectivityType: ConnectivityType,
+) {
+    public val timestamp: Long = Clock.System.now().toEpochMilliseconds()
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/discovery/DiscoveryResult.kt

@@ -0,0 +1,28 @@
+/*
+ * SPDX-FileCopyrightText: 2023 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.api.discovery
+
+public sealed class DiscoveryResult {
+    public data class DeviceDiscovered(
+        val devices: List<DiscoveryDevice>,
+    ) : DiscoveryResult()
+
+    public data object Ended : DiscoveryResult()
+
+    public sealed class Failure : DiscoveryResult() {
+        public data object LocationDisabled : Failure()
+
+        public data object BluetoothDisabled : Failure()
+
+        public data object BluetoothPermissionNotGranted : Failure()
+
+        public data object BluetoothBleNotSupported : Failure()
+
+        public data class Unknown(
+            val message: String,
+        ) : Failure()
+    }
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/utils/ByteArrayExtension.kt

@@ -0,0 +1,116 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.api.utils
+
+import com.ledger.devicesdk.shared.internal.transport.framer.toInt
+import com.ledger.devicesdk.shared.internal.transport.framer.toIntOn2Bytes
+import com.ledger.devicesdk.shared.internal.transport.framer.toUInt
+import com.ledger.devicesdk.shared.api.utils.isNotHexadecimal
+import com.ledger.devicesdk.shared.internal.transport.utils.isNotHexadecimal
+
+public fun ByteArray.isHexadecimal(): Boolean {
+    return if (isEmpty()) {
+        false
+    } else {
+        var result = true
+        this.forEach {
+            if (it.isNotHexadecimal()) {
+                result = false
+                return@forEach
+            }
+        }
+        result
+    }
+}
+
+@OptIn(ExperimentalStdlibApi::class)
+public fun ByteArray.toHexadecimalString(uppercase: Boolean = true): String {
+    var result = ""
+    forEach { result += it.toHexString() }
+    return if (uppercase) result.uppercase() else result
+}
+
+public fun ByteArray.extractField(
+    from: Int,
+    to: Int,
+    fromInclusive: Boolean = true,
+    toInclusive: Boolean = true,
+): ByteArray =
+    when (fromInclusive) {
+        true -> {
+            when (toInclusive) {
+                true -> this.sliceArray(from..to)
+                false -> this.sliceArray(from..<to)
+            }
+        }
+
+        false -> {
+            when (toInclusive) {
+                true -> this.sliceArray(from + 1..to)
+                false -> this.sliceArray(from + 1..<to)
+            }
+        }
+    }
+
+public fun ByteArray.extractFieldAsIntOn2Bytes(
+    from: Int,
+    to: Int,
+    fromInclusive: Boolean = true,
+    toInclusive: Boolean = true,
+): Int =
+    this
+        .extractField(
+            from = from,
+            to = to,
+            fromInclusive = fromInclusive,
+            toInclusive = toInclusive,
+        ).toIntOn2Bytes()
+
+public fun ByteArray.extractFieldAsUInt(
+    from: Int,
+    to: Int,
+    fromInclusive: Boolean = true,
+    toInclusive: Boolean = true,
+): UInt =
+    this
+        .extractField(
+            from = from,
+            to = to,
+            fromInclusive = fromInclusive,
+            toInclusive = toInclusive,
+        ).toUInt()
+
+public fun ByteArray.extractFieldAsInt(
+    from: Int,
+    to: Int,
+    fromInclusive: Boolean = true,
+    toInclusive: Boolean = true,
+): Int =
+    this
+        .extractField(
+            from = from,
+            to = to,
+            fromInclusive = fromInclusive,
+            toInclusive = toInclusive,
+        ).toInt()
+
+public fun ByteArray.decodeString(
+    from: Int,
+    to: Int,
+    fromInclusive: Boolean = true,
+    toInclusive: Boolean = true,
+): String =
+    this
+        .extractField(
+            from = from,
+            to = to,
+            fromInclusive = fromInclusive,
+            toInclusive = toInclusive,
+        ).decodeToString()
+
+public fun ByteArray.extractFieldAtIndexAsInt(at: Int): Int = this[at].toInt()
+
+public fun ByteArray.extractFieldAtIndexAsString(at: Int): String = this[at].toString()

package/android/src/main/kotlin/com/ledger/devicesdk/shared/api/utils/StringExtension.kt

@@ -0,0 +1,21 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.api.utils
+
+@Throws(IllegalStateException::class)
+public fun String.fromHexStringToBytesOrThrow(): ByteArray {
+    check(this.isHexadecimal()) { "$this is not in hexadecimal format" }
+    return chunked(2)
+        .map(String::fromHexStringToByteOrThrow)
+        .toByteArray()
+}
+
+@Throws(NumberFormatException::class)
+public fun String.fromHexStringToByteOrThrow(): Byte = this.toInt(16).toByte()
+
+public fun String.isHexadecimal(): Boolean = this.isNotEmpty() && this.matches(Regex("^[A-Fa-f0-9]+$"))
+
+public fun String.isNotHexadecimal(): Boolean = !this.isHexadecimal()

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/connection/InternalConnectedDevice.kt

@@ -0,0 +1,13 @@
+package com.ledger.devicesdk.shared.internal.connection
+
+import com.ledger.devicesdk.shared.api.apdu.SendApduResult
+import com.ledger.devicesdk.shared.api.device.LedgerDevice
+import com.ledger.devicesdk.shared.api.discovery.ConnectivityType
+
+internal data class InternalConnectedDevice(
+    val id: String,
+    val name: String,
+    val ledgerDevice: LedgerDevice,
+    val connectivity: ConnectivityType,
+    val sendApduFn: suspend (ByteArray) -> SendApduResult,
+)

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/connection/InternalConnectionResult.kt

@@ -0,0 +1,41 @@
+package com.ledger.devicesdk.shared.internal.connection
+
+internal sealed class InternalConnectionResult {
+    data class Connected(
+        val device: InternalConnectedDevice,
+        val sessionId: String,
+    ) : InternalConnectionResult()
+
+    data class ConnectionError(
+        val error: Failure,
+    ) : InternalConnectionResult()
+
+    // Most of these failures are mapped from the ble library but could be cleaned
+    sealed class Failure {
+        data object PairingFailed : Failure()
+
+        data object ConnectionTimeout : Failure()
+
+        data object DeviceNotFound : Failure()
+
+        data object NoDeviceAddress : Failure()
+
+        data object ServiceNotFound : Failure()
+
+        data object InternalState : Failure()
+
+        data object InitializingFailed : Failure()
+
+        data object PermissionNotGranted : Failure()
+
+        data object DeviceConnectivityBluetoothDisabled : Failure()
+
+        data object DeviceConnectivityLocationDisabled : Failure()
+
+        data object BleNotSupported : Failure()
+
+        data class Unknown(
+            val msg: String?,
+        ) : Failure()
+    }
+}

package/android/src/main/kotlin/com/ledger/devicesdk/shared/internal/coroutine/SDKScope.kt

@@ -0,0 +1,25 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Ledger SAS
+ * SPDX-License-Identifier: LicenseRef-LEDGER
+ */
+
+package com.ledger.devicesdk.shared.internal.coroutine
+
+import kotlin.coroutines.CoroutineContext
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.cancelChildren
+
+internal val sdkScope: SdkCloseableScope
+    get() = getSdkScope()
+
+internal class SdkCloseableScope(
+    context: CoroutineContext,
+) : CoroutineScope{
+    override val coroutineContext: CoroutineContext = context
+
+    override fun toString(): String = "CoroutineScope(context = $coroutineContext)"
+
+    fun close() {
+        coroutineContext.cancelChildren()
+    }
+}