status-im
/
status-desktop
mirror of https://github.com/status-im/status-desktop.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

feat: Added `chainId` to ens usernames

This commit is contained in:
Igor Sirotin 2023-01-11 19:10:13 +03:00 committed by Igor Sirotin
parent 0bd957e71a
commit 1523c9f2a0
19 changed files with 329 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/app/boot/app_controller.nim
View File

@ -422,8 +422,6 @@ proc buildAndRegisterUserProfile(self: AppController) =
let alias = self.settingsService.getName() let alias = self.settingsService.getName()
var preferredName = self.settingsService.getPreferredName() var preferredName = self.settingsService.getPreferredName()
let displayName = self.settingsService.getDisplayName() let displayName = self.settingsService.getDisplayName()
let ensUsernames = self.settingsService.getEnsUsernames()
let firstEnsName = if (ensUsernames.len > 0): ensUsernames[0] else: ""
let currentUserStatus = self.settingsService.getCurrentUserStatus() let currentUserStatus = self.settingsService.getCurrentUserStatus()
let loggedInAccount = self.accountsService.getLoggedInAccount() let loggedInAccount = self.accountsService.getLoggedInAccount()

61
src/app/modules/main/profile_section/ens_usernames/controller.nim
View File

@ -50,7 +50,7 @@ proc init*(self: Controller) =
self.events.on(SIGNAL_ENS_USERNAME_DETAILS_FETCHED) do(e:Args): self.events.on(SIGNAL_ENS_USERNAME_DETAILS_FETCHED) do(e:Args):
let args = EnsUsernameDetailsArgs(e) let args = EnsUsernameDetailsArgs(e)
self.delegate.onDetailsForEnsUsername(args.ensUsername, args.address, args.pubkey, args.isStatus, args.expirationTime) self.delegate.onDetailsForEnsUsername(args.chainId, args.ensUsername, args.address, args.pubkey, args.isStatus, args.expirationTime)
self.events.on(SIGNAL_ENS_TRANSACTION_CONFIRMED) do(e:Args): self.events.on(SIGNAL_ENS_TRANSACTION_CONFIRMED) do(e:Args):
let args = EnsTransactionArgs(e) let args = EnsTransactionArgs(e)
@ -66,44 +66,50 @@ proc init*(self: Controller) =
return return
self.delegate.onUserAuthenticated(args.password) self.delegate.onUserAuthenticated(args.password)
proc getChainId*(self: Controller): int =
return self.networkService.getChainIdForEns()
proc getNetwork*(self: Controller): NetworkDto =
return self.networkService.getNetworkForEns()
proc checkEnsUsernameAvailability*(self: Controller, desiredEnsUsername: string, statusDomain: bool) = proc checkEnsUsernameAvailability*(self: Controller, desiredEnsUsername: string, statusDomain: bool) =
self.ensService.checkEnsUsernameAvailability(desiredEnsUsername, statusDomain) self.ensService.checkEnsUsernameAvailability(desiredEnsUsername, statusDomain)
proc getMyPendingEnsUsernames*(self: Controller): seq[string] = proc getMyPendingEnsUsernames*(self: Controller): seq[EnsUsernameDto] =
return self.ensService.getMyPendingEnsUsernames() return self.ensService.getMyPendingEnsUsernames()
proc getAllMyEnsUsernames*(self: Controller, includePendingEnsUsernames: bool): seq[string] = proc getAllMyEnsUsernames*(self: Controller, includePendingEnsUsernames: bool): seq[EnsUsernameDto] =
return self.ensService.getAllMyEnsUsernames(includePendingEnsUsernames) return self.ensService.getAllMyEnsUsernames(includePendingEnsUsernames)
proc fetchDetailsForEnsUsername*(self: Controller, ensUsername: string) = proc fetchDetailsForEnsUsername*(self: Controller, chainId: int, ensUsername: string) =
self.ensService.fetchDetailsForEnsUsername(ensUsername) self.ensService.fetchDetailsForEnsUsername(chainId, ensUsername)
proc setPubKeyGasEstimate*(self: Controller, ensUsername: string, address: string): int = proc setPubKeyGasEstimate*(self: Controller, chainId: int, ensUsername: string, address: string): int =
return self.ensService.setPubKeyGasEstimate(ensUsername, address) return self.ensService.setPubKeyGasEstimate(chainId, ensUsername, address)
proc setPubKey*(self: Controller, ensUsername: string, address: string, gas: string, gasPrice: string, proc setPubKey*(self: Controller, chainId: int, ensUsername: string, address: string, gas: string, gasPrice: string,
maxPriorityFeePerGas: string, maxFeePerGas: string, password: string, eip1559Enabled: bool): string = maxPriorityFeePerGas: string, maxFeePerGas: string, password: string, eip1559Enabled: bool): string =
return self.ensService.setPubKey(ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, password, eip1559Enabled) return self.ensService.setPubKey(chainId, ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, password, eip1559Enabled)
proc getSigningPhrase*(self: Controller): string = proc getSigningPhrase*(self: Controller): string =
return self.settingsService.getSigningPhrase() return self.settingsService.getSigningPhrase()
proc saveNewEnsUsername*(self: Controller, ensUsername: string): bool = proc addEnsUsername*(self: Controller, chainId: int, ensUsername: string): bool =
return self.settingsService.saveNewEnsUsername(ensUsername) return self.ensService.add(chainId, ensUsername)
proc removeEnsUsername*(self: Controller, ensUsername: string): bool = proc removeEnsUsername*(self: Controller, chainId: int, ensUsername: string): bool =
return self.settingsService.removeEnsUsername(ensUsername) return self.ensService.remove(chainId, ensUsername)
proc getPreferredEnsUsername*(self: Controller): string = proc getPreferredEnsUsername*(self: Controller): string =
return self.settingsService.getPreferredName() return self.settingsService.getPreferredName()
proc releaseEnsEstimate*(self: Controller, ensUsername: string, address: string): int = proc releaseEnsEstimate*(self: Controller, chainId: int, ensUsername: string, address: string): int =
return self.ensService.releaseEnsEstimate(ensUsername, address) return self.ensService.releaseEnsEstimate(chainId, ensUsername, address)
proc release*(self: Controller, ensUsername: string, address: string, gas: string, gasPrice: string, proc release*(self: Controller, chainId: int, ensUsername: string, address: string, gas: string, gasPrice: string,
maxPriorityFeePerGas: string, maxFeePerGas: string, password: string, eip1559Enabled: bool): maxPriorityFeePerGas: string, maxFeePerGas: string, password: string, eip1559Enabled: bool):
string = string =
return self.ensService.release(ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, password, eip1559Enabled) return self.ensService.release(chainId, ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, password, eip1559Enabled)
proc setPreferredName*(self: Controller, preferredName: string) = proc setPreferredName*(self: Controller, preferredName: string) =
if(self.settingsService.savePreferredName(preferredName)): if(self.settingsService.savePreferredName(preferredName)):
@ -112,21 +118,27 @@ proc setPreferredName*(self: Controller, preferredName: string) =
info "an error occurred saving prefered ens username", methodName="setPreferredName" info "an error occurred saving prefered ens username", methodName="setPreferredName"
proc fixPreferredName*(self: Controller, ignoreCurrentValue: bool = false) = proc fixPreferredName*(self: Controller, ignoreCurrentValue: bool = false) =
# TODO: Remove this workaround and make proper prefferedName-chainId database storage
if (not ignoreCurrentValue and singletonInstance.userProfile.getPreferredName().len > 0): if (not ignoreCurrentValue and singletonInstance.userProfile.getPreferredName().len > 0):
return return
let ensUsernames = self.settingsService.getEnsUsernames() let ensUsernames = self.getAllMyEnsUsernames(false)
let firstEnsName = if (ensUsernames.len > 0): ensUsernames[0] else: "" let currentChainId = self.getNetwork().chainId
var firstEnsName = ""
for ensUsername in ensUsernames:
if ensUsername.chainId == currentChainId:
firstEnsName = ensUsername.username
break
self.setPreferredName(firstEnsName) self.setPreferredName(firstEnsName)
proc getEnsRegisteredAddress*(self: Controller): string = proc getEnsRegisteredAddress*(self: Controller): string =
return self.ensService.getEnsRegisteredAddress() return self.ensService.getEnsRegisteredAddress()
proc registerEnsGasEstimate*(self: Controller, ensUsername: string, address: string): int = proc registerEnsGasEstimate*(self: Controller, chainId: int, ensUsername: string, address: string): int =
return self.ensService.registerEnsGasEstimate(ensUsername, address) return self.ensService.registerEnsGasEstimate(chainId, ensUsername, address)
proc registerEns*(self: Controller, ensUsername: string, address: string, gas: string, gasPrice: string, proc registerEns*(self: Controller, chainId: int, ensUsername: string, address: string, gas: string, gasPrice: string,
maxPriorityFeePerGas: string, maxFeePerGas: string, password: string, eip1559Enabled: bool): string = maxPriorityFeePerGas: string, maxFeePerGas: string, password: string, eip1559Enabled: bool): string =
return self.ensService.registerEns(ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, password, eip1559Enabled) return self.ensService.registerEns(chainId, ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, password, eip1559Enabled)
proc getSNTBalance*(self: Controller): string = proc getSNTBalance*(self: Controller): string =
return self.ensService.getSNTBalance() return self.ensService.getSNTBalance()
@ -150,9 +162,6 @@ proc getStatusToken*(self: Controller): string =
} }
return $jsonObj return $jsonObj
proc getNetwork*(self: Controller): NetworkDto =
return self.networkService.getNetworkForEns()
proc authenticateUser*(self: Controller, keyUid = "") = proc authenticateUser*(self: Controller, keyUid = "") =
let data = SharedKeycarModuleAuthenticationArgs(uniqueIdentifier: UNIQUE_ENS_SECTION_TRANSACTION_MODULE_IDENTIFIER, let data = SharedKeycarModuleAuthenticationArgs(uniqueIdentifier: UNIQUE_ENS_SECTION_TRANSACTION_MODULE_IDENTIFIER,
keyUid: keyUid) keyUid: keyUid)

