@onekeyfe/react-native-network-throttle 3.0.83-alpha.0 → 3.0.85

package/README.md

@@ -5,16 +5,13 @@ React Native native network throttle for OneKey iOS and Android development sett
 Current scope is RN HTTP(S) latency and upload/download throughput. It does not
 emulate offline mode, WebView traffic, or third-party native networking stacks.
 
-`bypassUrlOrigins` excludes exact HTTP(S) origins from all throttling. Origins
-are canonicalized with their effective port and registered additively for the
-lifetime of the native process. This allows independently initialized React
-Native runtimes to register local development servers without clearing each
-other's configuration.
+`throttleUrlHosts` is an allowlist: when it is non-empty, only requests whose
+host matches are throttled, and everything else is left untouched. An entry is
+either an exact host or `*.example.com`, which matches sub-domains at any depth
+but not the bare apex. An empty allowlist throttles nothing.
 
-Known limitation: on Android the bypass decision is made once per logical
-request (OkHttp application interceptor), so a cross-origin redirect keeps the
-initial request's bypass decision; iOS re-evaluates each request. Exact-origin
-bypasses target local development servers, which do not redirect across
-origins.
+Hosts are registered additively for the lifetime of the native process, so
+independently initialized React Native runtimes cannot clear each other's
+configuration.
 
 This package only owns native request throttling. Product settings, persistence, and UI controls should remain in the host app.

package/android/build.gradle

@@ -62,4 +62,5 @@ def kotlin_version = getExtOrDefault("kotlinVersion")
 dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  testImplementation "junit:junit:4.13.2"
 }

package/android/src/main/java/com/onekeyfe/reactnativenetworkthrottle/NetworkThrottle.kt

@@ -14,7 +14,6 @@ import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicLong
 import java.util.concurrent.atomic.AtomicReference
 import okhttp3.HttpUrl
-import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
 import okhttp3.Interceptor
 import okhttp3.MediaType
 import okhttp3.OkHttpClient
