Usage

This section provides instructions on how to use WalletConnectModal in your project.

Implementation

Start by importing WalletConnectModal and initializing it.

import { WalletConnectModal } from "@walletconnect/modal";

const modal = new WalletConnectModal({
  projectId: "YOUR_PROJECT_ID",
  chains: ["eip155:1"],
});

Once you have obtained your connection uri, you can open or close the modal.From here on, use provider as you normally would, WalletConnectModal will be shown and hidden automatically i.e.

await modal.openModal({
  uri: "YOUR_CONNECTION_URI",
});

// Do some work...

modal.closeModal();

Configure Networking and Pair clients

Make sure that you properly configure Networking and Pair Clients first.

Networking

Initialize WalletConnectModal Client

In order to initialize a client just call a configure method from the WalletKit instance wrapper

let metadata = AppMetadata(
    name: "Example Wallet",
    description: "Wallet description",
    url: "example.wallet",
    icons: ["https://avatars.githubusercontent.com/u/37784886"],
    // Used for the Verify: to opt-out verification ignore this parameter
    verifyUrl: "verify.walletconnect.com"
)

WalletConnectModal.configure(
    projectId: PROJECT_ID,
    metadata: metadata
)

This example will default to using following namespaces.

let methods: Set<String> = ["eth_sendTransaction", "personal_sign", "eth_signTypedData"]
let events: Set<String> = ["chainChanged", "accountsChanged"]
let blockchains: Set<Blockchain> = [Blockchain("eip155:1")!]
let namespaces: [String: ProposalNamespace] = [
    "eip155": ProposalNamespace(
        chains: blockchains,
        methods: methods,
        events: events
    )
]

let defaultSessionParams =  SessionParams(
                                requiredNamespaces: namespaces,
                                optionalNamespaces: nil,
                                sessionProperties: nil
                            )

If you want to change that you can call configure and define your own session parameters like this.

let metadata = AppMetadata(...)

let sessionParams = SessionParams(...)

WalletConnectModal.configure(
    projectId: PROJECT_ID,
    metadata: metadata,
    sessionParams: sessionParams
)

or you can change them later by calling WalletConnectModal.set(sessionParams: SessionParams(...))

WalletConnectModal is a singleton that interacts with the WalletConnectModal SDK.

Initialize

val connectionType = ConnectionType.AUTOMATIC or ConnectionType.MANUAL
val projectId = "" // Get Project ID at https://dashboard.reown.com/
val appMetaData = Core.Model.AppMetaData(
    name = "Kotlin.WalletConnectModal",
    description = "Kotlin WalletConnectModal Implementation",
    url = "kotlin.walletconnect.com",
    icons = listOf("https://raw.githubusercontent.com/WalletConnect/walletconnect-assets/master/Icon/Gradient/Icon.png"),
    redirect = "kotlin-modal://request"
)

CoreClient.initialize(projectId = projectId, connectionType = connectionType, application = this, metaData = appMetaData)

WalletConnectModal.initialize(
    init = Modal.Params.Init(CoreClient),
    onSuccess = {
        // Callback will be called if initialization is successful
     },
    onError = { error ->
        // Error will be thrown if there's an issue during initialization
    }
)

SessionParams

This example will default to using following namespaces. You can define your own session parameters like this.

val methods: List<String> = listOf("eth_sendTransaction", "personal_sign", "eth_sign", "eth_signTypedData")
val events: List<String> = listOf("chainChanged", "accountsChanged")
val chains: List<String> = listOf("eip155:1")
val namespaces = mapOf(
    "eip155" to Modal.Model.Namespace.Proposal(
        chains = chains,
        methods = methods,
        events = events
    )
)

val sessionParams = Modal.Params.SessionParams(
    requiredNamespaces = namespaces,
    optionalNamespaces = null,
    properties = null
)

WalletConnectModal.setSessionParams(sessionParams)

IMPORTANT: SessionParams must be set before opening the modal.

Create your WalletConnectModalService which is your primary class for opening, closing, disconnecting, etc.Be sure to update the project ID and metadata with your own.

