FireWallet/firewallet
1
0
Fork 0
forked from nathanwoodburn/firewalletbrowser
Code Pull Requests Activity

fix: Allow wallet acctions from unencrypted wallets

Browse Source
This commit is contained in:
Nathan Woodburn
2025-05-08 12:09:04 +10:00
parent 6bbc294116
commit fd1ba1d059
5 changed files with 280 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@@ -122,7 +122,7 @@ HSD_IP: HSD IP address
THEME: Theme to use (dark-purple, black) THEME: Theme to use (dark-purple, black)
SHOW_EXPIRED: Show expired domains (true/false) SHOW_EXPIRED: Show expired domains (true/false)
EXCLUDE: Comma separated list of wallets to exclude from the wallet list (default primary) EXCLUDE: Comma separated list of wallets to exclude from the wallet list (default primary)
EXPLORER_TX: URL for exploring transactions (default https://niami.io/tx/) EXPLORER_TX: URL for exploring transactions (default https://shakeshift.com/transaction/)
HSD_NETWORK: Network to connect to (main, regtest, simnet) HSD_NETWORK: Network to connect to (main, regtest, simnet)
``` ```

411
account.py
View File

@@ -39,8 +39,8 @@ SHOW_EXPIRED = os.getenv("SHOW_EXPIRED")
if SHOW_EXPIRED is None: if SHOW_EXPIRED is None:
SHOW_EXPIRED = False SHOW_EXPIRED = False
hsd = api.hsd(HSD_API,HSD_IP,HSD_NODE_PORT) hsd = api.hsd(HSD_API, HSD_IP, HSD_NODE_PORT)
hsw = api.hsw(HSD_API,HSD_IP,HSD_WALLET_PORT) hsw = api.hsw(HSD_API, HSD_IP, HSD_WALLET_PORT)
cacheTime = 3600 cacheTime = 3600
@@ -51,11 +51,13 @@ EXCLUDE = ["primary"]
if os.getenv("EXCLUDE") is not None: if os.getenv("EXCLUDE") is not None:
EXCLUDE = os.getenv("EXCLUDE").split(",") EXCLUDE = os.getenv("EXCLUDE").split(",")
def hsdConnected(): def hsdConnected():
if hsdVersion() == -1: if hsdVersion() == -1:
return False return False
return True return True
def hsdVersion(format=True): def hsdVersion(format=True):
info = hsd.getInfo() info = hsd.getInfo()
if 'error' in info: if 'error' in info:
@@ -65,6 +67,7 @@ def hsdVersion(format=True):
else: else:
return info['version'] return info['version']
def check_account(cookie: str): def check_account(cookie: str):
if cookie is None: if cookie is None:
return False return False
@@ -80,6 +83,7 @@ def check_account(cookie: str):
return False return False
return account return account
def check_password(cookie: str, password: str): def check_password(cookie: str, password: str):
account = check_account(cookie) account = check_account(cookie)
if account == False: if account == False:
@@ -89,12 +93,13 @@ def check_password(cookie: str, password: str):
info = hsw.rpc_selectWallet(account) info = hsw.rpc_selectWallet(account)
if info['error'] is not None: if info['error'] is not None:
return False return False
info = hsw.rpc_walletPassphrase(password,1) info = hsw.rpc_walletPassphrase(password, 1)
if info['error'] is not None: if info['error'] is not None:
if info['error']['message'] != "Wallet is not encrypted.": if info['error']['message'] != "Wallet is not encrypted.":
return False return False
return True return True
def createWallet(account: str, password: str): def createWallet(account: str, password: str):
if not hsdConnected(): if not hsdConnected():
return { return {
@@ -104,7 +109,8 @@ def createWallet(account: str, password: str):
} }
# Create the account # Create the account
# Python wrapper doesn't support this yet # Python wrapper doesn't support this yet
response = requests.put(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account}") response = requests.put(
f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account}")
if response.status_code != 200: if response.status_code != 200:
return { return {
"error": { "error": {
@@ -116,10 +122,9 @@ def createWallet(account: str, password: str):
seed = hsw.getMasterHDKey(account) seed = hsw.getMasterHDKey(account)
seed = seed['mnemonic']['phrase'] seed = seed['mnemonic']['phrase']
# Encrypt the wallet (python wrapper doesn't support this yet) # Encrypt the wallet (python wrapper doesn't support this yet)
response = requests.post(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account}/passphrase", response = requests.post(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account}/passphrase",
json={"passphrase": password}) json={"passphrase": password})
return { return {
"seed": seed, "seed": seed,
@@ -127,7 +132,8 @@ def createWallet(account: str, password: str):
"password": password "password": password
} }
def importWallet(account: str, password: str,seed: str):
def importWallet(account: str, password: str, seed: str):
if not hsdConnected(): if not hsdConnected():
return { return {
"error": { "error": {
@@ -141,7 +147,8 @@ def importWallet(account: str, password: str,seed: str):
"mnemonic": seed, "mnemonic": seed,
} }
response = requests.put(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account}",json=data) response = requests.put(
f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account}", json=data)
if response.status_code != 200: if response.status_code != 200:
return { return {
"error": { "error": {
@@ -168,6 +175,7 @@ def listWallets():
return response return response
return ['Wallet not connected'] return ['Wallet not connected']
def selectWallet(account: str): def selectWallet(account: str):
# Select wallet # Select wallet
response = hsw.rpc_selectWallet(account) response = hsw.rpc_selectWallet(account)
@@ -178,9 +186,10 @@ def selectWallet(account: str):
} }
} }
def getBalance(account: str): def getBalance(account: str):
# Get the total balance # Get the total balance
info = hsw.getBalance('default',account) info = hsw.getBalance('default', account)
if 'error' in info: if 'error' in info:
return {'available': 0, 'total': 0} return {'available': 0, 'total': 0}
@@ -200,13 +209,13 @@ def getBalance(account: str):
total = total - (domainValue/1000000) total = total - (domainValue/1000000)
locked = locked - (domainValue/1000000) locked = locked - (domainValue/1000000)
# Only keep 2 decimal places # Only keep 2 decimal places
total = round(total, 2) total = round(total, 2)
available = round(available, 2) available = round(available, 2)
return {'available': available, 'total': total, 'locked': locked} return {'available': available, 'total': total, 'locked': locked}
def getBlockHeight(): def getBlockHeight():
# Get the block height # Get the block height
info = hsd.getInfo() info = hsd.getInfo()
@@ -214,6 +223,7 @@ def getBlockHeight():
return 0 return 0
return info['chain']['height'] return info['chain']['height']
def getAddress(account: str): def getAddress(account: str):
# Get the address # Get the address
info = hsw.getAccountInfo(account, 'default') info = hsw.getAccountInfo(account, 'default')
@@ -221,27 +231,31 @@ def getAddress(account: str):
return '' return ''
return info['receiveAddress'] return info['receiveAddress']
def getPendingTX(account: str): def getPendingTX(account: str):
pending = 0 pending = 0
page = 1 page = 1
pageSize = 10 pageSize = 10
while True: while True:
txs = getTransactions(account,page,pageSize) txs = getTransactions(account, page, pageSize)
page+=1 page += 1
pendingPage = 0 pendingPage = 0
for tx in txs: for tx in txs:
if tx['confirmations'] < 1: if tx['confirmations'] < 1:
pending+=1 pending += 1
pendingPage+=1 pendingPage += 1
if pendingPage < pageSize: if pendingPage < pageSize:
break break
return pending return pending
def getDomains(account,own=True):
def getDomains(account, own=True):
if own: if own:
response = requests.get(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account}/name?own=true") response = requests.get(
f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account}/name?own=true")
else: else:
response = requests.get(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account}/name") response = requests.get(
f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account}/name")
info = response.json() info = response.json()
if SHOW_EXPIRED: if SHOW_EXPIRED:
@@ -256,10 +270,10 @@ def getDomains(account,own=True):
continue continue
domains.append(domain) domains.append(domain)
return domains return domains
def getPageTXCache(account,page,size=100):
def getPageTXCache(account, page, size=100):
page = f"{page}-{size}" page = f"{page}-{size}"
if not os.path.exists(f'cache'): if not os.path.exists(f'cache'):
os.mkdir(f'cache') os.mkdir(f'cache')
@@ -274,7 +288,8 @@ def getPageTXCache(account,page,size=100):
return pageCache[page]['txid'] return pageCache[page]['txid']
return None return None
def pushPageTXCache(account,page,txid,size=100):
def pushPageTXCache(account, page, txid, size=100):
page = f"{page}-{size}" page = f"{page}-{size}"
if not os.path.exists(f'cache/{account}_page.json'): if not os.path.exists(f'cache/{account}_page.json'):
with open(f'cache/{account}_page.json', 'w') as f: with open(f'cache/{account}_page.json', 'w') as f:
@@ -287,27 +302,27 @@ def pushPageTXCache(account,page,txid,size=100):
'txid': txid 'txid': txid
} }
with open(f'cache/{account}_page.json', 'w') as f: with open(f'cache/{account}_page.json', 'w') as f:
json.dump(pageCache, f,indent=4) json.dump(pageCache, f, indent=4)
return pageCache[page]['txid'] return pageCache[page]['txid']
def getTXFromPage(account,page,size=100):
if page == 1:
return getTransactions(account,1,size)[-1]['hash']
cached = getPageTXCache(account,page,size) def getTXFromPage(account, page, size=100):
if page == 1:
return getTransactions(account, 1, size)[-1]['hash']
cached = getPageTXCache(account, page, size)
if cached: if cached:
return getPageTXCache(account,page,size) return getPageTXCache(account, page, size)
previous = getTransactions(account,page,size) previous = getTransactions(account, page, size)
if len(previous) == 0: if len(previous) == 0:
return None return None
hash = previous[-1]['hash'] hash = previous[-1]['hash']
pushPageTXCache(account,page,hash,size) pushPageTXCache(account, page, hash, size)
return hash return hash
def getTransactions(account, page=1, limit=100):
def getTransactions(account,page=1,limit=100):
# Get the transactions # Get the transactions
if hsdVersion() < 7: if hsdVersion() < 7:
if page != 1: if page != 1:
@@ -321,12 +336,14 @@ def getTransactions(account,page=1,limit=100):
if page < 1: if page < 1:
return [] return []
if page > 1: if page > 1:
lastTX = getTXFromPage(account,page-1,limit) lastTX = getTXFromPage(account, page-1, limit)
if lastTX: if lastTX:
response = requests.get(f'http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account}/tx/history?reverse=true&limit={limit}&after={lastTX}') response = requests.get(
f'http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account}/tx/history?reverse=true&limit={limit}&after={lastTX}')
elif page == 1: elif page == 1:
response = requests.get(f'http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account}/tx/history?reverse=true&limit={limit}') response = requests.get(
f'http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account}/tx/history?reverse=true&limit={limit}')
else: else:
return [] return []
@@ -336,23 +353,25 @@ def getTransactions(account,page=1,limit=100):
data = response.json() data = response.json()
# Refresh the cache if the next page is different # Refresh the cache if the next page is different
nextPage = getPageTXCache(account,page,limit) nextPage = getPageTXCache(account, page, limit)
if nextPage is not None and nextPage != data[-1]['hash']: if nextPage is not None and nextPage != data[-1]['hash']:
print(f'Refreshing page {page}') print(f'Refreshing page {page}')
pushPageTXCache(account,page,data[-1]['hash'],limit) pushPageTXCache(account, page, data[-1]['hash'], limit)
return data return data
def getAllTransactions(account): def getAllTransactions(account):
# Get the transactions # Get the transactions
page = 0 page = 0
txs = [] txs = []
while True: while True:
txs += getTransactions(account,page,1000) txs += getTransactions(account, page, 1000)
if len(txs) == 0: if len(txs) == 0:
break break
page += 1 page += 1
return txs return txs
def check_address(address: str, allow_name: bool = True, return_address: bool = False): def check_address(address: str, allow_name: bool = True, return_address: bool = False):
# Check if the address is valid # Check if the address is valid
if address.startswith('@'): if address.startswith('@'):
@@ -364,7 +383,7 @@ def check_address(address: str, allow_name: bool = True, return_address: bool =
return check_hip2(address[1:]) return check_hip2(address[1:])
# Check if the address is a valid HNS address # Check if the address is a valid HNS address
response = requests.post(f"http://x:{HSD_API}@{HSD_IP}:{HSD_NODE_PORT}",json={ response = requests.post(f"http://x:{HSD_API}@{HSD_IP}:{HSD_NODE_PORT}", json={
"method": "validateaddress", "method": "validateaddress",
"params": [address] "params": [address]
}).json() }).json()
@@ -394,13 +413,12 @@ def check_hip2(domain: str):
if address.startswith("Hip2: "): if address.startswith("Hip2: "):
return address return address
if not check_address(address, False,True): if not check_address(address, False, True):
return 'Hip2: Lookup succeeded but address is invalid' return 'Hip2: Lookup succeeded but address is invalid'
return address return address
def send(account, address, amount):
def send(account,address,amount):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
response = hsw.rpc_selectWallet(account_name) response = hsw.rpc_selectWallet(account_name)
@@ -411,18 +429,19 @@ def send(account,address,amount):
} }
} }
response = hsw.rpc_walletPassphrase(password,10) response = hsw.rpc_walletPassphrase(password, 10)
# Unlock the account # Unlock the account
# response = requests.post(f"http://x:{APIKEY}@{ip}:{HSD_WALLET_PORT}/wallet/{account_name}/unlock", # response = requests.post(f"http://x:{APIKEY}@{ip}:{HSD_WALLET_PORT}/wallet/{account_name}/unlock",
# json={"passphrase": password,"timeout": 10}) # json={"passphrase": password,"timeout": 10})
if response['error'] is not None: if response['error'] is not None:
return { if response['error']['message'] != "Wallet is not encrypted.":
"error": { return {
"message": response['error']['message'] "error": {
"message": response['error']['message']
}
} }
}
response = hsw.rpc_sendToAddress(address,amount) response = hsw.rpc_sendToAddress(address, amount)
if response['error'] is not None: if response['error'] is not None:
return { return {
"error": { "error": {
@@ -433,7 +452,8 @@ def send(account,address,amount):
"tx": response['result'] "tx": response['result']
} }
def isOwnDomain(account,name: str):
def isOwnDomain(account, name: str):
domains = getDomains(account) domains = getDomains(account)
for domain in domains: for domain in domains:
if domain['name'] == name: if domain['name'] == name:
@@ -452,7 +472,8 @@ def getDomain(domain: str):
} }
return response['result'] return response['result']
def renewDomain(account,domain):
def renewDomain(account, domain):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
@@ -463,9 +484,10 @@ def renewDomain(account,domain):
} }
} }
response = hsw.sendRENEW(account_name,password,domain) response = hsw.sendRENEW(account_name, password, domain)
return response return response
def getDNS(domain: str): def getDNS(domain: str):
# Get the DNS # Get the DNS
response = hsd.rpc_getNameResource(domain) response = hsd.rpc_getNameResource(domain)
@@ -484,7 +506,8 @@ def getDNS(domain: str):
return [] return []
return response['result']['records'] return response['result']['records']
def setDNS(account,domain,records):
def setDNS(account, domain, records):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
@@ -510,7 +533,7 @@ def setDNS(account,domain,records):
'type': 'NS', 'type': 'NS',
'ns': record['value'] 'ns': record['value']
}) })
elif record['type'] in ['GLUE4','GLUE6',"SYNTH4","SYNTH6"]: elif record['type'] in ['GLUE4', 'GLUE6', "SYNTH4", "SYNTH6"]:
newRecords.append({ newRecords.append({
'type': record['type'], 'type': record['type'],
'ns': str(record['value']).split(' ')[0], 'ns': str(record['value']).split(' ')[0],
@@ -524,13 +547,15 @@ def setDNS(account,domain,records):
'type': 'TXT', 'type': 'TXT',
'txt': TXTRecords 'txt': TXTRecords
}) })
data = '{"records":'+str(newRecords).replace("'","\"")+'}' data = '{"records":'+str(newRecords).replace("'", "\"")+'}'
response = hsw.sendUPDATE(account_name,password,domain,data) response = hsw.sendUPDATE(account_name, password, domain, data)
return response return response
def register(account,domain):
def register(account, domain):
# Maybe add default dns records? # Maybe add default dns records?
return setDNS(account,domain,'[]') return setDNS(account, domain, '[]')
def getNodeSync(): def getNodeSync():
response = hsd.getInfo() response = hsd.getInfo()
@@ -541,6 +566,7 @@ def getNodeSync():
sync = round(sync, 2) sync = round(sync, 2)
return sync return sync
def getWalletStatus(): def getWalletStatus():
response = hsw.rpc_getWalletInfo() response = hsw.rpc_getWalletInfo()
if 'error' in response and response['error'] != None: if 'error' in response and response['error'] != None:
@@ -559,12 +585,11 @@ def getWalletStatus():
return "Error wallet ahead of node" return "Error wallet ahead of node"
def getBids(account, domain="NONE"): def getBids(account, domain="NONE"):
if domain == "NONE": if domain == "NONE":
response = hsw.getWalletBids(account) response = hsw.getWalletBids(account)
else: else:
response = hsw.getWalletBidsByName(domain,account) response = hsw.getWalletBidsByName(domain, account)
# Add backup for bids with no value # Add backup for bids with no value
bids = [] bids = []
for bid in response: for bid in response:
@@ -577,16 +602,18 @@ def getBids(account, domain="NONE"):
bids.append(bid) bids.append(bid)
return bids return bids
def getReveals(account,domain):
return hsw.getWalletRevealsByName(domain,account) def getReveals(account, domain):
return hsw.getWalletRevealsByName(domain, account)
def getPendingReveals(account): def getPendingReveals(account):
bids = getBids(account) bids = getBids(account)
domains = getDomains(account,False) domains = getDomains(account, False)
pending = [] pending = []
for domain in domains: for domain in domains:
if domain['state'] == "REVEAL": if domain['state'] == "REVEAL":
reveals = getReveals(account,domain['name']) reveals = getReveals(account, domain['name'])
for bid in bids: for bid in bids:
if bid['name'] == domain['name']: if bid['name'] == domain['name']:
state_found = False state_found = False
@@ -600,10 +627,10 @@ def getPendingReveals(account):
return pending return pending
def getPendingRedeems(account,password): def getPendingRedeems(account, password):
hsw.rpc_selectWallet(account) hsw.rpc_selectWallet(account)
hsw.rpc_walletPassphrase(password,10) hsw.rpc_walletPassphrase(password, 10)
tx = hsw.rpc_createREDEEM('','default') tx = hsw.rpc_createREDEEM('', 'default')
if tx['error']: if tx['error']:
return [] return []
@@ -626,9 +653,10 @@ def getPendingRedeems(account,password):
return pending return pending
def getPendingRegisters(account): def getPendingRegisters(account):
bids = getBids(account) bids = getBids(account)
domains = getDomains(account,False) domains = getDomains(account, False)
pending = [] pending = []
for domain in domains: for domain in domains:
if domain['state'] == "CLOSED" and domain['registered'] == False: if domain['state'] == "CLOSED" and domain['registered'] == False:
@@ -638,8 +666,9 @@ def getPendingRegisters(account):
pending.append(bid) pending.append(bid)
return pending return pending
def getPendingFinalizes(account,password):
tx = createBatch(f'{account}:{password}',[["FINALIZE"]]) def getPendingFinalizes(account, password):
tx = createBatch(f'{account}:{password}', [["FINALIZE"]])
if 'error' in tx: if 'error' in tx:
return [] return []
@@ -677,7 +706,7 @@ def getRevealTX(reveal):
return tx['inputs'][index]['prevout']['hash'] return tx['inputs'][index]['prevout']['hash']
def revealAuction(account,domain): def revealAuction(account, domain):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
@@ -689,13 +718,14 @@ def revealAuction(account,domain):
} }
try: try:
response = hsw.sendREVEAL(account_name,password,domain) response = hsw.sendREVEAL(account_name, password, domain)
return response return response
except Exception as e: except Exception as e:
return { return {
"error": str(e) "error": str(e)
} }
def revealAll(account): def revealAll(account):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
@@ -712,11 +742,16 @@ def revealAll(account):
response = hsw.rpc_selectWallet(account_name) response = hsw.rpc_selectWallet(account_name)
if response['error'] is not None: if response['error'] is not None:
return return
response = hsw.rpc_walletPassphrase(password,10) response = hsw.rpc_walletPassphrase(password, 10)
if response['error'] is not None: if response['error'] is not None:
return if response['error']['message'] != "Wallet is not encrypted.":
return {
"error": {
"message": response['error']['message']
}
}
return requests.post(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}",json={"method": "sendbatch","params": [[["REVEAL"]]]}).json() return requests.post(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}", json={"method": "sendbatch", "params": [[["REVEAL"]]]}).json()
except Exception as e: except Exception as e:
return { return {
"error": { "error": {
@@ -724,6 +759,7 @@ def revealAll(account):
} }
} }
def redeemAll(account): def redeemAll(account):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
@@ -740,11 +776,16 @@ def redeemAll(account):
response = hsw.rpc_selectWallet(account_name) response = hsw.rpc_selectWallet(account_name)
if response['error'] is not None: if response['error'] is not None:
return return
response = hsw.rpc_walletPassphrase(password,10) response = hsw.rpc_walletPassphrase(password, 10)
if response['error'] is not None: if response['error'] is not None:
return if response['error']['message'] != "Wallet is not encrypted.":
return {
"error": {
"message": response['error']['message']
}
}
return requests.post(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}",json={"method": "sendbatch","params": [[["REDEEM"]]]}).json() return requests.post(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}", json={"method": "sendbatch", "params": [[["REDEEM"]]]}).json()
except Exception as e: except Exception as e:
return { return {
"error": { "error": {
@@ -752,6 +793,7 @@ def redeemAll(account):
} }
} }
def registerAll(account): def registerAll(account):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
@@ -773,8 +815,9 @@ def registerAll(account):
} }
batch = [] batch = []
for domain in domains: for domain in domains:
batch.append(["UPDATE",domain['name'],{"records":[]}]) batch.append(["UPDATE", domain['name'], {"records": []}])
return sendBatch(account,batch) return sendBatch(account, batch)
def finalizeAll(account): def finalizeAll(account):
account_name = check_account(account) account_name = check_account(account)
@@ -787,9 +830,10 @@ def finalizeAll(account):
} }
} }
return sendBatch(account,[["FINALIZE"]]) return sendBatch(account, [["FINALIZE"]])
def rescan_auction(account,domain):
def rescan_auction(account, domain):
# Get height of the start of the auction # Get height of the start of the auction
response = hsw.rpc_selectWallet(account) response = hsw.rpc_selectWallet(account)
response = hsd.rpc_getNameInfo(domain) response = hsd.rpc_getNameInfo(domain)
@@ -802,11 +846,11 @@ def rescan_auction(account,domain):
"error": "Not in auction" "error": "Not in auction"
} }
height = response['result']['info']['height']-1 height = response['result']['info']['height']-1
response = hsw.rpc_importName(domain,height) response = hsw.rpc_importName(domain, height)
return response return response
def bid(account,domain,bid,blind): def bid(account, domain, bid, blind):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
@@ -821,7 +865,7 @@ def bid(account,domain,bid,blind):
lockup = int(blind)*1000000 + bid lockup = int(blind)*1000000 + bid
try: try:
response = hsw.sendBID(account_name,password,domain,bid,lockup) response = hsw.sendBID(account_name, password, domain, bid, lockup)
return response return response
except Exception as e: except Exception as e:
return { return {
@@ -831,7 +875,7 @@ def bid(account,domain,bid,blind):
} }
def openAuction(account,domain): def openAuction(account, domain):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
@@ -843,7 +887,7 @@ def openAuction(account,domain):
} }
try: try:
response = hsw.sendOPEN(account_name,password,domain) response = hsw.sendOPEN(account_name, password, domain)
return response return response
except Exception as e: except Exception as e:
return { return {
@@ -853,8 +897,7 @@ def openAuction(account,domain):
} }
def transfer(account, domain, address):
def transfer(account,domain,address):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
@@ -866,7 +909,7 @@ def transfer(account,domain,address):
} }
try: try:
response = hsw.sendTRANSFER(account_name,password,domain,address) response = hsw.sendTRANSFER(account_name, password, domain, address)
return response return response
except Exception as e: except Exception as e:
return { return {
@@ -875,7 +918,8 @@ def transfer(account,domain,address):
} }
} }
def finalize(account,domain):
def finalize(account, domain):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
@@ -890,17 +934,18 @@ def finalize(account,domain):
response = hsw.rpc_selectWallet(account_name) response = hsw.rpc_selectWallet(account_name)
if response['error'] is not None: if response['error'] is not None:
return { return {
"error": { "error": {
"message": response['error']['message'] "message": response['error']['message']
}
} }
} response = hsw.rpc_walletPassphrase(password, 10)
response = hsw.rpc_walletPassphrase(password,10)
if response['error'] is not None: if response['error'] is not None:
return { if response['error']['message'] != "Wallet is not encrypted.":
"error": { return {
"message": response['error']['message'] "error": {
} "message": response['error']['message']
} }
}
response = hsw.rpc_sendFINALIZE(domain) response = hsw.rpc_sendFINALIZE(domain)
return response return response
except Exception as e: except Exception as e:
@@ -910,7 +955,8 @@ def finalize(account,domain):
} }
} }
def cancelTransfer(account,domain):
def cancelTransfer(account, domain):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
@@ -925,17 +971,18 @@ def cancelTransfer(account,domain):
response = hsw.rpc_selectWallet(account_name) response = hsw.rpc_selectWallet(account_name)
if response['error'] is not None: if response['error'] is not None:
return { return {
"error": { "error": {
"message": response['error']['message'] "message": response['error']['message']
}
} }
} response = hsw.rpc_walletPassphrase(password, 10)
response = hsw.rpc_walletPassphrase(password,10)
if response['error'] is not None: if response['error'] is not None:
return { if response['error']['message'] != "Wallet is not encrypted.":
"error": { return {
"message": response['error']['message'] "error": {
} "message": response['error']['message']
} }
}
response = hsw.rpc_sendCANCEL(domain) response = hsw.rpc_sendCANCEL(domain)
return response return response
except Exception as e: except Exception as e:
@@ -945,7 +992,8 @@ def cancelTransfer(account,domain):
} }
} }
def revoke(account,domain):
def revoke(account, domain):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
@@ -960,17 +1008,18 @@ def revoke(account,domain):
response = hsw.rpc_selectWallet(account_name) response = hsw.rpc_selectWallet(account_name)
if response['error'] is not None: if response['error'] is not None:
return { return {
"error": { "error": {
"message": response['error']['message'] "message": response['error']['message']
}
} }
} response = hsw.rpc_walletPassphrase(password, 10)
response = hsw.rpc_walletPassphrase(password,10)
if response['error'] is not None: if response['error'] is not None:
return { if response['error']['message'] != "Wallet is not encrypted.":
"error": { return {
"message": response['error']['message'] "error": {
} "message": response['error']['message']
} }
}
response = hsw.rpc_sendREVOKE(domain) response = hsw.rpc_sendREVOKE(domain)
return response return response
except Exception as e: except Exception as e:
@@ -980,6 +1029,7 @@ def revoke(account,domain):
} }
} }
def sendBatch(account, batch): def sendBatch(account, batch):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
@@ -995,18 +1045,19 @@ def sendBatch(account, batch):
response = hsw.rpc_selectWallet(account_name) response = hsw.rpc_selectWallet(account_name)
if response['error'] is not None: if response['error'] is not None:
return { return {
"error": { "error": {
"message": response['error']['message'] "message": response['error']['message']
}
} }
} response = hsw.rpc_walletPassphrase(password, 10)
response = hsw.rpc_walletPassphrase(password,10)
if response['error'] is not None: if response['error'] is not None:
return { if response['error']['message'] != "Wallet is not encrypted.":
"error": { return {
"message": response['error']['message'] "error": {
} "message": response['error']['message']
} }
response = requests.post(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}",json={ }
response = requests.post(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}", json={
"method": "sendbatch", "method": "sendbatch",
"params": [batch] "params": [batch]
}).json() }).json()
@@ -1014,10 +1065,10 @@ def sendBatch(account, batch):
return response return response
if 'result' not in response: if 'result' not in response:
return { return {
"error": { "error": {
"message": "No result" "message": "No result"
}
} }
}
return response['result'] return response['result']
except Exception as e: except Exception as e:
@@ -1027,6 +1078,7 @@ def sendBatch(account, batch):
} }
} }
def createBatch(account, batch): def createBatch(account, batch):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
@@ -1042,18 +1094,19 @@ def createBatch(account, batch):
response = hsw.rpc_selectWallet(account_name) response = hsw.rpc_selectWallet(account_name)
if response['error'] is not None: if response['error'] is not None:
return { return {
"error": { "error": {
"message": response['error']['message'] "message": response['error']['message']
}
} }
} response = hsw.rpc_walletPassphrase(password, 10)
response = hsw.rpc_walletPassphrase(password,10)
if response['error'] is not None: if response['error'] is not None:
return { if response['error']['message'] != "Wallet is not encrypted.":
"error": { return {
"message": response['error']['message'] "error": {
} "message": response['error']['message']
} }
response = requests.post(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}",json={ }
response = requests.post(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}", json={
"method": "createbatch", "method": "createbatch",
"params": [batch] "params": [batch]
}).json() }).json()
@@ -1061,10 +1114,10 @@ def createBatch(account, batch):
return response return response
if 'result' not in response: if 'result' not in response:
return { return {
"error": { "error": {
"message": "No result" "message": "No result"
}
} }
}
return response['result'] return response['result']
except Exception as e: except Exception as e:
@@ -1075,7 +1128,7 @@ def createBatch(account, batch):
} }
#region settingsAPIs # region settingsAPIs
def rescan(): def rescan():
try: try:
response = hsw.walletRescan(0) response = hsw.walletRescan(0)
@@ -1087,6 +1140,7 @@ def rescan():
} }
} }
def resendTXs(): def resendTXs():
try: try:
response = hsw.walletResend() response = hsw.walletResend()
@@ -1099,9 +1153,8 @@ def resendTXs():
} }
def zapTXs(account): def zapTXs(account):
age = 60 * 20 # 20 minutes age = 60 * 20 # 20 minutes
account_name = check_account(account) account_name = check_account(account)
@@ -1114,9 +1167,9 @@ def zapTXs(account):
try: try:
response = requests.post(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account_name}/zap", response = requests.post(f"http://x:{HSD_API}@{HSD_IP}:{HSD_WALLET_PORT}/wallet/{account_name}/zap",
json={"age": age, json={"age": age,
"account": "default" "account": "default"
}) })
return response return response
except Exception as e: except Exception as e:
return { return {
@@ -1136,9 +1189,8 @@ def getxPub(account):
} }
} }
try: try:
response = hsw.getAccountInfo(account_name,"default") response = hsw.getAccountInfo(account_name, "default")
if 'error' in response: if 'error' in response:
return { return {
"error": { "error": {
@@ -1156,7 +1208,7 @@ def getxPub(account):
} }
def signMessage(account,domain,message): def signMessage(account, domain, message):
account_name = check_account(account) account_name = check_account(account)
password = ":".join(account.split(":")[1:]) password = ":".join(account.split(":")[1:])
@@ -1167,23 +1219,23 @@ def signMessage(account,domain,message):
} }
} }
try: try:
response = hsw.rpc_selectWallet(account_name) response = hsw.rpc_selectWallet(account_name)
if response['error'] is not None: if response['error'] is not None:
return { return {
"error": { "error": {
"message": response['error']['message'] "message": response['error']['message']
}
} }
} response = hsw.rpc_walletPassphrase(password, 10)
response = hsw.rpc_walletPassphrase(password,10)
if response['error'] is not None: if response['error'] is not None:
return { if response['error']['message'] != "Wallet is not encrypted.":
"error": { return {
"message": response['error']['message'] "error": {
} "message": response['error']['message']
} }
response = hsw.rpc_signMessageWithName(domain,message) }
response = hsw.rpc_signMessageWithName(domain, message)
return response return response
except Exception as e: except Exception as e:
return { return {
@@ -1192,9 +1244,10 @@ def signMessage(account,domain,message):
} }
} }
def verifyMessageWithName(domain,signature,message):
def verifyMessageWithName(domain, signature, message):
try: try:
response = hsd.rpc_verifyMessageWithName(domain,signature,message) response = hsd.rpc_verifyMessageWithName(domain, signature, message)
if 'result' in response: if 'result' in response:
return response['result'] return response['result']
return False return False
@@ -1202,23 +1255,24 @@ def verifyMessageWithName(domain,signature,message):
return False return False
def verifyMessage(address,signature,message): def verifyMessage(address, signature, message):
try: try:
response = hsd.rpc_verifyMessage(address,signature,message) response = hsd.rpc_verifyMessage(address, signature, message)
if 'result' in response: if 'result' in response:
return response['result'] return response['result']
return False return False
except Exception as e: except Exception as e:
return False return False
#endregion # endregion
def generateReport(account,format="{name},{expiry},{value},{maxBid}"):
def generateReport(account, format="{name},{expiry},{value},{maxBid}"):
domains = getDomains(account) domains = getDomains(account)
lines = [format.replace("{","").replace("}","")] lines = [format.replace("{", "").replace("}", "")]
for domain in domains: for domain in domains:
line = format.replace("{name}",domain['name']) line = format.replace("{name}", domain['name'])
expiry = "N/A" expiry = "N/A"
expiryBlock = "N/A" expiryBlock = "N/A"
if 'daysUntilExpire' in domain['stats']: if 'daysUntilExpire' in domain['stats']:
@@ -1228,15 +1282,16 @@ def generateReport(account,format="{name},{expiry},{value},{maxBid}"):
expiry = expiry.strftime("%d/%m/%Y %H:%M:%S") expiry = expiry.strftime("%d/%m/%Y %H:%M:%S")
expiryBlock = str(domain['stats']['renewalPeriodEnd']) expiryBlock = str(domain['stats']['renewalPeriodEnd'])
line = line.replace("{expiry}",expiry) line = line.replace("{expiry}", expiry)
line = line.replace("{state}",domain['state']) line = line.replace("{state}", domain['state'])
line = line.replace("{expiryBlock}",expiryBlock) line = line.replace("{expiryBlock}", expiryBlock)
line = line.replace("{value}",str(domain['value']/1000000)) line = line.replace("{value}", str(domain['value']/1000000))
line = line.replace("{maxBid}",str(domain['highest']/1000000)) line = line.replace("{maxBid}", str(domain['highest']/1000000))
line = line.replace("{openHeight}",str(domain['height'])) line = line.replace("{openHeight}", str(domain['height']))
lines.append(line) lines.append(line)
return lines return lines
def convertHNS(value: int): def convertHNS(value: int):
return value/1000000 return value/1000000