@@ -40,7 +39,7 @@ internal object NetworkThrottle {
     private val downloadBps = AtomicLong(DEFAULT_THROUGHPUT_BPS.toLong())
     private val uploadBps = AtomicLong(DEFAULT_THROUGHPUT_BPS.toLong())
     private val installed = AtomicBoolean(false)
-    private val bypassUrlOrigins = AtomicReference<Set<String>>(emptySet())
+    private val throttleUrlHosts = AtomicReference<Set<String>>(emptySet())
 
     fun install(context: Context) {
         if (!installed.compareAndSet(false, true)) {
@@ -90,18 +89,18 @@ internal object NetworkThrottle {
         if (nextUploadBps <= 0) {
             nextUploadBps = DEFAULT_THROUGHPUT_BPS.toLong()
         }
-        if (config.hasKey("bypassUrlOrigins") && !config.isNull("bypassUrlOrigins")) {
-            val origins = config.getArray("bypassUrlOrigins")
-            val normalizedOrigins = buildSet {
-                if (origins != null) {
-                    for (index in 0 until origins.size()) {
-                        if (origins.getType(index) == ReadableType.String) {
-                            normalizeOrigin(origins.getString(index))?.let(::add)
+        if (config.hasKey("throttleUrlHosts") && !config.isNull("throttleUrlHosts")) {
+            val hosts = config.getArray("throttleUrlHosts")
+            val normalizedHosts = buildSet {
+                if (hosts != null) {
+                    for (index in 0 until hosts.size()) {
+                        if (hosts.getType(index) == ReadableType.String) {
+                            normalizeHost(hosts.getString(index))?.let(::add)
                         }
                     }
                 }
             }
-            bypassUrlOrigins.updateAndGet { current -> current + normalizedOrigins }
+            throttleUrlHosts.updateAndGet { current -> current + normalizedHosts }
         }
 
         enabled.set(nextEnabled)
@@ -122,9 +121,9 @@ internal object NetworkThrottle {
         map.putDouble("latencyMs", latencyNanos.get() / 1_000_000.0)
         map.putDouble("downloadBps", downloadBps.get().toDouble())
         map.putDouble("uploadBps", uploadBps.get().toDouble())
-        val origins = Arguments.createArray()
-        bypassUrlOrigins.get().sorted().forEach(origins::pushString)
-        map.putArray("bypassUrlOrigins", origins)
+        val hosts = Arguments.createArray()
+        throttleUrlHosts.get().sorted().forEach(hosts::pushString)
+        map.putArray("throttleUrlHosts", hosts)
         return map
     }
 
@@ -132,26 +131,31 @@ internal object NetworkThrottle {
     private fun getDownloadBps(): Long = if (enabled.get()) downloadBps.get() else 0L
     private fun getUploadBps(): Long = if (enabled.get()) uploadBps.get() else 0L
 
-    private fun canonicalOrigin(url: HttpUrl): String =
-        HttpUrl.Builder()
-            .scheme(url.scheme)
-            .host(url.host)
-            .port(url.port)
-            .build()
-            .toString()
-            .removeSuffix("/")
+    private fun normalizeHost(value: String?): String? =
+        value?.trim()?.lowercase()?.takeIf { it.isNotEmpty() }
 
-    private fun normalizeOrigin(value: String?): String? =
-        value?.toHttpUrlOrNull()?.let(::canonicalOrigin)
+    /**
+     * Hosts are matched as exact names, or as `*.example.com` which matches
+     * sub-domains at any depth but not the bare apex. This mirrors the URL
+     * patterns the desktop app installs, so both platforms throttle the same
+     * traffic.
+     */
+    internal fun matchesHost(host: String, pattern: String): Boolean =
+        if (pattern.startsWith("*.")) {
+            host.endsWith(pattern.substring(1))
+        } else {
+            host == pattern
+        }
 
-    private fun shouldBypass(requestUrl: HttpUrl): Boolean {
-        // The interceptor is installed in every build; skip the per-request
-        // canonicalization allocation while no origin is registered.
-        val origins = bypassUrlOrigins.get()
-        if (origins.isEmpty()) {
+    private fun shouldThrottle(requestUrl: HttpUrl): Boolean {
+        // The interceptor is installed in every build, so keep the empty case
+        // allocation-free. An empty allowlist throttles nothing.
+        val hosts = throttleUrlHosts.get()
+        if (hosts.isEmpty()) {
             return false
         }
-        return origins.contains(canonicalOrigin(requestUrl))
+        val host = requestUrl.host.lowercase()
+        return hosts.any { matchesHost(host, it) }
     }
 
     private fun sleepNanos(delayNanos: Long) {
@@ -245,7 +249,7 @@ internal object NetworkThrottle {
     private class ThrottleInterceptor : Interceptor {
         override fun intercept(chain: Interceptor.Chain): Response {
             val request = chain.request()
-            if (shouldBypass(request.url)) {
+            if (!shouldThrottle(request.url)) {
                 return chain.proceed(request)
             }
             val requestStartNanos = System.nanoTime()

package/android/src/test/java/com/onekeyfe/reactnativenetworkthrottle/NetworkThrottleHostMatchingTest.kt

@@ -0,0 +1,46 @@
+package com.onekeyfe.reactnativenetworkthrottle
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class NetworkThrottleHostMatchingTest {
+
+  @Test
+  fun matchesSubDomainsAtAnyDepth() {
+    assertTrue(NetworkThrottle.matchesHost("wallet.onekeycn.com", "*.onekeycn.com"))
+    assertTrue(NetworkThrottle.matchesHost("swap.onekeycn.com", "*.onekeycn.com"))
+    assertTrue(NetworkThrottle.matchesHost("a.b.onekeycn.com", "*.onekeycn.com"))
+    assertTrue(NetworkThrottle.matchesHost("uni.onekey-asset.com", "*.onekey-asset.com"))
+  }
+
+  @Test
+  fun matchesExactHosts() {
+    assertTrue(NetworkThrottle.matchesHost("app-assets.onekey.so", "app-assets.onekey.so"))
+    assertFalse(NetworkThrottle.matchesHost("other.onekey.so", "app-assets.onekey.so"))
+  }
+
+  @Test
+  fun doesNotMatchTheBareApex() {
+    // The desktop URLPattern wildcard behaves the same way, so a bare apex must
+    // stay untouched on both platforms.
+    assertFalse(NetworkThrottle.matchesHost("onekeycn.com", "*.onekeycn.com"))
+    assertFalse(NetworkThrottle.matchesHost("onekey-asset.com", "*.onekey-asset.com"))
+  }
+
+  @Test
+  fun doesNotMatchLookAlikeHosts() {
+    // A suffix check without the leading dot would wrongly match these, which
+    // would throttle traffic that is not OneKey's.
+    assertFalse(NetworkThrottle.matchesHost("evil-onekeycn.com", "*.onekeycn.com"))
+    assertFalse(NetworkThrottle.matchesHost("notonekeycn.com", "*.onekeycn.com"))
+  }
+
+  @Test
+  fun doesNotMatchUnrelatedHosts() {
+    for (host in listOf("mainnet.infura.io", "api.hyperliquid.xyz", "localhost", "127.0.0.1")) {
+      assertFalse(NetworkThrottle.matchesHost(host, "*.onekeycn.com"))
+      assertFalse(NetworkThrottle.matchesHost(host, "app-assets.onekey.so"))
+    }
+  }
+}

package/ios/OneKeyNetworkThrottle.m

@@ -10,18 +10,21 @@ static const NSTimeInterval OneKeyNetworkThrottleDefaultLatencyMs = 562.5;
 static const NSInteger OneKeyNetworkThrottleDefaultThroughputBps = 102 * 1024;
 static const NSUInteger OneKeyNetworkThrottleMaxPendingDownloadBytes = 256 * 1024;
 
-static NSString *OneKeyNetworkThrottleCanonicalOrigin(NSURL *url)
+static NSString *OneKeyNetworkThrottleNormalizedHost(NSString *value)
 {
-  NSString *scheme = url.scheme.lowercaseString;
-  NSString *host = url.host.lowercaseString;
-  if ((!([scheme isEqualToString:@"http"] || [scheme isEqualToString:@"https"])) || host.length == 0) {
-    return nil;
+  NSString *host = [value stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]].lowercaseString;
+  return host.length > 0 ? host : nil;
+}
+
+// Hosts match as exact names, or as `*.example.com` which matches sub-domains
+// at any depth but not the bare apex. This mirrors the URL patterns the
+// desktop app installs, so both platforms throttle the same traffic.
+static BOOL OneKeyNetworkThrottleHostMatches(NSString *host, NSString *pattern)
+{
+  if ([pattern hasPrefix:@"*."]) {
+    return [host hasSuffix:[pattern substringFromIndex:1]];
   }
-  NSURLComponents *components = [[NSURLComponents alloc] init];
-  components.scheme = scheme;
-  components.host = host;
-  components.port = url.port ?: @([scheme isEqualToString:@"https"] ? 443 : 80);
-  return components.string;
+  return [host isEqualToString:pattern];
 }
 
 @interface OneKeyNetworkThrottleState : NSObject
@@ -30,12 +33,12 @@ static NSString *OneKeyNetworkThrottleCanonicalOrigin(NSURL *url)
 + (NSTimeInterval)latencyMs;
 + (NSInteger)downloadBps;
 + (NSInteger)uploadBps;
-+ (BOOL)shouldBypassURL:(NSURL *)url;
++ (BOOL)shouldThrottleURL:(NSURL *)url;
 + (NSDictionary *)setEnabled:(BOOL)enabled
                     latencyMs:(NSTimeInterval)latencyMs
                    downloadBps:(NSInteger)downloadBps
                       uploadBps:(NSInteger)uploadBps
-                bypassUrlOrigins:(NSArray *)bypassUrlOrigins;
+                throttleUrlHosts:(NSArray *)throttleUrlHosts;
 @end
 
 @implementation OneKeyNetworkThrottleState
@@ -44,16 +47,16 @@ static atomic_bool _oneKeyNetworkThrottleEnabled = ATOMIC_VAR_INIT(false);
 static atomic_llong _oneKeyNetworkThrottleLatencyMicros = ATOMIC_VAR_INIT(562500);
 static atomic_llong _oneKeyNetworkThrottleDownloadBps = ATOMIC_VAR_INIT(102 * 1024);
 static atomic_llong _oneKeyNetworkThrottleUploadBps = ATOMIC_VAR_INIT(102 * 1024);
-static NSSet<NSString *> *_oneKeyNetworkThrottleBypassOrigins;
+static NSSet<NSString *> *_oneKeyNetworkThrottleHosts;
 
 + (NSDictionary *)currentConfig
 {
   BOOL enabled = atomic_load_explicit(&_oneKeyNetworkThrottleEnabled, memory_order_acquire);
   NSTimeInterval latencyMs =
     ((NSTimeInterval)atomic_load_explicit(&_oneKeyNetworkThrottleLatencyMicros, memory_order_relaxed)) / 1000.0;
-  NSArray<NSString *> *bypassUrlOrigins = nil;
+  NSArray<NSString *> *throttleUrlHosts = nil;
   @synchronized (self) {
-    bypassUrlOrigins = [[_oneKeyNetworkThrottleBypassOrigins ?: [NSSet set] allObjects]
+    throttleUrlHosts = [[_oneKeyNetworkThrottleHosts ?: [NSSet set] allObjects]
       sortedArrayUsingSelector:@selector(compare:)];
   }
   return @{
@@ -62,7 +65,7 @@ static NSSet<NSString *> *_oneKeyNetworkThrottleBypassOrigins;
     @"latencyMs": @(latencyMs),
     @"downloadBps": @([self downloadBps]),
     @"uploadBps": @([self uploadBps]),
-    @"bypassUrlOrigins": bypassUrlOrigins
+    @"throttleUrlHosts": throttleUrlHosts
   };
 }
 
@@ -86,15 +89,23 @@ static NSSet<NSString *> *_oneKeyNetworkThrottleBypassOrigins;
   return (NSInteger)atomic_load_explicit(&_oneKeyNetworkThrottleUploadBps, memory_order_relaxed);
 }
 
-+ (BOOL)shouldBypassURL:(NSURL *)url
++ (BOOL)shouldThrottleURL:(NSURL *)url
 {
-  NSString *origin = OneKeyNetworkThrottleCanonicalOrigin(url);
-  if (origin == nil) {
+  NSString *host = OneKeyNetworkThrottleNormalizedHost(url.host);
+  if (host == nil) {
     return NO;
   }
+  // An empty allowlist throttles nothing.
+  NSSet<NSString *> *hosts = nil;
   @synchronized (self) {
-    return [_oneKeyNetworkThrottleBypassOrigins containsObject:origin];
+    hosts = _oneKeyNetworkThrottleHosts;
   }
+  for (NSString *pattern in hosts) {
+    if (OneKeyNetworkThrottleHostMatches(host, pattern)) {
+      return YES;
+    }
+  }
+  return NO;
 }
 
 + (NSInteger)normalizeThroughputBps:(NSInteger)throughputBps
@@ -106,27 +117,27 @@ static NSSet<NSString *> *_oneKeyNetworkThrottleBypassOrigins;
                     latencyMs:(NSTimeInterval)latencyMs
                    downloadBps:(NSInteger)downloadBps
                       uploadBps:(NSInteger)uploadBps
-                bypassUrlOrigins:(NSArray *)bypassUrlOrigins
+                throttleUrlHosts:(NSArray *)throttleUrlHosts
 {
   NSTimeInterval normalizedLatencyMs = latencyMs > 0 ? latencyMs : OneKeyNetworkThrottleDefaultLatencyMs;
   NSInteger normalizedDownloadBps = [self normalizeThroughputBps:downloadBps];
   NSInteger normalizedUploadBps = [self normalizeThroughputBps:uploadBps];
-  if ([bypassUrlOrigins isKindOfClass:[NSArray class]]) {
-    NSMutableSet<NSString *> *normalizedOrigins = [NSMutableSet set];
-    for (id value in bypassUrlOrigins) {
+  if ([throttleUrlHosts isKindOfClass:[NSArray class]]) {
+    NSMutableSet<NSString *> *normalizedHosts = [NSMutableSet set];
+    for (id value in throttleUrlHosts) {
       if (![value isKindOfClass:[NSString class]]) {
         continue;
       }
-      NSString *origin = OneKeyNetworkThrottleCanonicalOrigin([NSURL URLWithString:(NSString *)value]);
-      if (origin != nil) {
-        [normalizedOrigins addObject:origin];
+      NSString *host = OneKeyNetworkThrottleNormalizedHost((NSString *)value);
+      if (host != nil) {
+        [normalizedHosts addObject:host];
       }
     }
     @synchronized (self) {
-      NSMutableSet<NSString *> *nextOrigins =
-        [_oneKeyNetworkThrottleBypassOrigins mutableCopy] ?: [NSMutableSet set];
-      [nextOrigins unionSet:normalizedOrigins];
-      _oneKeyNetworkThrottleBypassOrigins = [nextOrigins copy];
+      NSMutableSet<NSString *> *nextHosts =
+        [_oneKeyNetworkThrottleHosts mutableCopy] ?: [NSMutableSet set];
+      [nextHosts unionSet:normalizedHosts];
+      _oneKeyNetworkThrottleHosts = [nextHosts copy];
     }
   }
   atomic_store_explicit(
@@ -190,7 +201,7 @@ static NSSet<NSString *> *_oneKeyNetworkThrottleBypassOrigins;
   if ([NSURLProtocol propertyForKey:OneKeyNetworkThrottleHandledKey inRequest:request]) {
     return NO;
   }
-  if ([OneKeyNetworkThrottleState shouldBypassURL:request.URL]) {
+  if (![OneKeyNetworkThrottleState shouldThrottleURL:request.URL]) {
     return NO;
   }
   NSString *scheme = request.URL.scheme.lowercaseString;
@@ -573,14 +584,14 @@ RCT_REMAP_METHOD(setConfig, setConfig:(NSDictionary *)config resolver:(RCTPromis
     uploadBpsValue != nil && uploadBpsValue != [NSNull null]
       ? [uploadBpsValue integerValue]
       : [OneKeyNetworkThrottleState uploadBps];
-  id bypassUrlOriginsValue = config[@"bypassUrlOrigins"];
-  NSArray *bypassUrlOrigins = [bypassUrlOriginsValue isKindOfClass:[NSArray class]] ? bypassUrlOriginsValue : nil;
+  id throttleUrlHostsValue = config[@"throttleUrlHosts"];
+  NSArray *throttleUrlHosts = [throttleUrlHostsValue isKindOfClass:[NSArray class]] ? throttleUrlHostsValue : nil;
   resolve([OneKeyNetworkThrottleState
     setEnabled:enabled
     latencyMs:latencyMs
     downloadBps:downloadBps
     uploadBps:uploadBps
-    bypassUrlOrigins:bypassUrlOrigins]);
+    throttleUrlHosts:throttleUrlHosts]);
 }
 
 @end

package/lib/module/index.js

@@ -13,7 +13,7 @@ const nativeModule = NativeModules.OneKeyNetworkThrottle;
 function normalizeNativeConfig(config) {
   return {
     ...config,
-    bypassUrlOrigins: config.bypassUrlOrigins ?? []
+    throttleUrlHosts: config.throttleUrlHosts ?? []
   };
 }
 export const NetworkThrottle = nativeModule ? {
@@ -26,7 +26,7 @@ export const NetworkThrottle = nativeModule ? {
       latencyMs: config.latencyMs ?? currentConfig.latencyMs,
       downloadBps: config.downloadBps ?? currentConfig.downloadBps,
       uploadBps: config.uploadBps ?? currentConfig.uploadBps,
-      bypassUrlOrigins: config.bypassUrlOrigins ?? currentConfig.bypassUrlOrigins ?? []
+      throttleUrlHosts: config.throttleUrlHosts ?? currentConfig.throttleUrlHosts ?? []
     });
     return normalizeNativeConfig(nativeConfig);
   }

package/lib/typescript/src/index.d.ts

@@ -5,7 +5,7 @@ export type NetworkThrottleConfig = {
     latencyMs: number;
     downloadBps: number;
     uploadBps: number;
-    bypassUrlOrigins: string[];
+    throttleUrlHosts: string[];
 };
 export declare const NETWORK_THROTTLE_SLOW_4G_LATENCY_MS = 562.5;
 export declare const NETWORK_THROTTLE_102_KIB_BPS: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-network-throttle",
-  "version": "3.0.83-alpha.0",
+  "version": "3.0.85",
   "description": "react-native-network-throttle",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/index.tsx

@@ -8,7 +8,7 @@ export type NetworkThrottleConfig = {
   latencyMs: number;
   downloadBps: number;
   uploadBps: number;
-  bypassUrlOrigins: string[];
+  throttleUrlHosts: string[];
 };
 
 export const NETWORK_THROTTLE_SLOW_4G_LATENCY_MS = 562.5;
@@ -19,9 +19,9 @@ export const NETWORK_THROTTLE_SLOW_4G_UPLOAD_BPS = NETWORK_THROTTLE_102_KIB_BPS;
 
 type NativeNetworkThrottleConfig = Omit<
   NetworkThrottleConfig,
-  'bypassUrlOrigins'
+  'throttleUrlHosts'
 > & {
-  bypassUrlOrigins?: string[];
+  throttleUrlHosts?: string[];
 };
 
 type NativeNetworkThrottleModule = {
@@ -52,7 +52,7 @@ function normalizeNativeConfig(
 ): NetworkThrottleConfig {
   return {
     ...config,
-    bypassUrlOrigins: config.bypassUrlOrigins ?? [],
+    throttleUrlHosts: config.throttleUrlHosts ?? [],
   };
 }
 
@@ -70,8 +70,8 @@ export const NetworkThrottle: NetworkThrottleModule = nativeModule
           latencyMs: config.latencyMs ?? currentConfig.latencyMs,
           downloadBps: config.downloadBps ?? currentConfig.downloadBps,
           uploadBps: config.uploadBps ?? currentConfig.uploadBps,
-          bypassUrlOrigins:
-            config.bypassUrlOrigins ?? currentConfig.bypassUrlOrigins ?? [],
+          throttleUrlHosts:
+            config.throttleUrlHosts ?? currentConfig.throttleUrlHosts ?? [],
         });
         return normalizeNativeConfig(nativeConfig);
       },