nathanwoodburn/firewalletbrowser
1
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Optimize some of the auction routes

Browse Source
This commit is contained in:
Nathan Woodburn
2025-07-11 13:45:47 +10:00
parent b2db24c08e
commit 61d9f209b7
4 changed files with 188 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
FireWalletBrowser.bsdesign
View File

Binary file not shown.

87
account.py
View File

@@ -611,11 +611,24 @@ def getWalletStatus():
return "Error wallet ahead of node"
# Add a simple cache for bid data
_bid_cache = {}
_bid_cache_time = {}
_cache_duration = 60 # Cache duration in seconds
def getBids(account, domain="NONE"):
cache_key = f"{account}:{domain}"
current_time = time.time()
# Return cached data if available and fresh
if cache_key in _bid_cache and current_time - _bid_cache_time.get(cache_key, 0) < _cache_duration:
return _bid_cache[cache_key]
if domain == "NONE":
response = hsw.getWalletBids(account)
else:
response = hsw.getWalletBidsByName(domain, account)
# Add backup for bids with no value
bids = []
for bid in response:
@@ -626,6 +639,11 @@ def getBids(account, domain="NONE"):
if 'height' not in bid:
bid['height'] = 0
bids.append(bid)
# Cache the results
_bid_cache[cache_key] = bids
_bid_cache_time[cache_key] = current_time
return bids
def getPossibleOutbids(account):
@@ -640,28 +658,41 @@ def getPossibleOutbids(account):
# Sort out bids older than 720 blocks
bids = [bid for bid in bids if (current_height - bid['height']) <= 720]
possible_outbids = []
processed_domains = set() # Track domains we've already processed
# Pre-fetch domain info for all domains in a single batch
domains_to_check = {bid['name'] for bid in bids}
domain_info_map = {}
for domain in domains_to_check:
domain_info = getDomain(domain)
if ('info' in domain_info and 'state' in domain_info['info'] and
domain_info['info']['state'] == "BIDDING"):
domain_info_map[domain] = domain_info
for bid in bids:
domain = bid['name']
# Check to make sure that bidding is still happening
domain_info = getDomain(domain)
if 'info' not in domain_info or 'state' not in domain_info['info']:
print(f"Domain {domain} not found or no info available",flush=True)
continue
if domain_info['info']['state'] != "BIDDING":
# Skip if we've already processed this domain or it's not in bidding state
if domain in processed_domains or domain not in domain_info_map:
continue
processed_domains.add(domain)
current_highest_bid = bid['value']
# Get all bids for this domain in one call
domain_bids = getBids(account, domain)
# Find the highest bid we've made
current_highest_bid = bid['value']
for own_bid in domain_bids:
if own_bid["own"]:
current_highest_bid = max(current_highest_bid, own_bid['value'])
# Check if any unrevealed bids could outbid us
for domain_bid in domain_bids:
if domain_bid["own"]:
current_highest_bid = max(current_highest_bid, domain_bid['value'])
continue
if domain_bid['value'] != -1000000:
print("Revealed bid")
continue
if domain_bid["own"] or domain_bid['value'] != -1000000:
continue # Skip our own bids or revealed bids
if current_highest_bid < domain_bid["lockup"]:
possible_outbids.append(domain)
break
@@ -671,24 +702,28 @@ def getPossibleOutbids(account):
def getReveals(account, domain):
return hsw.getWalletRevealsByName(domain, account)
def getPendingReveals(account):
bids = getBids(account)
domains = getDomains(account, False)
# Only get domains in REVEAL state to reduce API calls
domains = [d for d in getDomains(account, False) if d['state'] == "REVEAL"]
pending = []
for domain in domains:
if domain['state'] == "REVEAL":
reveals = getReveals(account, domain['name'])
for bid in bids:
if bid['name'] == domain['name']:
state_found = False
for reveal in reveals:
if reveal['own'] == True:
if bid['value'] == reveal['value']:
state_found = True
if not state_found:
# Process domains in REVEAL state
domain_names = {domain['name']: domain for domain in domains}
for bid in bids:
if bid['name'] in domain_names:
reveals = getReveals(account, bid['name'])
# Check if this bid has been revealed
bid_revealed = any(
reveal['own'] == True and bid['value'] == reveal['value']
for reveal in reveals
)
if not bid_revealed:
pending.append(bid)
return pending

