DexLib is a library used by ParaSwap backend to integrate with decentralized exchanges. This library enables external DEX developers to integrate their DEX with ParaSwap by creating pull requests to this repository.

Go SDK & CLI for TRON blockchain — build wallets, exchanges, bots & backend services. gRPC client, HD wallets, Ledger support, TRC20/TRC10, multi-sig, staking.

An ONNX (Open Neural Network eXchange) API and backend for typeful, functional deep learning and classical machine learning in Scala 3

Splash, a flexible Spark shuffle manager that supports user-defined storage backends for shuffle data storage and exchange

Multi-exchange, real-time orderbook with a Go backend and a React + Vite frontend.

Coin Exchange back-end code. Coin Exchange is a high performance exchange system specialized for Crypto currency trading with different general purpose uses such as independent deposit and withdrawal channels for Bitcoin and Litecoin, and also a standalone exchange for different asset classes.

基于 Go/go-zero（REST + gRPC）的交易所后端微服务项目，按领域拆分为用户中心（ucenter）、行情中心（market）、交易/订单（exchange）与任务中心（jobcenter），并提供对应的 API 网关服务。系统使用 MySQL + MongoDB 存储业务与行情数据，Redis 做缓存，Kafka 串联异步流程与实时行情数据流。market-api 通过 Socket.IO/WebSocket 对外推送 K 线、盘口等实时数据，jobcenter 定时从 OKX 拉取行情与汇率并写入存储/推送消息

DexLib is a library used by Kyberswap backend to integrate with decentralized exchanges. This library enables external DEX developers to integrate their DEX with Kyberswap by creating pull requests to this repository.

FlexiBLAS - A BLAS and LAPACK wrapper library with runtime exchangeable backends. This is a read-only mirror of https://gitlab.mpi-magdeburg.mpg.de/software/flexiblas-release

