@onekeyfe/react-native-network-throttle 3.0.69

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 @onekeyhq
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# @onekeyfe/react-native-network-throttle
+
+React Native native network throttle for OneKey iOS and Android development settings.
+
+This package only owns native request throttling. Product settings, persistence, and UI controls should remain in the host app.

package/ReactNativeNetworkThrottle.podspec

@@ -0,0 +1,19 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ReactNativeNetworkThrottle"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/OneKeyHQ/app-modules/react-native-network-throttle.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+
+  install_modules_dependencies(s)
+end

package/android/build.gradle

@@ -0,0 +1,65 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['ReactNativeNetworkThrottle_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ReactNativeNetworkThrottle_" + name]).toInteger()
+}
+
+android {
+  namespace "com.onekeyfe.reactnativenetworkthrottle"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,8 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <application>
+        <provider
+            android:name=".NetworkThrottleInitProvider"
+            android:authorities="${applicationId}.network-throttle-init"
+            android:exported="false" />
+    </application>
+</manifest>

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

@@ -0,0 +1,84 @@
+package com.onekeyfe.reactnativenetworkthrottle
+
+import android.content.Context
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.network.OkHttpClientProvider
+import java.io.IOException
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicLong
+import okhttp3.Interceptor
+import okhttp3.OkHttpClient
+import okhttp3.Response
+
+internal object NetworkThrottle {
+    private const val TAG = "OneKeyNetworkThrottle"
+    private const val PROFILE_SLOW_4G = "slow4g"
+    private const val DEFAULT_LATENCY_MS = 562.5
+
+    private val enabled = AtomicBoolean(false)
+    private val latencyNanos = AtomicLong((DEFAULT_LATENCY_MS * 1_000_000.0).toLong())
+    private val installed = AtomicBoolean(false)
+
+    fun install(context: Context) {
+        if (!installed.compareAndSet(false, true)) {
+            return
+        }
+        val applicationContext = context.applicationContext
+        OkHttpClientProvider.setOkHttpClientFactory {
+            val builder: OkHttpClient.Builder =
+                OkHttpClientProvider.createClientBuilder(applicationContext)
+            builder.addInterceptor(LatencyInterceptor())
+            builder.build()
+        }
+        Log.i(TAG, "[onekey-network-throttle] installed RN OkHttp latency interceptor")
+    }
+
+    fun setConfig(config: ReadableMap): WritableMap {
+        val nextEnabled = config.hasKey("enabled") && config.getBoolean("enabled")
+        var nextLatencyMs =
+            if (config.hasKey("latencyMs")) config.getDouble("latencyMs") else DEFAULT_LATENCY_MS
+        if (nextLatencyMs <= 0) {
+            nextLatencyMs = DEFAULT_LATENCY_MS
+        }
+
+        enabled.set(nextEnabled)
+        latencyNanos.set((nextLatencyMs * 1_000_000.0).toLong())
+        Log.i(
+            TAG,
+            "[onekey-network-throttle] native config enabled=$nextEnabled profile=$PROFILE_SLOW_4G latencyMs=$nextLatencyMs"
+        )
+        return getConfig()
+    }
+
+    fun getConfig(): WritableMap {
+        val map = Arguments.createMap()
+        map.putBoolean("enabled", enabled.get())
+        map.putString("profile", PROFILE_SLOW_4G)
+        map.putDouble("latencyMs", latencyNanos.get() / 1_000_000.0)
+        return map
+    }
+
+    private fun getLatencyNanos(): Long = if (enabled.get()) latencyNanos.get() else 0L
+
+    private class LatencyInterceptor : Interceptor {
+        override fun intercept(chain: Interceptor.Chain): Response {
+            val delayNanos = getLatencyNanos()
+            if (delayNanos > 0) {
+                try {
+                    val delayMs = TimeUnit.NANOSECONDS.toMillis(delayNanos)
+                    val remainingNanos =
+                        (delayNanos - TimeUnit.MILLISECONDS.toNanos(delayMs)).toInt()
+                    Thread.sleep(delayMs, remainingNanos)
+                } catch (error: InterruptedException) {
+                    Thread.currentThread().interrupt()
+                    throw IOException("Interrupted while applying OneKey network throttle", error)
+                }
+            }
+            return chain.proceed(chain.request())
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+package com.onekeyfe.reactnativenetworkthrottle
+
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.database.Cursor
+import android.net.Uri
+
+class NetworkThrottleInitProvider : ContentProvider() {
+    override fun onCreate(): Boolean {
+        context?.let { NetworkThrottle.install(it) }
+        return true
+    }
+
+    override fun query(
+        uri: Uri,
+        projection: Array<String>?,
+        selection: String?,
+        selectionArgs: Array<String>?,
+        sortOrder: String?
+    ): Cursor? = null
+
+    override fun getType(uri: Uri): String? = null
+    override fun insert(uri: Uri, values: ContentValues?): Uri? = null
+    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<String>?): Int = 0
+    override fun update(
+        uri: Uri,
+        values: ContentValues?,
+        selection: String?,
+        selectionArgs: Array<String>?
+    ): Int = 0
+}

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

@@ -0,0 +1,33 @@
+package com.onekeyfe.reactnativenetworkthrottle
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = NetworkThrottleModule.NAME)
+class NetworkThrottleModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    companion object {
+        const val NAME = "OneKeyNetworkThrottle"
+    }
+
+    init {
+        NetworkThrottle.install(reactContext)
+    }
+
+    override fun getName(): String = NAME
+
+    @ReactMethod
+    fun getConfig(promise: Promise) {
+        promise.resolve(NetworkThrottle.getConfig())
+    }
+
+    @ReactMethod
+    fun setConfig(config: ReadableMap, promise: Promise) {
+        promise.resolve(NetworkThrottle.setConfig(config))
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.onekeyfe.reactnativenetworkthrottle
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+@Suppress("OVERRIDE_DEPRECATION")
+class NetworkThrottlePackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+        listOf(NetworkThrottleModule(reactContext))
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext
+    ): List<ViewManager<*, *>> = emptyList()
+}

package/ios/OneKeyNetworkThrottle.m

@@ -0,0 +1,206 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTHTTPRequestHandler.h>
+#import <math.h>
+#import <stdatomic.h>
+
+static NSString *const OneKeyNetworkThrottleHandledKey = @"OneKeyNetworkThrottleHandled";
+static NSString *const OneKeyNetworkThrottleProfileSlow4G = @"slow4g";
+static const NSTimeInterval OneKeyNetworkThrottleDefaultLatencyMs = 562.5;
+
+@interface OneKeyNetworkThrottleState : NSObject
++ (NSDictionary *)currentConfig;
++ (BOOL)isEnabled;
++ (NSTimeInterval)latencyMs;
++ (NSDictionary *)setEnabled:(BOOL)enabled latencyMs:(NSTimeInterval)latencyMs;
+@end
+
+@implementation OneKeyNetworkThrottleState
+
+static atomic_bool _oneKeyNetworkThrottleEnabled = ATOMIC_VAR_INIT(false);
+static atomic_llong _oneKeyNetworkThrottleLatencyMicros = ATOMIC_VAR_INIT(562500);
+
++ (NSDictionary *)currentConfig
+{
+  BOOL enabled = atomic_load_explicit(&_oneKeyNetworkThrottleEnabled, memory_order_acquire);
+  NSTimeInterval latencyMs =
+    ((NSTimeInterval)atomic_load_explicit(&_oneKeyNetworkThrottleLatencyMicros, memory_order_relaxed)) / 1000.0;
+  return @{
+    @"enabled": @(enabled),
+    @"profile": OneKeyNetworkThrottleProfileSlow4G,
+    @"latencyMs": @(latencyMs)
+  };
+}
+
++ (BOOL)isEnabled
+{
+  return atomic_load_explicit(&_oneKeyNetworkThrottleEnabled, memory_order_acquire);
+}
+
++ (NSTimeInterval)latencyMs
+{
+  return ((NSTimeInterval)atomic_load_explicit(&_oneKeyNetworkThrottleLatencyMicros, memory_order_relaxed)) / 1000.0;
+}
+
++ (NSDictionary *)setEnabled:(BOOL)enabled latencyMs:(NSTimeInterval)latencyMs
+{
+  NSTimeInterval normalizedLatencyMs = latencyMs > 0 ? latencyMs : OneKeyNetworkThrottleDefaultLatencyMs;
+  atomic_store_explicit(
+    &_oneKeyNetworkThrottleLatencyMicros,
+    (long long)llround(normalizedLatencyMs * 1000.0),
+    memory_order_relaxed
+  );
+  atomic_store_explicit(&_oneKeyNetworkThrottleEnabled, enabled, memory_order_release);
+  NSLog(
+    @"[onekey-network-throttle] native config enabled=%@ profile=%@ latencyMs=%.1f",
+    enabled ? @"true" : @"false",
+    OneKeyNetworkThrottleProfileSlow4G,
+    normalizedLatencyMs
+  );
+  return [self currentConfig];
+}
+
+@end
+
+@interface OneKeyNetworkThrottleURLProtocol : NSURLProtocol <NSURLSessionDataDelegate>
+@property (nonatomic, strong) NSURLSessionDataTask *task;
+@property (nonatomic, strong) NSURLSession *session;
+@property (atomic, assign) BOOL stopped;
+@end
+
+@implementation OneKeyNetworkThrottleURLProtocol
+
++ (BOOL)canInitWithRequest:(NSURLRequest *)request
+{
+  if (![OneKeyNetworkThrottleState isEnabled]) {
+    return NO;
+  }
+  if ([NSURLProtocol propertyForKey:OneKeyNetworkThrottleHandledKey inRequest:request]) {
+    return NO;
+  }
+  NSString *scheme = request.URL.scheme.lowercaseString;
+  return [scheme isEqualToString:@"http"] || [scheme isEqualToString:@"https"];
+}
+
++ (NSURLRequest *)canonicalRequestForRequest:(NSURLRequest *)request
+{
+  return request;
+}
+
+- (void)startLoading
+{
+  NSMutableURLRequest *request = [self.request mutableCopy];
+  [NSURLProtocol setProperty:@YES forKey:OneKeyNetworkThrottleHandledKey inRequest:request];
+
+  NSTimeInterval delay = [OneKeyNetworkThrottleState latencyMs] / 1000.0;
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delay * NSEC_PER_SEC)), dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
+    if (self.stopped) {
+      return;
+    }
+    NSURLSessionConfiguration *configuration = [NSURLSessionConfiguration defaultSessionConfiguration];
+    configuration.HTTPShouldSetCookies = YES;
+    configuration.HTTPCookieAcceptPolicy = NSHTTPCookieAcceptPolicyAlways;
+    configuration.HTTPCookieStorage = [NSHTTPCookieStorage sharedHTTPCookieStorage];
+    self.session = [NSURLSession sessionWithConfiguration:configuration delegate:self delegateQueue:nil];
+    self.task = [self.session dataTaskWithRequest:request];
+    [self.task resume];
+  });
+}
+
+- (void)stopLoading
+{
+  self.stopped = YES;
+  [self.task cancel];
+  [self.session invalidateAndCancel];
+  self.task = nil;
+  self.session = nil;
+}
+
+- (void)URLSession:(NSURLSession *)session
+                          task:(NSURLSessionTask *)task
+    willPerformHTTPRedirection:(NSHTTPURLResponse *)response
+                    newRequest:(NSURLRequest *)request
+             completionHandler:(void (^)(NSURLRequest * _Nullable))completionHandler
+{
+  [self.client URLProtocol:self wasRedirectedToRequest:request redirectResponse:response];
+  completionHandler(nil);
+}
+
+- (void)URLSession:(NSURLSession *)session
+          dataTask:(NSURLSessionDataTask *)dataTask
+didReceiveResponse:(NSURLResponse *)response
+ completionHandler:(void (^)(NSURLSessionResponseDisposition))completionHandler
+{
+  [self.client URLProtocol:self didReceiveResponse:response cacheStoragePolicy:NSURLCacheStorageNotAllowed];
+  completionHandler(NSURLSessionResponseAllow);
+}
+
+- (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data
+{
+  [self.client URLProtocol:self didLoadData:data];
+}
+
+- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error
+{
+  if (error) {
+    [self.client URLProtocol:self didFailWithError:error];
+  } else {
+    [self.client URLProtocolDidFinishLoading:self];
+  }
+}
+
+@end
+
+@interface OneKeyNetworkThrottleInstaller : NSObject
+@end
+
+@implementation OneKeyNetworkThrottleInstaller
+
++ (void)load
+{
+  RCTSetCustomNSURLSessionConfigurationProvider(^NSURLSessionConfiguration *{
+    NSURLSessionConfiguration *configuration = [NSURLSessionConfiguration defaultSessionConfiguration];
+    NSNumber *useWifiOnly = [[NSBundle mainBundle].infoDictionary objectForKey:@"ReactNetworkForceWifiOnly"];
+    if (useWifiOnly) {
+      configuration.allowsCellularAccess = ![useWifiOnly boolValue];
+    }
+    configuration.HTTPShouldSetCookies = YES;
+    configuration.HTTPCookieAcceptPolicy = NSHTTPCookieAcceptPolicyAlways;
+    configuration.HTTPCookieStorage = [NSHTTPCookieStorage sharedHTTPCookieStorage];
+
+    NSArray<Class> *existingProtocolClasses = configuration.protocolClasses ?: @[];
+    if (![existingProtocolClasses containsObject:[OneKeyNetworkThrottleURLProtocol class]]) {
+      configuration.protocolClasses = [[@[ [OneKeyNetworkThrottleURLProtocol class] ] arrayByAddingObjectsFromArray:existingProtocolClasses] copy];
+    }
+    return configuration;
+  });
+}
+
+@end
+
+@interface OneKeyNetworkThrottle : NSObject <RCTBridgeModule>
+@end
+
+@implementation OneKeyNetworkThrottle
+
+RCT_EXPORT_MODULE(OneKeyNetworkThrottle)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+RCT_REMAP_METHOD(getConfig, getConfigWithResolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+{
+  resolve([OneKeyNetworkThrottleState currentConfig]);
+}
+
+RCT_REMAP_METHOD(setConfig, setConfig:(NSDictionary *)config resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+{
+  BOOL enabled = [config[@"enabled"] boolValue];
+  NSNumber *latencyValue = config[@"latencyMs"];
+  NSTimeInterval latencyMs = latencyValue != nil ? [latencyValue doubleValue] : OneKeyNetworkThrottleDefaultLatencyMs;
+  resolve([OneKeyNetworkThrottleState setEnabled:enabled latencyMs:latencyMs]);
+}
+
+@end

package/lib/module/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import { NativeModules, Platform } from 'react-native';
+export const NETWORK_THROTTLE_SLOW_4G_LATENCY_MS = 562.5;
+const LINKING_ERROR = `The package '@onekeyfe/react-native-network-throttle' doesn't seem to be linked. ` + Platform.select({
+  ios: "- run 'pod install'\n",
+  default: ''
+}) + '- rebuild the app after installing the package';
+const nativeModule = NativeModules.OneKeyNetworkThrottle;
+export const NetworkThrottle = nativeModule ? nativeModule : new Proxy({}, {
+  get() {
+    throw new Error(LINKING_ERROR);
+  }
+});
+export default NetworkThrottle;
+//# sourceMappingURL=index.js.map

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

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

@@ -0,0 +1,14 @@
+export type NetworkThrottleProfile = 'slow4g';
+export type NetworkThrottleConfig = {
+    enabled: boolean;
+    profile: NetworkThrottleProfile;
+    latencyMs: number;
+};
+export declare const NETWORK_THROTTLE_SLOW_4G_LATENCY_MS = 562.5;
+type NativeNetworkThrottleModule = {
+    getConfig: () => Promise<NetworkThrottleConfig>;
+    setConfig: (config: Partial<NetworkThrottleConfig>) => Promise<NetworkThrottleConfig>;
+};
+export declare const NetworkThrottle: NativeNetworkThrottleModule;
+export default NetworkThrottle;
+//# sourceMappingURL=index.d.ts.map

package/package.json

@@ -0,0 +1,146 @@
+{
+  "name": "@onekeyfe/react-native-network-throttle",
+  "version": "3.0.69",
+  "description": "react-native-network-throttle",
+  "main": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.tsx",
+      "types": "./lib/typescript/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "*.podspec",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*",
+    "!**/*.map"
+  ],
+  "scripts": {
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
+    "prepare": "bob build",
+    "typecheck": "tsc",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "test": "jest",
+    "release": "yarn prepare && npm whoami && npm publish --access public"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android",
+    "network",
+    "throttle"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneKeyHQ/app-modules/react-native-network-throttle.git"
+  },
+  "author": "@onekeyhq <huanming@onekey.so> (https://github.com/OneKeyHQ/app-modules)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/OneKeyHQ/app-modules/react-native-network-throttle/issues"
+  },
+  "homepage": "https://github.com/OneKeyHQ/app-modules/react-native-network-throttle#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/compat": "^1.3.2",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.35.0",
+    "@react-native/babel-preset": "0.83.0",
+    "@react-native/eslint-config": "0.83.0",
+    "@release-it/conventional-changelog": "^10.0.1",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^19.2.0",
+    "commitlint": "^19.8.1",
+    "del-cli": "^6.0.0",
+    "eslint": "^9.35.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "jest": "^29.7.0",
+    "lefthook": "^2.0.3",
+    "prettier": "^2.8.8",
+    "react": "19.2.0",
+    "react-native": "patch:react-native@npm%3A0.83.0#~/.yarn/patches/react-native-npm-0.83.0-577d0f2d83.patch",
+    "react-native-builder-bob": "^0.40.17",
+    "release-it": "^19.0.4",
+    "turbo": "^2.5.6",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}"
+    },
+    "npm": {
+      "publish": true
+    },
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        }
+      }
+    }
+  }
+}