WalletConnectModalService service = WalletConnectModalService(
  projectId: 'YOUR_PROJECT_ID',
  metadata: const PairingMetadata(
    name: 'Flutter WalletConnect',
    description: 'Flutter WalletConnectModal Sign Example',
    url: 'https://walletconnect.com/',
    icons: ['https://walletconnect.com/walletconnect-logo.png'],
    redirect: Redirect(
      native: 'flutterdapp://',
      universal: 'https://www.walletconnect.com',
    ),
  ),
);
await service.init();

The service must be initialized before it can be used.With the WalletConnectModalService created and ready, you can call _service.open() to open the modal.To make things easy, you can use the WalletConnectModalConnect widget to open the modal. This is a button that changes its state based on the modal and connection. This widget requires the WalletConnectModalService to be passed in.

WalletConnectModalConnect(
  walletConnectModalService: _service,
),

iOS Setup

For each app you would like to be able to deep link to, you must add that app’s link into the ios/Runner/Info.plist file like so:

<key>LSApplicationQueriesSchemes</key>
<array>
  <string>metamask</string>
  <string>rainbow</string>
  <string>trust</string>
</array>

To handle deep linking to your app, you will also need to add the following to the plist file:

<key>CFBundleURLTypes</key>
<array>
    <dict>
        <key>CFBundleURLSchemes</key>
        <array>
            <string>flutterdapp</string> <!-- Change "flutterdapp" to be your deep link -->
        </array>
        <key>CFBundleURLName</key>
        <string>com.walletconnect.flutterdapp</string> <!-- Change this package name to be your package -->
    </dict>
</array>

Android Setup

On android 11+ you must specify that use can use the internet, along with the different packages you would like to be able to deep link to in the android/app/src/main/AndroidManifest.xml file like so:

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <!-- Intent so you can deep link to wallets -->
    <queries>
        <intent>
            <action android:name="android.intent.action.VIEW" />
            <category android:name="android.intent.category.BROWSABLE" />
            <data android:scheme="https" />
        </intent>
        <package android:name="io.metamask"/>
        <package android:name="com.wallet.crypto.trustapp"/>
        <package android:name="io.gnosis.safe"/>
        <package android:name="me.rainbow"/>
        <package android:name="io.zerion.android"/>
        <package android:name="com.imtoken.app"/>
        <!-- Add other wallets you would like to launch from within the app -->
    </queries>
    <!-- Permission to access the internet -->
    <uses-permission android:name="android.permission.INTERNET"/>
    <!-- Update your activity to handle the deep linking from other apps -->
    <activity
            ...>
            <intent-filter>
                <action android:name="android.intent.action.VIEW" />
                <category android:name="android.intent.category.DEFAULT" />
                <category android:name="android.intent.category.BROWSABLE" />

                <!-- Accepts URIs that begin with "flutterdapp://”, change this to be your deep link -->
                <data android:scheme="flutterdapp" />
            </intent-filter>
        </activity>
    ...
</manifest>

For other packages, see the example projectFor some reason, multiple wallets have the metamask intent, and will launch metamask as a result. This is a bug in the wallets, not this package.

Start by importing @walletconnect/react-native-compat at the top of your app. Then import the WalletConnect Modal package, replace YOUR_PROJECT_ID with your Reown Dashboard Project ID and add your Project’s info in providerMetadata

import "@walletconnect/react-native-compat";
import { WalletConnectModal } from "@walletconnect/modal-react-native";

const projectId = "YOUR_PROJECT_ID";

const providerMetadata = {
  name: "YOUR_PROJECT_NAME",
  description: "YOUR_PROJECT_DESCRIPTION",
  url: "https://your-project-website.com/",
  icons: ["https://your-project-logo.com/"],
  redirect: {
    native: "YOUR_APP_SCHEME://",
    universal: "YOUR_APP_UNIVERSAL_LINK.com",
  },
};

function App() {
  return (
    <>
      <WalletConnectModal
        projectId={projectId}
        providerMetadata={providerMetadata}
      />
    </>
  );
}

