fix of #577

0.38.17

CHANGELOG.md

@@ -1,5 +1,23 @@
 # TelegramBotAPI changelog
 
+## 0.38.18
+
+* `Core`:
+    * Add support of test servers (fix of [#577](https://github.com/InsanusMokrassar/TelegramBotAPI/issues/577))
+* `BehaviourBuilder`:
+    * Fixes in extension `BehaviourContext#doInSubContextWithUpdatesFilter` (thanks to [xzima](https://github.com/xzima))
+
+## 0.38.17
+
+* `Core`:
+    * Add `BotCommandScopeChat` as new `BotCommandScope` (fix of [#574](https://github.com/InsanusMokrassar/TelegramBotAPI/issues/574))
+    * `BotCommandScope` companion got several properties and functions for more useful scope creation
+
+## 0.38.16
+
+* `Core`:
+    * `TelegramAPIUrlsKeeper` now have two new things: properties `webAppDataSecretKey` and fun `checkWebAppLink`
+
 ## 0.38.15
 
 * `Common`:

gradle.properties

@@ -20,6 +20,6 @@ javax_activation_version=1.1.1
 dokka_version=1.6.10
 
 library_group=dev.inmo
-library_version=0.38.15
+library_version=0.38.18
 
 github_release_plugin_version=2.3.7

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/BotBuilder.kt

@@ -40,8 +40,9 @@ data class BotBuilder internal constructor(
 fun buildBot(
     token: String,
     apiUrl: String = telegramBotAPIDefaultUrl,
+    testServer: Boolean = false,
     block: BotBuilder.() -> Unit
 ) = telegramBot(
-    TelegramAPIUrlsKeeper(token, apiUrl),
+    TelegramAPIUrlsKeeper(token, testServer, apiUrl),
     BotBuilder().apply(block).createHttpClient()
 )

tgbotapi.api/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/api/BotExtensions.kt

@@ -66,17 +66,19 @@ inline fun telegramBot(
 inline fun telegramBot(
     token: String,
     apiUrl: String = telegramBotAPIDefaultUrl,
+    testServer: Boolean = false,
     client: HttpClient = HttpClient()
-): TelegramBot = telegramBot(TelegramAPIUrlsKeeper(token, apiUrl), client)
+): TelegramBot = telegramBot(TelegramAPIUrlsKeeper(token, testServer, apiUrl), client)
 
 @Suppress("NOTHING_TO_INLINE")
 inline fun <T: HttpClientEngineConfig> telegramBot(
     token: String,
     clientFactory: HttpClientEngineFactory<T>,
     apiUrl: String = telegramBotAPIDefaultUrl,
+    testServer: Boolean = false,
     noinline clientConfig: HttpClientConfig<T>.() -> Unit = {}
 ) = telegramBot(
-    TelegramAPIUrlsKeeper(token, apiUrl),
+    TelegramAPIUrlsKeeper(token, testServer, apiUrl),
     clientFactory,
     clientConfig
 )
@@ -90,9 +92,10 @@ inline fun telegramBot(
     token: String,
     clientEngine: HttpClientEngine,
     apiUrl: String = telegramBotAPIDefaultUrl,
+    testServer: Boolean = false,
     noinline clientConfig: HttpClientConfig<*>.() -> Unit = {}
 ) = telegramBot(
-    TelegramAPIUrlsKeeper(token, apiUrl),
+    TelegramAPIUrlsKeeper(token, testServer, apiUrl),
     clientEngine,
     clientConfig
 )
@@ -105,8 +108,9 @@ inline fun telegramBot(
 inline fun telegramBot(
     token: String,
     apiUrl: String = telegramBotAPIDefaultUrl,
+    testServer: Boolean = false,
     noinline clientConfig: HttpClientConfig<*>.() -> Unit
 ) = telegramBot(
-    TelegramAPIUrlsKeeper(token, apiUrl),
+    TelegramAPIUrlsKeeper(token, testServer, apiUrl),
     clientConfig
 )

tgbotapi.behaviour_builder.fsm/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/TelegramBotWithFSM.kt

@@ -38,10 +38,12 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSM(
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
     presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
+    testServer: Boolean = false,
     block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
 ): TelegramBot = telegramBot(
     token,
     apiUrl,
+    testServer,
     builder
 ).apply {
     buildBehaviourWithFSMAndStartLongPolling(
@@ -73,11 +75,13 @@ suspend fun <T : State> telegramBotWithBehaviourAndFSMAndStartLongPolling(
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
     statesManager: StatesManager<T> = DefaultStatesManager(InMemoryDefaultStatesManagerRepo()),
     presetHandlers: MutableList<BehaviourWithFSMStateHandlerHolder<*, T>> = mutableListOf(),
+    testServer: Boolean = false,
     block: CustomBehaviourContextReceiver<BehaviourContextWithFSMBuilder<T>, Unit>
 ): Pair<TelegramBot, Job> {
     return telegramBot(
         token,
         apiUrl,
+        testServer,
         builder
     ).let {
         it to it.buildBehaviourWithFSMAndStartLongPolling (

tgbotapi.behaviour_builder/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/BehaviourContext.kt

@@ -90,7 +90,7 @@ class DefaultBehaviourContext(
         onBufferOverflow: BufferOverflow,
         upstreamUpdatesFlow: Flow<Update>?,
         updatesFilter: BehaviourContextAndTypeReceiver<Boolean, Update>?
-    ): BehaviourContext = DefaultBehaviourContext(bot, scope, broadcastChannelsSize, onBufferOverflow, upstreamUpdatesFlow, updatesFilter)
+    ): DefaultBehaviourContext = DefaultBehaviourContext(bot, scope, broadcastChannelsSize, onBufferOverflow, upstreamUpdatesFlow, updatesFilter)
 }
 
 fun BehaviourContext(
@@ -116,19 +116,20 @@ suspend fun <T, BC : BehaviourContext> BC.doInSubContextWithUpdatesFilter(
     updatesUpstreamFlow: Flow<Update> = allUpdatesFlow,
     scope: CoroutineScope = LinkedSupervisorScope(),
     behaviourContextReceiver: CustomBehaviourContextReceiver<BC, T>
-): T = copy(
-    scope = scope,
-    updatesFilter = updatesFilter ?.let { _ ->
-        {
-            (this as? BC) ?.run {
-                updatesFilter(it)
-            } ?: true
-        }
-    },
-    upstreamUpdatesFlow = updatesUpstreamFlow
-).run {
-    withContext(coroutineContext) {
-        behaviourContextReceiver().also { if (stopOnCompletion) stop() }
+): T {
+    val newContext = copy(
+        scope = scope,
+        updatesFilter = updatesFilter ?.let { _ ->
+            {
+                (this as? BC) ?.run {
+                    updatesFilter(it)
+                } ?: true
+            }
+        },
+        upstreamUpdatesFlow = updatesUpstreamFlow
+    ) as BC
+    return withContext(currentCoroutineContext()) {
+        newContext.behaviourContextReceiver().also { if (stopOnCompletion) newContext.stop() }
     }
 }
 

tgbotapi.behaviour_builder/src/commonMain/kotlin/dev/inmo/tgbotapi/extensions/behaviour_builder/TelegramBot.kt

@@ -30,10 +30,12 @@ suspend fun telegramBotWithBehaviour(
     apiUrl: String = telegramBotAPIDefaultUrl,
     builder: KtorRequestsExecutorBuilder.() -> Unit = {},
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
+    testServer: Boolean = false,
     block: BehaviourContextReceiver<Unit>
 ): TelegramBot = telegramBot(
     token,
     apiUrl,
+    testServer,
     builder
 ).apply {
     buildBehaviour(
@@ -63,11 +65,13 @@ suspend fun telegramBotWithBehaviourAndLongPolling(
     apiUrl: String = telegramBotAPIDefaultUrl,
     builder: KtorRequestsExecutorBuilder.() -> Unit = {},
     defaultExceptionsHandler: ExceptionHandler<Unit>? = null,
+    testServer: Boolean = false,
     block: BehaviourContextReceiver<Unit>
 ): Pair<TelegramBot, Job> {
     return telegramBot(
         token,
         apiUrl,
+        testServer,
         builder
     ).let {
         it to it.buildBehaviourWithLongPolling(

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/bot/Ktor/KtorRequestsExecutor.kt

@@ -125,5 +125,6 @@ inline fun telegramBot(
 inline fun telegramBot(
     token: String,
     apiUrl: String = telegramBotAPIDefaultUrl,
+    testServer: Boolean = false,
     builder: KtorRequestsExecutorBuilder.() -> Unit = {}
-): TelegramBot = telegramBot(TelegramAPIUrlsKeeper(token, apiUrl), builder)
+): TelegramBot = telegramBot(TelegramAPIUrlsKeeper(token, testServer, apiUrl), builder)

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/types/commands/BotCommandScope.kt

@@ -22,11 +22,14 @@ private class SurrogateBotCommandScope(
         BotCommandScopeAllGroupChats.type -> BotCommandScopeAllGroupChats
         BotCommandScopeAllChatAdministrators.type -> BotCommandScopeAllChatAdministrators
         BotCommandScopeChatAdministrators.type -> BotCommandScopeChatAdministrators(
-            chatId ?: error("chat_administrators type must have $chatIdField field, but have no")
+            chatId ?: error("${BotCommandScopeChatAdministrators.type} type must have $chatIdField field, but have no")
         )
         BotCommandScopeChatMember.type -> BotCommandScopeChatMember(
-            chatId ?: error("chat_administrators type must have $chatIdField field, but have no"),
-            userId ?: error("chat_administrators type must have $userIdField field, but have no")
+            chatId ?: error("${BotCommandScopeChatMember.type} type must have $chatIdField field, but have no"),
+            userId ?: error("${BotCommandScopeChatMember.type} type must have $userIdField field, but have no")
+        )
+        BotCommandScopeChat.type -> BotCommandScopeChat(
+            chatId ?: error("${BotCommandScopeChat.type} type must have $chatIdField field, but have no")
         )
         else -> UnknownBotCommandScope(type)
     }
@@ -40,6 +43,7 @@ private class SurrogateBotCommandScope(
             BotCommandScopeAllChatAdministrators -> SurrogateBotCommandScope(scope.type)
             is BotCommandScopeChatAdministrators -> SurrogateBotCommandScope(scope.type, scope.chatId)
             is BotCommandScopeChatMember -> SurrogateBotCommandScope(scope.type, scope.chatId, scope.userId)
+            is BotCommandScopeChat -> SurrogateBotCommandScope(scope.type, scope.chatId)
         }
     }
 }
@@ -47,6 +51,16 @@ private class SurrogateBotCommandScope(
 @Serializable(BotCommandScopeSerializer::class)
 sealed interface BotCommandScope {
     val type: String
+
+    companion object {
+        val Default = BotCommandScopeDefault
+        val AllPrivateChats = BotCommandScopeAllPrivateChats
+        val AllGroupChats = BotCommandScopeAllGroupChats
+        val AllChatAdministrators = BotCommandScopeAllChatAdministrators
+        fun ChatAdministrators(chatId: ChatIdentifier) = BotCommandScopeChatAdministrators(chatId)
+        fun Chat(chatId: ChatIdentifier) = BotCommandScopeChat(chatId)
+        fun ChatMember(chatId: ChatIdentifier, userId: UserId) = BotCommandScopeChatMember(chatId, userId)
+    }
 }
 
 @Serializable
@@ -94,6 +108,17 @@ data class BotCommandScopeChatAdministrators(
     }
 }
 
+@Serializable
+data class BotCommandScopeChat(
+    override val chatId: ChatIdentifier
+) : ChatBotCommandScope {
+    @Required
+    override val type: String = BotCommandScopeChat.type
+    companion object {
+        const val type = "chat"
+    }
+}
+
 @Serializable
 data class BotCommandScopeChatMember(
     override val chatId: ChatIdentifier,

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/utils/Crypto.kt

@@ -0,0 +1,19 @@
+package dev.inmo.tgbotapi.utils
+
+import dev.inmo.micro_utils.crypto.SourceBytes
+import dev.inmo.micro_utils.crypto.SourceString
+
+internal expect fun SourceString.hmacSha256(key: String): String
+private val HEX_ARRAY = "0123456789abcdef".toCharArray()
+
+internal fun SourceBytes.hex(): String {
+    val hexChars = CharArray(size * 2)
+    for (j in indices) {
+        val v: Int = this[j].toInt() and 0xFF
+        hexChars[j * 2] = HEX_ARRAY[v ushr 4]
+        hexChars[j * 2 + 1] = HEX_ARRAY[v and 0x0F]
+    }
+    return hexChars.concatToString()
+}
+
+internal fun SourceString.hex(): String = encodeToByteArray().hex()

tgbotapi.core/src/commonMain/kotlin/dev/inmo/tgbotapi/utils/TelegramAPIUrlsKeeper.kt

@@ -16,16 +16,33 @@ private inline val String.withoutLastSlash: String
 
 class TelegramAPIUrlsKeeper(
     token: String,
-    hostUrl: String = telegramBotAPIDefaultUrl
+    hostUrl: String = telegramBotAPIDefaultUrl,
+    urlsSuffixes: String = ""
 ) {
+    val webAppDataSecretKey by lazy {
+        token.hmacSha256("WebAppData")
+    }
+
     val commonAPIUrl: String
     val fileBaseUrl: String
 
+    constructor(token: String, testServer: Boolean, hostUrl: String = telegramBotAPIDefaultUrl) : this(
+        token,
+        hostUrl,
+        "/test".takeIf { testServer } ?: ""
+    )
+
     init {
         val correctedHost = hostUrl.withoutLastSlash
-        commonAPIUrl = "$correctedHost/bot$token"
-        fileBaseUrl = "$correctedHost/file/bot$token"
+        commonAPIUrl = "$correctedHost/bot$token$urlsSuffixes"
+        fileBaseUrl = "$correctedHost/file/bot$token$urlsSuffixes"
     }
 
     fun createFileLinkUrl(filePath: String) = "${fileBaseUrl}/$filePath"
+
+    /**
+     * @param rawData Data from [dev.inmo.tgbotapi.webapps.WebApp.initData]
+     * @param hash Data from [dev.inmo.tgbotapi.webapps.WebApp.initDataUnsafe] from the field [dev.inmo.tgbotapi.webapps.WebAppInitData.hash]
+     */
+    fun checkWebAppLink(rawData: String, hash: String) = rawData.hmacSha256(webAppDataSecretKey).hex() == hash
 }

tgbotapi.core/src/jsMain/kotlin/dev/inmo/tgbotapi/utils/CryptoActual.kt

@@ -0,0 +1,6 @@
+package dev.inmo.tgbotapi.utils
+
+import dev.inmo.micro_utils.crypto.CryptoJS
+import dev.inmo.micro_utils.crypto.SourceString
+
+actual fun SourceString.hmacSha256(key: String) = CryptoJS.asDynamic().HmacSHA256(this, key).toString().unsafeCast<String>()

tgbotapi.core/src/jvmMain/kotlin/dev/inmo/tgbotapi/utils/CryptoActual.kt

@@ -0,0 +1,14 @@
+package dev.inmo.tgbotapi.utils
+
+import dev.inmo.micro_utils.crypto.SourceString
+import javax.crypto.Mac
+import javax.crypto.spec.SecretKeySpec
+
+actual fun SourceString.hmacSha256(key: String): String {
+    val mac = Mac.getInstance("HmacSHA256")
+
+    val secretKey = SecretKeySpec(key.toByteArray(), "HmacSHA256")
+    mac.init(secretKey)
+
+    return mac.doFinal(toByteArray()).hex()
+}

tgbotapi.webapps/build.gradle

@@ -27,6 +27,13 @@ repositories {
 }
 
 kotlin {
+    jvm {
+        compilations.main {
+            kotlinOptions {
+                jvmTarget = "1.8"
+            }
+        }
+    }
     js(IR) {
         browser()
         nodejs()

tgbotapi.webapps/src/jsMain/kotlin/dev/inmo/tgbotapi/webapps/WebApp.kt

@@ -1,6 +1,7 @@
 package dev.inmo.tgbotapi.webapps
 
 import dev.inmo.micro_utils.crypto.CryptoJS
+import dev.inmo.tgbotapi.utils.TelegramAPIUrlsKeeper
 
 external class WebApp {
     val initData: String
@@ -76,6 +77,7 @@ fun WebApp.onMainButtonClicked(eventHandler: EventHandler) = onEvent(EventType.M
  */
 fun WebApp.onViewportChanged(eventHandler: ViewportChangedEventHandler) = onEvent(EventType.ViewportChanged, eventHandler)
 
-fun WebApp.isInitDataSafe(botToken: String) = CryptoJS.hex(
-    CryptoJS.HmacSHA256(botToken, "WebAppData")
-) == initDataUnsafe.hash
+fun WebApp.isInitDataSafe(botToken: String) = TelegramAPIUrlsKeeper(botToken).checkWebAppLink(
+    initData,
+    initDataUnsafe.hash
+)