281 lines
10 KiB
QML
281 lines
10 KiB
QML
import QtQuick 2.15
|
|
|
|
import StatusQ 0.1
|
|
import StatusQ.Core.Utils 0.1 as SQUtils
|
|
|
|
import AppLayouts.Wallet 1.0
|
|
import AppLayouts.Wallet.services.dapps 1.0
|
|
import AppLayouts.Wallet.services.dapps.types 1.0
|
|
import shared.popups.walletconnect 1.0
|
|
|
|
import SortFilterProxyModel 0.2
|
|
import utils 1.0
|
|
|
|
import "types"
|
|
|
|
SQUtils.QObject {
|
|
id: root
|
|
|
|
required property DAppsModule dappsModule
|
|
required property string selectedAddress
|
|
required property var accountsModel
|
|
|
|
property bool walletConnectFeatureEnabled: true
|
|
property bool connectorFeatureEnabled: true
|
|
|
|
// Output properties
|
|
/// Model contaning all dApps available for the currently selected account
|
|
readonly property var dappsModel: d.filteredDappsModel
|
|
/// Model containig the dApps session requests to be resolved by the user
|
|
readonly property SessionRequestsModel sessionRequestsModel: dappsModule.requestsModel
|
|
/// Service can interact with the current address selection
|
|
/// Default value: true
|
|
readonly property bool serviceAvailableToCurrentAddress: !root.selectedAddress ||
|
|
SQUtils.ModelUtils.contains(root.accountsModel, "address", root.selectedAddress, Qt.CaseInsensitive)
|
|
|
|
readonly property bool isServiceOnline: dappsModule.isServiceOnline
|
|
|
|
// signals
|
|
signal connectDApp(var dappChains, url dappUrl, string dappName, url dappIcon, string connectorIcon, string key)
|
|
// Emitted as a response to DAppsService.approveSession
|
|
// @param key The key of the session proposal
|
|
// @param error The error message
|
|
// @param topic The new topic of the session
|
|
signal approveSessionResult(string key, var error, string topic)
|
|
// Emitted when a new session is requested by a dApp
|
|
signal sessionRequest(string id)
|
|
// Emitted when the services requests to display a toast message
|
|
// @param message The message to display
|
|
// @param type The type of the message. Maps to Constants.ephemeralNotificationType
|
|
signal displayToastMessage(string message, int type)
|
|
// Emitted as a response to DAppsService.validatePairingUri or other DAppsService.pair
|
|
// and DAppsService.approvePair errors
|
|
signal pairingValidated(int validationState)
|
|
|
|
// methods
|
|
/// Triggers the signing process for the given session request
|
|
/// @param topic The topic of the session
|
|
/// @param id The id of the session request
|
|
function sign(topic, id) {
|
|
// The authentication triggers the signing process
|
|
// authenticate -> sign -> inform the dApp
|
|
d.sign(topic, id)
|
|
}
|
|
|
|
function rejectSign(topic, id, hasError) {
|
|
d.rejectSign(topic, id, hasError)
|
|
}
|
|
|
|
function signRequestIsLive(topic, id) {
|
|
d.signRequestIsLive(topic, id)
|
|
}
|
|
|
|
/// Validates the pairing URI
|
|
function validatePairingUri(uri) {
|
|
d.validatePairingUri(uri)
|
|
}
|
|
|
|
/// Initiates the pairing process with the given URI
|
|
function pair(uri) {
|
|
timeoutTimer.start()
|
|
dappsModule.pair(uri)
|
|
}
|
|
|
|
/// Approves or rejects the session proposal
|
|
function approvePairSession(key, approvedChainIds, accountAddress) {
|
|
dappsModule.approvePairSession(key, approvedChainIds, accountAddress)
|
|
}
|
|
|
|
|
|
/// Rejects the session proposal
|
|
function rejectPairSession(id) {
|
|
dappsModule.rejectPairSession(id)
|
|
}
|
|
|
|
/// Disconnects the dApp with the given topic
|
|
/// @param topic The topic of the dApp
|
|
/// @param source The source of the dApp; either "walletConnect" or "connector"
|
|
function disconnectDapp(topic) {
|
|
d.disconnectDapp(topic)
|
|
}
|
|
|
|
SQUtils.QObject {
|
|
id: d
|
|
|
|
readonly property var filteredDappsModel: SortFilterProxyModel {
|
|
id: dappsFilteredModel
|
|
objectName: "DAppsModelFiltered"
|
|
sourceModel: root.dappsModule.dappsModel
|
|
readonly property string selectedAddress: root.selectedAddress
|
|
readonly property var connectorIcons: Constants.dappImageByType
|
|
|
|
proxyRoles: [
|
|
FastExpressionRole {
|
|
name: "connectorBadge"
|
|
expression: dappsFilteredModel.connectorIcons[connectorId]
|
|
expectedRoles: "connectorId"
|
|
}
|
|
]
|
|
filters: FastExpressionFilter {
|
|
enabled: !!dappsFilteredModel.selectedAddress
|
|
|
|
function isAddressIncluded(accountAddressesSubModel, selectedAddress) {
|
|
if (!accountAddressesSubModel) {
|
|
return false
|
|
}
|
|
const addresses = SQUtils.ModelUtils.modelToFlatArray(accountAddressesSubModel, "address")
|
|
return addresses.includes(selectedAddress)
|
|
}
|
|
expression: isAddressIncluded(model.accountAddresses, dappsFilteredModel.selectedAddress)
|
|
|
|
expectedRoles: "accountAddresses"
|
|
}
|
|
}
|
|
|
|
function disconnectDapp(connectionId) {
|
|
dappsModule.disconnectSession(connectionId)
|
|
}
|
|
|
|
function validatePairingUri(uri) {
|
|
// Check if emoji inside the URI
|
|
if(Constants.regularExpressions.emoji.test(uri)) {
|
|
root.pairingValidated(Pairing.errors.tooCool)
|
|
return
|
|
} else if(!DAppsHelpers.validURI(uri)) {
|
|
root.pairingValidated(Pairing.errors.invalidUri)
|
|
return
|
|
}
|
|
|
|
dappsModule.validatePairingUri(uri)
|
|
}
|
|
|
|
function signRequestIsLive(topic, id) {
|
|
const request = root.sessionRequestsModel.findRequest(topic, id)
|
|
if (!request) {
|
|
console.error("Session request not found")
|
|
return
|
|
}
|
|
request.setActive()
|
|
}
|
|
|
|
function sign(topic, id) {
|
|
const request = root.sessionRequestsModel.findRequest(topic, id)
|
|
if (!request) {
|
|
console.error("Session request not found")
|
|
return
|
|
}
|
|
request.accept()
|
|
}
|
|
|
|
function rejectSign(topic, id, hasError) {
|
|
const request = root.sessionRequestsModel.findRequest(topic, id)
|
|
if (!request) {
|
|
console.error("Session request not found")
|
|
return
|
|
}
|
|
request.reject(hasError)
|
|
}
|
|
|
|
function reportPairErrorState(state) {
|
|
timeoutTimer.stop()
|
|
root.pairingValidated(state)
|
|
}
|
|
}
|
|
|
|
Connections {
|
|
target: root.dappsModule
|
|
enabled: root.walletConnectFeatureEnabled || root.connectorFeatureEnabled
|
|
function onPairingValidated(state) {
|
|
timeoutTimer.stop()
|
|
root.pairingValidated(state)
|
|
}
|
|
|
|
function onPairingResponse(key, state) {
|
|
timeoutTimer.stop()
|
|
if (state != Pairing.errors.uriOk) {
|
|
d.reportPairErrorState(state)
|
|
}
|
|
}
|
|
|
|
function onConnectDApp(dappChains, dappUrl, dappName, dappIcon, connectorId, key) {
|
|
const connectorIcon = Constants.dappImageByType[connectorId]
|
|
root.connectDApp(dappChains, dappUrl, dappName, dappIcon, connectorIcon, key)
|
|
}
|
|
|
|
function onDappConnected(proposal, topic, url, connectorId) {
|
|
const dappDomain = SQUtils.StringUtils.extractDomainFromLink(url)
|
|
const connectorName = connectorId === Constants.WalletConnect ? "WalletConnect" : "Status Connector"
|
|
root.displayToastMessage(qsTr("Connected to %1 via %2").arg(dappDomain).arg(connectorName), Constants.ephemeralNotificationType.success)
|
|
root.approveSessionResult(proposal, null, topic)
|
|
}
|
|
|
|
function onDappDisconnected(topic, url) {
|
|
const appDomain = SQUtils.StringUtils.extractDomainFromLink(url)
|
|
root.displayToastMessage(qsTr("Disconnected from %1").arg(appDomain), Constants.ephemeralNotificationType.success)
|
|
}
|
|
|
|
function onNewConnectionFailed(key, url, error) {
|
|
timeoutTimer.stop()
|
|
const dappDomain = SQUtils.StringUtils.extractDomainFromLink(url)
|
|
if (error === Pairing.errors.userRejected) {
|
|
root.displayToastMessage(qsTr("Connection request for %1 was rejected").arg(dappDomain), Constants.ephemeralNotificationType.success)
|
|
}
|
|
if (error === Pairing.errors.rejectFailed) {
|
|
root.displayToastMessage(qsTr("Failed to reject connection request for %1").arg(dappDomain), Constants.ephemeralNotificationType.danger)
|
|
}
|
|
d.reportPairErrorState(error)
|
|
root.approveSessionResult(key, error, "")
|
|
}
|
|
|
|
function onSignCompleted(topic, id, userAccepted, error) {
|
|
const request = root.sessionRequestsModel.findRequest(topic, id)
|
|
if (!request) {
|
|
console.error("Session request not found")
|
|
return
|
|
}
|
|
|
|
const methodStr = SessionRequest.methodToUserString(request.method)
|
|
const appUrl = request.dappUrl
|
|
const appDomain = SQUtils.StringUtils.extractDomainFromLink(appUrl)
|
|
if (!methodStr) {
|
|
console.error("Error finding user string for method", request.method)
|
|
return
|
|
}
|
|
|
|
if (error) {
|
|
root.displayToastMessage(qsTr("Fail to %1 from %2").arg(methodStr).arg(appDomain), Constants.ephemeralNotificationType.danger)
|
|
return
|
|
}
|
|
|
|
const requestExpired = request.isExpired()
|
|
if (requestExpired) {
|
|
root.displayToastMessage("%1 sign request timed out".arg(appDomain), Constants.ephemeralNotificationType.normal)
|
|
return
|
|
}
|
|
|
|
const actionStr = userAccepted ? qsTr("accepted") : qsTr("rejected")
|
|
root.displayToastMessage("%1 %2 %3".arg(appDomain).arg(methodStr).arg(actionStr), Constants.ephemeralNotificationType.success)
|
|
}
|
|
|
|
function onSiweCompleted(topic, id, userAccepted, error) {
|
|
if (error) {
|
|
root.displayToastMessage(error, Constants.ephemeralNotificationType.danger)
|
|
}
|
|
root.approveSessionResult(id, error, topic)
|
|
}
|
|
}
|
|
|
|
// Timeout for the corner case where the URL was already dismissed and the SDK doesn't respond with an error nor advances with the proposal
|
|
Timer {
|
|
id: timeoutTimer
|
|
|
|
interval: 10000 // (10 seconds)
|
|
running: false
|
|
repeat: false
|
|
|
|
onTriggered: {
|
|
d.reportPairErrorState(Pairing.errors.unknownError)
|
|
}
|
|
}
|
|
}
|