Fill in the Project ID and Metadata fields in the Assets/WalletConnectUnity/Resources/WalletConnectProjectConfig asset.
- If you don’t have a Project ID, you can create one at Reown Dashboard.).
- The Redirect fields are optional. They are used to redirect the user back to your app after they approve or reject the session.
Add WalletConnectModal prefab from WalletConnectUnity Modal package to the first scene in your game.

openModal

Action to open the modal. Returns promise that resolves once modal is visible.

Example

await modal.openModal({
  uri: "YOUR_CONNECTION_URI",
});

Reference

openModal: (options?: OpenOptions) => Promise<void>;

interface OpenOptions {
  // Uri that will be used to generate qrcode and mobile links, required
  uri: string;
  // CAIP-2 compliant chain ids to override initial chains defined when creating the modal
  // Learn about CAIP-10: https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-10.md
  chains?: string[];
}

closeModal

Action to close the modal.

Example

modal.closeModal();

Reference

closeModal: () => void

subscribeModal

Action to subscribe to modal state changes.

Example

modal.subscribeModal((state) => console.log(state));

Reference

subscribeModal: (callback: (state: ModalState) => void) => void

interface ModalState {
  open: boolean;
}

To actually present the modal you can simply call.

WalletConnectModal.present()

It will traverse the view hierarchy and try to present from top most controller. This is meant more towards SwiftUI.Otherwise you can specify the viewController to present from.

WalletConnectModal.present(from: viewController)

The following publishers are available to subscribe:

public var sessionPublisher: AnyPublisher<[Session], Never>
public var sessionSettlePublisher: AnyPublisher<Session, Never>
public var sessionRejectionPublisher: AnyPublisher<(Session.Proposal, Reason), Never>
public var sessionDeletePublisher: AnyPublisher<(String, Reason), Never>
public var sessionResponsePublisher: AnyPublisher<Response, Never>
public var socketConnectionStatusPublisher: AnyPublisher<SocketConnectionStatus, Never>

Sign methods

WalletConnectModal is internally using Sign SDK and most of its method are being exposed through WalletConnectModal interface.

Where to go from here

Check the WalletConnectModal usage in our Example Showcase app that is part of WalletConnectSwiftV2 repository. Build API documentation in Xcode by going to Product -> Build Documentation

Android Compose

import androidx.compose.material.ExperimentalMaterialApi
import androidx.compose.material.ModalBottomSheetState
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import com.google.accompanist.navigation.material.BottomSheetNavigator
import com.google.accompanist.navigation.material.ExperimentalMaterialNavigationApi
import com.google.accompanist.navigation.material.ModalBottomSheetLayout
import com.google.accompanist.navigation.material.bottomSheet
import com.walletconnect.wcmodal.ui.walletConnectModalGraph

setContent {
    val modalSheetState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden, skipHalfExpanded = true)
    val bottomSheetNavigator = BottomSheetNavigator(modalSheetState)
    val navController = rememberNavController(bottomSheetNavigator)

    ModalBottomSheetLayout(bottomSheetNavigator = bottomSheetNavigator) {
        NavHost(
            navController = navController,
            startDestination = "home"
        ) {
            composable("home") {
                HomeScreen()
            }
            walletConnectModalGraph(navController)
        }
    }
}

IMPORTANT: WalletConnectModal uses accompanist navigation material inside. ModalBottomSheetLayout should be imported from Accompanist Navigation Material

import com.walletconnect.wcmodal.ui.openWalletConnectModal

navController.openWalletConnectModal()

Android View

<navigation >
    <fragment
        android:id="@+id/HomeFragment"
        android:name="com.walletconnect.sample.HomeFragment">

        <action
            android:id="@+id/action_to_bottomSheet"
            app:destination="@id/bottomSheet" />
    </fragment>

    <dialog
        android:id="@+id/bottomSheet"
        android:name="com.walletconnect.wcmodal.ui.WalletConnectModalSheet" />
</navigation>

import androidx.navigation.fragment.findNavController
import com.walletconnect.wcmodal.ui.openWalletConnectModal

