The Pairing API is a lightweight API for establishing an encrypted, protocol-agnostic communication layer between peers. Its purpose is to provide a secure channel for proposing protocols or sending requests between dapp and wallet.
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.
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.
You can add a WalletConnect Core SDKs to your project with Swift Package Manager. In order to do that:
Kotlin implementation of Android CoreClient for all WalletConnect SDKs. This SDK is developed in Kotlin and usable in both Java and Kotlin files.
root/build.gradle.kts:
app/build.gradle
To use initialize RelayClient properly you will need a projectId. Go to https://cloud.reown.com/app, register your project and get projectId.
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 Cloud, the WebSocket URL, choose the connection type, and pass the application class. You can also pass your own Relay instance using the RelayConnectionInterface
.
The CoreClient offers the ability to use a custom Relay client. Just creating an instance of RelayConnectionInterface
and passing it to CoreClient.initialize
.
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 WalletConnect.Core
nuget package, which implements the Pairing API
Once the 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.
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
.
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:
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:
Advanced Project Settings
from the gear ⚙ menu located at the top right of the Package Manager’s toolbarOpenUPM
https://package.openupm.com
com.walletconnect
Save
buttonsAdd package by name...
com.walletconnect.core
Add
buttonAdd package from git URL...
WalletConnectUnity Core
Add
buttonIt’s possible to lock the version of the package by adding #{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:
Due to WebGL’s single-threaded nature, certain asynchronous operations like Task.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:
Assets/WalletConnectUnity/Resources/WalletConnectProjectConfig
asset.
Redirect
fields are optional. They are used to redirect the user back to your app after they approve or reject the session.WalletConnect
and get reference to the instance of Core
: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).
The Pairing API currently emits the following events:
pairing_ping
pairing_delete
pairing_expire
Any of these events can be listened for via the standard Node EventEmitter
interface:
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).
The Pairing API currently emits the following events:
pairing_ping
pairing_delete
pairing_expire
Any of these events can be listened for via the standard Node EventEmitter
interface:
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 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.
In pair wallet with dapp, the user needs to scan a QR code or open a deep link generated by dapp, then instantiate WalletConnectURI
from the scanned QR code string and call the pair()
function as follows.
Now wallet and a dapp have a secure communication channel that will be used by top level APIs.
In order to pair dapp and a wallet, dapp needs to generate and share a uri with wallet.
To generate a uri call create()
function on Pair instance as follows.
Now you can share the uri with the wallet.
When first establishing a pairing with a Peer, call 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.
To pair the wallet with the Dapp, call the CoreClient.Pairing’s pair function which needs a Core.Params.Pair
parameter. Core.Params.Pair
is where the WC Uri will be passed.
To get a list of the most current active pairings, call CoreClient.Pairing.getPairings()
which will return a list of type Core.Model.Pairing
.
To disconnect from a pairing, just pass the topic of the pairing to disconnect from (use 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).
The Pairing API currently emits the following events:
pairing_ping
pairing_delete
pairing_expire
Any of these events can be listened for via the standard Node EventEmitter
interface:
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 the Pair()
function as follows.
Now the wallet and a dapp have a secure communication channel that will be used by top level APIs.
In order to pair dapp and a wallet, dapp needs to generate and share a uri with wallet. To generate a uri call create()
function on Pair instance as follows.
Now you can share the uri with the wallet either through a QR Code or by using a deep link.
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 the MessageHandler
module.
A response can be sent for any request by setting the 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.
The Pairing API is a lightweight API for establishing an encrypted, protocol-agnostic communication layer between peers. Its purpose is to provide a secure channel for proposing protocols or sending requests between dapp and wallet.
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.
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.
You can add a WalletConnect Core SDKs to your project with Swift Package Manager. In order to do that:
Kotlin implementation of Android CoreClient for all WalletConnect SDKs. This SDK is developed in Kotlin and usable in both Java and Kotlin files.
root/build.gradle.kts:
app/build.gradle
To use initialize RelayClient properly you will need a projectId. Go to https://cloud.reown.com/app, register your project and get projectId.
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 Cloud, the WebSocket URL, choose the connection type, and pass the application class. You can also pass your own Relay instance using the RelayConnectionInterface
.
The CoreClient offers the ability to use a custom Relay client. Just creating an instance of RelayConnectionInterface
and passing it to CoreClient.initialize
.
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 WalletConnect.Core
nuget package, which implements the Pairing API
Once the 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.
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
.
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:
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:
Advanced Project Settings
from the gear ⚙ menu located at the top right of the Package Manager’s toolbarOpenUPM
https://package.openupm.com
com.walletconnect
Save
buttonsAdd package by name...
com.walletconnect.core
Add
buttonAdd package from git URL...
WalletConnectUnity Core
Add
buttonIt’s possible to lock the version of the package by adding #{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:
Due to WebGL’s single-threaded nature, certain asynchronous operations like Task.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:
Assets/WalletConnectUnity/Resources/WalletConnectProjectConfig
asset.
Redirect
fields are optional. They are used to redirect the user back to your app after they approve or reject the session.WalletConnect
and get reference to the instance of Core
: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).
The Pairing API currently emits the following events:
pairing_ping
pairing_delete
pairing_expire
Any of these events can be listened for via the standard Node EventEmitter
interface:
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).
The Pairing API currently emits the following events:
pairing_ping
pairing_delete
pairing_expire
Any of these events can be listened for via the standard Node EventEmitter
interface:
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 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.
In pair wallet with dapp, the user needs to scan a QR code or open a deep link generated by dapp, then instantiate WalletConnectURI
from the scanned QR code string and call the pair()
function as follows.
Now wallet and a dapp have a secure communication channel that will be used by top level APIs.
In order to pair dapp and a wallet, dapp needs to generate and share a uri with wallet.
To generate a uri call create()
function on Pair instance as follows.
Now you can share the uri with the wallet.
When first establishing a pairing with a Peer, call 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.
To pair the wallet with the Dapp, call the CoreClient.Pairing’s pair function which needs a Core.Params.Pair
parameter. Core.Params.Pair
is where the WC Uri will be passed.
To get a list of the most current active pairings, call CoreClient.Pairing.getPairings()
which will return a list of type Core.Model.Pairing
.
To disconnect from a pairing, just pass the topic of the pairing to disconnect from (use 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).
The Pairing API currently emits the following events:
pairing_ping
pairing_delete
pairing_expire
Any of these events can be listened for via the standard Node EventEmitter
interface:
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 the Pair()
function as follows.
Now the wallet and a dapp have a secure communication channel that will be used by top level APIs.
In order to pair dapp and a wallet, dapp needs to generate and share a uri with wallet. To generate a uri call create()
function on Pair instance as follows.
Now you can share the uri with the wallet either through a QR Code or by using a deep link.
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 the MessageHandler
module.
A response can be sent for any request by setting the 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.