Mirror/robosats
1
0
Fork 0
mirror of https://github.com/RoboSats/robosats.git synced 2024-12-13 10:56:24 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #1208 from KoalaSat/new-tor-engine

Browse Source 
New tor engine
This commit is contained in:
Reckless_Satoshi 2024-03-29 02:18:11 +00:00 committed by GitHub
commit d77a066bd9
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
25 changed files with 709 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
frontend/src/basic/RobotPage/index.tsx
View File

@ -44,7 +44,7 @@ const RobotPage = (): JSX.Element => {
const token = urlToken ?? garage.currentSlot;
if (token !== undefined && token !== null && page === 'robot') {
setInputToken(token);
if (window.NativeRobosats === undefined || torStatus === '"Done"') {
if (window.NativeRobosats === undefined || torStatus === 'ON') {
getGenerateRobot(token);
setView('profile');
}
@ -83,7 +83,7 @@ const RobotPage = (): JSX.Element => {
garage.deleteSlot();
};
if (!(window.NativeRobosats === undefined) && !(torStatus === 'DONE' || torStatus === '"Done"')) {
if (!(window.NativeRobosats === undefined) && !(torStatus === 'ON')) {
return (
<Paper
elevation={12}

1
frontend/src/components/RobotInfo/index.tsx
View File

@ -95,7 +95,6 @@ const RobotInfo: React.FC<Props> = ({ coordinator, onClose, disabled }: Props) =
(signedInvoice) => {
console.log('Signed message:', signedInvoice);
void coordinator.fetchReward(signedInvoice, garage, slot?.token).then((data) => {
console.log(data);
setBadInvoice(data.bad_invoice ?? '');
setShowRewardsSpinner(false);
setWithdrawn(data.successful_withdrawal);

1
frontend/src/components/SettingsForm/index.tsx
View File

@ -226,7 +226,6 @@ const SettingsForm = ({ dense = false }: SettingsFormProps): JSX.Element => {
value={settings.network}
onChange={(e, network) => {
setSettings({ ...settings, network });
void federation.updateUrls(origin, { ...settings, network }, hostUrl);
systemClient.setItem('settings_network', network);
}}
>

4
frontend/src/components/TorConnection.tsx
View File

@ -62,7 +62,7 @@ const TorConnectionBadge = (): JSX.Element => {
return <></>;
}
if (torStatus === 'NOTINIT') {
if (torStatus === 'OFF' || torStatus === 'STOPPING') {
return (
<TorIndicator
color='primary'
@ -80,7 +80,7 @@ const TorConnectionBadge = (): JSX.Element => {
title={t('Connecting to TOR network')}
/>
);
} else if (torStatus === '"Done"' || torStatus === 'DONE') {
} else if (torStatus === 'ON') {
return <TorIndicator color='success' progress={false} title={t('Connected to TOR network')} />;
} else {
return (

4
frontend/src/components/TorConnection/index.tsx
View File

@ -62,7 +62,7 @@ const TorConnectionBadge = (): JSX.Element => {
return <></>;
}
if (torStatus === 'NOTINIT') {
if (torStatus === 'OFF' || torStatus === 'STOPING') {
return (
<TorIndicator
color='primary'
@ -80,7 +80,7 @@ const TorConnectionBadge = (): JSX.Element => {
title={t('Connecting to TOR network')}
/>
);
} else if (torStatus === '"Done"' || torStatus === 'DONE') {
} else if (torStatus === 'ON') {
return <TorIndicator color='success' progress={false} title={t('Connected to TOR network')} />;
} else {
return (

6
frontend/src/contexts/AppContext.tsx
View File

@ -34,7 +34,7 @@ export interface SlideDirection {
out: 'left' | 'right' | undefined;
}
export type TorStatus = 'NOTINIT' | 'STARTING' | '"Done"' | 'DONE';
export type TorStatus = 'ON' | 'STARTING' | 'STOPPING' | 'OFF';
export const isNativeRoboSats = !(window.NativeRobosats === undefined);
@ -139,7 +139,7 @@ export interface UseAppStoreType {
export const initialAppContext: UseAppStoreType = {
theme: undefined,
torStatus: 'NOTINIT',
torStatus: 'STARTING',
settings: new Settings(),
setSettings: () => {},
page: entryPage,
@ -209,7 +209,7 @@ export const AppContextProvider = ({ children }: AppContextProviderProps): JSX.E
() => {
setTorStatus(event?.detail);
},
event?.detail === '"Done"' ? 5000 : 0,
event?.detail === 'ON' ? 5000 : 0,
);
});
}, []);

26
frontend/src/contexts/FederationContext.tsx
View File

@ -9,12 +9,13 @@ import React, {
type ReactNode,
} from 'react';
import { type Order, Federation } from '../models';
import { type Order, Federation, Settings } from '../models';
import { federationLottery } from '../utils';
import { AppContext, type UseAppStoreType } from './AppContext';
import { GarageContext, type UseGarageStoreType } from './GarageContext';
import NativeRobosats from '../services/Native';
// Refresh delays (ms) according to Order status
const defaultDelay = 5000;
@ -61,7 +62,7 @@ export interface UseFederationStoreType {
}
export const initialFederationContext: UseFederationStoreType = {
federation: new Federation(),
federation: new Federation('onion', new Settings(), ''),
sortedCoordinators: [],
setDelay: () => {},
currentOrderId: { id: null, shortAlias: null },
@ -79,7 +80,7 @@ export const FederationContextProvider = ({
const { settings, page, origin, hostUrl, open, torStatus } =
useContext<UseAppStoreType>(AppContext);
const { setMaker, garage, setBadOrder } = useContext<UseGarageStoreType>(GarageContext);
const [federation, setFederation] = useState(initialFederationContext.federation);
const [federation] = useState(new Federation(origin, settings, hostUrl));
const sortedCoordinators = useMemo(() => federationLottery(federation), []);
const [coordinatorUpdatedAt, setCoordinatorUpdatedAt] = useState<string>(
new Date().toISOString(),
@ -101,19 +102,20 @@ export const FederationContextProvider = ({
setMaker((maker) => {
return { ...maker, coordinator: sortedCoordinators[0] };
}); // default MakerForm coordinator is decided via sorted lottery
federation.registerHook('onFederationUpdate', () => {
setFederationUpdatedAt(new Date().toISOString());
});
federation.registerHook('onCoordinatorUpdate', () => {
setCoordinatorUpdatedAt(new Date().toISOString());
});
}, []);
useEffect(() => {
// On bitcoin network change we reset book, limits and federation info and fetch everything again
const newFed = initialFederationContext.federation;
newFed.registerHook('onFederationUpdate', () => {
setFederationUpdatedAt(new Date().toISOString());
});
newFed.registerHook('onCoordinatorUpdate', () => {
setCoordinatorUpdatedAt(new Date().toISOString());
});
void newFed.start(origin, settings, hostUrl);
setFederation(newFed);
if (window.NativeRobosats === undefined || torStatus === 'ON') {
void federation.updateUrl(origin, settings, hostUrl);
void federation.update();
}
}, [settings.network, torStatus]);
const onOrderReceived = (order: Order): void => {

25
frontend/src/models/Coordinator.model.ts
View File

@ -97,7 +97,7 @@ function calculateSizeLimit(inputDate: Date): number {
}
export class Coordinator {
constructor(value: any) {
constructor(value: any, origin: Origin, settings: Settings, hostUrl: string) {
const established = new Date(value.established);
this.longAlias = value.longAlias;
this.shortAlias = value.shortAlias;
@ -115,6 +115,8 @@ export class Coordinator {
this.testnetNodesPubkeys = value.testnetNodesPubkeys;
this.url = '';
this.basePath = '';
this.updateUrl(origin, settings, hostUrl);
}
// These properties are loaded from federation.json
@ -145,22 +147,7 @@ export class Coordinator {
public loadingLimits: boolean = false;
public loadingRobot: boolean = true;
start = async (
origin: Origin,
settings: Settings,
hostUrl: string,
onUpdate: (shortAlias: string) => void = () => {},
): Promise<void> => {
if (this.enabled !== true) return;
void this.updateUrl(settings, origin, hostUrl, onUpdate);
};
updateUrl = async (
settings: Settings,
origin: Origin,
hostUrl: string,
onUpdate: (shortAlias: string) => void = () => {},
): Promise<void> => {
updateUrl = (origin: Origin, settings: Settings, hostUrl: string): void => {
if (settings.selfhostedClient && this.shortAlias !== 'local') {
this.url = hostUrl;
this.basePath = `/${settings.network}/${this.shortAlias}`;
@ -168,9 +155,6 @@ export class Coordinator {
this.url = String(this[settings.network][origin]);
this.basePath = '';
}
void this.update(() => {
onUpdate(this.shortAlias);
});
};
update = async (onUpdate: (shortAlias: string) => void = () => {}): Promise<void> => {
@ -370,7 +354,6 @@ export class Coordinator {
return await apiClient
.get(this.url, `${this.basePath}/api/order/?order_id=${orderId}`, authHeaders)
.then((data) => {
console.log('data', data);
const order: Order = {
...defaultOrder,
...data,

48
frontend/src/models/Federation.model.ts
View File

@ -14,14 +14,14 @@ import { updateExchangeInfo } from './Exchange.model';
type FederationHooks = 'onCoordinatorUpdate' | 'onFederationUpdate';
export class Federation {
constructor() {
constructor(origin: Origin, settings: Settings, hostUrl: string) {
this.coordinators = Object.entries(defaultFederation).reduce(
(acc: Record<string, Coordinator>, [key, value]: [string, any]) => {
if (getHost() !== '127.0.0.1:8000' && key === 'local') {
// Do not add `Local Dev` unless it is running on localhost
return acc;
} else {
acc[key] = new Coordinator(value);
acc[key] = new Coordinator(value, origin, settings, hostUrl);
return acc;
}
},
@ -36,7 +36,16 @@ export class Federation {
onCoordinatorUpdate: [],
onFederationUpdate: [],
};
this.loading = true;
this.exchange.loadingCoordinators = Object.keys(this.coordinators).length;
const host = getHost();
const url = `${window.location.protocol}//${host}`;
const tesnetHost = Object.values(this.coordinators).find((coor) => {
return Object.values(coor.testnet).includes(url);
});
if (tesnetHost) settings.network = 'testnet';
}
public coordinators: Record<string, Coordinator>;
@ -69,38 +78,10 @@ export class Federation {
this.triggerHook('onFederationUpdate');
};
// Setup
start = async (origin: Origin, settings: Settings, hostUrl: string): Promise<void> => {
const onCoordinatorStarted = (): void => {
this.exchange.onlineCoordinators = this.exchange.onlineCoordinators + 1;
this.onCoordinatorSaved();
};
this.loading = true;
this.exchange.loadingCoordinators = Object.keys(this.coordinators).length;
const host = getHost();
const url = `${window.location.protocol}//${host}`;
const tesnetHost = Object.values(this.coordinators).find((coor) => {
return Object.values(coor.testnet).includes(url);
});
if (tesnetHost) settings.network = 'testnet';
updateUrl = async (origin: Origin, settings: Settings, hostUrl: string): Promise<void> => {
for (const coor of Object.values(this.coordinators)) {
if (coor.enabled) {
await coor.start(origin, settings, hostUrl, onCoordinatorStarted);
}
coor.updateUrl(origin, settings, hostUrl);
}
this.updateEnabledCoordinators();
};
// On Testnet/Mainnet change
updateUrls = async (origin: Origin, settings: Settings, hostUrl: string): Promise<void> => {
this.loading = true;
for (const coor of Object.values(this.coordinators)) {
await coor.updateUrl(settings, origin, hostUrl);
}
this.loading = false;
};
update = async (): Promise<void> => {
@ -115,9 +96,12 @@ export class Federation {
lifetime_volume: 0,
version: { major: 0, minor: 0, patch: 0 },
};
this.exchange.onlineCoordinators = 0;
this.exchange.loadingCoordinators = Object.keys(this.coordinators).length;
this.updateEnabledCoordinators();
for (const coor of Object.values(this.coordinators)) {
await coor.update(() => {
this.exchange.onlineCoordinators = this.exchange.onlineCoordinators + 1;
this.onCoordinatorSaved();
});
}

2
frontend/src/services/Native/index.d.ts vendored
View File

@ -14,7 +14,7 @@ export interface ReactNativeWebView {
export interface NativeWebViewMessageHttp {
id?: number;
category: 'http';
type: 'post' | 'get' | 'put' | 'delete' | 'xhr';
type: 'post' | 'get' | 'put' | 'delete';
path: string;
baseUrl: string;
headers?: object;

36
frontend/src/services/api/ApiNativeClient/index.ts
View File

@ -30,6 +30,7 @@ class ApiNativeClient implements ApiClient {
};
private readonly parseResponse = (response: Record<string, any>): object => {
console.log('response', response);
if (response.headers['set-cookie'] != null) {
response.headers['set-cookie'].forEach((cookie: string) => {
const keySplit: string[] = cookie.split('=');
@ -89,41 +90,6 @@ class ApiNativeClient implements ApiClient {
headers: this.getHeaders(auth),
}).then(this.parseResponse);
};
public fileImageUrl: (baseUrl: string, path: string) => Promise<string | undefined> = async (
baseUrl,
path,
) => {
if (path === '') {
return await Promise.resolve('');
}
if (this.assetsCache[path] != null) {
return await Promise.resolve(this.assetsCache[path]);
} else if (this.assetsPromises.has(path)) {
return await this.assetsPromises.get(path);
}
this.assetsPromises.set(
path,
new Promise<string>((resolve, reject) => {
window.NativeRobosats?.postMessage({
category: 'http',
type: 'xhr',
baseUrl,
path,
})
.then((fileB64: { b64Data: string }) => {
this.assetsCache[path] = `data:image/png;base64,${fileB64.b64Data}`;
this.assetsPromises.delete(path);
resolve(this.assetsCache[path]);
})
.catch(reject);
}),
);
return await this.assetsPromises.get(path);
};
}
export default ApiNativeClient;

1
frontend/src/services/api/index.ts
View File

@ -11,7 +11,6 @@ export interface ApiClient {
put: (baseUrl: string, path: string, body: object, auth?: Auth) => Promise<object | undefined>;
get: (baseUrl: string, path: string, auth?: Auth) => Promise<object | undefined>;
delete: (baseUrl: string, path: string, auth?: Auth) => Promise<object | undefined>;
fileImageUrl?: (baseUrl: string, path: string) => Promise<string | undefined>;
}
export const apiClient: ApiClient =

60
mobile/App.tsx
View File

@ -1,23 +1,44 @@
import React, { useRef } from 'react';
import React, { useEffect, useRef } from 'react';
import { WebView, WebViewMessageEvent } from 'react-native-webview';
import { SafeAreaView, Text, Platform, Appearance } from 'react-native';
import { SafeAreaView, Text, Platform, Appearance, DeviceEventEmitter } from 'react-native';
import TorClient from './services/Tor';
import Clipboard from '@react-native-clipboard/clipboard';
import NetInfo from '@react-native-community/netinfo';
import EncryptedStorage from 'react-native-encrypted-storage';
import { name as app_name, version as app_version } from './package.json';
import TorModule from './lib/native/TorModule';
const backgroundColors = {
light: 'white',
dark: 'black',
};
export type TorStatus = 'ON' | 'STARTING' | 'STOPPING' | 'OFF';
const App = () => {
const colorScheme = Appearance.getColorScheme() ?? 'light';
const torClient = new TorClient();
const webViewRef = useRef<WebView>();
const uri = (Platform.OS === 'android' ? 'file:///android_asset/' : '') + 'Web.bundle/index.html';
useEffect(() => {
TorModule.start();
DeviceEventEmitter.addListener('TorStatus', (payload) => {
if (payload.torStatus === 'OFF') TorModule.restart();
injectMessage({
category: 'system',
type: 'torStatus',
detail: payload.torStatus,
});
});
}, []);
useEffect(() => {
const interval = setInterval(() => {
TorModule.getTorStatus();
}, 2000);
return () => clearInterval(interval);
}, []);
const injectMessageResolve = (id: string, data?: object) => {
const json = JSON.stringify(data || {});
webViewRef.current?.injectJavaScript(
@ -72,7 +93,7 @@ const App = () => {
const onMessage = async (event: WebViewMessageEvent) => {
const data = JSON.parse(event.nativeEvent.data);
if (data.category === 'http') {
sendTorStatus();
TorModule.getTorStatus();
if (data.type === 'get') {
torClient
.get(data.baseUrl, data.path, data.headers)
@ -80,7 +101,7 @@ const App = () => {
injectMessageResolve(data.id, response);
})
.catch((e) => onCatch(data.id, e))
.finally(sendTorStatus);
.finally(TorModule.getTorStatus);
} else if (data.type === 'post') {
torClient
.post(data.baseUrl, data.path, data.body, data.headers)
@ -88,7 +109,7 @@ const App = () => {
injectMessageResolve(data.id, response);
})
.catch((e) => onCatch(data.id, e))
.finally(sendTorStatus);
.finally(TorModule.getTorStatus);
} else if (data.type === 'delete') {
torClient
.delete(data.baseUrl, data.path, data.headers)
@ -96,15 +117,7 @@ const App = () => {
injectMessageResolve(data.id, response);
})
.catch((e) => onCatch(data.id, e))
.finally(sendTorStatus);
} else if (data.type === 'xhr') {
torClient
.request(data.baseUrl, data.path)
.then((response: object) => {
injectMessageResolve(data.id, response);
})
.catch((e) => onCatch(data.id, e))
.finally(sendTorStatus);
.finally(TorModule.getTorStatus);
}
} else if (data.category === 'system') {
if (data.type === 'init') {
@ -132,23 +145,6 @@ const App = () => {
} catch (error) {}
};
const sendTorStatus = async (event?: any) => {
NetInfo.fetch().then(async (state) => {
let daemonStatus = 'ERROR';
if (state.isInternetReachable) {
try {
daemonStatus = await torClient.daemon.getDaemonStatus();
} catch {}
}
injectMessage({
category: 'system',
type: 'torStatus',
detail: daemonStatus,
});
});
};
return (
<SafeAreaView style={{ flex: 1, backgroundColor: backgroundColors[colorScheme] }}>
<WebView

7
mobile/android/app/build.gradle
View File

@ -271,6 +271,7 @@ android {
packagingOptions {
// Make sure libjsc.so does not packed in APK
exclude "**/libjsc.so"
jniLibs.useLegacyPackaging = true
}
}
@ -282,7 +283,9 @@ dependencies {
implementation "androidx.swiperefreshlayout:swiperefreshlayout:1.0.0"
implementation files("../../node_modules/react-native-tor/android/libs/sifir_android.aar")
implementation "io.matthewnelson.kotlin-components:kmp-tor:4.8.6-0-1.4.4"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.2"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.2"
if (enableHermes) {
//noinspection GradleDynamicVersion
@ -326,3 +329,5 @@ def isNewArchitectureEnabled() {
// - Set an environment variable `ORG_GRADLE_PROJECT_newArchEnabled=true`
return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
}
apply plugin: 'kotlin-android'

4
mobile/android/app/src/main/AndroidManifest.xml
View File

@ -10,7 +10,9 @@
android:roundIcon="@mipmap/ic_launcher_round"
android:allowBackup="false"
android:usesCleartextTraffic="true"
android:theme="@style/AppTheme">
android:theme="@style/AppTheme"
android:extractNativeLibs="true"
>
<activity
android:name=".MainActivity"
android:label="@string/app_name"

5
mobile/android/app/src/main/java/com/robosats/MainApplication.java
View File

@ -1,17 +1,14 @@
package com.robosats;
import android.app.Application;
import android.content.Context;
import com.facebook.react.PackageList;
import com.facebook.react.ReactApplication;
import com.facebook.react.ReactInstanceManager;
import com.facebook.react.ReactNativeHost;
import com.facebook.react.ReactPackage;
import com.facebook.react.config.ReactFeatureFlags;
import com.facebook.soloader.SoLoader;
import android.webkit.WebView;
import com.robosats.newarchitecture.MainApplicationReactNativeHost;
import java.lang.reflect.InvocationTargetException;
import java.util.List;
public class MainApplication extends Application implements ReactApplication {
@ -29,6 +26,8 @@ public class MainApplication extends Application implements ReactApplication {
List<ReactPackage> packages = new PackageList(this).getPackages();
// Packages that cannot be autolinked yet can be added manually here, for example:
// packages.add(new MyReactNativePackage());
packages.add(new RobosatsPackage());
return packages;
}

28
mobile/android/app/src/main/java/com/robosats/RobosatsPackage.java Normal file
View File

@ -0,0 +1,28 @@
package com.robosats;
import com.facebook.react.ReactPackage;
import com.facebook.react.bridge.NativeModule;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.uimanager.ViewManager;
import com.robosats.modules.TorModule;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class RobosatsPackage implements ReactPackage {
@Override
public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
return Collections.emptyList();
}
@Override
public List<NativeModule> createNativeModules(
ReactApplicationContext reactContext) {
List<NativeModule> modules = new ArrayList<>();
modules.add(new TorModule(reactContext));
return modules;
}
}

164
mobile/android/app/src/main/java/com/robosats/modules/TorModule.java Normal file
View File

@ -0,0 +1,164 @@
package com.robosats.modules;
import android.util.Log;
import androidx.annotation.NonNull;
import com.facebook.react.bridge.Arguments;
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.WritableMap;
import com.facebook.react.modules.core.DeviceEventManagerModule;
import com.robosats.tor.TorKmpManager;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.IOException;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
public class TorModule extends ReactContextBaseJavaModule {
private TorKmpManager torKmpManager;
private ReactApplicationContext context;
public TorModule(ReactApplicationContext reactContext) {
context = reactContext;
}
@Override
public String getName() {
return "TorModule";
}
@ReactMethod
public void sendRequest(String action, String url, String headers, String body, final Promise promise) throws JSONException {
Log.d("RobosatsUrl", url);
OkHttpClient client = new OkHttpClient.Builder()
.connectTimeout(60, TimeUnit.SECONDS) // Set connection timeout
.readTimeout(30, TimeUnit.SECONDS) // Set read timeout
.proxy(torKmpManager.getProxy()).build();
Request.Builder requestBuilder = new Request.Builder().url(url);
JSONObject headersObject = new JSONObject(headers);
headersObject.keys().forEachRemaining(key -> {
String value = headersObject.optString(key);
requestBuilder.addHeader(key, value);
});
if (Objects.equals(action, "DELETE")) {
requestBuilder.delete();
} else if (Objects.equals(action, "POST")) {
RequestBody requestBody = RequestBody.create(body, MediaType.get("application/json; charset=utf-8"));
requestBuilder.post(requestBody);
} else {
requestBuilder.get();
}
Request request = requestBuilder.build();
client.newCall(request).enqueue(new Callback() {
@Override
public void onFailure(@NonNull Call call, @NonNull IOException e) {
Log.d("RobosatsError", e.toString());
}
@Override
public void onResponse(Call call, Response response) throws IOException {
Log.d("RobosatsCode", String.valueOf(response.code()));
String body = response.body() != null ? response.body().string() : "{}";
JSONObject headersJson = new JSONObject();
response.headers().names().forEach(name -> {
try {
headersJson.put(name, response.header(name));
} catch (JSONException e) {
throw new RuntimeException(e);
}
});
if (response.code() != 200 && response.code() != 201) {
Log.d("RobosatsError", "Request error code: " + response.code());
} else if (response.isSuccessful()) {
promise.resolve("{\"json\":" + body + ", \"headers\": " + headersJson +"}");
}
}
});
}
@ReactMethod
public void getTorStatus() {
String torState = torKmpManager.getTorState().getState().name();
WritableMap payload = Arguments.createMap();
payload.putString("torStatus", torState);
context
.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
.emit("TorStatus", payload);
}
@ReactMethod
public void isConnected() {
String isConnected = String.valueOf(torKmpManager.isConnected());
WritableMap payload = Arguments.createMap();
payload.putString("isConnected", isConnected);
context
.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
.emit("TorIsConnected", payload);
}
@ReactMethod
public void isStarting() {
String isStarting = String.valueOf(torKmpManager.isStarting());
WritableMap payload = Arguments.createMap();
payload.putString("isStarting", isStarting);
context
.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
.emit("TorIsStarting", payload);
}
@ReactMethod
public void stop() {
torKmpManager.getTorOperationManager().stopQuietly();
WritableMap payload = Arguments.createMap();
context
.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
.emit("TorStop", payload);
}
@ReactMethod
public void start() {
torKmpManager = new TorKmpManager(context.getCurrentActivity().getApplication());
torKmpManager.getTorOperationManager().startQuietly();
WritableMap payload = Arguments.createMap();
context
.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
.emit("TorStart", payload);
}
@ReactMethod
public void restart() {
torKmpManager = new TorKmpManager(context.getCurrentActivity().getApplication());
torKmpManager.getTorOperationManager().restartQuietly();
WritableMap payload = Arguments.createMap();
context
.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
.emit("TorRestart", payload);
}
@ReactMethod
public void newIdentity() {
torKmpManager.newIdentity(context.getCurrentActivity().getApplication());
WritableMap payload = Arguments.createMap();
context
.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
.emit("TorNewIdentity", payload);
}
}

8
mobile/android/app/src/main/java/com/robosats/tor/EnumTorState.kt Normal file
View File

@ -0,0 +1,8 @@
package com.robosats.tor
enum class EnumTorState {
STARTING,
ON,
STOPPING,
OFF
}

389
mobile/android/app/src/main/java/com/robosats/tor/TorKmpManager.kt Normal file
View File

@ -0,0 +1,389 @@
package com.robosats.tor
import android.app.Application
import android.util.Log
import android.widget.Toast
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import io.matthewnelson.kmp.tor.KmpTorLoaderAndroid
import io.matthewnelson.kmp.tor.TorConfigProviderAndroid
import io.matthewnelson.kmp.tor.common.address.*
import io.matthewnelson.kmp.tor.controller.common.config.TorConfig
import io.matthewnelson.kmp.tor.controller.common.config.TorConfig.Option.*
import io.matthewnelson.kmp.tor.controller.common.config.TorConfig.Setting.*
import io.matthewnelson.kmp.tor.controller.common.control.usecase.TorControlInfoGet
import io.matthewnelson.kmp.tor.controller.common.control.usecase.TorControlSignal
import io.matthewnelson.kmp.tor.controller.common.events.TorEvent
import io.matthewnelson.kmp.tor.manager.TorManager
import io.matthewnelson.kmp.tor.manager.TorServiceConfig
import io.matthewnelson.kmp.tor.manager.common.TorControlManager
import io.matthewnelson.kmp.tor.manager.common.TorOperationManager
import io.matthewnelson.kmp.tor.manager.common.event.TorManagerEvent
import io.matthewnelson.kmp.tor.manager.common.state.isOff
import io.matthewnelson.kmp.tor.manager.common.state.isOn
import io.matthewnelson.kmp.tor.manager.common.state.isStarting
import io.matthewnelson.kmp.tor.manager.common.state.isStopping
import io.matthewnelson.kmp.tor.manager.R
import kotlinx.coroutines.*
import java.net.InetSocketAddress
import java.net.Proxy
class TorKmpManager(application : Application) {
private val TAG = "TorListener"
private val providerAndroid by lazy {
object : TorConfigProviderAndroid(context = application) {
override fun provide(): TorConfig {
return TorConfig.Builder {
// Set multiple ports for all of the things
val dns = Ports.Dns()
put(dns.set(AorDorPort.Value(PortProxy(9252))))
put(dns.set(AorDorPort.Value(PortProxy(9253))))
val socks = Ports.Socks()
put(socks.set(AorDorPort.Value(PortProxy(9254))))
put(socks.set(AorDorPort.Value(PortProxy(9255))))
val http = Ports.HttpTunnel()
put(http.set(AorDorPort.Value(PortProxy(9258))))
put(http.set(AorDorPort.Value(PortProxy(9259))))
val trans = Ports.Trans()
put(trans.set(AorDorPort.Value(PortProxy(9262))))
put(trans.set(AorDorPort.Value(PortProxy(9263))))
// If a port (9263) is already taken (by ^^^^ trans port above)
// this will take its place and "overwrite" the trans port entry
// because port 9263 is taken.
put(socks.set(AorDorPort.Value(PortProxy(9263))))
// Set Flags
socks.setFlags(setOf(
Ports.Socks.Flag.OnionTrafficOnly
)).setIsolationFlags(setOf(
Ports.IsolationFlag.IsolateClientAddr,
)).set(AorDorPort.Value(PortProxy(9264)))
put(socks)
// reset our socks object to defaults
socks.setDefault()
// Not necessary, as if ControlPort is missing it will be
// automatically added for you; but for demonstration purposes...
// put(Ports.Control().set(AorDorPort.Auto))
// Use a UnixSocket instead of TCP for the ControlPort.
//
// A unix domain socket will always be preferred on Android
// if neither Ports.Control or UnixSockets.Control are provided.
put(UnixSockets.Control().set(FileSystemFile(
workDir.builder {
// Put the file in the "data" directory
// so that we avoid any directory permission
// issues.
//
// Note that DataDirectory is automatically added
// for you if it is not present in your provided
// config. If you set a custom Path for it, you
// should use it here.
addSegment(DataDirectory.DEFAULT_NAME)
addSegment(UnixSockets.Control.DEFAULT_NAME)
}
)))
// Use a UnixSocket instead of TCP for the SocksPort.
put(UnixSockets.Socks().set(FileSystemFile(
workDir.builder {
// Put the file in the "data" directory
// so that we avoid any directory permission
// issues.
//
// Note that DataDirectory is automatically added
// for you if it is not present in your provided
// config. If you set a custom Path for it, you
// should use it here.
addSegment(DataDirectory.DEFAULT_NAME)
addSegment(UnixSockets.Socks.DEFAULT_NAME)
}
)))
// For Android, disabling & reducing connection padding is
// advisable to minimize mobile data usage.
put(ConnectionPadding().set(AorTorF.False))
put(ConnectionPaddingReduced().set(TorF.True))
// Tor default is 24h. Reducing to 10 min helps mitigate
// unnecessary mobile data usage.
put(DormantClientTimeout().set(Time.Minutes(10)))
// Tor defaults this setting to false which would mean if
// Tor goes dormant, the next time it is started it will still
// be in the dormant state and will not bootstrap until being
// set to "active". This ensures that if it is a fresh start,
// dormancy will be cancelled automatically.
put(DormantCanceledByStartup().set(TorF.True))
// If planning to use v3 Client Authentication in a persistent
// manner (where private keys are saved to disk via the "Persist"
// flag), this is needed to be set.
put(ClientOnionAuthDir().set(FileSystemDir(
workDir.builder { addSegment(ClientOnionAuthDir.DEFAULT_NAME) }
)))
val hsPath = workDir.builder {
addSegment(HiddenService.DEFAULT_PARENT_DIR_NAME)
addSegment("test_service")
}
// Add Hidden services
put(HiddenService()
.setPorts(ports = setOf(
// Use a unix domain socket to communicate via IPC instead of over TCP
HiddenService.UnixSocket(virtualPort = Port(80), targetUnixSocket = hsPath.builder {
addSegment(HiddenService.UnixSocket.DEFAULT_UNIX_SOCKET_NAME)
}),
))
.setMaxStreams(maxStreams = HiddenService.MaxStreams(value = 2))
.setMaxStreamsCloseCircuit(value = TorF.True)
.set(FileSystemDir(path = hsPath))
)
put(HiddenService()
.setPorts(ports = setOf(
HiddenService.Ports(virtualPort = Port(80), targetPort = Port(1030)), // http
HiddenService.Ports(virtualPort = Port(443), targetPort = Port(1030)) // https
))
.set(FileSystemDir(path =
workDir.builder {
addSegment(HiddenService.DEFAULT_PARENT_DIR_NAME)
addSegment("test_service_2")
}
))
)
}.build()
}
}
}
private val loaderAndroid by lazy {
KmpTorLoaderAndroid(provider = providerAndroid)
}
private val manager: TorManager by lazy {
TorManager.newInstance(application = application, loader = loaderAndroid, requiredEvents = null)
}
// only expose necessary interfaces
val torOperationManager: TorOperationManager get() = manager
val torControlManager: TorControlManager get() = manager
private val listener = TorListener()
val events: LiveData<String> get() = listener.eventLines
private val appScope by lazy {
CoroutineScope(Dispatchers.Main.immediate + SupervisorJob())
}
val torStateLiveData: MutableLiveData<TorState> = MutableLiveData()
get() = field
var torState: TorState = TorState()
get() = field
var proxy: Proxy? = null
get() = field
init {
manager.debug(true)
manager.addListener(listener)
listener.addLine(TorServiceConfig.getMetaData(application).toString())
}
fun isConnected(): Boolean {
return manager.state.isOn() && manager.state.bootstrap >= 100
}
fun isStarting(): Boolean {
return manager.state.isStarting() ||
(manager.state.isOn() && manager.state.bootstrap < 100);
}
fun newIdentity(appContext: Application) {
appScope.launch {
val result = manager.signal(TorControlSignal.Signal.NewNym)
result.onSuccess {
if (it !is String) {
listener.addLine(TorControlSignal.NEW_NYM_SUCCESS)
Toast.makeText(appContext, TorControlSignal.NEW_NYM_SUCCESS, Toast.LENGTH_SHORT).show()
return@onSuccess
}
val post: String? = when {
it.startsWith(TorControlSignal.NEW_NYM_RATE_LIMITED) -> {
// Rate limiting NEWNYM request: delaying by 8 second(s)
val seconds: Int? = it.drop(TorControlSignal.NEW_NYM_RATE_LIMITED.length)
.substringBefore(' ')
.toIntOrNull()
if (seconds == null) {
it
} else {
appContext.getString(
R.string.kmp_tor_newnym_rate_limited,
seconds
)
}
}
it == TorControlSignal.NEW_NYM_SUCCESS -> {
appContext.getString(R.string.kmp_tor_newnym_success)
}
else -> {
null
}
}
if (post != null) {
listener.addLine(post)
Toast.makeText(appContext, post, Toast.LENGTH_SHORT).show()
}
}
result.onFailure {
val msg = "Tor identity change failed"
listener.addLine(msg)
Toast.makeText(appContext, msg, Toast.LENGTH_SHORT).show()
}
}
}
private inner class TorListener: TorManagerEvent.Listener() {
private val _eventLines: MutableLiveData<String> = MutableLiveData("")
val eventLines: LiveData<String> = _eventLines
private val events: MutableList<String> = ArrayList(50)
fun addLine(line: String) {
synchronized(this) {
if (events.size > 49) {
events.removeAt(0)
}
events.add(line)
//Log.i(TAG, line)
//_eventLines.value = events.joinToString("\n")
_eventLines.postValue(events.joinToString("\n"))
}
}
override fun onEvent(event: TorManagerEvent) {
if (event is TorManagerEvent.State) {
val stateEvent: TorManagerEvent.State = event
val state = stateEvent.torState
torState.progressIndicator = state.bootstrap
val liveTorState = TorState()
liveTorState.progressIndicator = state.bootstrap
if (state.isOn()) {
if (state.bootstrap >= 100) {
torState.state = EnumTorState.ON
liveTorState.state = EnumTorState.ON
} else {
torState.state = EnumTorState.STARTING
liveTorState.state = EnumTorState.STARTING
}
} else if (state.isStarting()) {
torState.state = EnumTorState.STARTING
liveTorState.state = EnumTorState.STARTING
} else if (state.isOff()) {
torState.state = EnumTorState.OFF
liveTorState.state = EnumTorState.OFF
} else if (state.isStopping()) {
torState.state = EnumTorState.STOPPING
liveTorState.state = EnumTorState.STOPPING
}
torStateLiveData.postValue(liveTorState)
}
addLine(event.toString())
super.onEvent(event)
}
override fun onEvent(event: TorEvent.Type.SingleLineEvent, output: String) {
addLine("$event - $output")
super.onEvent(event, output)
}
override fun onEvent(event: TorEvent.Type.MultiLineEvent, output: List<String>) {
addLine("multi-line event: $event. See Logs.")
// these events are many many many lines and should be moved
// off the main thread if ever needed to be dealt with.
val enabled = false
if (enabled) {
appScope.launch(Dispatchers.IO) {
Log.d(TAG, "-------------- multi-line event START: $event --------------")
for (line in output) {
Log.d(TAG, line)
}
Log.d(TAG, "--------------- multi-line event END: $event ---------------")
}
}
super.onEvent(event, output)
}
override fun managerEventError(t: Throwable) {
t.printStackTrace()
}
override fun managerEventAddressInfo(info: TorManagerEvent.AddressInfo) {
if (info.isNull) {
// Tear down HttpClient
} else {
info.socksInfoToProxyAddressOrNull()?.firstOrNull()?.let { proxyAddress ->
@Suppress("UNUSED_VARIABLE")
val socket = InetSocketAddress(proxyAddress.address.value, proxyAddress.port.value)
proxy = Proxy(Proxy.Type.SOCKS, socket)
}
}
}
override fun managerEventStartUpCompleteForTorInstance() {
// Do one-time things after we're bootstrapped
appScope.launch {
torControlManager.onionAddNew(
type = OnionAddress.PrivateKey.Type.ED25519_V3,
hsPorts = setOf(HiddenService.Ports(virtualPort = Port(443))),
flags = null,
maxStreams = null,
).onSuccess { hsEntry ->
addLine(
"New HiddenService: " +
"\n - Address: https://${hsEntry.address.canonicalHostname()}" +
"\n - PrivateKey: ${hsEntry.privateKey}"
)
torControlManager.onionDel(hsEntry.address).onSuccess {
addLine("Aaaaaaaaand it's gone...")
}.onFailure { t ->
t.printStackTrace()
}
}.onFailure { t ->
t.printStackTrace()
}
delay(20_000L)
torControlManager.infoGet(TorControlInfoGet.KeyWord.Uptime()).onSuccess { uptime ->
addLine("Uptime - $uptime")
}.onFailure { t ->
t.printStackTrace()
}
}
}
}
}

14
mobile/android/app/src/main/java/com/robosats/tor/TorState.kt Normal file
View File

@ -0,0 +1,14 @@
package com.robosats.tor
class TorState {
var state : EnumTorState = EnumTorState.OFF
get() = field
set(value) {
field = value
}
var progressIndicator : Int = 0
get() = field
set(value) {
field = value
}
}

1
mobile/android/build.gradle
View File

@ -9,7 +9,6 @@ buildscript {
compileSdkVersion = 33
targetSdkVersion = 33
kotlin_version = "1.8.21"
kotlinVersion = "1.8.21" //for react-native-tor
if (System.properties['os.arch'] == "aarch64") {
// For M1 Users we need to use the NDK 24 which added support for aarch64

17
mobile/package-lock.json generated
View File

@ -13,7 +13,6 @@
"react": "18.2.0",
"react-native": "^0.71.8",
"react-native-encrypted-storage": "^4.0.3",
"react-native-tor": "^0.1.8",
"react-native-webview": "^13.3.0"
},
"devDependencies": {
@ -4235,10 +4234,6 @@
"@sinonjs/commons": "^3.0.0"
}
},
"node_modules/@types/async": {
"version": "3.2.20",
"license": "MIT"
},
"node_modules/@types/babel__core": {
"version": "7.20.2",
"resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.2.tgz",
@ -12620,18 +12615,6 @@
"version": "0.71.18",
"license": "MIT"
},
"node_modules/react-native-tor": {
"version": "0.1.8",
"license": "MIT",
"dependencies": {
"@types/async": "^3.2.6",
"async": "^3.2.0"
},
"peerDependencies": {
"react": "*",
"react-native": "*"
}
},
"node_modules/react-native-webview": {
"version": "13.3.0",
"resolved": "https://registry.npmjs.org/react-native-webview/-/react-native-webview-13.3.0.tgz",

1
mobile/package.json
View File

@ -17,7 +17,6 @@
"react": "18.2.0",
"react-native": "^0.71.8",
"react-native-encrypted-storage": "^4.0.3",
"react-native-tor": "^0.1.8",
"react-native-webview": "^13.3.0"
},
"devDependencies": {

74
mobile/services/Tor/index.ts
View File

@ -1,29 +1,6 @@
import Tor from 'react-native-tor';
import TorModule from '../../lib/native/TorModule';
class TorClient {
daemon: ReturnType<typeof Tor>;
constructor() {
this.daemon = Tor({
stopDaemonOnBackground: false,
numberConcurrentRequests: 0,
});
}
private readonly connectDaemon: () => void = async () => {
try {
this.daemon.startIfNotStarted();
} catch {
console.log('TOR already started');
}
};
public reset: () => void = async () => {
console.log('Reset TOR');
await this.daemon.stopIfRunning();
await this.daemon.startIfNotStarted();
};
public get: (baseUrl: string, path: string, headers: object) => Promise<object> = async (
baseUrl,
path,
@ -31,9 +8,13 @@ class TorClient {
) => {
return await new Promise<object>(async (resolve, reject) => {
try {
const response = await this.daemon.get(`${baseUrl}${path}`, headers);
resolve(response);
const response = await TorModule.sendRequest(
'GET',
`${baseUrl}${path}`,
JSON.stringify(headers),
'{}',
);
resolve(JSON.parse(response));
} catch (error) {
reject(error);
}
@ -47,28 +28,13 @@ class TorClient {
) => {
return await new Promise<object>(async (resolve, reject) => {
try {
const response = await this.daemon.delete(`${baseUrl}${path}`, '', headers);
resolve(response);
} catch (error) {
reject(error);
}
});
};
public request: (baseUrl: string, path: string) => Promise<object> = async (
baseUrl: string,
path,
) => {
return await new Promise<object>(async (resolve, reject) => {
try {
const response = await this.daemon
.request(`${baseUrl}${path}`, 'GET', '', {}, true)
.then((resp) => {
resolve(resp);
});
resolve(response);
const response = await TorModule.sendRequest(
'DELETE',
`${baseUrl}${path}`,
JSON.stringify(headers),
'{}',
);
resolve(JSON.parse(response));
} catch (error) {
reject(error);
}
@ -80,9 +46,13 @@ class TorClient {
return await new Promise<object>(async (resolve, reject) => {
try {
const json = JSON.stringify(body);
const response = await this.daemon.post(`${baseUrl}${path}`, json, headers);
resolve(response);
const response = await TorModule.sendRequest(
'POST',
`${baseUrl}${path}`,
JSON.stringify(headers),
json,
);
resolve(JSON.parse(response));
} catch (error) {
reject(error);
}