findNavController().openWalletConnectModal(id = R.id.action_to_bottomSheet)

Kotlin DSL

import androidx.navigation.createGraph
import androidx.navigation.fragment.fragment
import com.walletconnect.wcmodal.ui.walletConnectModal

navController.graph = navController.createGraph("Home") {
    fragment<HomeFragment>("Home")
    walletConnectModal()
}

import androidx.navigation.fragment.findNavController
import com.walletconnect.wcmodal.ui.openWalletConnectModal

findNavController().openWalletConnectModal()

WalletConnectModal.ModalDelegate

val walletConnectModalDelegate = object : WalletConnectModal.ModalDelegate {
    override fun onSessionApproved(approvedSession: Modal.Model.ApprovedSession) {
        // Triggered when receives the session approval from wallet
    }

    override fun onSessionRejected(rejectedSession: Modal.Model.RejectedSession) {
        // Triggered when receives the session rejection from wallet
    }

    override fun onSessionUpdate(updatedSession: Modal.Model.UpdatedSession) {
        // Triggered when receives the session update from wallet
    }

    override fun onSessionExtend(session: Modal.Model.Session) {
        // Triggered when receives the session extend from wallet
    }

    override fun onSessionEvent(sessionEvent: Modal.Model.SessionEvent) {
        // Triggered when the peer emits events that match the list of events agreed upon session settlement
    }

    override fun onSessionDelete(deletedSession: Modal.Model.DeletedSession) {
        // Triggered when receives the session delete from wallet
    }

    override fun onSessionRequestResponse(response: Modal.Model.SessionRequestResponse) {
        // Triggered when receives the session request response from wallet
    }

    override fun onProposalExpired(proposal: Modal.Model.ExpiredProposal) {
        // Triggered when a proposal becomes expired
    }

    override fun onRequestExpired(request: Modal.Model.ExpiredRequest) {
        // Triggered when a request becomes expired
    }

    override fun onConnectionStateChange(state: Modal.Model.ConnectionState) {
        //Triggered whenever the connection state is changed
    }

    override fun onError(error: Modal.Model.Error) {
        // Triggered whenever there is an issue inside the SDK
    }
}

The WalletConnectModal needs a WalletConnectModal.ModalDelegate passed to it for it to be able to expose asynchronously updates sent from the Wallet. It can only be called after successful WalletConnectModal initialization

Connect

val namespace: String = /*Namespace identifier, see for reference: https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-2.md#syntax*/
val chains: List<String> = /*List of chains that wallet will be requested for*/
val methods: List<String> = /*List of methods that wallet will be requested for*/
val events: List<String> = /*List of events that wallet will be requested for*/
val requiredNamespaces: Map<String, Modal.Model.Namespaces.Proposal> = mapOf(namespace, Modal.Model.Namespaces.Proposal(accounts, methods, events)) /*Required namespaces to setup a session*/
val optionalNamespaces: Map<String, Modal.Model.Namespaces.Proposal> = mapOf(namespace, Modal.Model.Namespaces.Proposal(accounts, methods, events)) /*Optional namespaces to setup a session*/
val pairing: Core.Model.Pairing = /*Either an active or inactive pairing*/
val connectParams = Modal.Params.Connect(requiredNamespaces, optionalNamespaces, pairing)

WalletConnectModal.connect(
    connect = connectParams,
    onSuccess = {
        /* callback that letting you know that you have successfully initiated connecting */
    },
    onError = { error =>
        /* callback for error while trying to initiate a connection with a peer */
    }
)

More about optional and required namespaces can be found here

Disconnect

val disconnectParams = WalletConnectModal.Params.Disconnect(topic)

WalletConnectModal.disconnect(
    disconnect = disconnectParams,
    onSuccess = {
    /* callback that letting you know that you have successfully disconnected */
    },
    onError = { error ->
    /* callback for error while trying to disconnection with a peer */
    }
)

Request

val requestParams = Modal.Params.Request(
    sessionTopic = sessionTopic,
    method = /* Selected method */,
    params = /* Method params  */,
    chainId = /* Chain id */
)