114
main.py
View File

@@ -273,84 +273,74 @@ def auctions():
if not account:
return redirect("/logout")
bids = account_module.getBids(account)
domains = account_module.getDomains(account,False)
# Sort
sort = request.args.get("sort")
if sort == None:
sort = "time"
sort = sort.lower()
sort_price = ""
sort_price_next = "⬇"
sort_state = ""
sort_state_next = "⬇"
sort_domain = ""
sort_domain_next = "⬇"
sort_time = ""
sort_time_next = "⬇"
reverse = False
# Get sort parameters with defaults
sort = request.args.get("sort", "time").lower()
direction = request.args.get("direction")
if direction == None:
if sort == "time":
direction = "⬆"
else:
direction = "⬇"
if direction is None:
direction = "⬆" if sort == "time" else "⬇"
if direction == "⬆":
reverse = True
reverse = (direction == "⬆")
# Initialize sort indicators with a more efficient approach
sort_indicators = {
"price": ["", "⬇"],
"state": ["", "⬇"],
"domain": ["", "⬇"],
"time": ["", "⬇"]
}
# Set the current sort column's indicators
sort_indicators[sort][0] = direction
sort_indicators[sort][1] = reverseDirection(direction)
# Efficiently retrieve data
bids = account_module.getBids(account)
domains = account_module.getDomains(account, False)
# Determine if sorting by domains and apply appropriate sort
sortbyDomain = False
if sort == "price":
# Sort by price
bids = sorted(bids, key=lambda k: k['value'],reverse=reverse)
sort_price = direction
sort_price_next = reverseDirection(direction)
bids = sorted(bids, key=lambda k: k['value'], reverse=reverse)
elif sort == "state":
sort_state = direction
sort_state_next = reverseDirection(direction)
domains = sorted(domains, key=lambda k: k['state'],reverse=reverse)
domains = sorted(domains, key=lambda k: k['state'], reverse=reverse)
sortbyDomain = True
elif sort == "time":
sort_time = direction
sort_time_next = reverseDirection(direction)
# If older HSD version sort by domain height
if bids[0]['height'] == 0:
domains = sorted(domains, key=lambda k: k['height'],reverse=reverse)
# Handle older HSD versions that don't have height in bids
if bids and bids[0]['height'] == 0:
domains = sorted(domains, key=lambda k: k['height'], reverse=reverse)
sortbyDomain = True
else:
bids = sorted(bids, key=lambda k: k['height'],reverse=reverse)
else:
# Sort by domain
bids = sorted(bids, key=lambda k: k['name'],reverse=reverse)
sort_domain = direction
sort_domain_next = reverseDirection(direction)
bids = sorted(bids, key=lambda k: k['height'], reverse=reverse)
else: # Default to domain name sorting
bids = sorted(bids, key=lambda k: k['name'], reverse=reverse)
# Check if outbids set to true
outbids = request.args.get("outbids")
if outbids is not None and outbids.lower() == "true":
# Get outbid domains
# Get outbids only if explicitly requested
outbids = []
if request.args.get("outbids", "").lower() == "true":
outbids = account_module.getPossibleOutbids(account)
# Generate HTML just once
bidsHtml = render.bidDomains(bids, domains, sortbyDomain, outbids)
bidsHtml = render.bidDomains(bids,domains,sortbyDomain,outbids)
plugins = ""
message = ''
if 'message' in request.args:
message = request.args.get("message")
return render_template("auctions.html", account=account, domains=bidsHtml,
domainsMobile=bidsHtml, plugins=plugins,
domain_count=bidsHtml,sort_price=sort_price,
sort_state=sort_state,sort_domain=sort_domain,
sort_price_next=sort_price_next,
sort_state_next=sort_state_next,sort_domain_next=sort_domain_next,
bids=len(bids),message=message,
sort_time=sort_time,sort_time_next=sort_time_next)
# Get message if present
message = request.args.get("message", "")
return render_template("auctions.html", account=account,
domains=bidsHtml,
domainsMobile=bidsHtml,
plugins="",
domain_count=bidsHtml,
sort_price=sort_indicators["price"][0],
sort_state=sort_indicators["state"][0],
sort_domain=sort_indicators["domain"][0],
sort_time=sort_indicators["time"][0],
sort_price_next=sort_indicators["price"][1],
sort_state_next=sort_indicators["state"][1],
sort_domain_next=sort_indicators["domain"][1],
sort_time_next=sort_indicators["time"][1],
bids=len(bids),
message=message)
#endregion
#region All Auctions
@app.route('/reveal')

