320 lines
11 KiB
QML
320 lines
11 KiB
QML
import QtQuick 2.15
|
|
|
|
import StatusQ.Core.Utils 0.1 as SQUtils
|
|
import AppLayouts.Wallet.services.dapps 1.0
|
|
import AppLayouts.Wallet.services.dapps.types 1.0
|
|
|
|
import shared.stores 1.0
|
|
import utils 1.0
|
|
|
|
SQUtils.QObject {
|
|
id: root
|
|
|
|
// The SIWE lifecycle is a state machine that handles the lifecycle of a SIWE request
|
|
// Steps:
|
|
// 1. Make sure we have session approvals from the user
|
|
// 2. Populate the auth payload
|
|
// 3. Format the auth message
|
|
// 4. Present the formatted auth message to the user
|
|
// 5. Sign the auth message
|
|
required property WalletConnectSDKBase sdk
|
|
// Store object expected with sign and autheticate methods and signals
|
|
required property DAppsStore store
|
|
// JSON object received from WC
|
|
// We're interested in the following properties:
|
|
// {
|
|
// topic,
|
|
// params: {
|
|
// requester: {
|
|
// metadata: {
|
|
// name,
|
|
// url,
|
|
// icons: [url]
|
|
// }
|
|
// },
|
|
// authPayload: {
|
|
// chains: [chainIds]
|
|
// },
|
|
// expiryTimestamp
|
|
// },
|
|
// id
|
|
// }
|
|
required property var request
|
|
// Account model with the following roles:
|
|
// - address
|
|
required property var accountsModel
|
|
// Networks model with the following roles:
|
|
// - chainId
|
|
required property var networksModel
|
|
|
|
// Signals the starting of the lifecycle
|
|
signal started()
|
|
// Signals the end of the lifecycle
|
|
signal finished(string error)
|
|
// Request session approval from the user
|
|
// This request should provide the approved chains, accounts and methods the dApp can use
|
|
signal requestSessionApproval(var chains, string dAppUrl, string dAppName, string dAppIcon, var key)
|
|
// Register a SessionRequestResolved object to be presented to the user for signing
|
|
signal registerSignRequest(var request)
|
|
// Unregister the SessionRequestResolved object
|
|
signal unregisterSignRequest(var id)
|
|
|
|
onFinished: {
|
|
if (!request.requestId) {
|
|
return
|
|
}
|
|
sdkConnections.enabled = false
|
|
root.unregisterSignRequest(request.requestId)
|
|
}
|
|
|
|
function start() {
|
|
d.start()
|
|
}
|
|
|
|
// Session approved provides the approved namespaces containing the chains, accounts and methods
|
|
function sessionApproved(key, approvedNamespaces) {
|
|
if (root.request.id != key) {
|
|
return false
|
|
}
|
|
d.sessionApproved(key, approvedNamespaces)
|
|
}
|
|
|
|
// Session rejected by the user
|
|
function sessionRejected(key) {
|
|
if (root.request.id != key) {
|
|
return
|
|
}
|
|
|
|
root.finished("Session rejected")
|
|
}
|
|
|
|
Connections {
|
|
id: sdkConnections
|
|
target: root.sdk
|
|
enabled: false
|
|
|
|
//Third step: format auth message
|
|
function onPopulateAuthPayloadResult(id, authPayload, error) {
|
|
try {
|
|
if (root.request.id != id) {
|
|
return
|
|
}
|
|
|
|
if (error || !authPayload) {
|
|
root.finished(error)
|
|
return
|
|
}
|
|
const iss = request.approvedNamespaces.eip155.accounts[0]
|
|
request.authPayload = authPayload
|
|
sdk.formatAuthMessage(id, authPayload, iss)
|
|
} catch (e) {
|
|
console.warn("Error in SiweLifeCycle::onPopulateAuthPayloadResult", e)
|
|
root.finished(e)
|
|
}
|
|
}
|
|
|
|
//Fourth step: present formatted auth message to user
|
|
function onFormatAuthMessageResult(id, authData, error) {
|
|
try {
|
|
if (root.request.id != id) {
|
|
return
|
|
}
|
|
|
|
if (error || !authData) {
|
|
root.finished(error)
|
|
return
|
|
}
|
|
request.preparedData = authData
|
|
root.registerSignRequest(request)
|
|
} catch (e) {
|
|
console.warn("Error in SiweLifeCycle::onFormatAuthMessageResult", e)
|
|
root.finished(e)
|
|
}
|
|
}
|
|
|
|
function onAcceptSessionAuthenticateResult(id, result, error) {
|
|
if (root.request.id != id) {
|
|
return
|
|
}
|
|
|
|
if (error || !result) {
|
|
root.finished(error)
|
|
return
|
|
}
|
|
|
|
root.finished("")
|
|
}
|
|
}
|
|
|
|
// Request object to be used for signing
|
|
// The data on this object is filled step by step with the sdk callbacks
|
|
// After user has signed the data, the request is sent to the sdk for further processing
|
|
SessionRequestWithAuth {
|
|
id: request
|
|
|
|
property var approvedNamespaces
|
|
property var authPayload
|
|
property var extractedChainsAndAccounts: approvedNamespaces ?
|
|
DAppsHelpers.extractChainsAndAccountsFromApprovedNamespaces(approvedNamespaces) :
|
|
{ chains: [], accounts: [] }
|
|
|
|
sourceId: Constants.DAppConnectors.WalletConnect
|
|
store: root.store
|
|
|
|
dappUrl: root.request.params.requester.metadata.url
|
|
dappName: root.request.params.requester.metadata.name
|
|
dappIcon: root.request.params.requester.metadata.icons && root.request.params.requester.metadata.icons.length > 0 ?
|
|
root.request.params.requester.metadata.icons[0] : ""
|
|
|
|
requestId: root.request.id
|
|
accountAddress: extractedChainsAndAccounts.accounts[0] ?? ""
|
|
chainId: extractedChainsAndAccounts.chains[0] ?? ""
|
|
method: SessionRequest.methods.personalSign.name
|
|
event: root.request
|
|
topic: root.request.topic
|
|
data: ""
|
|
preparedData: ""
|
|
expirationTimestamp: root.request.params.expiryTimestamp
|
|
|
|
function onBuildAuthenticationObjectResult(id, authObject, error) {
|
|
if (id != request.requestId) {
|
|
return
|
|
}
|
|
|
|
try {
|
|
if (error) {
|
|
root.finished(error)
|
|
return
|
|
}
|
|
|
|
sdk.buildAuthObjectResult.disconnect(request.onBuildAuthenticationObjectResult)
|
|
if (error) {
|
|
request.reject(true)
|
|
}
|
|
sdk.acceptSessionAuthenticate(id, [authObject])
|
|
} catch (e) {
|
|
console.warn("Error in SiweLifeCycle::onBuildAuthenticationObjectResult", e)
|
|
root.finished(e)
|
|
}
|
|
}
|
|
|
|
function signedHandler(topic, id, data) {
|
|
if (topic != request.topic || id != request.requestId) {
|
|
return
|
|
}
|
|
|
|
try {
|
|
root.store.signingResult.disconnect(request.signedHandler)
|
|
let hasErrors = (data == "")
|
|
if (hasErrors) {
|
|
request.reject(true)
|
|
}
|
|
|
|
sdk.buildAuthObjectResult.connect(request.onBuildAuthenticationObjectResult)
|
|
sdk.buildAuthObject(id, request.authPayload, data, request.approvedNamespaces.eip155.accounts[0])
|
|
} catch (e) {
|
|
console.warn("Error in SiweLifeCycle::signedHandler", e)
|
|
root.finished(e)
|
|
}
|
|
}
|
|
|
|
onRejected: (hasError) => {
|
|
try {
|
|
sdk.rejectSessionAuthenticate(request.requestId, hasError)
|
|
root.finished("Signing rejected")
|
|
} catch (e) {
|
|
console.warn("Error in SiweLifeCycle::onRejected", e)
|
|
root.finished(e)
|
|
}
|
|
}
|
|
|
|
onAuthFailed: () => {
|
|
try {
|
|
sdk.rejectSessionAuthenticate(request.requestId, true)
|
|
const appDomain = SQUtils.StringUtils.extractDomainFromLink(request.dappUrl)
|
|
const methodStr = SessionRequest.methodToUserString(request.method)
|
|
if (!methodStr) {
|
|
return
|
|
}
|
|
|
|
root.finished(qsTr("Failed to authenticate %1 from %2").arg(methodStr).arg(appDomain))
|
|
} catch (e) {
|
|
console.warn("Error in SiweLifeCycle::onAuthFailed", e)
|
|
root.finished(e)
|
|
}
|
|
}
|
|
|
|
onExecute: (password, pin) => {
|
|
try {
|
|
root.store.signingResult.connect(request.signedHandler)
|
|
root.store.signMessage(request.topic, request.requestId, request.accountAddress, request.preparedData, password, pin)
|
|
} catch (e) {
|
|
console.warn("Error in SiweLifeCycle::onExecute", e)
|
|
root.finished(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
QtObject {
|
|
id: d
|
|
|
|
function start() {
|
|
if (request.isExpired()) {
|
|
console.warn("Error in SiweLifeCycle", "Request expired")
|
|
root.finished("Request expired")
|
|
return
|
|
}
|
|
|
|
if (!root.request.id || !root.request.topic) {
|
|
console.warn("Error in SiweLifeCycle", "Invalid request")
|
|
root.finished("Invalid request")
|
|
return
|
|
}
|
|
sdkConnections.enabled = true
|
|
root.started()
|
|
// First step: make sure we have session approvals
|
|
sdk.getActiveSessions((allSessionsAllProfiles) => {
|
|
try {
|
|
const sessions = DAppsHelpers.filterActiveSessionsForKnownAccounts(allSessionsAllProfiles, root.accountsModel)
|
|
for (const topic in sessions) {
|
|
if (topic == root.request.pairingTopic || topic == root.request.topic) {
|
|
//TODO: In theory it's possible for a dApp to request SIWE after establishing a session
|
|
// This is how MetaMask handles it, but for WC connections it's not clear yet if it's possible
|
|
console.warn("Session already exists for request", root.request.id)
|
|
root.finished("")
|
|
return
|
|
}
|
|
}
|
|
|
|
const key = root.request.id
|
|
const chains = root.request.params.authPayload.chains.map(DAppsHelpers.chainIdFromEip155)
|
|
const dAppUrl = root.request.params.requester.metadata.url
|
|
const dAppName = root.request.params.requester.metadata.name
|
|
const dAppIcons = root.request.params.requester.metadata.icons
|
|
const dAppIcon = dAppIcons && dAppIcons.length > 0 ? dAppIcons[0] : ""
|
|
|
|
root.requestSessionApproval(chains, dAppUrl, dAppName, dAppIcon, key)
|
|
} catch (e) {
|
|
console.warn("Error in SiweLifeCycle", e)
|
|
root.finished(e)
|
|
}
|
|
})
|
|
}
|
|
|
|
//Second step: populate auth payload
|
|
function sessionApproved(key, approvedNamespaces) {
|
|
try {
|
|
request.approvedNamespaces = approvedNamespaces
|
|
const supportedChains = approvedNamespaces.eip155.chains
|
|
const supportedMethods = approvedNamespaces.eip155.methods
|
|
sdk.populateAuthPayload(request.requestId, root.request.params.authPayload, supportedChains, supportedMethods)
|
|
return true
|
|
} catch (e) {
|
|
console.warn("Error in SiweLifeCycle::sessionApproved", e)
|
|
root.finished(e)
|
|
}
|
|
return false
|
|
}
|
|
}
|
|
}
|