WalletConnectModal.request(
    request = requestParams,
    onSuccess = {
    /* callback that letting you know that you have successful request */
    },
    onError = { error ->
    /* callback for error */
    }
)

Get List of Active Sessions

WalletConnectModal.getListOfActiveSessions()

To get a list of active sessions, call WalletConnectModal.getListOfActiveSessions() which will return a list of type Modal.Model.Session.

Get list of pending session requests for a topic

WalletConnectModal.getActiveSessionByTopic(topic)

To get an active session for a topic, call WalletConnectModal.getActiveSessionByTopic() and pass a topic which will return a Modal.Model.Session object containing requestId, method, chainIs and params for pending request.

You can launch the currently connected wallet by calling service.launchCurrentWallet().

useWalletConnectModal

Hook to programmatically control the modal. Useful when you want to use your own UI elements and subscribe to modals state.*Note: A new session is created automatically when the modal is opened, so avoid calling provider.connect by yourself.

import { useWalletConnectModal } from "@walletconnect/modal-react-native";

const { isOpen, open, close, provider, isConnected, address } = useWalletConnectModal();

// Modal's open state
isOpen;

// Open modal
interface Options {
  route?: 'ConnectWallet' | 'Qrcode' | 'WalletExplorer';
}
await open(options?: Options);

// Close modal
close();

// Initialized provider
provider;

// Wallet connection state
isConnected;

// Connected account's address
address;

Example

import { Pressable, Text } from "react-native";
import "@walletconnect/react-native-compat";
import {
  WalletConnectModal,
  useWalletConnectModal,
} from "@walletconnect/modal-react-native";

const projectId = "YOUR_PROJECT_ID";

const providerMetadata = {
  name: "YOUR_PROJECT_NAME",
  description: "YOUR_PROJECT_DESCRIPTION",
  url: "https://your-project-website.com/",
  icons: ["https://your-project-logo.com/"],
  redirect: {
    native: "YOUR_APP_SCHEME://",
    universal: "YOUR_APP_UNIVERSAL_LINK.com",
  },
};

function App() {
  const { open, isConnected, provider } = useWalletConnectModal();

  const onPress = () => {
    if (isConnected) {
      provider.disconnect();
    } else {
      open();
    }
  };

  return (
    <>
      <Pressable onPress={onPress}>
        <Text>{isConnected ? "Disconnect" : "Connect"}</Text>
      </Pressable>
      <WalletConnectModal
        projectId={projectId}
        providerMetadata={providerMetadata}
      />
    </>
  );
}

Connection and Events

WalletConnect Modal is a singleton that can be accessed from any scene.
By default Modal will initialize itself asynchronously on Awake. During initialization it will also try to connect to the last session.
After initialization, Modal invokes WalletConnectModal.Ready static event.
If Ready argument’s SessionResumed is true, it means that Modal has successfully connected to the last session. In this case you don’t need to open the modal. Otherwise, open the modal with WalletConnectModal.Open() static method.

private void Start()
{
    WalletConnectModal.Ready += (sender, args) =>
    {
        if (args.SessionResumed)
        {
            // Session has been resumed, proceed to the game
        }
        else
        {
            // Session hasn't been resumed

            // Define required namespaces for new session
            var requiredNamespaces = new RequiredNamespaces
            {
                {
                    "eip155", new ProposedNamespace
                    {
                        Methods = new[]
                        {
                            "eth_sendTransaction",
                            "personal_sign",
                            "eth_signTypedData"
                        },
                        Chains = new[]
                        {
                            "eip155:1"
                        },
                        Events = new[]
                        {
                            "chainChanged",
                            "accountsChanged"
                        }
                    }
                }
            };

            var connectOptions = new ConnectOptions
            {
                RequiredNamespaces = requiredNamespaces
            };

            // Open the modal
            WalletConnectModal.Open(new WalletConnectModalOptions
            {
                ConnectOptions = connectOptions
            });
        }
    };
}

Subscribe to ActiveSessionChanged and SessionDeleted events. It’s recommended to do it in Ready event handler.