18
src/app/modules/main/profile_section/ens_usernames/io_interface.nim
View File

@ -18,7 +18,7 @@ method getModuleAsVariant*(self: AccessInterface): QVariant {.base.} =
method ensUsernameAvailabilityChecked*(self: AccessInterface, availabilityStatus: string) {.base.} = method ensUsernameAvailabilityChecked*(self: AccessInterface, availabilityStatus: string) {.base.} =
raise newException(ValueError, "No implementation available") raise newException(ValueError, "No implementation available")
method onDetailsForEnsUsername*(self: AccessInterface, ensUsername: string, address: string, pubkey: string, method onDetailsForEnsUsername*(self: AccessInterface, chainId: int, ensUsername: string, address: string, pubkey: string,
isStatus: bool, expirationTime: int) {.base.} = isStatus: bool, expirationTime: int) {.base.} =
raise newException(ValueError, "No implementation available") raise newException(ValueError, "No implementation available")
@ -39,23 +39,23 @@ method checkEnsUsernameAvailability*(self: AccessInterface, desiredEnsUsername:
method numOfPendingEnsUsernames*(self: AccessInterface): int {.base.} = method numOfPendingEnsUsernames*(self: AccessInterface): int {.base.} =
raise newException(ValueError, "No implementation available") raise newException(ValueError, "No implementation available")
method fetchDetailsForEnsUsername*(self: AccessInterface, ensUsername: string) {.base.} = method fetchDetailsForEnsUsername*(self: AccessInterface, chainId: int, ensUsername: string) {.base.} =
raise newException(ValueError, "No implementation available") raise newException(ValueError, "No implementation available")
method setPubKeyGasEstimate*(self: AccessInterface, ensUsername: string, address: string): int {.base.} = method setPubKeyGasEstimate*(self: AccessInterface, chainId: int, ensUsername: string, address: string): int {.base.} =
raise newException(ValueError, "No implementation available") raise newException(ValueError, "No implementation available")
method authenticateAndSetPubKey*(self: AccessInterface, ensUsername: string, address: string, gas: string, gasPrice: string, method authenticateAndSetPubKey*(self: AccessInterface, chainId: int, ensUsername: string, address: string, gas: string, gasPrice: string,
maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) {.base.} = maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) {.base.} =
raise newException(ValueError, "No implementation available") raise newException(ValueError, "No implementation available")
method removeEnsUsername*(self: AccessInterface, ensUsername: string): bool {.base.} = method removeEnsUsername*(self: AccessInterface, chainId: int, ensUsername: string): bool {.base.} =
raise newException(ValueError, "No implementation available") raise newException(ValueError, "No implementation available")
method releaseEnsEstimate*(self: AccessInterface, ensUsername: string, address: string): int {.base.} = method releaseEnsEstimate*(self: AccessInterface, chainId: int, ensUsername: string, address: string): int {.base.} =
raise newException(ValueError, "No implementation available") raise newException(ValueError, "No implementation available")
method authenticateAndReleaseEns*(self: AccessInterface, ensUsername: string, address: string, gas: string, gasPrice: string, method authenticateAndReleaseEns*(self: AccessInterface, chainId: int, ensUsername: string, address: string, gas: string, gasPrice: string,
maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) {.base.} = maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) {.base.} =
raise newException(ValueError, "No implementation available") raise newException(ValueError, "No implementation available")
@ -65,10 +65,10 @@ method connectOwnedUsername*(self: AccessInterface, ensUsername: string, isStatu
method getEnsRegisteredAddress*(self: AccessInterface): string {.base.} = method getEnsRegisteredAddress*(self: AccessInterface): string {.base.} =
raise newException(ValueError, "No implementation available") raise newException(ValueError, "No implementation available")
method registerEnsGasEstimate*(self: AccessInterface, ensUsername: string, address: string): int {.base.} = method registerEnsGasEstimate*(self: AccessInterface, chainId: int, ensUsername: string, address: string): int {.base.} =
raise newException(ValueError, "No implementation available") raise newException(ValueError, "No implementation available")
method authenticateAndRegisterEns*(self: AccessInterface, ensUsername: string, address: string, gas: string, gasPrice: string, method authenticateAndRegisterEns*(self: AccessInterface, chainId: int, ensUsername: string, address: string, gas: string, gasPrice: string,
maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) {.base.} = maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) {.base.} =
raise newException(ValueError, "No implementation available") raise newException(ValueError, "No implementation available")

27
src/app/modules/main/profile_section/ens_usernames/model.nim
View File

@ -3,11 +3,13 @@ import NimQml, Tables
type Item* = object type Item* = object
ensUsername*: string ensUsername*: string
isPending*: bool isPending*: bool
chainId*: int
type type
ModelRole {.pure.} = enum ModelRole {.pure.} = enum
EnsUsername = UserRole + 1 EnsUsername = UserRole + 1
IsPending IsPending
ChainId
QtObject: QtObject:
type type
@ -38,7 +40,8 @@ QtObject:
method roleNames(self: Model): Table[int, string] = method roleNames(self: Model): Table[int, string] =
{ {
ModelRole.EnsUsername.int:"ensUsername", ModelRole.EnsUsername.int:"ensUsername",
ModelRole.IsPending.int:"isPending" ModelRole.IsPending.int:"isPending",
ModelRole.ChainId.int:"chainId"
}.toTable }.toTable
method data(self: Model, index: QModelIndex, role: int): QVariant = method data(self: Model, index: QModelIndex, role: int): QVariant =
@ -56,18 +59,22 @@ QtObject:
result = newQVariant(item.ensUsername) result = newQVariant(item.ensUsername)
of ModelRole.IsPending: of ModelRole.IsPending:
result = newQVariant(item.isPending) result = newQVariant(item.isPending)
of ModelRole.ChainId:
result = newQVariant(item.chainId)
proc findIndexForItemWithEnsUsername(self: Model, ensUsername: string): int = proc findIndex(self: Model, chainId: int, ensUsername: string): int =
for i in 0 ..< self.items.len: for i in 0 ..< self.items.len:
if(self.items[i].ensUsername == ensUsername): let item = self.items[i]
if (item.chainId == chainId and
item.ensUsername == ensUsername):
return i return i
return -1 return -1
proc containsEnsUsername*(self: Model, ensUsername: string): bool = proc containsEnsUsername*(self: Model, chainId: int, ensUsername: string): bool =
return self.findIndexForItemWithEnsUsername(ensUsername) != -1 return self.findIndex(chainId, ensUsername) != -1
proc addItem*(self: Model, item: Item) = proc addItem*(self: Model, item: Item) =
if(self.containsEnsUsername(item.ensUsername)): if(self.containsEnsUsername(item.chainId, item.ensUsername)):
return return
let parentModelIndex = newQModelIndex() let parentModelIndex = newQModelIndex()
@ -78,8 +85,8 @@ QtObject:
self.endInsertRows() self.endInsertRows()
self.countChanged() self.countChanged()
proc removeItemByEnsUsername*(self: Model, ensUsername: string) = proc removeItemByEnsUsername*(self: Model, chainId: int, ensUsername: string) =
let index = self.findIndexForItemWithEnsUsername(ensUsername) let index = self.findIndex(chainId, ensUsername)
if(index == -1): if(index == -1):
return return
@ -91,8 +98,8 @@ QtObject:
self.endRemoveRows() self.endRemoveRows()
self.countChanged() self.countChanged()
proc updatePendingStatus*(self: Model, ensUsername: string, pendingStatus: bool) = proc updatePendingStatus*(self: Model, chainId: int, ensUsername: string, pendingStatus: bool) =
let ind = self.findIndexForItemWithEnsUsername(ensUsername) let ind = self.findIndex(chainId, ensUsername)
if(ind == -1): if(ind == -1):
return return

102
src/app/modules/main/profile_section/ens_usernames/module.nim
View File

@ -25,6 +25,7 @@ const cancelledRequest* = "cancelled"
# Shouldn't be public ever, use only within this module. # Shouldn't be public ever, use only within this module.
type TmpSendEnsTransactionDetails = object type TmpSendEnsTransactionDetails = object
chainId: int
ensUsername: string ensUsername: string
address: string address: string
gas: string gas: string
@ -44,6 +45,7 @@ type
controller: Controller controller: Controller
moduleLoaded: bool moduleLoaded: bool
tmpSendEnsTransactionDetails: TmpSendEnsTransactionDetails tmpSendEnsTransactionDetails: TmpSendEnsTransactionDetails
events: EventEmitter
proc newModule*( proc newModule*(
delegate: delegate_interface.AccessInterface, events: EventEmitter, delegate: delegate_interface.AccessInterface, events: EventEmitter,
@ -58,6 +60,7 @@ proc newModule*(
result.viewVariant = newQVariant(result.view) result.viewVariant = newQVariant(result.view)
result.controller = controller.newController(result, events, settingsService, ensService, walletAccountService, networkService, tokenService) result.controller = controller.newController(result, events, settingsService, ensService, walletAccountService, networkService, tokenService)
result.moduleLoaded = false result.moduleLoaded = false
result.events = events
method delete*(self: Module) = method delete*(self: Module) =
self.view.delete self.view.delete
@ -71,18 +74,28 @@ method load*(self: Module) =
let link = self.controller.getNetwork().blockExplorerUrl & "/tx/" let link = self.controller.getNetwork().blockExplorerUrl & "/tx/"
self.view.load(link, signingPhrase) self.view.load(link, signingPhrase)
self.events.on(SIGNAL_WALLET_ACCOUNT_NETWORK_ENABLED_UPDATED) do(e: Args):
self.view.emitChainIdChanged()
self.controller.fixPreferredName(true)
method isLoaded*(self: Module): bool = method isLoaded*(self: Module): bool =
return self.moduleLoaded return self.moduleLoaded
method viewDidLoad*(self: Module) = method viewDidLoad*(self: Module) =
# add registered ens usernames # add registered ens usernames
let registeredEnsUsernames = self.controller.getAllMyEnsUsernames(includePendingEnsUsernames = false) let registeredEnsUsernames = self.controller.getAllMyEnsUsernames(includePendingEnsUsernames = false)
for u in registeredEnsUsernames: for dto in registeredEnsUsernames:
self.view.model().addItem(Item(ensUsername: u, isPending: false)) let item = Item(chainId: dto.chainId,
ensUsername: dto.username,
isPending: false)
self.view.model().addItem(item)
# add pending ens usernames # add pending ens usernames
let pendingEnsUsernames = self.controller.getMyPendingEnsUsernames() let pendingEnsUsernames = self.controller.getMyPendingEnsUsernames()
for u in pendingEnsUsernames: for dto in pendingEnsUsernames:
self.view.model().addItem(Item(ensUsername: u, isPending: true)) let item = Item(chainId: dto.chainId,
ensUsername: dto.username,
isPending: true)
self.view.model().addItem(item)
self.moduleLoaded = true self.moduleLoaded = true
self.delegate.ensUsernamesModuleDidLoad() self.delegate.ensUsernamesModuleDidLoad()
@ -99,18 +112,20 @@ method ensUsernameAvailabilityChecked*(self: Module, availabilityStatus: string)
method numOfPendingEnsUsernames*(self: Module): int = method numOfPendingEnsUsernames*(self: Module): int =
return self.controller.getMyPendingEnsUsernames().len return self.controller.getMyPendingEnsUsernames().len
method fetchDetailsForEnsUsername*(self: Module, ensUsername: string) = method fetchDetailsForEnsUsername*(self: Module, chainId: int, ensUsername: string) =
self.controller.fetchDetailsForEnsUsername(ensUsername) self.controller.fetchDetailsForEnsUsername(chainId, ensUsername)
method onDetailsForEnsUsername*(self: Module, ensUsername: string, address: string, pubkey: string, isStatus: bool, method onDetailsForEnsUsername*(self: Module, chainId: int, ensUsername: string, address: string, pubkey: string, isStatus: bool,
expirationTime: int) = expirationTime: int) =
self.view.setDetailsForEnsUsername(ensUsername, address, pubkey, isStatus, expirationTime) self.view.processObtainedEnsUsermesDetails(chainId, ensUsername, address, pubkey, isStatus, expirationTime)
method setPubKeyGasEstimate*(self: Module, ensUsername: string, address: string): int = method setPubKeyGasEstimate*(self: Module, chainId: int, ensUsername: string, address: string): int =
return self.controller.setPubKeyGasEstimate(ensUsername, address) return self.controller.setPubKeyGasEstimate(chainId, ensUsername, address)
method authenticateAndSetPubKey*(self: Module, ensUsername: string, address: string, gas: string, gasPrice: string, method authenticateAndSetPubKey*(self: Module, chainId: int, ensUsername: string, address: string, gas: string, gasPrice: string,
maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) = maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) =
self.tmpSendEnsTransactionDetails.chainId = chainId
self.tmpSendEnsTransactionDetails.ensUsername = ensUsername self.tmpSendEnsTransactionDetails.ensUsername = ensUsername
self.tmpSendEnsTransactionDetails.address = address self.tmpSendEnsTransactionDetails.address = address
self.tmpSendEnsTransactionDetails.gas = gas self.tmpSendEnsTransactionDetails.gas = gas
@ -130,6 +145,7 @@ method authenticateAndSetPubKey*(self: Module, ensUsername: string, address: str
method setPubKey*(self: Module, password: string) = method setPubKey*(self: Module, password: string) =
let response = self.controller.setPubKey( let response = self.controller.setPubKey(
self.tmpSendEnsTransactionDetails.chainId,
self.tmpSendEnsTransactionDetails.ensUsername, self.tmpSendEnsTransactionDetails.ensUsername,
self.tmpSendEnsTransactionDetails.address, self.tmpSendEnsTransactionDetails.address,
self.tmpSendEnsTransactionDetails.gas, self.tmpSendEnsTransactionDetails.gas,
@ -154,14 +170,19 @@ method setPubKey*(self: Module, password: string) =
var respResult: string var respResult: string
if(responseObj.getProp("result", respResult)): if(responseObj.getProp("result", respResult)):
self.view.model().addItem(Item(ensUsername: self.tmpSendEnsTransactionDetails.ensUsername, isPending: true)) let item = Item(chainId: self.tmpSendEnsTransactionDetails.chainId,
ensUsername: self.tmpSendEnsTransactionDetails.ensUsername,
isPending: true)
self.view.model().addItem(item)
self.view.emitTransactionWasSentSignal(response) self.view.emitTransactionWasSentSignal(response)
method releaseEnsEstimate*(self: Module, ensUsername: string, address: string): int = method releaseEnsEstimate*(self: Module, chainId: int, ensUsername: string, address: string): int =
return self.controller.releaseEnsEstimate(ensUsername, address) return self.controller.releaseEnsEstimate(chainId, ensUsername, address)
method authenticateAndReleaseEns*(self: Module, ensUsername: string, address: string, gas: string, gasPrice: string, method authenticateAndReleaseEns*(self: Module, chainId: int, ensUsername: string, address: string, gas: string, gasPrice: string,
maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) = maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) =
self.tmpSendEnsTransactionDetails.chainId = chainId
self.tmpSendEnsTransactionDetails.ensUsername = ensUsername self.tmpSendEnsTransactionDetails.ensUsername = ensUsername
self.tmpSendEnsTransactionDetails.address = address self.tmpSendEnsTransactionDetails.address = address
self.tmpSendEnsTransactionDetails.gas = gas self.tmpSendEnsTransactionDetails.gas = gas
@ -179,17 +200,21 @@ method authenticateAndReleaseEns*(self: Module, ensUsername: string, address: st
else: else:
self.controller.authenticateUser() self.controller.authenticateUser()
method removeEnsUsername*(self: Module, ensUsername: string): bool = method onEnsUsernameRemoved(self: Module, chainId: int, ensUsername: string) =
if (not self.controller.removeEnsUsername(ensUsername)):
info "an error occurred removing ens username", methodName="removeEnsUsername"
return false
if (self.controller.getPreferredEnsUsername() == ensUsername): if (self.controller.getPreferredEnsUsername() == ensUsername):
self.controller.fixPreferredName(true) self.controller.fixPreferredName(true)
self.view.model().removeItemByEnsUsername(ensUsername) self.view.model().removeItemByEnsUsername(chainId, ensUsername)
method removeEnsUsername*(self: Module, chainId: int, ensUsername: string): bool =
if (not self.controller.removeEnsUsername(chainId, ensUsername)):
info "an error occurred removing ens username", methodName="removeEnsUsername", ensUsername, chainId
return false
self.onEnsUsernameRemoved(chainId, ensUsername)
return true return true
method releaseEns*(self: Module, password: string) = method releaseEns*(self: Module, password: string) =
let response = self.controller.release( let response = self.controller.release(
self.tmpSendEnsTransactionDetails.chainId,
self.tmpSendEnsTransactionDetails.ensUsername, self.tmpSendEnsTransactionDetails.ensUsername,
self.tmpSendEnsTransactionDetails.address, self.tmpSendEnsTransactionDetails.address,
self.tmpSendEnsTransactionDetails.gas, self.tmpSendEnsTransactionDetails.gas,
@ -216,7 +241,7 @@ method releaseEns*(self: Module, password: string) =
var result: string var result: string
if(responseObj.getProp("result", result)): if(responseObj.getProp("result", result)):
let removed = self.removeEnsUsername(self.tmpSendEnsTransactionDetails.ensUsername) self.onEnsUsernameRemoved(self.tmpSendEnsTransactionDetails.chainId, self.tmpSendEnsTransactionDetails.ensUsername)
self.view.emitTransactionWasSentSignal(response) self.view.emitTransactionWasSentSignal(response)
proc formatUsername(self: Module, ensUsername: string, isStatus: bool): string = proc formatUsername(self: Module, ensUsername: string, isStatus: bool): string =
@ -225,38 +250,40 @@ proc formatUsername(self: Module, ensUsername: string, isStatus: bool): string =
result = ensUsername & ens_utils.STATUS_DOMAIN result = ensUsername & ens_utils.STATUS_DOMAIN
method connectOwnedUsername*(self: Module, ensUsername: string, isStatus: bool) = method connectOwnedUsername*(self: Module, ensUsername: string, isStatus: bool) =
let chainId = self.getChainIdForEns()
var ensUsername = self.formatUsername(ensUsername, isStatus) var ensUsername = self.formatUsername(ensUsername, isStatus)
if(not self.controller.saveNewEnsUsername(ensUsername)): if(not self.controller.addEnsUsername(chainId, ensUsername)):
info "an error occurred saving ens username", methodName="connectOwnedUsername" info "an error occurred saving ens username", methodName="connectOwnedUsername"
return return
self.controller.fixPreferredName() self.controller.fixPreferredName()
self.view.model().addItem(Item(ensUsername: ensUsername, isPending: false)) self.view.model().addItem(Item(chainId: chainId, ensUsername: ensUsername, isPending: false))
method ensTransactionConfirmed*(self: Module, trxType: string, ensUsername: string, transactionHash: string) = method ensTransactionConfirmed*(self: Module, trxType: string, ensUsername: string, transactionHash: string) =
if(not self.controller.saveNewEnsUsername(ensUsername)): let chainId = self.getChainIdForEns()
info "an error occurred saving ens username", methodName="ensTransactionConfirmed"
return
self.controller.fixPreferredName() self.controller.fixPreferredName()
if(self.view.model().containsEnsUsername(ensUsername)): if(self.view.model().containsEnsUsername(chainId, ensUsername)):
self.view.model().updatePendingStatus(ensUsername, false) self.view.model().updatePendingStatus(chainId, ensUsername, false)
else: else:
self.view.model().addItem(Item(ensUsername: ensUsername, isPending: false)) self.view.model().addItem(Item(chainId: chainId, ensUsername: ensUsername, isPending: false))
self.view.emitTransactionCompletedSignal(true, transactionHash, ensUsername, trxType, "") self.view.emitTransactionCompletedSignal(true, transactionHash, ensUsername, trxType, "")
method ensTransactionReverted*(self: Module, trxType: string, ensUsername: string, transactionHash: string, method ensTransactionReverted*(self: Module, trxType: string, ensUsername: string, transactionHash: string,
revertReason: string) = revertReason: string) =
self.view.model().removeItemByEnsUsername(ensUsername) let chainId = self.getChainIdForEns()
self.view.model().removeItemByEnsUsername(chainId, ensUsername)
self.view.emitTransactionCompletedSignal(false, transactionHash, ensUsername, trxType, revertReason) self.view.emitTransactionCompletedSignal(false, transactionHash, ensUsername, trxType, revertReason)
method getEnsRegisteredAddress*(self: Module): string = method getEnsRegisteredAddress*(self: Module): string =
return self.controller.getEnsRegisteredAddress() return self.controller.getEnsRegisteredAddress()
method registerEnsGasEstimate*(self: Module, ensUsername: string, address: string): int = method registerEnsGasEstimate*(self: Module, chainId: int, ensUsername: string, address: string): int =
return self.controller.registerEnsGasEstimate(ensUsername, address) return self.controller.registerEnsGasEstimate(chainId, ensUsername, address)
method authenticateAndRegisterEns*(self: Module, ensUsername: string, address: string, gas: string, gasPrice: string, method authenticateAndRegisterEns*(self: Module, chainId: int, ensUsername: string, address: string, gas: string, gasPrice: string,
maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) = maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) =
self.tmpSendEnsTransactionDetails.chainId = chainId
self.tmpSendEnsTransactionDetails.ensUsername = ensUsername self.tmpSendEnsTransactionDetails.ensUsername = ensUsername
self.tmpSendEnsTransactionDetails.address = address self.tmpSendEnsTransactionDetails.address = address
self.tmpSendEnsTransactionDetails.gas = gas self.tmpSendEnsTransactionDetails.gas = gas
@ -297,6 +324,7 @@ method authenticateAndRegisterEns*(self: Module, ensUsername: string, address: s
method registerEns(self: Module, password: string) = method registerEns(self: Module, password: string) =
let response = self.controller.registerEns( let response = self.controller.registerEns(
self.tmpSendEnsTransactionDetails.chainId,
self.tmpSendEnsTransactionDetails.ensUsername, self.tmpSendEnsTransactionDetails.ensUsername,
self.tmpSendEnsTransactionDetails.address, self.tmpSendEnsTransactionDetails.address,
self.tmpSendEnsTransactionDetails.gas, self.tmpSendEnsTransactionDetails.gas,
@ -314,8 +342,10 @@ method registerEns(self: Module, password: string) =
var respResult: string var respResult: string
if(responseObj.getProp("result", respResult) and responseObj{"success"}.getBool == true): if(responseObj.getProp("result", respResult) and responseObj{"success"}.getBool == true):
let ensUsername = self.formatUsername(self.tmpSendEnsTransactionDetails.ensUsername, true)
let item = Item(chainId: self.tmpSendEnsTransactionDetails.chainId, ensUsername: ensUsername, isPending: true)
self.controller.fixPreferredName() self.controller.fixPreferredName()
self.view.model().addItem(Item(ensUsername: self.formatUsername(self.tmpSendEnsTransactionDetails.ensUsername, true), isPending: true)) self.view.model().addItem(item)
self.view.emitTransactionWasSentSignal(response) self.view.emitTransactionWasSentSignal(response)
method getSNTBalance*(self: Module): string = method getSNTBalance*(self: Module): string =
@ -380,7 +410,7 @@ method getStatusToken*(self: Module): string =
return self.controller.getStatusToken() return self.controller.getStatusToken()
method getChainIdForEns*(self: Module): int = method getChainIdForEns*(self: Module): int =
return self.controller.getNetwork().chainId return self.controller.getChainId()
method setPrefferedEnsUsername*(self: Module, ensUsername: string) = method setPrefferedEnsUsername*(self: Module, ensUsername: string) =
self.controller.setPreferredName(ensUsername) self.controller.setPreferredName(ensUsername)

48
src/app/modules/main/profile_section/ens_usernames/view.nim
View File

@ -39,6 +39,16 @@ QtObject:
read = getModel read = getModel
notify = modelChanged notify = modelChanged
proc chainIdChanged*(self: View) {.signal.}
proc chainId(self: View): int {.slot.} =
return self.delegate.getChainIdForEns()
QtProperty[int] chainId:
read = chainId
notify = chainIdChanged
proc emitChainIdChanged*(self: View) =
self.chainIdChanged()
proc getEnsRegistry(self: View): string {.slot.} = proc getEnsRegistry(self: View): string {.slot.} =
return ENS_REGISTRY return ENS_REGISTRY
@ -53,27 +63,27 @@ QtObject:
return self.delegate.numOfPendingEnsUsernames() return self.delegate.numOfPendingEnsUsernames()
proc loading(self: View, isLoading: bool) {.signal.} proc loading(self: View, isLoading: bool) {.signal.}
proc detailsObtained(self: View, ensName: string, address: string, pubkey: string, isStatus: bool, expirationTime: int) {.signal.} proc detailsObtained(self: View, chainId: int, ensName: string, address: string, pubkey: string, isStatus: bool, expirationTime: int) {.signal.}
proc fetchDetailsForEnsUsername*(self: View, ensUsername: string) {.slot.} = proc fetchDetailsForEnsUsername*(self: View, chainId: int, ensUsername: string) {.slot.} =
self.loading(true) self.loading(true)
self.delegate.fetchDetailsForEnsUsername(ensUsername) self.delegate.fetchDetailsForEnsUsername(chainId, ensUsername)
proc setDetailsForEnsUsername*(self: View, ensUsername: string, address: string, pubkey: string, isStatus: bool, proc processObtainedEnsUsermesDetails*(self: View, chainId: int, ensUsername: string, address: string, pubkey: string, isStatus: bool,
expirationTime: int) = expirationTime: int) =
self.loading(false) self.loading(false)
self.detailsObtained(ensUsername, address, pubkey, isStatus, expirationTime) self.detailsObtained(chainId, ensUsername, address, pubkey, isStatus, expirationTime)
proc transactionWasSent(self: View, txResult: string) {.signal.} proc transactionWasSent(self: View, txResult: string) {.signal.}
proc emitTransactionWasSentSignal*(self: View, txResult: string) = proc emitTransactionWasSentSignal*(self: View, txResult: string) =
self.transactionWasSent(txResult) self.transactionWasSent(txResult)
proc setPubKeyGasEstimate*(self: View, ensUsername: string, address: string): int {.slot.} = proc setPubKeyGasEstimate*(self: View, chainId: int, ensUsername: string, address: string): int {.slot.} =
return self.delegate.setPubKeyGasEstimate(ensUsername, address) return self.delegate.setPubKeyGasEstimate(chainId, ensUsername, address)
proc authenticateAndSetPubKey*(self: View, ensUsername: string, address: string, gas: string, gasPrice: string, proc authenticateAndSetPubKey*(self: View, chainId: int, ensUsername: string, address: string, gas: string, gasPrice: string,
maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) {.slot.} = maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) {.slot.} =
self.delegate.authenticateAndSetPubKey(ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, eip1559Enabled) self.delegate.authenticateAndSetPubKey(chainId, ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, eip1559Enabled)
proc getEtherscanLink*(self: View): string {.slot.} = proc getEtherscanLink*(self: View): string {.slot.} =
return self.etherscanLink return self.etherscanLink
@ -91,15 +101,15 @@ QtObject:
revertReason: string) = revertReason: string) =
self.transactionCompleted(success, txHash, username, trxType, revertReason) self.transactionCompleted(success, txHash, username, trxType, revertReason)
proc removeEnsUsername*(self: View, ensUsername: string): bool {.slot.} = proc removeEnsUsername*(self: View, chainId: int, ensUsername: string): bool {.slot.} =
return self.delegate.removeEnsUsername(ensUsername) return self.delegate.removeEnsUsername(chainId, ensUsername)
proc releaseEnsEstimate*(self: View, ensUsername: string, address: string): int {.slot.} = proc releaseEnsEstimate*(self: View, chainId: int, ensUsername: string, address: string): int {.slot.} =
return self.delegate.releaseEnsEstimate(ensUsername, address) return self.delegate.releaseEnsEstimate(chainId, ensUsername, address)
proc authenticateAndReleaseEns*(self: View, ensUsername: string, address: string, gas: string, gasPrice: string, proc authenticateAndReleaseEns*(self: View, chainId: int, ensUsername: string, address: string, gas: string, gasPrice: string,
maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) {.slot.} = maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) {.slot.} =
self.delegate.authenticateAndReleaseEns(ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, eip1559Enabled) self.delegate.authenticateAndReleaseEns(chainId, ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, eip1559Enabled)
proc connectOwnedUsername*(self: View, ensUsername: string, isStatus: bool) {.slot.} = proc connectOwnedUsername*(self: View, ensUsername: string, isStatus: bool) {.slot.} =
self.delegate.connectOwnedUsername(ensUsername, isStatus) self.delegate.connectOwnedUsername(ensUsername, isStatus)
@ -107,12 +117,12 @@ QtObject:
proc getEnsRegisteredAddress*(self: View): string {.slot.} = proc getEnsRegisteredAddress*(self: View): string {.slot.} =
return self.delegate.getEnsRegisteredAddress() return self.delegate.getEnsRegisteredAddress()
proc registerEnsGasEstimate*(self: View, ensUsername: string, address: string): int {.slot.} = proc registerEnsGasEstimate*(self: View, chainId: int, ensUsername: string, address: string): int {.slot.} =
return self.delegate.registerEnsGasEstimate(ensUsername, address) return self.delegate.registerEnsGasEstimate(chainId, ensUsername, address)
proc authenticateAndRegisterEns*(self: View, ensUsername: string, address: string, gas: string, gasPrice: string, proc authenticateAndRegisterEns*(self: View, chainId: int, ensUsername: string, address: string, gas: string, gasPrice: string,
maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) {.slot.} = maxPriorityFeePerGas: string, maxFeePerGas: string, eip1559Enabled: bool) {.slot.} =
self.delegate.authenticateAndRegisterEns(ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, eip1559Enabled) self.delegate.authenticateAndRegisterEns(chainId, ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, eip1559Enabled)
proc getSNTBalance*(self: View): string {.slot.} = proc getSNTBalance*(self: View): string {.slot.} =
return self.delegate.getSNTBalance() return self.delegate.getSNTBalance()

1
src/app_service/service/ens/async_tasks.nim
View File

@ -59,6 +59,7 @@ const ensUsernameDetailsTask: Task = proc(argEncoded: string) {.gcsafe, nimcall.
expirationTime = ens_utils.getExpirationTime(arg.chainId, arg.ensUsername) expirationTime = ens_utils.getExpirationTime(arg.chainId, arg.ensUsername)
let responseJson = %* { let responseJson = %* {
"chainId": arg.chainId,
"ensUsername": arg.ensUsername, "ensUsername": arg.ensUsername,
"address": address, "address": address,
"pubkey": pubkey, "pubkey": pubkey,

25
src/app_service/service/ens/dto/ens_username_dto.nim Normal file
View File

@ -0,0 +1,25 @@
{.used.}
import json, strformat, hashes
include ../../../common/json_utils
type EnsUsernameDto* = ref object
chainId*: int
username*: string
proc `==`*(l, r: EnsUsernameDto): bool =
return l.chainId == r.chainid and l.username == r.username
proc `$`*(self: EnsUsernameDto): string =
result = fmt"""ContactDto(
chainId: {self.chainId},
username: {self.username}
)"""
proc hash*(dto: EnsUsernameDto): Hash =
return ($dto).hash
proc toEnsUsernameDto*(jsonObj: JsonNode): EnsUsernameDto =
result = EnsUsernameDto()
discard jsonObj.getProp("chainId", result.chainId)
discard jsonObj.getProp("username", result.username)

138
src/app_service/service/ens/service.nim
View File

@ -23,7 +23,9 @@ import ../network/service as network_service
import ../token/service as token_service import ../token/service as token_service
import ../eth/dto/coder import ../eth/dto/coder
import ../eth/dto/transaction import ../eth/dto/transaction
import dto/ens_username_dto
export ens_username_dto
logScope: logScope:
topics = "ens-service" topics = "ens-service"
@ -44,6 +46,7 @@ type
availabilityStatus*: string availabilityStatus*: string
EnsUsernameDetailsArgs* = ref object of Args EnsUsernameDetailsArgs* = ref object of Args
chainId*: int
ensUsername*: string ensUsername*: string
address*: string address*: string
pubkey*: string pubkey*: string
@ -70,7 +73,7 @@ QtObject:
Service* = ref object of QObject Service* = ref object of QObject
events: EventEmitter events: EventEmitter
threadpool: ThreadPool threadpool: ThreadPool
pendingEnsUsernames*: HashSet[string] pendingEnsUsernames*: HashSet[EnsUsernameDto]
settingsService: settings_service.Service settingsService: settings_service.Service
walletAccountService: wallet_account_service.Service walletAccountService: wallet_account_service.Service
transactionService: transaction_service.Service transactionService: transaction_service.Service
@ -99,17 +102,20 @@ QtObject:
result.networkService = networkService result.networkService = networkService
result.tokenService = tokenService result.tokenService = tokenService
proc getChainId(self: Service): int =
return self.networkService.getNetworkForEns().chainId
proc confirmTransaction(self: Service, trxType: string, ensUsername: string, transactionHash: string) = proc confirmTransaction(self: Service, trxType: string, ensUsername: string, transactionHash: string) =
self.pendingEnsUsernames.excl(ensUsername) let dto = EnsUsernameDto(chainId: self.getChainId(), username: ensUsername)
let data = EnsTransactionArgs(transactionHash: transactionHash, ensUsername: ensUsername, transactionType: $trxType) let data = EnsTransactionArgs(transactionHash: transactionHash, ensUsername: ensUsername, transactionType: $trxType)
self.pendingEnsUsernames.excl(dto)
self.events.emit(SIGNAL_ENS_TRANSACTION_CONFIRMED, data) self.events.emit(SIGNAL_ENS_TRANSACTION_CONFIRMED, data)
proc revertTransaction(self: Service, trxType: string, ensUsername: string, transactionHash: string, proc revertTransaction(self: Service, trxType: string, ensUsername: string, transactionHash: string,
revertReason: string) = revertReason: string) =
self.pendingEnsUsernames.excl(ensUsername) let dto = EnsUsernameDto(chainId: self.getChainId(), username: ensUsername)
let data = EnsTransactionArgs( let data = EnsTransactionArgs(transactionHash: transactionHash, ensUsername: ensUsername, transactionType: $trxType, revertReason: revertReason)
transactionHash: transactionHash, ensUsername: ensUsername, transactionType: $trxType, revertReason: revertReason self.pendingEnsUsernames.excl(dto)
)
self.events.emit(SIGNAL_ENS_TRANSACTION_REVERTED, data) self.events.emit(SIGNAL_ENS_TRANSACTION_REVERTED, data)
proc doConnect(self: Service) = proc doConnect(self: Service) =
@ -134,16 +140,56 @@ QtObject:
for trx in self.transactionService.getPendingTransactions(): for trx in self.transactionService.getPendingTransactions():
if trx.typeValue == $PendingTransactionTypeDto.RegisterENS or trx.typeValue == $PendingTransactionTypeDto.SetPubKey: if trx.typeValue == $PendingTransactionTypeDto.RegisterENS or trx.typeValue == $PendingTransactionTypeDto.SetPubKey:
self.pendingEnsUsernames.incl trx.additionalData let dto = EnsUsernameDto(chainId: trx.chainId, username: trx.additionalData)
self.pendingEnsUsernames.incl(dto)
proc getMyPendingEnsUsernames*(self: Service): seq[string] = proc getMyPendingEnsUsernames*(self: Service): seq[EnsUsernameDto] =
for i in self.pendingEnsUsernames.items: for i in self.pendingEnsUsernames.items:
result.add(i) result.add(i)
proc getAllMyEnsUsernames*(self: Service, includePending: bool): seq[string] = proc getAllMyEnsUsernames*(self: Service, includePending: bool): seq[EnsUsernameDto] =
result = self.settingsService.getEnsUsernames()
if(includePending): var response: JsonNode
result.add(self.getMyPendingEnsUsernames()) try:
response = status_ens.getEnsUsernames().result
except Exception as e:
error "error occurred", procName="getAllMyEnsUsernames", msg = e.msg
return
if (response.kind != JArray):
warn "expected response is not a json object", procName="getAllMyEnsUsernames"
return
for jsonContact in response:
result.add(jsonContact.toEnsUsernameDto())
if (includePending):
for dto in self.getMyPendingEnsUsernames():
result.add(dto)
proc add*(self: Service, chainId: int, username: string): bool =
try:
let response = status_ens.add(chainId, username)
if (not response.error.isNil):
let msg = response.error.message
error "error adding ens username ", msg
return false
except Exception as e:
error "error occurred", procName="add", msg = e.msg
return false
return true
proc remove*(self: Service, chainId: int, username: string): bool =
try:
let response = status_ens.remove(chainId, username)
if (not response.error.isNil):
let msg = response.error.message
error "error removing ens username ", msg
return false
except Exception as e:
error "error occurred", procName="remove", msg = e.msg
return false
return true
proc onEnsUsernameAvailabilityChecked*(self: Service, response: string) {.slot.} = proc onEnsUsernameAvailabilityChecked*(self: Service, response: string) {.slot.} =
let responseObj = response.parseJson let responseObj = response.parseJson
@ -165,9 +211,10 @@ QtObject:
proc checkEnsUsernameAvailability*(self: Service, ensUsername: string, isStatus: bool) = proc checkEnsUsernameAvailability*(self: Service, ensUsername: string, isStatus: bool) =
let registeredEnsUsernames = self.getAllMyEnsUsernames(true) let registeredEnsUsernames = self.getAllMyEnsUsernames(true)
var desiredEnsUsername = self.formatUsername(ensUsername, isStatus) let dto = EnsUsernameDto(chainId: self.getChainId(),
username: self.formatUsername(ensUsername, isStatus))
var availability = "" var availability = ""
if registeredEnsUsernames.filter(proc(x: string):bool = x == desiredEnsUsername).len > 0: if registeredEnsUsernames.find(dto) >= 0:
let data = EnsUsernameAvailabilityArgs(availabilityStatus: ENS_AVAILABILITY_STATUS_ALREADY_CONNECTED) let data = EnsUsernameAvailabilityArgs(availabilityStatus: ENS_AVAILABILITY_STATUS_ALREADY_CONNECTED)
self.events.emit(SIGNAL_ENS_USERNAME_AVAILABILITY_CHECKED, data) self.events.emit(SIGNAL_ENS_USERNAME_AVAILABILITY_CHECKED, data)
else: else:
@ -176,7 +223,7 @@ QtObject:
vptr: cast[ByteAddress](self.vptr), vptr: cast[ByteAddress](self.vptr),
slot: "onEnsUsernameAvailabilityChecked", slot: "onEnsUsernameAvailabilityChecked",
ensUsername: ensUsername, ensUsername: ensUsername,
chainId: self.networkService.getNetworkForEns().chainId, chainId: self.getChainId(),
isStatus: isStatus, isStatus: isStatus,
myPublicKey: self.settingsService.getPublicKey(), myPublicKey: self.settingsService.getPublicKey(),
myWalletAddress: self.walletAccountService.getWalletAccount(0).address myWalletAddress: self.walletAccountService.getWalletAccount(0).address
@ -192,6 +239,7 @@ QtObject:
return return
var data = EnsUsernameDetailsArgs() var data = EnsUsernameDetailsArgs()
discard responseObj.getProp("chainId", data.chainId)
discard responseObj.getProp("ensUsername", data.ensUsername) discard responseObj.getProp("ensUsername", data.ensUsername)
discard responseObj.getProp("address", data.address) discard responseObj.getProp("address", data.address)
discard responseObj.getProp("pubkey", data.pubkey) discard responseObj.getProp("pubkey", data.pubkey)
@ -199,7 +247,7 @@ QtObject:
discard responseObj.getProp("expirationTime", data.expirationTime) discard responseObj.getProp("expirationTime", data.expirationTime)
self.events.emit(SIGNAL_ENS_USERNAME_DETAILS_FETCHED, data) self.events.emit(SIGNAL_ENS_USERNAME_DETAILS_FETCHED, data)
proc fetchDetailsForEnsUsername*(self: Service, ensUsername: string) = proc fetchDetailsForEnsUsername*(self: Service, chainId: int, ensUsername: string) =
var isStatus = false var isStatus = false
var username = ensUsername var username = ensUsername
if ensUsername.endsWith(ens_utils.STATUS_DOMAIN): if ensUsername.endsWith(ens_utils.STATUS_DOMAIN):
@ -211,7 +259,7 @@ QtObject:
vptr: cast[ByteAddress](self.vptr), vptr: cast[ByteAddress](self.vptr),
slot: "onEnsUsernameDetailsFetched", slot: "onEnsUsernameDetailsFetched",
ensUsername: username, ensUsername: username,
chainId: self.networkService.getNetworkForEns().chainId, chainId: chainId,
isStatus: isStatus isStatus: isStatus
) )
self.threadpool.start(arg) self.threadpool.start(arg)
@ -219,12 +267,9 @@ QtObject:
proc extractCoordinates(self: Service, pubkey: string):tuple[x: string, y:string] = proc extractCoordinates(self: Service, pubkey: string):tuple[x: string, y:string] =
result = ("0x" & pubkey[4..67], "0x" & pubkey[68..131]) result = ("0x" & pubkey[4..67], "0x" & pubkey[68..131])
proc setPubKeyGasEstimate*(self: Service, ensUsername: string, address: string): int = proc setPubKeyGasEstimate*(self: Service, chainId: int, ensUsername: string, address: string): int =
try: try:
let let txData = ens_utils.buildTransaction(parseAddress(address), 0.u256)
chainId = self.networkService.getNetworkForEns().chainId
txData = ens_utils.buildTransaction(parseAddress(address), 0.u256)
let resp = status_ens.setPubKeyEstimate(chainId, %txData, ensUsername, let resp = status_ens.setPubKeyEstimate(chainId, %txData, ensUsername,
singletonInstance.userProfile.getPubKey()) singletonInstance.userProfile.getPubKey())
result = resp.result.getInt result = resp.result.getInt
@ -234,6 +279,7 @@ QtObject:
proc setPubKey*( proc setPubKey*(
self: Service, self: Service,
chainId: int,
ensUsername: string, ensUsername: string,
address: string, address: string,
gas: string, gas: string,
@ -244,11 +290,8 @@ QtObject:
eip1559Enabled: bool, eip1559Enabled: bool,
): string = ): string =
try: try:
let let txData = ens_utils.buildTransaction(parseAddress(address), 0.u256, gas, gasPrice,
chainId = self.networkService.getNetworkForEns().chainId
txData = ens_utils.buildTransaction(parseAddress(address), 0.u256, gas, gasPrice,
eip1559Enabled, maxPriorityFeePerGas, maxFeePerGas) eip1559Enabled, maxPriorityFeePerGas, maxFeePerGas)
let resp = status_ens.setPubKey(chainId, %txData, password, ensUsername.addDomain(), let resp = status_ens.setPubKey(chainId, %txData, password, ensUsername.addDomain(),
singletonInstance.userProfile.getPubKey()) singletonInstance.userProfile.getPubKey())
let hash = resp.result.getStr let hash = resp.result.getStr
@ -258,19 +301,17 @@ QtObject:
hash, $address, resolverAddress, hash, $address, resolverAddress,
$PendingTransactionTypeDto.SetPubKey, ensUsername, chainId $PendingTransactionTypeDto.SetPubKey, ensUsername, chainId
) )
self.pendingEnsUsernames.incl(ensUsername) let dto = EnsUsernameDto(chainId: chainId, username: ensUsername)
self.pendingEnsUsernames.incl(dto)
result = $(%* { "result": hash, "success": true }) result = $(%* { "result": hash, "success": true })
except Exception as e: except Exception as e:
error "error occurred", procName="setPubKey", msg = e.msg error "error occurred", procName="setPubKey", msg = e.msg
result = $(%* { "result": e.msg, "success": false }) result = $(%* { "result": e.msg, "success": false })
proc releaseEnsEstimate*(self: Service, ensUsername: string, address: string): int = proc releaseEnsEstimate*(self: Service, chainId: int, ensUsername: string, address: string): int =
try: try:
let let txData = ens_utils.buildTransaction(parseAddress(address), 0.u256)
chainId = self.networkService.getNetworkForEns().chainId
txData = ens_utils.buildTransaction(parseAddress(address), 0.u256)
var userNameNoDomain = ensUsername var userNameNoDomain = ensUsername
if ensUsername.endsWith(ens_utils.STATUS_DOMAIN): if ensUsername.endsWith(ens_utils.STATUS_DOMAIN):
userNameNoDomain = ensUsername.replace(ens_utils.STATUS_DOMAIN, "") userNameNoDomain = ensUsername.replace(ens_utils.STATUS_DOMAIN, "")
@ -282,12 +323,11 @@ QtObject:
result = 100000 result = 100000
proc getEnsRegisteredAddress*(self: Service): string = proc getEnsRegisteredAddress*(self: Service): string =
let networkDto = self.networkService.getNetworkForEns() return status_ens.getRegistrarAddress(self.getChainId()).result.getStr
return status_ens.getRegistrarAddress(networkDto.chainId).result.getStr
proc release*( proc release*(
self: Service, self: Service,
chainId: int,
ensUsername: string, ensUsername: string,
address: string, address: string,
gas: string, gas: string,
@ -299,7 +339,6 @@ QtObject:
): string = ): string =
try: try:
let let
chainId = self.networkService.getNetworkForEns().chainId
txData = ens_utils.buildTransaction(parseAddress(address), 0.u256, gas, gasPrice, txData = ens_utils.buildTransaction(parseAddress(address), 0.u256, gas, gasPrice,
eip1559Enabled, maxPriorityFeePerGas, maxFeePerGas) eip1559Enabled, maxPriorityFeePerGas, maxFeePerGas)
@ -315,19 +354,17 @@ QtObject:
hash, address, ensUsernamesAddress, hash, address, ensUsernamesAddress,
$PendingTransactionTypeDto.ReleaseENS, ensUsername, chainId $PendingTransactionTypeDto.ReleaseENS, ensUsername, chainId
) )
self.pendingEnsUsernames.excl(ensUsername) let dto = EnsUsernameDto(chainId: chainId, username: ensUsername)
self.pendingEnsUsernames.excl(dto)
result = $(%* { "result": hash, "success": true }) result = $(%* { "result": hash, "success": true })
except Exception as e: except Exception as e:
error "error occurred", procName="release", msg = e.msg error "error occurred", procName="release", msg = e.msg
result = $(%* { "result": e.msg, "success": false }) result = $(%* { "result": e.msg, "success": false })
proc registerENSGasEstimate*(self: Service, ensUsername: string, address: string): int = proc registerENSGasEstimate*(self: Service, chainId: int, ensUsername: string, address: string): int =
try: try:
let let txData = ens_utils.buildTransaction(parseAddress(address), 0.u256)
chainId = self.networkService.getNetworkForEns().chainId
txData = ens_utils.buildTransaction(parseAddress(address), 0.u256)
let resp = status_ens.registerEstimate(chainId, %txData, ensUsername, let resp = status_ens.registerEstimate(chainId, %txData, ensUsername,
singletonInstance.userProfile.getPubKey()) singletonInstance.userProfile.getPubKey())
result = resp.result.getInt result = resp.result.getInt
@ -337,11 +374,11 @@ QtObject:
proc getStatusToken*(self: Service): TokenDto = proc getStatusToken*(self: Service): TokenDto =
let networkDto = self.networkService.getNetworkForEns() let networkDto = self.networkService.getNetworkForEns()
return self.tokenService.findTokenBySymbol(networkDto, networkDto.sntSymbol()) return self.tokenService.findTokenBySymbol(networkDto, networkDto.sntSymbol())
proc registerEns*( proc registerEns*(
self: Service, self: Service,
chainId: int,
username: string, username: string,
address: string, address: string,
gas: string, gas: string,
@ -352,11 +389,8 @@ QtObject:
eip1559Enabled: bool, eip1559Enabled: bool,
): string = ): string =
try: try:
let let txData = ens_utils.buildTransaction(parseAddress(address), 0.u256, gas, gasPrice,
chainId = self.networkService.getNetworkForEns().chainId
txData = ens_utils.buildTransaction(parseAddress(address), 0.u256, gas, gasPrice,
eip1559Enabled, maxPriorityFeePerGas, maxFeePerGas) eip1559Enabled, maxPriorityFeePerGas, maxFeePerGas)
let resp = status_ens.register(chainId, %txData, password, username, let resp = status_ens.register(chainId, %txData, password, username,
singletonInstance.userProfile.getPubKey()) singletonInstance.userProfile.getPubKey())
let hash = resp.result.getStr let hash = resp.result.getStr
@ -368,7 +402,8 @@ QtObject:
chainId chainId
) )
self.pendingEnsUsernames.incl(ensUsername) let dto = EnsUsernameDto(chainId: chainId, username: ensUsername)
self.pendingEnsUsernames.incl(dto)
result = $(%* { "result": hash, "success": true }) result = $(%* { "result": hash, "success": true })
except Exception as e: except Exception as e:
error "error occurred", procName="registerEns", msg = e.msg error "error occurred", procName="registerEns", msg = e.msg
@ -377,15 +412,12 @@ QtObject:
proc getSNTBalance*(self: Service): string = proc getSNTBalance*(self: Service): string =
let token = self.getStatusToken() let token = self.getStatusToken()
let account = self.walletAccountService.getWalletAccount(0).address let account = self.walletAccountService.getWalletAccount(0).address
let networkDto = self.networkService.getNetworkForEns() let balances = status_go_backend.getTokensBalancesForChainIDs(@[self.getChainId()], @[account], @[token.addressAsString()]).result
let balances = status_go_backend.getTokensBalancesForChainIDs(@[networkDto.chainId], @[account], @[token.addressAsString()]).result
return ens_utils.hex2Token(balances{account}{token.addressAsString()}.getStr, token.decimals) return ens_utils.hex2Token(balances{account}{token.addressAsString()}.getStr, token.decimals)
proc resourceUrl*(self: Service, username: string): (string, string, string) = proc resourceUrl*(self: Service, username: string): (string, string, string) =
try: try:
let chainId = self.networkService.getNetworkForEns().chainId let response = status_ens.resourceURL(self.getChainId(), username)
let response = status_ens.resourceURL(chainId, username)
return (response.result{"Scheme"}.getStr, response.result{"Host"}.getStr, response.result{"Path"}.getStr) return (response.result{"Scheme"}.getStr, response.result{"Host"}.getStr, response.result{"Path"}.getStr)
except Exception as e: except Exception as e:
error "Error getting ENS resourceUrl", username=username, exception=e.msg error "Error getting ENS resourceUrl", username=username, exception=e.msg

9
src/app_service/service/network/service.nim
View File

@ -96,11 +96,14 @@ proc toggleNetwork*(self: Service, chainId: int) =
network.enabled = not network.enabled network.enabled = not network.enabled
self.upsertNetwork(network) self.upsertNetwork(network)
proc getNetworkForEns*(self: Service): NetworkDto = proc getChainIdForEns*(self: Service): int =
if self.settingsService.areTestNetworksEnabled(): if self.settingsService.areTestNetworksEnabled():
return self.getNetwork(Goerli) return Goerli
return Mainnet
return self.getNetwork(Mainnet) proc getNetworkForEns*(self: Service): NetworkDto =
let chainId = self.getChainIdForEns()
return self.getNetwork(chainId)
proc getNetworkForStickers*(self: Service): NetworkDto = proc getNetworkForStickers*(self: Service): NetworkDto =
if self.settingsService.areTestNetworksEnabled(): if self.settingsService.areTestNetworksEnabled():

26
src/app_service/service/settings/service.nim
View File

@ -153,32 +153,6 @@ QtObject:
return true return true
return false return false
proc saveNewEnsUsername*(self: Service, username: string): bool =
var newEnsUsernames = self.settings.ensUsernames
newEnsUsernames.add(username)
let newEnsUsernamesAsJson = %* newEnsUsernames
if(self.saveSetting(KEY_ENS_USERNAMES, newEnsUsernamesAsJson)):
self.settings.ensUsernames = newEnsUsernames
return true
return false
proc removeEnsUsername*(self: Service, username: string): bool =
var newEnsUsernames = self.settings.ensUsernames
let index = newEnsUsernames.find(username)
if (index < 0):
return false
newEnsUsernames.delete(index)
let newEnsUsernamesAsJson = %* newEnsUsernames
if(self.saveSetting(KEY_ENS_USERNAMES, newEnsUsernamesAsJson)):
self.settings.ensUsernames = newEnsUsernames
return true
return false
proc getEnsUsernames*(self: Service): seq[string] =
return self.settings.ensUsernames
proc saveKeyUid*(self: Service, value: string): bool = proc saveKeyUid*(self: Service, value: string): bool =
if(self.saveSetting(KEY_KEY_UID, value)): if(self.saveSetting(KEY_KEY_UID, value)):
self.settings.keyUid = value self.settings.keyUid = value

12
src/backend/ens.nim
View File

@ -3,6 +3,18 @@ import ./core, ./response_type
import ./utils import ./utils
export response_type export response_type
proc getEnsUsernames*(): RpcResponse[JsonNode] {.raises: [Exception].} =
let payload = %* []
return core.callPrivateRPC("ens_getEnsUsernames", payload)
proc add*(chainId: int, username: string): RpcResponse[JsonNode] {.raises: [Exception].} =
let payload = %* [chainId, username]
return core.callPrivateRPC("ens_add", payload)
proc remove*(chainId: int, username: string): RpcResponse[JsonNode] {.raises: [Exception].} =
let payload = %* [chainId, username]
return core.callPrivateRPC("ens_remove", payload)
proc getRegistrarAddress*(chainId: int): RpcResponse[JsonNode] {.raises: [Exception].} = proc getRegistrarAddress*(chainId: int): RpcResponse[JsonNode] {.raises: [Exception].} =
let payload = %* [chainId] let payload = %* [chainId]

3
ui/app/AppLayouts/Profile/popups/ENSPopup.qml
View File

@ -72,8 +72,7 @@ StatusDialog {
Layout.fillWidth: true Layout.fillWidth: true
Layout.fillHeight: true Layout.fillHeight: true
implicitHeight: contentHeight implicitHeight: contentHeight
model: root.ensUsernamesStore.currentChainEnsUsernamesModel
model: root.ensUsernamesStore.ensUsernamesModel
delegate: RadioDelegate { delegate: RadioDelegate {
id: radioDelegate id: radioDelegate

40
ui/app/AppLayouts/Profile/stores/EnsUsernamesStore.qml
View File

@ -1,5 +1,6 @@
import QtQuick 2.13 import QtQuick 2.13
import utils 1.0 import utils 1.0
import SortFilterProxyModel 0.2
QtObject { QtObject {
id: root id: root
@ -8,9 +9,18 @@ QtObject {
property var ensUsernamesModel: root.ensUsernamesModule ? ensUsernamesModule.model : [] property var ensUsernamesModel: root.ensUsernamesModule ? ensUsernamesModule.model : []
readonly property QtObject currentChainEnsUsernamesModel: SortFilterProxyModel {
sourceModel: root.ensUsernamesModel
filters: ValueFilter {
roleName: "chainId"
value: root.chainId
}
}
property string pubkey: userProfile.pubKey property string pubkey: userProfile.pubKey
property string icon: userProfile.icon property string icon: userProfile.icon
property string preferredUsername: userProfile.preferredName property string preferredUsername: userProfile.preferredName
readonly property string chainId: ensUsernamesModule.chainId
property string username: userProfile.username property string username: userProfile.username
@ -34,22 +44,22 @@ QtObject {
return ensUsernamesModule.numOfPendingEnsUsernames() return ensUsernamesModule.numOfPendingEnsUsernames()
} }
function ensDetails(ensUsername) { function ensDetails(chainId, ensUsername) {
if(!root.ensUsernamesModule) if(!root.ensUsernamesModule)
return "" return ""
ensUsernamesModule.fetchDetailsForEnsUsername(ensUsername) ensUsernamesModule.fetchDetailsForEnsUsername(chainId, ensUsername)
} }
function setPubKeyGasEstimate(ensUsername, address) { function setPubKeyGasEstimate(chainId, ensUsername, address) {
if(!root.ensUsernamesModule) if(!root.ensUsernamesModule)
return 0 return 0
return ensUsernamesModule.setPubKeyGasEstimate(ensUsername, address) return ensUsernamesModule.setPubKeyGasEstimate(chainId, ensUsername, address)
} }
function authenticateAndSetPubKey(ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, eip1559Enabled) { function authenticateAndSetPubKey(chainId, ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, eip1559Enabled) {
if(!root.ensUsernamesModule) if(!root.ensUsernamesModule)
return "" return ""
return ensUsernamesModule.authenticateAndSetPubKey(ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, eip1559Enabled) return ensUsernamesModule.authenticateAndSetPubKey(chainId, ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, eip1559Enabled)
} }
function getEtherscanLink() { function getEtherscanLink() {
@ -68,10 +78,10 @@ QtObject {
globalUtils.copyToClipboard(value) globalUtils.copyToClipboard(value)
} }
function authenticateAndReleaseEns(ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, eip1559Enabled) { function authenticateAndReleaseEns(chainId, ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, eip1559Enabled) {
if(!root.ensUsernamesModule) if(!root.ensUsernamesModule)
return "" return ""
return ensUsernamesModule.authenticateAndReleaseEns(ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, eip1559Enabled) return ensUsernamesModule.authenticateAndReleaseEns(chainId, ensUsername, address, gas, gasPrice, maxPriorityFeePerGas, maxFeePerGas, eip1559Enabled)
} }
function ensConnectOwnedUsername(name, isStatus) { function ensConnectOwnedUsername(name, isStatus) {
@ -86,10 +96,10 @@ QtObject {
return ensUsernamesModule.getEnsRegisteredAddress() return ensUsernamesModule.getEnsRegisteredAddress()
} }
function authenticateAndRegisterEns(ensUsername, address, gasLimit, gasPrice, tipLimit, overallLimit, eip1559Enabled) { function authenticateAndRegisterEns(chainId, ensUsername, address, gasLimit, gasPrice, tipLimit, overallLimit, eip1559Enabled) {
if(!root.ensUsernamesModule) if(!root.ensUsernamesModule)
return return
ensUsernamesModule.authenticateAndRegisterEns(ensUsername, address, gasLimit, gasPrice, tipLimit, overallLimit, eip1559Enabled) ensUsernamesModule.authenticateAndRegisterEns(chainId, ensUsername, address, gasLimit, gasPrice, tipLimit, overallLimit, eip1559Enabled)
} }
function getEnsRegistry() { function getEnsRegistry() {
@ -148,16 +158,10 @@ QtObject {
return JSON.parse(walletSectionTransactions.suggestedFees(chainId)) return JSON.parse(walletSectionTransactions.suggestedFees(chainId))
} }
function getChainIdForEns() { function removeEnsUsername(chainId, ensUsername) {
if(!root.ensUsernamesModule) if(!root.ensUsernamesModule)
return "" return ""
return ensUsernamesModule.getChainIdForEns() return ensUsernamesModule.removeEnsUsername(chainId, ensUsername)
}
function removeEnsUsername(ensUsername) {
if(!root.ensUsernamesModule)
return ""
return ensUsernamesModule.removeEnsUsername(ensUsername)
} }
} }

8
ui/app/AppLayouts/Profile/views/EnsDetailsView.qml
View File

@ -16,11 +16,12 @@ Item {
property var ensUsernamesStore property var ensUsernamesStore
property var contactsStore property var contactsStore
property string username: "" property string username: ""
property string chainId: ""
property string walletAddress: "-" property string walletAddress: "-"
property string key: "-" property string key: "-"
signal backBtnClicked(); signal backBtnClicked();
signal usernameReleased(username: string); signal usernameReleased()
QtObject { QtObject {
id: d id: d
@ -140,6 +141,7 @@ Item {
let eip1559Enabled = path.gasFees.eip1559Enabled let eip1559Enabled = path.gasFees.eip1559Enabled
let maxFeePerGas = path.gasFees.maxFeePerGasM let maxFeePerGas = path.gasFees.maxFeePerGasM
root.ensUsernamesStore.authenticateAndReleaseEns( root.ensUsernamesStore.authenticateAndReleaseEns(
root.chainId,
root.username, root.username,
selectedAccount.address, selectedAccount.address,
path.gasAmount, path.gasAmount,
@ -163,7 +165,7 @@ Item {
return releaseEnsModal.sendingError.open() return releaseEnsModal.sendingError.open()
} }
for(var i=0; i<releaseEnsModal.bestRoutes.length; i++) { for(var i=0; i<releaseEnsModal.bestRoutes.length; i++) {
usernameReleased(username); usernameReleased()
let url = "%1/%2".arg(releaseEnsModal.store.getEtherscanLink(releaseEnsModal.bestRoutes[i].fromNetwork.chainId)).arg(response.result) let url = "%1/%2".arg(releaseEnsModal.store.getEtherscanLink(releaseEnsModal.bestRoutes[i].fromNetwork.chainId)).arg(response.result)
Global.displayToastMessage(qsTr("Transaction pending..."), Global.displayToastMessage(qsTr("Transaction pending..."),
qsTr("View on etherscan"), qsTr("View on etherscan"),
@ -195,7 +197,7 @@ Item {
type: StatusQControls.StatusBaseButton.Type.Danger type: StatusQControls.StatusBaseButton.Type.Danger
text: qsTr("Remove username") text: qsTr("Remove username")
onClicked: { onClicked: {
root.ensUsernamesStore.removeEnsUsername(root.username) root.ensUsernamesStore.removeEnsUsername(root.chainId, root.username)
root.backBtnClicked() root.backBtnClicked()
} }
} }

7
ui/app/AppLayouts/Profile/views/EnsListView.qml
View File

@ -23,7 +23,7 @@ Item {
property int profileContentWidth property int profileContentWidth
signal addBtnClicked() signal addBtnClicked()
signal selectEns(string username) signal selectEns(string username, string chainId)
Component.onCompleted: { Component.onCompleted: {
d.updateNumberOfPendingEnsUsernames() d.updateNumberOfPendingEnsUsernames()
@ -121,7 +121,8 @@ Item {
StatusListView { StatusListView {
id: lvEns id: lvEns
anchors.fill: parent anchors.fill: parent
model: root.ensUsernamesStore.ensUsernamesModel model: root.ensUsernamesStore.currentChainEnsUsernamesModel
spacing: 10 spacing: 10
delegate: StatusListItem { delegate: StatusListItem {
readonly property int indexOfDomainStart: model.ensUsername.indexOf(".") readonly property int indexOfDomainStart: model.ensUsername.indexOf(".")
@ -149,7 +150,7 @@ Item {
] ]
onClicked: { onClicked: {
root.selectEns(model.ensUsername) root.selectEns(model.ensUsername, model.chainId)
} }
} }

1
ui/app/AppLayouts/Profile/views/EnsSearchView.qml
View File

@ -86,6 +86,7 @@ Item {
let path = bestRoutes[0] let path = bestRoutes[0]
let eip1559Enabled = path.gasFees.eip1559Enabled let eip1559Enabled = path.gasFees.eip1559Enabled
root.ensUsernamesStore.authenticateAndSetPubKey( root.ensUsernamesStore.authenticateAndSetPubKey(
root.ensUsernamesStore.chainId,
ensUsername.text + (isStatus ? ".stateofus.eth" : "" ), ensUsername.text + (isStatus ? ".stateofus.eth" : "" ),
selectedAccount.address, selectedAccount.address,
path.gasAmount, path.gasAmount,

1
ui/app/AppLayouts/Profile/views/EnsTermsAndConditionsView.qml
View File

@ -73,6 +73,7 @@ Item {
let eip1559Enabled = path.gasFees.eip1559Enabled let eip1559Enabled = path.gasFees.eip1559Enabled
let maxFeePerGas = path.gasFees.maxFeePerGasM let maxFeePerGas = path.gasFees.maxFeePerGasM
root.ensUsernamesStore.authenticateAndRegisterEns( root.ensUsernamesStore.authenticateAndRegisterEns(
root.ensUsernamesStore.chainId,
username, username,
selectedAccount.address, selectedAccount.address,
path.gasAmount, path.gasAmount,

14
ui/app/AppLayouts/Profile/views/EnsView.qml
View File

@ -20,6 +20,7 @@ Item {
property bool showSearchScreen: false property bool showSearchScreen: false
property string addedUsername: "" property string addedUsername: ""
property string selectedUsername: "" property string selectedUsername: ""
property string selectedChainId: ""
signal next(output: string) signal next(output: string)
signal back() signal back()
@ -292,8 +293,9 @@ Item {
profileContentWidth: ensView.profileContentWidth profileContentWidth: ensView.profileContentWidth
onAddBtnClicked: next("search") onAddBtnClicked: next("search")
onSelectEns: { onSelectEns: {
ensView.ensUsernamesStore.ensDetails(username) ensView.ensUsernamesStore.ensDetails(chainId, username)
selectedUsername = username; selectedUsername = username
selectedChainId = chainId
next("details") next("details")
} }
} }
@ -305,10 +307,12 @@ Item {
ensUsernamesStore: ensView.ensUsernamesStore ensUsernamesStore: ensView.ensUsernamesStore
contactsStore: ensView.contactsStore contactsStore: ensView.contactsStore
username: selectedUsername username: selectedUsername
onBackBtnClicked: back(); chainId: selectedChainId
onBackBtnClicked: back()
onUsernameReleased: { onUsernameReleased: {
selectedUsername = username; selectedUsername = username
done(username); selectedChainId = chainId
done(username)
} }
} }
} }