WalletConnectSwift

Swift SDK implementing WalletConnect 1.x.x protocol for native iOS Dapps and Wallets.

Features

Server (wallet side)
- Create, reconnect, disconnect, and update session
- Flexible, extendable request handling with Codable support via JSON RPC 2.0
Client (native dapp side)
- Create, reconnect, disconnect, and update session
- Default implementation of WalletConnect SDK API
  - personal_sign
  - eth_sign
  - eth_signTypedData
  - eth_sendTransaction
  - eth_signTransaction
  - eth_sendRawTransaction
- Send custom RPC requests with Codable support via JSON RPC 2.0

Example Code

Example code is in a separate repository: https://github.com/WalletConnect/WalletConnectSwift-Example

Wallet Example App:
- Connecting via QR code reader
- Connecting via deep link ("wc" scheme)
- Reconnecting after restart
- Examples of request handlers
Dapp Example App:
- Connecting via QR code reader
- Connecting via deep link ("wc" scheme)
- Reconnecting after restart
- Examples of request handlers

Usage in a Wallet

To start connections, you need to create and retain a Server object to which you provide a delegate:

letserver=Server(delegate:self)

The library handles WalletConnect-specific session requests for you - wc_sessionRequest and wc_sessionUpdate.

To register for the important session update events, implement the delegate methods shouldStart, didConnect, didDisconnect and didFailToConnect.

By default, the server cannot handle any other reqeusts - you need to provide your implementation.

You do this by registering request handlers. You have the flexibility to register one handler per request method, or a catch-all request handler.

server.register(handler:PersonalSignHandler(for:self, server: server, wallet: wallet))

Handlers are asked (in order of registration) whether they can handle each request. First handler that returns true from canHandle(request:) method will get the handle(request:) call. All other handlers will be skipped.

In the request handler, check the incoming request's method in canHandle implementation, and handle actual request in the handle(request:) implementation.

func canHandle(request:Request)->Bool{return request.method =="eth_signTransaction"}

You can send back response for the request through the server using send method:

func handle(request:Request){
// do you stuff here ...
// error response - rejected by user
server.send(.reject(request))
// or send actual response - assuming the request.id exists, and MyCodableStruct type defined
try server.send(Response(url: request.url, value:MyCodableStruct(value:"Something"), id: request.id!))}

For more details, see the ExampleApps/ServerApp

Usage in a Dapp

To start connections, you need to create and keep alive a Client object to which you provide DappInfo and a delegate:

letclient=Client(delegate:self, dAppInfo: dAppInfo)

The delegate then will receive calls when connection established, failed, or disconnected.

Upon successful connection, you can invoke various API methods on the Client.

try? client.personal_sign(url: session.url, message:"Hi there!", account: session.walletInfo!.accounts[0]){[weak self] response in
// handle the response from Wallet here
}

You can also send a custom request. The request ID required by JSON RPC is generated and handled by the library internally.

try? client.send(Request(url: url, method:"eth_gasPrice")){[weak self] response in
// handle the response
}

You can convert the received response result to a Decodable type.

letnonceString=try response.result(as:String.self)

You can also check if the wallet responded with error:

iflet error = response.error { // NSError
// handle error
}

For more details, see the ExampleApps/ClientApp

Logs

Filter the type of logs being printed by changing the log level LogService.level = .info.

Running Example Apps

Please open ExampleApps/ExampleApps.xcodeproj

Installation

Prerequisites

iOS 13.0 or macOS 10.14
Swift 5