WalletConnectModal.Ready += (sender, args) =>
{
    // ....

    // Invoked after wallet connected
    WalletConnect.Instance.ActiveSessionChanged += (_, sessionStruct) =>
    {
        // Session connected/updated, proceed to the game if sessionStruct.topic is not null/empty
    };

    // Invoked after wallet disconnected
    WalletConnect.Instance.SessionDisconnected += (_, _) =>
    {
        // Session deleted, show sign in screen
    };
};

Disconnection

To disconnect from the current session, call WalletConnectModal.Disconnect() static method.

Interaction with RPC

The WalletConnect Modal is responsible for facilitating communication between the game and the wallet. Some methods do not require the user to interact with the wallet. For example, eth_getBalance is used to get the address balance, and eth_call is used to read data from a smart contract without modifying its state, hence no signature is required.To call these methods, you can use the Nethereum.Web3 package.

private static async Task GetAccountBalance()
{
    var session = WalletConnect.Instance.ActiveSession;

    // Because one session can have multiple namespaces, we need to select one.
    // In most cases, especially in games, dapp will use only one namespace.
    var @namespace = session.Namespaces.First();
    var address = session.CurrentAddress(@namespace.Key).Address;

    var config = ProjectConfiguration.Load();

    // Using WalletConnect Blockchain API: https://docs.walletconnect.com/cloud/blockchain-api
    var url = $"https://rpc.walletconnect.com/v1?chainId={@namespace.Value.Chains[0]}&projectId={config.Id}";

    var web3 = new Nethereum.Web3.Web3(url);
    var balance = await web3.Eth.GetBalance.SendRequestAsync(address);
    Debug.Log($"Balance of {address} in Wei: {balance.Value}");

    var etherAmount = Nethereum.Web3.Web3.Convert.FromWei(balance.Value);
    Debug.Log($"Balance of {address} in Ether: {etherAmount}");
}

Interaction with Smart Contracts

To query smart contracts, you can use Nethereum.Web3 package to make eth_call requests directly to the RPC endpoint. However, to call methods that modify the state of the smart contract, you need user to sign the transaction in the wallet.There are two ways to interact with smart contracts:

With Interceptor: using Nethereum’s RequestInterceptor (recommended)
Manual: using Nethereum’s tools to encode data and make requests directly with WalletConnect

Interceptor (recommended)
Manual

WalletConnect provides a Nethereum interceptor utility that will route requests that require user signature to the wallet. With this approach, you don’t need to manually encode data and make requests. Use convenient Nethereum’s methods to interact with smart contracts, and interceptor will automatically route requests to the wallet.WalletConnectUnity Nethereum source code

Install interceptor

openupm add com.walletconnect.nethereum

Use interceptor

This example shows how to call transfer method of ERC20 smart contract using interceptor.

// Nethereum's Web3 instance
var web3 = new Web3();

// Instance of WalletConnect singleton
var walletConnect = WalletConnect.Instance;

// Interceptor that will route requests requiring signing to the wallet connected with WalletConnect
var walletConnectUnityInterceptor = new WalletConnectUnityInterceptor(walletConnect);

// Assign the interceptor to the Web3 instance
web3.Client.OverridingRequestInterceptor = walletConnectUnityInterceptor;

const string contractAddress = "0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984";
const string recipientAddress = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
const BigInteger amount = 1;

// Get ERC20 contract service
var contractService = Web3Modal.Web3.Eth.ERC20.GetContractService(contractAddress);

// Call transfer method of ERC20 contract
await contractService.TransferRequestAsync(recipientAddress, amount);

Nethereum allows to deploy and interact with custom smart contracts as well. Refer to the Nethereum documentation for more information.

The example below shows how to call approve method of WETH9 (Wrapped Ether) smart contract. It encodes data with Nethereum and makes request with WalletConnect.