56
render.py
View File

@@ -336,12 +336,25 @@ def bids(bids,reveals):
return html
def bidDomains(bids,domains, sortbyDomains=False, outbids=[]):
def bidDomains(bids, domains, sortbyDomains=False, outbids=[]):
html = ''
if not sortbyDomains:
# Create lookup dictionaries for O(1) lookups instead of O(n) searches
domain_lookup = {d['name']: d for d in domains}
bid_lookup = {}
for bid in bids:
for domain in domains:
if bid['name'] == domain['name']:
if bid['name'] not in bid_lookup or bid['value'] > bid_lookup[bid['name']]['value']:
bid_lookup[bid['name']] = bid
if not sortbyDomains:
# Process by bids first
for bid in bids:
domain_name = bid['name']
if domain_name not in domain_lookup:
continue
domain = domain_lookup[domain_name]
lockup = bid['lockup']
lockup = lockup / 1000000
bidValue = bid['value'] / 1000000
@@ -353,30 +366,47 @@ def bidDomains(bids,domains, sortbyDomains=False, outbids=[]):
bidDisplay = f'<b>{bidValue:,.2f}</b> HNS'
html += "<tr>"
if domain['name'] in outbids:
html += f"<td style='background-color: red;'><a class='text-decoration-none' style='color: var(--bs-table-color-state, var(--bs-table-color-type, var(--bs-table-color)));' href='/auction/{domain['name']}'>{renderDomain(domain['name'])}</a></td>"
else:
html += f"<td><a class='text-decoration-none' style='color: var(--bs-table-color-state, var(--bs-table-color-type, var(--bs-table-color)));' href='/auction/{domain['name']}'>{renderDomain(domain['name'])}</a></td>"
# Efficiently check if domain is in outbids list
is_outbid = domain_name in outbids
td_style = " style='background-color: red;'" if is_outbid else ""
html += f"<td{td_style}><a class='text-decoration-none' style='color: var(--bs-table-color-state, var(--bs-table-color-type, var(--bs-table-color)));' href='/auction/{domain_name}'>{renderDomain(domain_name)}</a></td>"
html += f"<td>{domain['state']}</td>"
html += f"<td style='white-space: nowrap;'>{bidDisplay}</td>"
html += f"<td class='hide-mobile'>{bid['height']:,}</td>"
html += "</tr>"
else:
# Process by domains first (for state sorting)
for domain in domains:
for bid in bids:
if bid['name'] == domain['name']:
domain_name = domain['name']
if domain_name not in bid_lookup:
continue
bid = bid_lookup[domain_name]
lockup = bid['lockup']
lockup = lockup / 1000000
bidValue = bid['value'] / 1000000
blind = lockup - bidValue
bidDisplay = f'<b>{bidValue:,.2f} HNS</b> + {blind:,.2f} HNS blind'
if blind > 0:
bidDisplay = f'<b>{bidValue:,.2f}</b> (+{blind:,.2f}) HNS'
else:
bidDisplay = f'<b>{bidValue:,.2f}</b> HNS'
html += "<tr>"
html += f"<td><a class='text-decoration-none' style='color: var(--bs-table-color-state, var(--bs-table-color-type, var(--bs-table-color)));' href='/auction/{domain['name']}'>{renderDomain(domain['name'])}</a></td>"
# Efficiently check if domain is in outbids list
is_outbid = domain_name in outbids
td_style = " style='background-color: red;'" if is_outbid else ""
html += f"<td{td_style}><a class='text-decoration-none' style='color: var(--bs-table-color-state, var(--bs-table-color-type, var(--bs-table-color)));' href='/auction/{domain_name}'>{renderDomain(domain_name)}</a></td>"
html += f"<td>{domain['state']}</td>"
html += f"<td>{bidDisplay}</td>"
html += f"<td style='white-space: nowrap;'>{bidDisplay}</td>"
html += f"<td class='hide-mobile'>{bid['height']:,}</td>"
html += "</tr>"
return html