Don't have a project ID?
Head over to Reown Dashboard and create a new project.
Installation
- Web
- iOS
- Android
- React Native
- .NET
- Unity
WalletConnect currently offers Sign and Auth SDKs.
To allow a reusable communication channel between peers,
the Pairing API exposes a standard interface and allows for sending and receiving multi-protocol requests over a single pairing.Each SDK uses the same implementation of
core/pairing (via @walletconnect/core) to manage pairings.
To run multiple SDKs side-by-side (e.g. Sign and Auth), please refer to the [Sharing a Core instance] guide.Add SDK for your project.
You can add a WalletConnect Core SDKs to your project with Swift Package Manager. In order to do that:- Open XCode
- Go to File -> Add Packages
- Paste the repo GitHub URL: https://github.com/reown-com/reown-swift
- Tap Add Package
- Select WalletConnectPairing check mark
Kotlin implementation of Android CoreClient for all WalletConnect SDKs. This SDK is developed in Kotlin and usable in both Java and Kotlin files.
app/build.gradle
Requirements
- Android min SDK 23
- Java 11
Installation
root/build.gradle.kts:allprojects {
repositories {
mavenCentral()
maven { url "https://jitpack.io" }
}
}
implementation("com.walletconnect:android-core:release_version")
Project set up
To use initialize RelayClient properly you will need a projectId. Go to https://dashboard.reown.com/app, register your project and get projectId.CoreClient initialization
Before using any of the WalletConnect Kotlin SDKs, it is necessary to initialize the CoreClient. The initialization of CoreClient must always happen in the Android Application class. Provide the projectId generated in the Reown Dashboard, the WebSocket URL, choose the connection type, and pass the application class. You can also pass your own Relay instance using theRelayConnectionInterface.val projectId = "" //Get Project ID at https://dashboard.reown.com/
val connectionType = ConnectionType.AUTOMATIC or ConnectionType.MANUAL
val application = //Android Application level class
[Optional] val optionalRelay: RelayConnectionInterface? = /*implement interface*/
CoreClient.initialize(projectId = projectId, connectionType = connectionType, application = application, relay = optionalRelay)
Using your own Relay instance
The CoreClient offers the ability to use a custom Relay client. Just creating an instance ofRelayConnectionInterface and passing it to CoreClient.initialize....
val optionalRelay: RelayConnectionInterface = /*implement interface*/
CoreClient.initialize(projectId = projectId, connectionType = connectionType, application = application, relay = optionalRelay)
WalletConnect currently offers Sign and Auth SDKs.
To allow a reusable communication channel between peers,
the Pairing API exposes a standard interface and allows for sending and receiving multi-protocol requests over a single pairing.Each SDK uses the same implementation of
core/pairing (via @walletconnect/core) to manage pairings.
To run multiple SDKs side-by-side (e.g. Sign and Auth), please refer to the [Sharing a Core instance] guide.Install the Once the
WalletConnect.Core nuget package, which implements the Pairing APIdotnet add package WalletConnect.Core
WalletConnect.Core library is installed, create a Metadata object. It will describe your application and define its appearance in a web browser. Then configure the Pair instance with a metadata object you have instantiated.var metadata = new Metadata()
{
Name = "my-app",
Description = "My app description",
Icons = new[] { "https://walletconnect.com/meta/favicon.ico" },
Url = "https://walletconnect.com",
}
var options = new CoreOptions()
{
ProjectId = "...",
Name = "my-app",
}
var core = new WalletConnectCore(options);
core.Pairing.Configure(metadata);
Since
WalletConnectUnity is a wrapper around WalletConnectSharp, usage of the pairing API is identical to .NET. Please refer to .NET documentation on how to use Pairing inside WalletConnectUnity.Package Installation
- OpenUPM CLI
- Package Manager with OpenUPM
- Package Manager with Git URL
To install packages via OpenUPM, you need to have Node.js and openupm-cli installed. Once you have them installed, you can run the following commands:
openupm add com.walletconnect.core
- Open
Advanced Project Settingsfrom the gear ⚙ menu located at the top right of the Package Manager’s toolbar - Add a new scoped registry with the following details:
- Name:
OpenUPM - URL:
https://package.openupm.com - Scope(s):
com.walletconnect
- Name:
- Press plus ➕ and then
Savebuttons - In the Package Manager windows open the add ➕ menu from the toolbar
- Select
Add package by name... - Enter the package name:
com.walletconnect.core
- Press
Addbutton
- Open the add ➕ menu in the Package Manager’s toolbar
- Select
Add package from git URL... - Enter the package URL:
https://github.com/WalletConnect/WalletConnectUnity.git?path=Packages/com.walletconnect.core
- Press
Addbutton
#{version} at the end of the git URL, where #{version} is the git tag of the version you want to use.
For example, to install version 1.0.1 of WalletConnectUnity Modal, use the following URL:https://github.com/WalletConnect/WalletConnectUnity.git?path=Packages/com.walletconnect.core#core/1.0.1
WebGL
Due to WebGL’s single-threaded nature, certain asynchronous operations likeTask.Run, Task.ContinueWith, Task.Delay, and ConfigureAwait(false) are not natively supported.To enable these operations in WebGL builds, an additional third-party package, WebGLThreadingPatcher, is required. This package modifies the Unity WebGL build to delegate work to the SynchronizationContext, allowing these operations to be executed on the same thread without blocking the main application. Please note that all tasks are still executed on a single thread, and any blocking calls will freeze the entire application.The WebGLThreadingPatcher package can be added via git URL:https://github.com/VolodymyrBS/WebGLThreadingPatcher.git
Initialization
- Fill in the Project ID and Metadata fields in the
Assets/WalletConnectUnity/Resources/WalletConnectProjectConfigasset.- If you don’t have a Project ID, you can create one at Reown Dashboard.).
- The
Redirectfields are optional. They are used to redirect the user back to your app after they approve or reject the session.
- Initialize
WalletConnectand get reference to the instance ofCore:
// Initialize singleton
await WalletConnect.Instance.InitializeAsync();
// Or handle instancing manually
var walletConnectUnity = new WalletConnect();
await walletConnectUnity.InitializeAsync();
var core = WalletConnect.Instance.SignClient.Core;
Usage
- Web
- iOS
- Android
- React Native
- .NET
The methods listed below are limited to only the public methods of the Pairing API that we recommend you interact with directly.
For an exhaustive list, please refer to the spec and/or implementation linked under Useful Links above.The keyword
sdkClient is used here as a placeholder for any WalletConnect SDK that implements the Pairing API (e.g. signClient, authClient, etc). // Creates a new (inactive) pairing. Returns the URI for a peer to consume via `pair`, as well as the pairing topic.
const {topic, uri} = await sdkClient.core.pairing.create()
// Pair with a peer's proposed pairing, extracted from the provided `uri` parameter.
await sdkClient.core.pairing.pair({ uri: "wc:1b3eda3f4..." })
// Activate a previously created pairing (e.g. after the peer has paired), by providing the pairing topic.
await sdkClient.core.pairing.activate({ topic: "1b3eda3f4..." })
// Updates the expiry of an existing pairing, by providing the pairing topic and an `expiry` in seconds (e.g. `60` for one minute from now)
await sdkClient.core.pairing.updateExpiry({ topic: "1b3eda3f4...", expiry: 60 })
// Updates a pairing's metadata, by providing the pairing topic and the desired metadata.
await sdkClient.core.pairing.updateMetadata({ topic: "1b3eda3f4...", metadata: { name: "MyDapp", ... } })
// Returns an array of all existing pairings.
const pairings = sdkClient.core.pairing.getPairings()
// Pings a pairing's peer, by providing the pairing topic.
await sdkClient.core.pairing.ping({ topic: "1b3eda3f4..." })
// Disconnects/Removes a pairing, by providing the pairing topic.
await sdkClient.core.pairing.disconnect({ topic: "1b3eda3f4..." })
Listeners for pairing-related events
The Pairing API currently emits the following events:pairing_pingpairing_deletepairing_expire
EventEmitter interface:sdkClient.core.pairing.events.on("pairing_delete", ({ id, topic }) => {
// clean up after the pairing for `topic` was deleted.
});
Create an AppMetadata object. It will describe your application and define its appearance in a web browser.Starting from WalletConnect SDK version 1.9.5, the Now wallet and a dapp have a secure communication channel that will be used by top level APIs.Now you can share the uri with the wallet.
redirect field in the AppMetadata object is mandatory. Ensure that the provided value matches your app’s URL scheme to prevent redirection-related issues.Then configure the Pair instance with a metadata object you have instantiated.let metadata = AppMetadata(name: <String>,
description: <String>,
url: <String>,
icons: <[String]>,
redirect: AppMetadata.Redirect(native: "example://", universal: nil))
Pair.configure(metadata: metadata)
Pairing Wallet Usage
In pair wallet with dapp, the user needs to scan a QR code or open a deep link generated by dapp, then instantiateWalletConnectURI from the scanned QR code string and call the pair() function as follows.let uri WalletConnectURI(string: <String>)
try! await Pair.instance.pair(uri: uri)
Pairing Dapp Usage
In order to pair dapp and a wallet, dapp needs to generate and share a uri with wallet. To generate a uri callcreate() function on Pair instance as follows.let uri = try await Pair.instance.create()
Create Pairing
val pairing: Pairing? = CoreClient.Pairing.create() { error -> }
CoreClient.Pairing.create. This will try and generate a new pairing with a URI parameter that can be used to establish a connection with the other Peer as well as other meta data related to the pairing.Pair Clients
val pairingParams = Core.Params.Pair(pairingUri)
CoreClient.Pairing.pair(pairingParams) { error -> }
Core.Params.Pair parameter. Core.Params.Pair is where the WC Uri will be passed.Get List of Active Pairings
val listOfActivePairings: List<Core.Model.Pairing> = CoreClient.Pairing.getPairings()
CoreClient.Pairing.getPairings() which will return a list of type Core.Model.Pairing.Disconnect a Pairing
CoreClient.Pairing.disconnect(topic = /*Pairing topic*/") { error -> }
getPairings() to get a list of all active pairings and their topics).The methods listed below are limited to only the public methods of the Pairing API that we recommend you interact with directly.
For an exhaustive list, please refer to the spec and/or implementation linked under Useful Links above.The keyword
sdkClient is used here as a placeholder for any WalletConnect SDK that implements the Pairing API (e.g. signClient, authClient, etc). // Creates a new (inactive) pairing. Returns the URI for a peer to consume via `pair`, as well as the pairing topic.
const {topic, uri} = await sdkClient.core.pairing.create()
// Pair with a peer's proposed pairing, extracted from the provided `uri` parameter.
await sdkClient.core.pairing.pair({ uri: "wc:1b3eda3f4..." })
// Activate a previously created pairing (e.g. after the peer has paired), by providing the pairing topic.
await sdkClient.core.pairing.activate({ topic: "1b3eda3f4..." })
// Updates the expiry of an existing pairing, by providing the pairing topic and an `expiry` in seconds (e.g. `60` for one minute from now)
await sdkClient.core.pairing.updateExpiry({ topic: "1b3eda3f4...", expiry: 60 })
// Updates a pairing's metadata, by providing the pairing topic and the desired metadata.
await sdkClient.core.pairing.updateMetadata({ topic: "1b3eda3f4...", metadata: { name: "MyDapp", ... } })
// Returns an array of all existing pairings.
const pairings = sdkClient.core.pairing.getPairings()
// Pings a pairing's peer, by providing the pairing topic.
await sdkClient.core.pairing.ping({ topic: "1b3eda3f4..." })
// Disconnects/Removes a pairing, by providing the pairing topic.
await sdkClient.core.pairing.disconnect({ topic: "1b3eda3f4..." })
Listeners for pairing-related events
The Pairing API currently emits the following events:pairing_pingpairing_deletepairing_expire
EventEmitter interface:sdkClient.core.pairing.events.on("pairing_delete", ({ id, topic }) => {
// clean up after the pairing for `topic` was deleted.
});
Pairing Wallet Usage
When paring a wallet with a dapp, the user needs to scan a QR code or open a deep link generated by the dapp. Grab the string from the scanned QR code string or from the deep link and call thePair() function as follows.var uri = "...";
PairingStruct pairingData = await core.Pairing.Pair(uri);
Pairing Dapp Usage
In order to pair dapp and a wallet, dapp needs to generate and share a uri with wallet. To generate a uri callcreate() function on Pair instance as follows.
var pairData = await core.Pairing.Create();
string topic = pairData.Topic;
string uri = pairData.Uri;
Message Sending / Handling
Once a wallet and dapp has been paired, they can send messages securely to the pairing topic.Requests can be received from the dapp by handling the message callback in theMessageHandler module.core.MessageHandler.MessageEventHandler<MyRequest, MyResponse>()
.FilterRequests(r => r.Topic == pairingData.Topic)
.OnRequest +=
async delegate(RequestEventArgs<MyRequest, MyResponse> eventArgs)
{
Console.WriteLine(eventArgs.Request);
eventArgs.Response = new MyResponse()
{
// ...
};
};
Response field in the eventArgs parameter.Receiving responses is handled the same way, but instead of the OnRequest event you would use the OnResponse event.Request, Responses and Errors can be sent using the SendRequest , SendResult and SendError functions in the MessageHandler module.long id = await core.MessageHandler.SendRequest<MyRequest, MyResponse>(pairingTopic, data);