public async Task ContractTransaction()
{
    var session = WalletConnect.Instance.ActiveSession;

    // Because one session can have multiple namespaces, we need to select one.
    // In most cases, especially in games, dapp will use only one namespace.
    var @namespace = session.Namespaces.First();
    var myAddress = session.CurrentAddress(@namespace.Key).Address;

    // Define contract and function details
    var contractAddress = "0x4200000000000000000000000000000000000006";
    var toAddress = myAddress; // Use sender's address for the sake of example
    var amount = new BigInteger(12345);

    // Define the parameters for the approve function
    var parameters = new Parameter[] {
        new("address", "guy"),
        new("uint256", "wad")
    };

    var functionCallEncoder = new FunctionCallEncoder();
    var sha3Signature = new Sha3Keccack().CalculateHash("approve(address,uint256)");

    // Encode the parameters
    var encodedParameters = functionCallEncoder
        .EncodeParameters(parameters, toAddress, amount)
        .ToHex();

    // Combine signature and parameters
    var data = "0x" + sha3Signature[..8] + encodedParameters;

    // Create transaction
    var ethSendTransaction = new EthSendTransaction(new Transaction
    {
        From = myAddress,
        To = contractAddress,
        Value = "0",
        Data = data
    });

    try
    {
        var result = await WalletConnect.Instance.RequestAsync<EthSendTransaction, string>(ethSendTransaction);
        Debug.Log($"Transaction success! TxHash: {result}", this);
    }
    catch (Exception e)
    {
        Debug.LogError(e, this);
    }
}

public class Transaction
{
    [JsonProperty("from")] public string From { get; set; }

    [JsonProperty("to")] public string To { get; set; }

    [JsonProperty("gas", NullValueHandling = NullValueHandling.Ignore)]
    public string Gas { get; set; }

    [JsonProperty("gasPrice", NullValueHandling = NullValueHandling.Ignore)]
    public string GasPrice { get; set; }

    [JsonProperty("value")] public string Value { get; set; }

    [JsonProperty("data", NullValueHandling = NullValueHandling.Ignore)]
    public string Data { get; set; } = "0x";
}

[RpcMethod("eth_sendTransaction"), RpcRequestOptions(Clock.ONE_MINUTE, 99997)]
public class EthSendTransaction : List<Transaction>
{
    public EthSendTransaction(params Transaction[] transactions) : base(transactions)
    {
    }

    [Preserve]
    public EthSendTransaction()
    {
    }
}

Please refer to Nethereum documentation for more details. Nethereum provides tools to simplify encoding and decoding. These tools hadn’t been used in the example above to better illustrate the process.

var signClient = WalletConnect.Instance.SignClient;
signClient.SubscribeToSessionEvent("chainChanged", OnChainChanged);

Dashboard

Advanced

Technical Reference

​Implementation

​Trigger the modal

​Configure Networking and Pair clients

​Initialize WalletConnectModal Client

​Initialize

​SessionParams

​iOS Setup

​Android Setup

​Usage

​openModal

​Example

​Reference

​closeModal

​Example

​Reference

​subscribeModal

​Example

​Reference

​Subscribe for WalletConnectModal Publishers

​Sign methods

​Where to go from here

​Android Compose

​Android View

​Navigation Component

​Kotlin DSL

​WalletConnectModal.ModalDelegate

​Connect

​Disconnect

​Request

​Get List of Active Sessions

​Get list of pending session requests for a topic

​useWalletConnectModal

​Example

​Connection and Events

​Disconnection

​Interaction with RPC

​Interaction with Smart Contracts

​Install interceptor

​Use interceptor

​Subscribe to session events

Implementation

Trigger the modal

Configure Networking and Pair clients

Initialize WalletConnectModal Client

Initialize

SessionParams

iOS Setup

Android Setup

Usage

openModal

Example

Reference

closeModal

Example

Reference

subscribeModal

Example

Reference

Subscribe for WalletConnectModal Publishers

Sign methods

Where to go from here

Android Compose

Android View

Navigation Component

Kotlin DSL

WalletConnectModal.ModalDelegate

Connect

Disconnect

Request

Get List of Active Sessions

Get list of pending session requests for a topic

useWalletConnectModal

Example

Connection and Events

Disconnection

Interaction with RPC

Interaction with Smart Contracts

Install interceptor

Use interceptor

Subscribe to session events