High-performance paper trading terminal UI (React + TS + Vite). Real-time market data via API/WebSocket, mobile & desktop UX, Web Worker + Zustand + decimal precision. Frontend-only (not an exchange backend).

 [](https://search.maven.org/search?q=g:net.openid%20appauth) [](http://javadoc.io/doc/net.openid/appauth) [](https://github.com/openid/AppAuth-Android/actions/workflows/build.yml) [](https://codecov.io/github/openid/AppAuth-Android?branch=master) AppAuth for Android is a client SDK for communicating with [OAuth 2.0](https://tools.ietf.org/html/rfc6749) and [OpenID Connect](http://openid.net/specs/openid-connect-core-1_0.html) providers. It strives to directly map the requests and responses of those specifications, while following the idiomatic style of the implementation language. In addition to mapping the raw protocol flows, convenience methods are available to assist with common tasks like performing an action with fresh tokens. The library follows the best practices set out in [RFC 8252 - OAuth 2.0 for Native Apps](https://tools.ietf.org/html/rfc8252), including using [Custom Tabs](https://developer.chrome.com/multidevice/android/customtabs) for authorization requests. For this reason, `WebView` is explicitly *not* supported due to usability and security reasons. The library also supports the [PKCE](https://tools.ietf.org/html/rfc7636) extension to OAuth which was created to secure authorization codes in public clients when custom URI scheme redirects are used. The library is friendly to other extensions (standard or otherwise) with the ability to handle additional parameters in all protocol requests and responses. A talk providing an overview of using the library for enterprise single sign-on (produced by Google) can be found here: [Enterprise SSO with Chrome Custom Tabs](https://www.youtube.com/watch?v=DdQTXrk6YTk). ## Download AppAuth for Android is available on [MavenCentral](https://search.maven.org/search?q=g:net.openid%20appauth) ```groovy implementation 'net.openid:appauth:<version>' ``` ## Requirements AppAuth supports Android API 16 (Jellybean) and above. Browsers which provide a custom tabs implementation are preferred by the library, but not required. Both Custom URI Schemes (all supported versions of Android) and App Links (Android M / API 23+) can be used with the library. In general, AppAuth can work with any Authorization Server (AS) that supports native apps as documented in [RFC 8252](https://tools.ietf.org/html/rfc8252), either through custom URI scheme redirects, or App Links. AS's that assume all clients are web-based or require clients to maintain confidentiality of the client secrets may not work well. ## Demo app A demo app is contained within this repository. For instructions on how to build and configure this app, see the [demo app readme](https://github.com/openid/AppAuth-Android/blob/master/app/README.md). ## Conceptual overview AppAuth encapsulates the authorization state of the user in the [net.openid.appauth.AuthState](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthState.java) class, and communicates with an authorization server through the use of the [net.openid.appauth.AuthorizationService](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationService.java) class. AuthState is designed to be easily persistable as a JSON string, using the storage mechanism of your choice (e.g. [SharedPreferences](https://developer.android.com/training/basics/data-storage/shared-preferences.html), [sqlite](https://developer.android.com/training/basics/data-storage/databases.html), or even just [in a file](https://developer.android.com/training/basics/data-storage/files.html)). AppAuth provides data classes which are intended to model the OAuth2 specification as closely as possible; this provides the greatest flexibility in interacting with a wide variety of OAuth2 and OpenID Connect implementations. Authorizing the user occurs via the user's web browser, and the request is described using instances of [AuthorizationRequest](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationRequest.java). The request is dispatched using [performAuthorizationRequest()](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationService.java#L159) on an AuthorizationService instance, and the response (an [AuthorizationResponse](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationResponse.java) instance) will be dispatched to the activity of your choice, expressed via an Intent. Token requests, such as obtaining a new access token using a refresh token, follow a similar pattern: [TokenRequest](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/TokenRequest.java) instances are dispatched using [performTokenRequest()](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationService.java#L252) on an AuthorizationService instance, and a [TokenResponse](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/TokenResponse.java) instance is returned via a callback. Responses can be provided to the [update()](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthState.java#L367) methods on AuthState in order to track and persist changes to the authorization state. Once in an authorized state, the [performActionWithFreshTokens()](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthState.java#L449) method on AuthState can be used to automatically refresh access tokens as necessary before performing actions that require valid tokens. ## Implementing the authorization code flow It is recommended that native apps use the [authorization code](https://tools.ietf.org/html/rfc6749#section-1.3.1) flow with a public client to gain authorization to access user data. This has the primary advantage for native clients that the authorization flow, which must occur in a browser, only needs to be performed once. This flow is effectively composed of four stages: 1. Discovering or specifying the endpoints to interact with the provider. 2. Authorizing the user, via a browser, in order to obtain an authorization code. 3. Exchanging the authorization code with the authorization server, to obtain a refresh token and/or ID token. 4. Using access tokens derived from the refresh token to interact with a resource server for further access to user data. At each step of the process, an AuthState instance can (optionally) be updated with the result to help with tracking the state of the flow. ### Authorization service configuration First, AppAuth must be instructed how to interact with the authorization service. This can be done either by directly creating an [AuthorizationServiceConfiguration](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationServiceConfiguration.java#L102) instance, or by retrieving an OpenID Connect discovery document. Directly specifying an AuthorizationServiceConfiguration involves providing the URIs of the authorization endpoint and token endpoint, and optionally a dynamic client registration endpoint (see "Dynamic client registration" for more info): ```java AuthorizationServiceConfiguration serviceConfig = new AuthorizationServiceConfiguration( Uri.parse("https://idp.example.com/auth"), // authorization endpoint Uri.parse("https://idp.example.com/token")); // token endpoint ``` Where available, using an OpenID Connect discovery document is preferable: ```java AuthorizationServiceConfiguration.fetchFromIssuer( Uri.parse("https://idp.example.com"), new AuthorizationServiceConfiguration.RetrieveConfigurationCallback() { public void onFetchConfigurationCompleted( @Nullable AuthorizationServiceConfiguration serviceConfiguration, @Nullable AuthorizationException ex) { if (ex != null) { Log.e(TAG, "failed to fetch configuration"); return; } // use serviceConfiguration as needed } }); ``` This will attempt to download a discovery document from the standard location under this base URI, `https://idp.example.com/.well-known/openid-configuration`. If the discovery document for your IDP is in some other non-standard location, you can instead provide the full URI as follows: ```java AuthorizationServiceConfiguration.fetchFromUrl( Uri.parse("https://idp.example.com/exampletenant/openid-config"), new AuthorizationServiceConfiguration.RetrieveConfigurationCallback() { ... } }); ``` If desired, this configuration can be used to seed an AuthState instance, to persist the configuration easily: ```java AuthState authState = new AuthState(serviceConfig); ``` ### Obtaining an authorization code An authorization code can now be acquired by constructing an AuthorizationRequest, using its Builder. In AppAuth, the builders for each data class accept the mandatory parameters via the builder constructor: ```java AuthorizationRequest.Builder authRequestBuilder = new AuthorizationRequest.Builder( serviceConfig, // the authorization service configuration MY_CLIENT_ID, // the client ID, typically pre-registered and static ResponseTypeValues.CODE, // the response_type value: we want a code MY_REDIRECT_URI); // the redirect URI to which the auth response is sent ``` Other optional parameters, such as the OAuth2 [scope string](https://tools.ietf.org/html/rfc6749#section-3.3) or OpenID Connect [login hint](http://openid.net/specs/openid-connect-core-1_0.html#rfc.section.3.1.2.1) are specified through set methods on the builder: ```java AuthorizationRequest authRequest = authRequestBuilder .setScope("openid email profile https://idp.example.com/custom-scope") .setLoginHint("jdoe@user.example.com") .build(); ``` This request can then be dispatched using one of two approaches. a `startActivityForResult` call using an Intent returned from the `AuthorizationService`, or by calling `performAuthorizationRequest` and providing pending intent for completion and cancelation handling activities. The `startActivityForResult` approach is simpler to use but may require more processing of the result: ```java private void doAuthorization() { AuthorizationService authService = new AuthorizationService(this); Intent authIntent = authService.getAuthorizationRequestIntent(authRequest); startActivityForResult(authIntent, RC_AUTH); } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == RC_AUTH) { AuthorizationResponse resp = AuthorizationResponse.fromIntent(data); AuthorizationException ex = AuthorizationException.fromIntent(data); // ... process the response or exception ... } else { // ... } } ``` If instead you wish to directly transition to another activity on completion or cancelation, you can use `performAuthorizationRequest`: ```java AuthorizationService authService = new AuthorizationService(this); authService.performAuthorizationRequest( authRequest, PendingIntent.getActivity(this, 0, new Intent(this, MyAuthCompleteActivity.class), 0), PendingIntent.getActivity(this, 0, new Intent(this, MyAuthCanceledActivity.class), 0)); ``` The intents may be customized to carry any additional data or flags required for the correct handling of the authorization response. #### Capturing the authorization redirect Once the authorization flow is completed in the browser, the authorization service will redirect to a URI specified as part of the authorization request, providing the response via query parameters. In order for your app to capture this response, it must register with the Android OS as a handler for this redirect URI. We recommend using a custom scheme based redirect URI (i.e. those of form `my.scheme:/path`), as this is the most widely supported across all versions of Android. To avoid conflicts with other apps, it is recommended to configure a distinct scheme using "reverse domain name notation". This can either match your service web domain (in reverse) e.g. `com.example.service` or your package name `com.example.app` or be something completely new as long as it's distinct enough. Using the package name of your app is quite common but it's not always possible if it contains illegal characters for URI schemes (like underscores) or if you already have another handler for that scheme - so just use something else. When a custom scheme is used, AppAuth can be easily configured to capture all redirects using this custom scheme through a manifest placeholder: ```groovy android.defaultConfig.manifestPlaceholders = [ 'appAuthRedirectScheme': 'com.example.app' ] ``` Alternatively, the redirect URI can be directly configured by adding an intent-filter for AppAuth's RedirectUriReceiverActivity to your AndroidManifest.xml: ```xml <activity android:name="net.openid.appauth.RedirectUriReceiverActivity" tools:node="replace"> <intent-filter> <action android:name="android.intent.action.VIEW"/> <category android:name="android.intent.category.DEFAULT"/> <category android:name="android.intent.category.BROWSABLE"/> <data android:scheme="com.example.app"/> </intent-filter> </activity> ``` If an HTTPS redirect URI is required instead of a custom scheme, the same approach (modifying your AndroidManifest.xml) is used: ```xml <activity android:name="net.openid.appauth.RedirectUriReceiverActivity" tools:node="replace"> <intent-filter> <action android:name="android.intent.action.VIEW"/> <category android:name="android.intent.category.DEFAULT"/> <category android:name="android.intent.category.BROWSABLE"/> <data android:scheme="https" android:host="app.example.com" android:path="/oauth2redirect"/> </intent-filter> </activity> ``` HTTPS redirects can be secured by configuring the redirect URI as an [app link](https://developer.android.com/training/app-links/index.html) in Android M and above. We recommend that a fallback page be configured at the same address to forward authorization responses to your app via a custom scheme, for older Android devices. #### Handling the authorization response Upon completion of the authorization flow, the completion Intent provided to performAuthorizationRequest will be triggered. The authorization response is provided to this activity via Intent extra data, which can be extracted using the `fromIntent()` methods on AuthorizationResponse and AuthorizationException respectively: ```java public void onCreate(Bundle b) { AuthorizationResponse resp = AuthorizationResponse.fromIntent(getIntent()); AuthorizationException ex = AuthorizationException.fromIntent(getIntent()); if (resp != null) { // authorization completed } else { // authorization failed, check ex for more details } // ... } ``` The response can be provided to the AuthState instance for easy persistence and further processing: ``` authState.update(resp, ex); ``` If the full redirect URI is required in order to extract additional information that AppAuth does not provide, this is also provided to your activity: ```java public void onCreate(Bundle b) { // ... Uri redirectUri = getIntent().getData(); // ... } ``` ### Exchanging the authorization code Given a successful authorization response carrying an authorization code, a token request can be made to exchange the code for a refresh token: ```java authService.performTokenRequest( resp.createTokenExchangeRequest(), new AuthorizationService.TokenResponseCallback() { @Override public void onTokenRequestCompleted( TokenResponse resp, AuthorizationException ex) { if (resp != null) { // exchange succeeded } else { // authorization failed, check ex for more details } } }); ``` The token response can also be used to update an AuthState instance: ```java authState.update(resp, ex); ``` ### Using access tokens Finally, the retrieved access token can be used to interact with a resource server. This can be done directly, by extracting the access token from a token response. However, in most cases, it is simpler to use the `performActionWithFreshTokens` utility method provided by AuthState: ```java authState.performActionWithFreshTokens(service, new AuthStateAction() { @Override public void execute( String accessToken, String idToken, AuthorizationException ex) { if (ex != null) { // negotiation for fresh tokens failed, check ex for more details return; } // use the access token to do something ... } }); ``` This also updates the AuthState object with current access, id, and refresh tokens. If you are storing your AuthState in persistent storage, you should write the updated copy in the callback to this method. ### Ending current session Given you have a logged in session and you want to end it. In that case you need to get: - `AuthorizationServiceConfiguration` - valid Open Id Token that you should get after authentication - End of session URI that should be provided within you OpenId service config First you have to build EndSessionRequest ```java EndSessionRequest endSessionRequest = new EndSessionRequest.Builder(authorizationServiceConfiguration) .setIdTokenHint(idToken) .setPostLogoutRedirectUri(endSessionRedirectUri) .build(); ``` This request can then be dispatched using one of two approaches. a `startActivityForResult` call using an Intent returned from the `AuthorizationService`, or by calling `performEndSessionRequest` and providing pending intent for completion and cancelation handling activities. The startActivityForResult approach is simpler to use but may require more processing of the result: ```java private void endSession() { AuthorizationService authService = new AuthorizationService(this); Intent endSessionItent = authService.getEndSessionRequestIntent(endSessionRequest); startActivityForResult(endSessionItent, RC_END_SESSION); } @Override protected void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == RC_END_SESSION) { EndSessionResonse resp = EndSessionResonse.fromIntent(data); AuthorizationException ex = AuthorizationException.fromIntent(data); // ... process the response or exception ... } else { // ... } } ``` If instead you wish to directly transition to another activity on completion or cancelation, you can use `performEndSessionRequest`: ```java AuthorizationService authService = new AuthorizationService(this); authService.performEndSessionRequest( endSessionRequest, PendingIntent.getActivity(this, 0, new Intent(this, MyAuthCompleteActivity.class), 0), PendingIntent.getActivity(this, 0, new Intent(this, MyAuthCanceledActivity.class), 0)); ``` End session flow will also work involving browser mechanism that is described in authorization mechanism session. Handling response mechanism with transition to another activity should be as follows: ```java public void onCreate(Bundle b) { EndSessionResponse resp = EndSessionResponse.fromIntent(getIntent()); AuthorizationException ex = AuthorizationException.fromIntent(getIntent()); if (resp != null) { // authorization completed } else { // authorization failed, check ex for more details } // ... } ``` ### AuthState persistence Instances of `AuthState` keep track of the authorization and token requests and responses. This is the only object that you need to persist to retain the authorization state of the session. Typically, one would do this by storing the authorization state in SharedPreferences or some other persistent store private to the app: ```java @NonNull public AuthState readAuthState() { SharedPreferences authPrefs = getSharedPreferences("auth", MODE_PRIVATE); String stateJson = authPrefs.getString("stateJson", null); if (stateJson != null) { return AuthState.jsonDeserialize(stateJson); } else { return new AuthState(); } } public void writeAuthState(@NonNull AuthState state) { SharedPreferences authPrefs = getSharedPreferences("auth", MODE_PRIVATE); authPrefs.edit() .putString("stateJson", state.jsonSerializeString()) .apply(); } ``` The demo app has an [AuthStateManager](https://github.com/openid/AppAuth-Android/blob/master/app/java/net/openid/appauthdemo/AuthStateManager.java) type which demonstrates this in more detail. ## Advanced configuration AppAuth provides some advanced configuration options via [AppAuthConfiguration](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AppAuthConfiguration.java) instances, which can be provided to [AuthorizationService](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationService.java) during construction. ### Controlling which browser is used for authorization Some applications require explicit control over which browsers can be used for authorization - for example, to require that Chrome be used for second factor authentication to work, or require that some custom browser is used for authentication in an enterprise environment. Control over which browsers can be used can be achieved by defining a [BrowserMatcher](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/BrowserMatcher.java), and supplying this to the builder of AppAuthConfiguration. A BrowserMatcher is suppled with a [BrowserDescriptor](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/BrowserDescriptor.java) instance, and must decide whether this browser is permitted for the authorization flow. By default, [AnyBrowserMatcher](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/AnyBrowserMatcher.java) is used. For your convenience, utility classes to help define a browser matcher are provided, such as: - [Browsers](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/Browsers.java): contains a set of constants for the official package names and signatures of Chrome, Firefox and Samsung SBrowser. - [VersionedBrowserMatcher](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/VersionedBrowserMatcher.java): will match a browser if it has a matching package name and signature, and a version number within a defined [VersionRange](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/VersionRange.java). This class also provides some static instances for matching Chrome, Firefox and Samsung SBrowser. - [BrowserAllowList](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/BrowserAllowList.java): takes a list of BrowserMatcher instances, and will match a browser if any of these child BrowserMatcher instances signals a match. - [BrowserDenyList](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/browser/BrowserDenyList.java): the inverse of BrowserAllowList - takes a list of browser matcher instances, and will match a browser if it _does not_ match any of these child BrowserMatcher instances. For instance, in order to restrict the authorization flow to using Chrome or SBrowser as a custom tab: ```java AppAuthConfiguration appAuthConfig = new AppAuthConfiguration.Builder() .setBrowserMatcher(new BrowserAllowList( VersionedBrowserMatcher.CHROME_CUSTOM_TAB, VersionedBrowserMatcher.SAMSUNG_CUSTOM_TAB)) .build(); AuthorizationService authService = new AuthorizationService(context, appAuthConfig); ``` Or, to prevent the use of a buggy version of the custom tabs in Samsung SBrowser: ```java AppAuthConfiguration appAuthConfig = new AppAuthConfiguration.Builder() .setBrowserMatcher(new BrowserDenyList( new VersionedBrowserMatcher( Browsers.SBrowser.PACKAGE_NAME, Browsers.SBrowser.SIGNATURE_SET, true, // when this browser is used via a custom tab VersionRange.atMost("5.3") ))) .build(); AuthorizationService authService = new AuthorizationService(context, appAuthConfig); ``` ### Customizing the connection builder for HTTP requests It can be desirable to customize how HTTP connections are made when performing token requests, for instance to use [certificate pinning](https://www.owasp.org/index.php/Certificate_and_Public_Key_Pinning) or to add additional trusted certificate authorities for an enterprise environment. This can be achieved in AppAuth by providing a custom [ConnectionBuilder](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/connectivity/ConnectionBuilder.java) instance. For example, to custom the SSL socket factory used, one could do the following: ```java AppAuthConfiguration appAuthConfig = new AppAuthConfiguration.Builder() .setConnectionBuilder(new ConnectionBuilder() { public HttpURLConnection openConnect(Uri uri) throws IOException { URL url = new URL(uri.toString()); HttpURLConnection connection = (HttpURLConnection) url.openConnection(); if (connection instanceof HttpsUrlConnection) { HttpsURLConnection connection = (HttpsURLConnection) connection; connection.setSSLSocketFactory(MySocketFactory.getInstance()); } } }) .build(); ``` ### Issues with [ID Token](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/IdToken.java#L118) validation ID Token validation was introduced in `0.8.0` but not all authorization servers or configurations support it correctly. - For testing environments [setSkipIssuerHttpsCheck](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AppAuthConfiguration.java#L129) can be used to bypass the fact the issuer needs to be HTTPS. ```java AppAuthConfiguration appAuthConfig = new AppAuthConfiguration.Builder() .setSkipIssuerHttpsCheck(true) .build() ``` - For services that don't support nonce[s] resulting in **IdTokenException** `Nonce mismatch` just set nonce to `null` on the `AuthorizationRequest`. Please consider **raising an issue** with your Identity Provider and removing this once it is fixed. ```java AuthorizationRequest authRequest = authRequestBuilder .setNonce(null) .build(); ``` ## Dynamic client registration AppAuth supports the [OAuth2 dynamic client registration protocol](https://tools.ietf.org/html/rfc7591). In order to dynamically register a client, create a [RegistrationRequest](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/RegistrationRequest.java) and dispatch it using [performRegistrationRequest](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationService.java#L278) on your AuthorizationService instance. The registration endpoint can either be defined directly as part of your [AuthorizationServiceConfiguration](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationServiceConfiguration.java), or discovered from an OpenID Connect discovery document. ```java RegistrationRequest registrationRequest = new RegistrationRequest.Builder( serviceConfig, Arrays.asList(redirectUri)) .build(); ``` Requests are dispatched with the help of `AuthorizationService`. As this request is asynchronous the response is passed to a callback: ```java service.performRegistrationRequest( registrationRequest, new AuthorizationService.RegistrationResponseCallback() { @Override public void onRegistrationRequestCompleted( @Nullable RegistrationResponse resp, @Nullable AuthorizationException ex) { if (resp != null) { // registration succeeded, store the registration response AuthState state = new AuthState(resp); //proceed to authorization... } else { // registration failed, check ex for more details } } }); ``` ## Utilizing client secrets (DANGEROUS) We _strongly recommend_ you avoid using static client secrets in your native applications whenever possible. Client secrets derived via a dynamic client registration are safe to use, but static client secrets can be easily extracted from your apps and allow others to impersonate your app and steal user data. If client secrets must be used by the OAuth2 provider you are integrating with, we strongly recommend performing the code exchange step on your backend, where the client secret can be kept hidden. Having said this, in some cases using client secrets is unavoidable. In these cases, a [ClientAuthentication](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/ClientAuthentication.java) instance can be provided to AppAuth when performing a token request. This allows additional parameters (both HTTP headers and request body parameters) to be added to token requests. Two standard implementations of ClientAuthentication are provided: - [ClientSecretBasic](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/ClientSecretBasic.java): includes a client ID and client secret as an HTTP Basic Authorization header. - [ClientSecretPost](https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/ClientSecretPost.java): includes a client ID and client secret as additional request parameters. So, in order to send a token request using HTTP basic authorization, one would write: ```java ClientAuthentication clientAuth = new ClientSecretBasic(MY_CLIENT_SECRET); TokenRequest req = ...; authService.performTokenRequest(req, clientAuth, callback); ``` This can also be done when using `performActionWithFreshTokens` on AuthState: ```java ClientAuthentication clientAuth = new ClientSecretPost(MY_CLIENT_SECRET); authState.performActionWithFreshTokens( authService, clientAuth, action); ``` ## Modifying or contributing to AppAuth This project requires the Android SDK for API level 25 (Nougat) to build, though the produced binaries only require API level 16 (Jellybean) to be used. We recommend that you fork and/or clone this repository to make modifications; downloading the source has been known to cause some developers problems. For contributors, see the additional instructions in [CONTRIBUTING.md](https://github.com/openid/AppAuth-Android/blob/master/CONTRIBUTING.md). ### Building from the Command line AppAuth for Android uses Gradle as its build system. In order to build the library and app binaries, run `./gradlew assemble`. The library AAR files are output to `library/build/outputs/aar`, while the demo app is output to `app/build/outputs/apk`. In order to run the tests and code analysis, run `./gradlew check`. ### Building from Android Studio In AndroidStudio, File -> New -> Import project. Select the root folder (the one with the `build.gradle` file).

The project focused on the use of public data to assess the economic situation in the country based on the state of the stock market and national means of payment, in particular - of the national currency. As sources are used: Open data Ministry of Finance of the Russian Federation These Moscow Exchange Google Finance Data Technologies used: Backend: Databases (relational) - Microsoft SQL Server 2014 Databases (multivariate) models DataMining, OLAP-cube - Microsoft Analysis Services 12.0 Веб-сервер - Windows Server 2012 / Internet Information Services Самописный ASP.NET HTTP Restful интерфейс для взаимодействия с Frontend ETL (загрузка и пре-процессинг данных, управление обновлением данных) SQL Server Integration Services 2014 (разработка в Visual Studio 2013, SSDT) Frontend: AngularJS ChartJS Twitter Bootstrap These were chosen so that the detail (granularity) in the set is not less than 1 day. The result has been created and filled with data analytic repository (Kimball model, topology - star), which was used to build a multi-dimensional databases and OLAP-based cubes on it, as well as models of analysis of data on two main algorithms: Microsoft Time Series, Microsoft Neural Network . To ensure interoperability frontend and backend server for backend-server was set up HTTP-Restful interface JSON-issuing documents in the form of finished sets. The project includes two main areas: Intelligent visualization of open data Analysis of open data and the construction of forecasts based on them Intelligent visualization involves the use of MDX-queries to the OLAP-cube, followed by depression (drilldown) in the data, the system allows the user to quickly find the "weak points" of the economy, as part of the data collected. To predict the time a standard mix of algorithms ARTXP / ARIMA, without the use of queries involving cross-prediction (but it is possible to enroll in the system correct data). These algorithms have been tested primarily on foreign exchange rates (US dollar) and the assets of banks included in the special list of Ministry of Finance. In addition, for assets shows the different customization options algorithms - a long-term, short-term and medium-term (balanced) plan. Assessing the impact of oil prices and foreign currency exchange rate for the total market capitalization was conducted on a sample of the data collected: companies with a total market capitalization of 100 to 500 million rubles, present in the market during 2013-2015 Analytical server builds the neural network receiving the input exchange rates, companies, the weighted average share price, total capitalization of the company and the price of oil to requests received models give the opportunity to evaluate the growth rate of \ fall (if at all) the company's capitalization at historical exchange rates and / or the cost of oil. Built a system can expand to include new indicators, which will significantly increase the accuracy of forecasting.

Sample showing how to use Google SignIn on the client. Then obtain the server auth code to send to a backend server so it can be exchanged for an OAuth access_token.

Backend for a ViaBTC exchange server (trading engine)

Code-N-Collab Server is the Backend for the Code-N-Collab for real-time exchange of data between users

This repository contains reverse-engineered gRPC `.proto` files from the Cursor IDE, helping developers understand data exchanges with backend services. Compile these files to generate gRPC clients and servers, and explore the API structure with tools like Charles Proxy. 🐙✨

A Coinbase Bitcoin Exchange clone built on Vue/Vuex with xstream for websocket stream and a Go backend.

A textbook exchange platform for college students. ReactJS frontend, serverless backend with Firebase. First prize winning project at MEC-labs 18 :trophy:

A lightweight and deployment-friendly API gateway for making direct SQL queries to PostgreSQL and MSSQL databases. Designed for fast prototyping and data exchange, it simplifies API creation for database-driven applications without complex backend logic.

# 1. MAGENTO 2 MARKETPLACE FACEBOOK LIVECHAT Facebook has taken the world by storm and become an important element in the field of communications. For businesses, Facebook messenger is about connecting businesses with customers. Some businesses are finding that Facebook may even replace their websites. The integration of Facebook Messenger into your marketplace can make the communication in business enhanced remarkably. Using Magento 2 Marketplace Facebook Live Chat Extension, you can easily keep in touch with various of customers at a time. The chatbox of this extension will help you send and receive messages from users instantly. Let's see outstanding advantages of this extension: Unlimited History Chat One step log in with Facebook, not setup requires Familiar chat box with Facebook Messenger Interface Easily enable/disable and configure Chatbox at the backend Unlimited color Show store profile and like button in the chat box Set greeting, upcoming event, store Facebook profile to the chatbox Chat with unlimited customers on Facebook page User Statistic Increase Fanpage View and Like Purchasing [MAGENTO 2 MARKETPLACE FACEBOOK LIVECHAT](https://landofcoder.com/marketplace-facebook-livechat.html/) This is a plugin of [Magento 2 Marketplace Extension](https://landofcoder.com/magento-2-marketplace-extension.html/). To use this module smoothly, you must install Magento 2 Marketplace Module first. ## 2. Documentation - Installation guide: https://blog.landofcoder.com/magento-2-install-extension/ - User guide: http://guide.landofcoder.com/ - Download from our Live site: https://landofcoder.com/magento-2-pre-order-extension.html/ - Get Support: https://landofcoder.ticksy.com/ ## 3. Highlight Features ### One step log in with Facebook Super Fast Logging in Facebook has never been easy like this with Magento 2 marketplace Facebook live chat extension. Type your email address/ your telephone number and your password in the box or if you have not had account, it seems to be simple way to create new account for you. Just by one click on your website, your customer can easily send and receive messages from you. No complicated setup requires. ### Configure all features of Chatbox Appearance of your chatbox plays an important role in how to communicate effectively with your customers. With Magento 2 marketplace facebook live chat extension, creating the best comfortable space for interaction can be optimized. You can change Title/ color/ Text color of tab close, Title/ Unlimited Color/ Width/ Height of Tab Open. Especially, you can even justify your avatar image width/height to raise your customers’impression when communicating with you. ### Get user information In the blink of eye This extension provides you the best management’s system with the board of “Manage data user”. You can keep track of how many people visit, interact in your web and how many people have real interest or enroll to spam. Name, Email, DOB, Location, Link Facebook of register users are now all on your list. ### Set greeting, upcoming event, store Facebook profile Being the first one to welcome your customers in your web can make them feel being respected. You can choose to send messages of greeting, event to customer manually or automatically. What can make them pay attention to is all the information in your web coming to them first. Magento 2 marketplace facebook live chat can help you to update the recent message and upcoming event for your customers or even you can send message to the host of page. ### Show site/product/category on the chat box When receiving a request from the customer, you can send them the site/product/category links in the chatbox. It will be always appear in your screen, so it seems to be very simple to do multitasks: both searching products’information and keeping in touch with the customers. ### Unlimited History Chat The same function as Facebook messenger app, Marketplace facebook live chat extension provides you responsive interface in which you can scroll down or search for any customer in your history no matter when it is. This goes beyond the limitation of current chat desk. If you need to find exact customers to check the exchanged information, you can only search a part of his/her name and the system will send you limited list for you. ### Increase Fanpage View and Like By using Magento 2 Marketplace Facebook Live Chat, you can drive your customer to your Facebook page. Keep theme follow your business all the time with updated news. They will not only interact in your website, but they can also do this in your fanpage on Facebook. ### Multiple and RLT Languages Magento 2 Marketplace Facebook Live Chat do not forget customers who want to use multiple languages or RTL language system. It helps you attract lots of customers without any limitation of cultures and languages.Take it easy for all! ### Familiar chat box with Facebook Messenger Interface With the familiar Facebook Messenger Interface in Magento store, customers and owners can communicate each other with ease. ### Enable/disable the extension by one click Simply to Enable/ Disable Magento 2 Marketplace Facebook Livechat extension for your store in the board of “Facebook support Live settings”. Just one click required! ## 4. Full features: - Easy log in with Facebook - Configure all features of Chatbox - Easy user management - Automatically send greeting and upcoming events notification. - Flexible functions of chatbox. - Unlimited History Chat - Promote interaction on Facebook fanpage - Multiple and RLT Languages - Familiar Facebook messenger interface of chat box - One-click operation of this extension - Show store profile and like button in the chat box - Chat with unlimited customers on Facebook page ## LandOfCoder extensions on Magento Marketplace, Github - [Magento 2 Multivendor Marketplace](https://landofcoder.com/magento-2-marketplace-extension.html/) - [Magento 2 Blog Extension](https://landofcoder.com/magento-2-blog-extension.html/) - [Magento 2 Testimonial Extension](https://landofcoder.com/testimonial-extension-for-magento2.html/) - [Magento 2 Image Gallery](https://landofcoder.com/magento-2-image-gallery.html/) - [Magento 2 Faq Extension](https://landofcoder.com/faq-extension-for-magento2.html/) - [Magento 2 Help Desk](https://landofcoder.com/magento-2-help-desk-extension.html) - [Magento 2 OUT OF STOCK NOTIFICATION](https://landofcoder.com/magento-2-out-of-stock-notification.html/) - [Magento 2 CUSTOMER QUOTATION FOR MAGENTO 2](https://landofcoder.com/magento-2-quote-extension.html/) - [Magento 2 RMA Extension](https://landofcoder.com/magento-2-rma-extension.html/) - [Magento 2 Stripe Payment](https://landofcoder.com/magento-2-stripe-payment-pro.html/) - [Magento 2 SMS Notification](https://landofcoder.com/magento-2-sms-notification-extension.html/) - [Magento 2 Page Builder](https://landofcoder.com/magento-2-page-builder.html/) - [Magento 2 Form Builder](https://landofcoder.com/magento-2-form-builder.html/) - [Magento 2 Advanced Report](https://landofcoder.com/magento-2-advanced-reports.html/) - [Magento 2 Marketplace PRO](https://landofcoder.com/magento-2-marketplace-pro.html/) - [Magento 2 Order Tracking](https://landofcoder.com/magento-2-order-tracking-extension.html/) - [Magento 2 Order Tracking PRO](https://landofcoder.com/magento-2-order-tracking-pro-extension.html/) - [Magento 2 Multiple Flat Rate](https://landofcoder.com/magento-2-multiple-flat-rate-shipping.html/) - [Magento 2 Shipping Per Product](https://landofcoder.com/magento-2-shipping-per-product.html/) - [Magento 2 Social Login](https://landofcoder.com/magento-2-social-login.html/) - [Magento 2 Store Locator](https://landofcoder.com/magento-2-store-locator.html/) - [Magento 2 Auto Search Extension](https://landofcoder.com/magento-2-search.html/) - [Magento 2 Mega Menu](https://landofcoder.com/magento-2-mega-menu.html/) - [Magento 2 Mega Menu PRO](https://landofcoder.com/magento-2-mega-menu-pro.html) - [Magento 2 Image Gallery PRO](https://landofcoder.com/magento-2-image-gallery-pro.html/) - [Magento 2 Layered Navigation](https://landofcoder.com/magento-2-layered-navigation.html/) - [Magento 2 Auction Extension](https://landofcoder.com/magento-2-auction-extension.html/) - [Magento 2 Store Credit](https://landofcoder.com/magento-2-store-credit.html/) - [Magento 2 Reward Point](https://landofcoder.com/magento-2-reward-points.html/) - [Magento 2 Follow Up Email](https://landofcoder.com/magento-2-follow-up-email.html/) - [Magento 2 Coupon Code Generator](https://landofcoder.com/magento-2-coupon-extension.html/) - [Magento 2 Hide Price](https://landofcoder.com/magento-2-hide-price.html/) - [Magento 2 Price Comparison](https://landofcoder.com/magento-2-price-comparison.html/) - [Magento 2 SMTP Extension](https://landofcoder.com/magento-2-smtp-extension.html) - [Magento 2 Price Comparison](https://landofcoder.com/magento-2-price-comparison.html/) - [Magento 2 Affiliate Extension](https://landofcoder.com/magento-2-affiliate-extension.html/) - [Magento 2 One Step Checkout](https://landofcoder.com/magento-2-one-step-checkout.html/) Sources: https://landofcoder.com/marketplace-facebook-livechat.html/

WARNING: This project is not actively developed and probably doesn't work. A CalDAV server designed to support multiple backends. The goal was to have a fully working Microsoft Exchange backend using Exchange 2007 Web Services.

Proxy server that automatically stores messages exchanged between any OAI-compatible frontend and backend as a ShareGPT dataset to be used for training/finetuning.

Backend for FtNox exchange.

Haskell: A flexible job queue with exchangeable backends

django backend, react frontend - currency exchange

This GitHub repository is dedicated to the backend services, focusing on two primary components: the DEX Pair Alpha Beta and DEX TON Smart-Contracts. It serves as a central hub for developers and contributors involved in building and maintaining the backend infrastructure of decentralized exchange platform.

High-performance NEPSE (Nepal Stock Exchange) Unofficial API client in TS. Type-safe & Scalable, designed for backend use.

backend of nft exchanger

RESTful Web API dedicated to Stock Exchange Application [2019]

CVE-2023-32031 MS Exchange PowerShell backend RCE