package/src/index.tsx

@@ -0,0 +1,40 @@
+import { NativeModules, Platform } from 'react-native';
+
+export type NetworkThrottleProfile = 'slow4g';
+
+export type NetworkThrottleConfig = {
+  enabled: boolean;
+  profile: NetworkThrottleProfile;
+  latencyMs: number;
+};
+
+export const NETWORK_THROTTLE_SLOW_4G_LATENCY_MS = 562.5;
+
+type NativeNetworkThrottleModule = {
+  getConfig: () => Promise<NetworkThrottleConfig>;
+  setConfig: (
+    config: Partial<NetworkThrottleConfig>
+  ) => Promise<NetworkThrottleConfig>;
+};
+
+const LINKING_ERROR =
+  `The package '@onekeyfe/react-native-network-throttle' doesn't seem to be linked. ` +
+  Platform.select({ ios: "- run 'pod install'\n", default: '' }) +
+  '- rebuild the app after installing the package';
+
+const nativeModule = NativeModules.OneKeyNetworkThrottle as
+  | NativeNetworkThrottleModule
+  | undefined;
+
+export const NetworkThrottle: NativeNetworkThrottleModule = nativeModule
+  ? nativeModule
+  : (new Proxy(
+      {},
+      {
+        get() {
+          throw new Error(LINKING_ERROR);
+        },
+      }
+    ) as NativeNetworkThrottleModule);
+
+export default NetworkThrottle;