10
main.py
View File

@@ -178,7 +178,15 @@ def sendConfirmed():
address = request.args.get("address") address = request.args.get("address")
amount = float(request.args.get("amount")) amount = float(request.args.get("amount"))
response = account_module.send(request.cookies.get("account"),address,amount) response = account_module.send(request.cookies.get("account"),address,amount)
if 'error' in response: if 'error' in response and response['error'] != None:
# If error is a dict get the message
if isinstance(response['error'], dict):
if 'message' in response['error']:
return redirect("/send?message=" + response['error']['message'] + "&address=" + address + "&amount=" + str(amount))
else:
return redirect("/send?message=" + str(response['error']) + "&address=" + address + "&amount=" + str(amount))
# If error is a string
return redirect("/send?message=" + response['error'] + "&address=" + address + "&amount=" + str(amount)) return redirect("/send?message=" + response['error'] + "&address=" + address + "&amount=" + str(amount))
return redirect("/success?tx=" + response['tx']) return redirect("/success?tx=" + response['tx'])

3
plugins/batching.py
View File

@@ -9,7 +9,7 @@ import os
info = { info = {
"name": "Batching Functions", "name": "Batching Functions",
"description": "This is a plugin that provides multiple functions to batch transactions", "description": "This is a plugin that provides multiple functions to batch transactions",
"version": "1.0", "version": "1.1",
"author": "Nathan.Woodburn/" "author": "Nathan.Woodburn/"
} }
# https://hsd-dev.org/api-docs/?shell--cli#sendbatch # https://hsd-dev.org/api-docs/?shell--cli#sendbatch
@@ -394,7 +394,6 @@ def bid(params, authentication):
for domain in domains: for domain in domains:
batch.append(['BID', domain, bid, blind]) batch.append(['BID', domain, bid, blind])
print(batch)
response = sendBatch(batch, authentication) response = sendBatch(batch, authentication)
if 'error' in response: if 'error' in response:
return { return {

2
render.py
View File

@@ -8,7 +8,7 @@ import os
# Get Explorer URL # Get Explorer URL
TX_EXPLORER_URL = os.getenv("EXPLORER_TX") TX_EXPLORER_URL = os.getenv("EXPLORER_TX")
if TX_EXPLORER_URL is None: if TX_EXPLORER_URL is None:
TX_EXPLORER_URL = "https://niami.io/tx/" TX_EXPLORER_URL = "https://shakeshift.com/transaction/"