131 lines
4.6 KiB
Python
Executable File
131 lines
4.6 KiB
Python
Executable File
#!/usr/bin/env python
|
|
"""
|
|
.. module:: CryptoWalletRPC
|
|
:synopsis: Module capable of operating bitcoind-style RPC. Provided as a service.
|
|
|
|
.. moduleauthor:: Dave Pedu <dave@davepedu.com>
|
|
|
|
"""
|
|
|
|
from pyircbot.modulebase import ModuleBase
|
|
from bitcoinrpc.authproxy import AuthServiceProxy
|
|
from threading import Thread
|
|
|
|
|
|
class CryptoWalletRPC(ModuleBase):
|
|
def __init__(self, bot, moduleName):
|
|
ModuleBase.__init__(self, bot, moduleName)
|
|
self.services = ["bitcoinrpc"]
|
|
self.rpcservices = {}
|
|
self.loadrpcservices()
|
|
|
|
def loadrpcservices(self):
|
|
# Create a dict of abbreviation=>BitcoinRPC objcet relation
|
|
self.log.info("CryptoWalletRPC: loadrpcservices: connecting to RPCs")
|
|
for key in self.config["types"]:
|
|
self.rpcservices[key.lower()] = BitcoinRPC(self, key, self.config["types"][key]["host"],
|
|
self.config["types"][key]["port"],
|
|
self.config["types"][key]["username"],
|
|
self.config["types"][key]["password"],
|
|
self.config["types"][key]["precision"],
|
|
self.config["types"][key]["reserve"])
|
|
|
|
def getRpc(self, currencyAbbr):
|
|
# Return the rpc for the currency requested
|
|
# self.getRpc("LTC") -> returns a litecoin rpc instance
|
|
currencyAbbr = currencyAbbr.lower()
|
|
if currencyAbbr in self.rpcservices:
|
|
return self.rpcservices[currencyAbbr]
|
|
return None
|
|
|
|
def getSupported(self):
|
|
# return a list of (appreviatons of) supported currencies
|
|
return list(self.rpcservices.keys())
|
|
|
|
def isSupported(self, abbr):
|
|
# true/false if currency is supported
|
|
supported = self.getSupported()
|
|
return abbr.lower() in supported
|
|
|
|
def getInfo(self, abbr):
|
|
# return the coin's info from config
|
|
if self.isSupported(abbr):
|
|
return self.config["types"][abbr.upper()]
|
|
|
|
|
|
class BitcoinRPC:
|
|
def __init__(self, parent, name, host, port, username, password, precision, reserve):
|
|
# Store info and connect
|
|
self.master = parent
|
|
self.name = name
|
|
self.host = host
|
|
self.port = port
|
|
self.username = username
|
|
self.password = password
|
|
self.precision = precision
|
|
self.reserve = reserve
|
|
self.log = self.master.log
|
|
|
|
# AuthServiceProxy (json client) stored here
|
|
self.con = None
|
|
# Connect
|
|
Thread(target=self.ping).start()
|
|
|
|
def getBal(self, acct):
|
|
# get a balance of an address or an account
|
|
return self.getAcctBal(acct)
|
|
|
|
def getAcctAddr(self, acct):
|
|
# returns the address for an account. creates if necessary
|
|
self.ping()
|
|
addrs = self.con.getaddressesbyaccount(acct)
|
|
if len(addrs) == 0:
|
|
return self.con.getnewaddress(acct)
|
|
return addrs[0]
|
|
|
|
def getAcctBal(self, acct):
|
|
# returns an account's balance
|
|
self.ping()
|
|
return float(self.con.getbalance(acct))
|
|
|
|
def canMove(self, fromAcct, toAcct, amount):
|
|
# true or false if fromAcct can afford to give toAcct an amount of coins
|
|
balfrom = self.getAcctBal(fromAcct)
|
|
return balfrom >= amount
|
|
|
|
def move(self, fromAcct, toAcct, amount):
|
|
# move coins from one account to another
|
|
self.ping()
|
|
if self.canMove(fromAcct, toAcct, amount):
|
|
return self.con.move(fromAcct, toAcct, amount)
|
|
return False
|
|
|
|
def send(self, fromAcct, toAddr, amount):
|
|
# send coins to an external addr
|
|
self.ping()
|
|
if self.canMove(fromAcct, toAddr, amount):
|
|
return self.con.sendfrom(fromAcct, toAddr, amount)
|
|
return False
|
|
|
|
def checkPrecision(self, amount):
|
|
return amount == round(amount, self.precision)
|
|
|
|
def ping(self):
|
|
# internal. test connection and connect if necessary
|
|
try:
|
|
self.con.getinfo()
|
|
except:
|
|
self.connect()
|
|
|
|
def connect(self):
|
|
# internal. connect to the service
|
|
self.log.info("CryptoWalletRPC: %s: Connecting to %s:%s" % (self.name, self.host, self.port))
|
|
try:
|
|
self.con = AuthServiceProxy("http://%s:%s@%s:%s" % (self.username, self.password, self.host, self.port))
|
|
except Exception as e:
|
|
self.log.error("CryptoWalletRPC: %s: Could not connect to %s:%s: %s" %
|
|
(self.name, self.host, self.port, str(e)))
|
|
return
|
|
|
|
self.log.info("CryptoWalletRPC: %s: Connected to %s:%s" % (self.name, self.host, self.port))
|