You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
445 lines
14 KiB
445 lines
14 KiB
#!/bin/python
|
|
#
|
|
# Cryptonote tipbot - utility functions
|
|
# Copyright 2014,2015 moneromooo
|
|
#
|
|
# The Cryptonote tipbot is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License as published
|
|
# by the Free Software Foundation; either version 2, or (at your option)
|
|
# any later version.
|
|
#
|
|
|
|
import redis
|
|
import hashlib
|
|
import json
|
|
import httplib
|
|
import time
|
|
import threading
|
|
import math
|
|
import string
|
|
import random
|
|
from Crypto.Random.random import getrandbits
|
|
from decimal import *
|
|
import tipbot.config as config
|
|
import tipbot.coinspecs as coinspecs
|
|
from tipbot.log import log_error, log_warn, log_info, log_log
|
|
from tipbot.link import Link
|
|
from tipbot.redisdb import *
|
|
|
|
registered_networks=dict()
|
|
networks=[]
|
|
cached_tipbot_balance=None
|
|
cached_tipbot_unlocked_balance=None
|
|
cached_tipbot_balance_timestamp=None
|
|
|
|
core_lock = threading.RLock()
|
|
|
|
def GetPassword(name):
|
|
try:
|
|
f = open('tipbot-password.txt', 'r')
|
|
for p in f:
|
|
p = p.strip("\r\n")
|
|
parts=p.split(':')
|
|
if parts[0]==name:
|
|
return parts[1]
|
|
except Exception,e:
|
|
log_error('could not fetch password: %s' % str(e))
|
|
raise
|
|
return "xxx"
|
|
finally:
|
|
f.close()
|
|
|
|
def IsParamPresent(parms,idx):
|
|
return len(parms) > idx
|
|
|
|
def GetParam(parms,idx):
|
|
if IsParamPresent(parms,idx):
|
|
return parms[idx]
|
|
return None
|
|
|
|
def SetPaymentID(link,pid):
|
|
try:
|
|
redis_hset("paymentid",pid,link.identity())
|
|
except Exception,e:
|
|
log_error('GetPaymentID: failed to set payment ID for %s to redis: %s' % (link.identity(),str(e)))
|
|
return
|
|
|
|
def GetPaymentID(link,random=False):
|
|
salt="2u3g55bkwrui32fi3g4bGR$j5g4ugnujb-"+coinspecs.name+"-";
|
|
if random:
|
|
salt = salt + "-" + str(time.time()) + "-" + str(getrandbits(128))
|
|
p = hashlib.sha256(salt+link.identity()).hexdigest();
|
|
try:
|
|
redis_hset("paymentid",p,link.identity())
|
|
except Exception,e:
|
|
log_error('GetPaymentID: failed to set payment ID for %s to redis: %s' % (link.identity(),str(e)))
|
|
return p
|
|
|
|
def GetRandomPaymentID(link):
|
|
return GetPaymentID(link, True)
|
|
|
|
def GetIdentityFromPaymentID(p):
|
|
if not redis_hexists("paymentid",p):
|
|
log_log('PaymentID %s not found' % p)
|
|
return None
|
|
identity = redis_hget("paymentid",p)
|
|
log_log('PaymentID %s => %s' % (p, str(identity)))
|
|
# HACK - grandfathering pre-network payment IDs
|
|
if identity.index(':') == -1:
|
|
log_warn('Pre-network payment ID found, assuming freenode')
|
|
identity = "freenode:"+identity
|
|
return identity
|
|
|
|
def IsAddressLengthValid(address):
|
|
if type(coinspecs.address_length[0]) == list:
|
|
for allist in coinspecs.address_length:
|
|
if len(address) >= allist[0] and len(address) <= allist[1]:
|
|
return True
|
|
else:
|
|
if len(address) >= coinspecs.address_length[0] and len(address) <= coinspecs.address_length[1]:
|
|
return True
|
|
return False
|
|
|
|
def IsValidAddress(address):
|
|
if not IsAddressLengthValid(address):
|
|
return False
|
|
for prefix in coinspecs.address_prefix:
|
|
if address.startswith(prefix):
|
|
return True
|
|
return False
|
|
|
|
def IsValidPaymentID(payment_id):
|
|
if len(payment_id)!=64:
|
|
return False
|
|
for char in payment_id:
|
|
if char not in string.hexdigits:
|
|
return False
|
|
return True
|
|
|
|
# Code taken from the Python documentation
|
|
def moneyfmt(value, places=2, curr='', sep=',', dp='.',
|
|
pos='', neg='-', trailneg=''):
|
|
"""Convert Decimal to a money formatted string.
|
|
|
|
places: required number of places after the decimal point
|
|
curr: optional currency symbol before the sign (may be blank)
|
|
sep: optional grouping separator (comma, period, space, or blank)
|
|
dp: decimal point indicator (comma or period)
|
|
only specify as blank when places is zero
|
|
pos: optional sign for positive numbers: '+', space or blank
|
|
neg: optional sign for negative numbers: '-', '(', space or blank
|
|
trailneg:optional trailing minus indicator: '-', ')', space or blank
|
|
|
|
>>> d = Decimal('-1234567.8901')
|
|
>>> moneyfmt(d, curr='$')
|
|
'-$1,234,567.89'
|
|
>>> moneyfmt(d, places=0, sep='.', dp='', neg='', trailneg='-')
|
|
'1.234.568-'
|
|
>>> moneyfmt(d, curr='$', neg='(', trailneg=')')
|
|
'($1,234,567.89)'
|
|
>>> moneyfmt(Decimal(123456789), sep=' ')
|
|
'123 456 789.00'
|
|
>>> moneyfmt(Decimal('-0.02'), neg='<', trailneg='>')
|
|
'<0.02>'
|
|
|
|
"""
|
|
q = Decimal(10) ** -places # 2 places --> '0.01'
|
|
sign, digits, exp = value.quantize(q).as_tuple()
|
|
result = []
|
|
digits = map(str, digits)
|
|
build, next = result.append, digits.pop
|
|
if sign:
|
|
build(trailneg)
|
|
for i in range(places):
|
|
build(next() if digits else '0')
|
|
build(dp)
|
|
if not digits:
|
|
build('0')
|
|
i = 0
|
|
while digits:
|
|
build(next())
|
|
i += 1
|
|
if i == 3 and digits:
|
|
i = 0
|
|
build(sep)
|
|
build(curr)
|
|
build(neg if sign else pos)
|
|
s = ''.join(reversed(result))
|
|
|
|
if dp in s:
|
|
s=s.strip('0').rstrip(dp)
|
|
if s=="" or s[0]==dp:
|
|
s="0"+s
|
|
return s
|
|
|
|
def AmountToString(amount):
|
|
if amount == None:
|
|
amount = 0
|
|
lamount=long(amount)
|
|
samount = None
|
|
if lamount == 0:
|
|
samount = "0 %s" % coinspecs.name
|
|
else:
|
|
places=long(0.5+math.log10(coinspecs.atomic_units))
|
|
for den in coinspecs.denominations:
|
|
if lamount < den[0]:
|
|
samount = moneyfmt(Decimal(lamount)/Decimal(den[1]),places=places) + " " + den[2]
|
|
break
|
|
if not samount:
|
|
samount = moneyfmt(Decimal(lamount)/Decimal(coinspecs.atomic_units),places=places) + " " + coinspecs.name
|
|
return samount
|
|
|
|
def TimeToString(seconds):
|
|
seconds=float(seconds)
|
|
if seconds < 1e-3:
|
|
return "%.2f microseconds" % (seconds*1e6)
|
|
if seconds < 1:
|
|
return "%.2f milliseconds" % (seconds*1e3)
|
|
if seconds < 60:
|
|
return "%.2f seconds" % (seconds)
|
|
if seconds < 3600:
|
|
return "%.2f minutes" % (seconds / 60)
|
|
if seconds < 3600 * 24:
|
|
return "%.2f hours" % (seconds / 3600)
|
|
if seconds < 3600 * 24 * 30.5:
|
|
return "%.2f days" % (seconds / (3600*24))
|
|
if seconds < 3600 * 24 * 365.25:
|
|
return "%.2f months" % (seconds / (3600*24*30.5))
|
|
if seconds < 3600 * 24 * 365.25 * 100:
|
|
return "%.2f years" % (seconds / (3600*24*365.25))
|
|
if seconds < 3600 * 24 * 365.25 * 1000:
|
|
return "%.2f centuries" % (seconds / (3600*24*365.25 * 100))
|
|
if seconds < 3600 * 24 * 365.25 * 1000000:
|
|
return "%.2f millenia" % (seconds / (3600*24*365.25 * 100))
|
|
return "like, forever, dude"
|
|
|
|
def StringToUnits(s):
|
|
try:
|
|
return long(Decimal(s)*long(coinspecs.atomic_units))
|
|
except Exception,e:
|
|
log_error('Failed to convert %s to units: %s' % (s,str(e)))
|
|
raise
|
|
|
|
def SendJSONRPCCommand(host,port,method,params):
|
|
try:
|
|
http = httplib.HTTPConnection(host,port,timeout=config.rpc_timeout)
|
|
except Exception,e:
|
|
log_error('SendJSONRPCCommand: Error connecting to %s:%u: %s' % (host, port, str(e)))
|
|
raise
|
|
d = dict(id="0",jsonrpc="2.0",method=method,params=params)
|
|
try:
|
|
j = json.dumps(d).encode()
|
|
except Exception,e:
|
|
log_error('SendJSONRPCCommand: Failed to encode JSON: %s' % str(e))
|
|
http.close()
|
|
raise
|
|
log_log('SendJSONRPCCommand: Sending json as body: %s' % j)
|
|
headers = None
|
|
try:
|
|
http.request("POST","/json_rpc",body=j)
|
|
except Exception,e:
|
|
log_error('SendJSONRPCCommand: Failed to post request: %s' % str(e))
|
|
http.close()
|
|
raise
|
|
response = http.getresponse()
|
|
if response.status != 200:
|
|
log_error('SendJSONRPCCommand: Error, received reply status %s' % str(response.status))
|
|
http.close()
|
|
raise RuntimeError("Error "+response.status)
|
|
s = response.read()
|
|
log_log('SendJSONRPCCommand: Received reply status %s: %s' % (response.status, str(s).replace('\r\n',' ').replace('\n',' ')))
|
|
try:
|
|
j = json.loads(s)
|
|
except Exception,e:
|
|
log_error('SendJSONRPCCommand: Failed to decode JSON: %s' % str(e))
|
|
http.close()
|
|
raise
|
|
http.close()
|
|
return j
|
|
|
|
def SendHTMLCommand(host,port,method):
|
|
try:
|
|
http = httplib.HTTPConnection(host,port,timeout=config.rpc_timeout)
|
|
except Exception,e:
|
|
log_error('SendHTMLCommand: Error connecting to %s:%u: %s' % (host, port, str(e)))
|
|
raise
|
|
headers = None
|
|
try:
|
|
http.request("POST","/"+method)
|
|
except Exception,e:
|
|
log_error('SendHTMLCommand: Failed to post request: %s' % str(e))
|
|
http.close()
|
|
raise
|
|
response = http.getresponse()
|
|
if response.status != 200:
|
|
log_error('SendHTMLCommand: Error, received reply status %s' % str(response.status))
|
|
http.close()
|
|
raise RuntimeError("Error "+response.status)
|
|
s = response.read()
|
|
log_log('SendHTMLCommand: Received reply status %s: %s' % (response.status,s.replace('\r\n',' ').replace('\n',' ')))
|
|
try:
|
|
j = json.loads(s)
|
|
except Exception,e:
|
|
log_error('SendHTMLCommand: Failed to decode JSON: %s' % str(e))
|
|
http.close()
|
|
raise
|
|
http.close()
|
|
return j
|
|
|
|
def SendWalletJSONRPCCommand(method,params):
|
|
return SendJSONRPCCommand(config.wallet_host,config.wallet_port,method,params)
|
|
|
|
def SendDaemonJSONRPCCommand(method,params):
|
|
return SendJSONRPCCommand(config.daemon_host,config.daemon_port,method,params)
|
|
|
|
def SendDaemonHTMLCommand(method):
|
|
return SendHTMLCommand(config.daemon_host,config.daemon_port,method)
|
|
|
|
def RetrieveTipbotBalance(force_refresh=False):
|
|
global cached_tipbot_balance, cached_tipbot_unlocked_balance, cached_tipbot_balance_timestamp
|
|
if not force_refresh and cached_tipbot_balance_timestamp and time.time()-cached_tipbot_balance_timestamp < config.tipbot_balance_cache_time:
|
|
return cached_tipbot_balance, cached_tipbot_unlocked_balance
|
|
|
|
j = SendWalletJSONRPCCommand("getbalance",None)
|
|
if not "result" in j:
|
|
log_error('RetrieveTipbotBalance: result not found in reply')
|
|
raise RuntimeError("")
|
|
return
|
|
result = j["result"]
|
|
if not "balance" in result:
|
|
log_error('RetrieveTipbotBalance: balance not found in result')
|
|
raise RuntimeError("")
|
|
return
|
|
if not "unlocked_balance" in result:
|
|
log_error('RetrieveTipbotBalance: unlocked_balance not found in result')
|
|
raise RuntimeError("")
|
|
return
|
|
balance = result["balance"]
|
|
unlocked_balance = result["unlocked_balance"]
|
|
log_log('RetrieveTipbotBalance: balance: %s' % str(balance))
|
|
log_log('RetrieveTipbotBalance: unlocked_balance: %s' % str(unlocked_balance))
|
|
pending = long(balance)-long(unlocked_balance)
|
|
if pending < 0:
|
|
log_error('RetrieveTipbotBalance: Negative pending balance! balance %s, unlocked %s' % (str(balance),str(unlocked_balance)))
|
|
raise RuntimeError("")
|
|
return
|
|
cached_tipbot_balance_timestamp=time.time()
|
|
cached_tipbot_balance=balance
|
|
cached_tipbot_unlocked_balance=unlocked_balance
|
|
return balance, unlocked_balance
|
|
|
|
def GetAccount(link_or_identity):
|
|
if isinstance(link_or_identity,Link):
|
|
identity=link_or_identity.identity()
|
|
else:
|
|
identity=link_or_identity
|
|
account = redis_hget('accounts',identity)
|
|
if account == None:
|
|
log_info('No account found for %s, creating new one' % identity)
|
|
next_account_id = long(redis_get('next_account_id') or 0)
|
|
account = next_account_id
|
|
if redis_hexists('accounts',account):
|
|
raise RuntimeError('Next account ID already exists (%d)', account)
|
|
redis_hset('accounts',identity,account)
|
|
next_account_id += 1
|
|
redis_set('next_account_id',next_account_id)
|
|
return account
|
|
|
|
def RetrieveBalance(link):
|
|
try:
|
|
account = GetAccount(link)
|
|
balance = redis_hget("balances",account) or 0
|
|
confirming = redis_hget("confirming_payments",account) or 0
|
|
return long(balance), long(confirming)
|
|
except Exception, e:
|
|
log_error('RetrieveBalance: exception: %s' % str(e))
|
|
raise
|
|
|
|
def LinkCore(link,other_identity):
|
|
try:
|
|
identity=link.identity()
|
|
if identity==other_identity:
|
|
return True, "same-identity"
|
|
links=redis_hget('links',identity)
|
|
if links:
|
|
if other_identity in links.split(chr(0)):
|
|
return True, "already"
|
|
links=links+chr(0)+other_identity
|
|
else:
|
|
links=other_identity
|
|
redis_hset('links',identity,links)
|
|
|
|
links=redis_hget('links',other_identity)
|
|
if links:
|
|
if identity in links.split(chr(0)):
|
|
# we have both
|
|
account=GetAccount(identity)
|
|
other_account=GetAccount(other_identity)
|
|
if account==other_account:
|
|
log_info('%s and %s already have the same account: %s' % (identity,other_identity,account))
|
|
return True, "same-account"
|
|
|
|
balance=long(redis_hget('balances',account))
|
|
log_info('Linking accounts %s (%s) and %s (%s)' % (account,identity,other_account,other_identity))
|
|
p=redis_pipeline()
|
|
p.hincrby('balances',other_account,balance)
|
|
p.hincrby('balances',account,-balance)
|
|
accounts=redis_hgetall('accounts')
|
|
for a in accounts:
|
|
if accounts[a]==account:
|
|
log_info('Changing %s\'s account from %s to %s' % (a,account,other_account))
|
|
p.hset('accounts',a,other_account)
|
|
p.execute()
|
|
return True, "linked"
|
|
except Exception,e:
|
|
log_error('Error linking %s and %s: %s' % (identity,other_identity,str(e)))
|
|
return False, "error"
|
|
|
|
return True, "ok"
|
|
|
|
def IdentityFromString(link,s):
|
|
if s.find(':') == -1:
|
|
network = link.network
|
|
nick=s
|
|
else:
|
|
parts=s.split(':')
|
|
network_name=parts[0]
|
|
network=GetNetworkByName(network_name)
|
|
if not network:
|
|
log_error('unknown network: %s' % network_name)
|
|
raise RuntimeError('Unknown network: %s' % network_name)
|
|
nick=parts[1]
|
|
return network.name+':'+network.canonicalize(nick)
|
|
|
|
def NetworkFromIdentity(identity):
|
|
return identity.split(':')[0]
|
|
|
|
def NickFromIdentity(identity):
|
|
return identity.split(':')[1]
|
|
|
|
def RegisterNetwork(name,type):
|
|
registered_networks[name]=type
|
|
|
|
def AddNetwork(network):
|
|
networks.append(network)
|
|
|
|
def GetNetworkByName(name):
|
|
for network in networks:
|
|
if network.name==name:
|
|
return network
|
|
return None
|
|
|
|
def GetNetworkByType(type):
|
|
for network in networks:
|
|
if isinstance(network,type):
|
|
return network
|
|
return None
|
|
|
|
def Lock():
|
|
return core_lock.acquire()
|
|
|
|
def Unlock():
|
|
core_lock.release()
|
|
return True
|
|
|