def get_rpc(self):
if not self.rpcConnectionType:
log.debug("get_rpc: init rpc")
tmpRpc = namerpc.CoinRpc(connectionType="auto")
self.rpcConnectionType = tmpRpc.connectionType
self.rpcOptions = tmpRpc.options
return namerpc.CoinRpc(connectionType=self.rpcConnectionType,
options=self.rpcOptions)
class BitSocket(socket.socket):
rpc = namerpc.CoinRpc(connectionType="nmcontrol") # threading/sync?
original_connect = socket.socket.connect
ipTable = {}
def connect(self, (hostname, port)):
try:
ip = None
if not hostname.endswith(".bit"): # legacy domains
ip, fresh = BitSocket.get_ip(hostname)
try:
socket.socket.connect(self, (ip, port))
except:
if not fresh:
ip, fresh = BitSocket.get_ip(hostname, force=True)
#print "ip, port, fresh:", ip, type(port), fresh
socket.socket.connect(self, (ip, port))
else:
raise
else: # .bit
r = self.rpc.call("dns", ["getIp4", hostname])
ip = str(json.loads(r["reply"])[0])
socket.socket.connect(self, (ip, port))
except:
print "###### exception remote connect: ", hostname, ip, port
traceback.print_exc()
raise
def __init__(self):
self.names = {}
self.connected = False
self.blockchainUptodate = False
self.inPoll = False
self.stopped = False
self.blockCount = None
self.balance = -1
self.firstUpdateQueue = []
self.updateCount = 0
self.blockHashPrev = None
self.listSinceBlockPrev = None
self.isLocked = None
self.passphrase = None
self.unlocked = False # did we unlock the wallet?
self.unlockNeeded = None
util.ensure_dirs(shared.CONFFOLDER)
self.nameNewDb = lineperdic.LPD(shared.NAMENEWDBFILENAMEPATH)
self.log = shared.get_my_logger(name=__file__)
datadir = shared.args.namecoindatadir
# rpc does currently not work asynchronously
self._rpc = namerpc.CoinRpc(connectionType="client", datadir=datadir) # poll
self.rpc = namerpc.CoinRpc(connectionType="client", datadir=datadir) # other functions
self._doStop = False
self._updateNow = False
self._initialUpdate = True
self._pollThread = threading.Thread(target=self._poll)
self.log.info("model poll start ----------------------------------")
self._pollThread.start()
# Compensation must be in a single output.
# As always all inputs must be signed.
## Outgoing
# Name to transfer is in my wallet.
# Exactly one input is signed with the key that holds the name.
# The value of the signed input is of NAMENEWFEENMC.
# The previous name tx has the same name as this tx. (necessary?)
# There is only one name_op in this tx and in the previous name tx.
import traceback
while 1:
try: # pause on error for GUI start
import namerpc
import shared
rpc = namerpc.CoinRpc()
unlockedWallet = shared.UnlockWallet(rpc)
if not rpc.blockchain_is_uptodate():
raise Exception(
"Blockchain does not seem up to date. Download all blocks first."
)
# tx input
print "Enter unfinished hex TX from buyer:"
hexTx = ""
while 1:
r = raw_input().strip().replace("\n",
"").replace("\r",
"").replace(" ", "")
try:
class ProxyHandler(BaseHTTPRequestHandler):
rpc = namerpc.CoinRpc(connectionType="nmcontrol") # threading/sync?
r = compile(r'http://[^/]+(/?.*)(?i)')
def __init__(self, request, client_address, server):
self.is_connect = False
self.remote_context = None
self.local_context = None
BaseHTTPRequestHandler.__init__(self, request, client_address, server)
def _connect_to_host(self):
# Get hostname and port to connect to
if self.is_connect:
self.hostname, self.port = self.path.split(':')
else:
u = urlparse(self.path)
if u.scheme != 'http':
raise UnsupportedSchemeException('Unknown scheme %s' %
repr(u.scheme))
self.hostname = u.hostname
self.port = u.port or 80
self.path = urlunparse(
ParseResult(scheme='',
netloc='',
params=u.params,
path=u.path or '/',
query=u.query,
fragment=u.fragment))
self.port = int(self.port)
# Connect to destination
self._proxy_sock = BitSocket()
self._proxy_sock.settimeout(10)
self._proxy_sock.connect((self.hostname, self.port))
# Wrap socket if SSL is required
if self.is_connect:
if not self.remote_context:
self.remote_context = ssl.create_default_context()
self.remote_context.check_hostname = False
self._proxy_sock = self.remote_context.wrap_socket(
self._proxy_sock, server_hostname=self.hostname)
if self.hostname.endswith(".bit"):
r = self.rpc.call("dns", ["getFingerprint", self.hostname])
nmcFpr = json.loads(r["reply"])[0].lower().replace(":", "")
#print "nmcFpr:", nmcFpr, self.hostname
remoteFpr = hashlib.sha1(
self._proxy_sock.getpeercert(True)).hexdigest()
if not remoteFpr == nmcFpr:
raise Exception("tls fingerprint mismatch")
else:
ssl.match_hostname(self._proxy_sock.getpeercert(),
self._proxy_sock.server_hostname)
def _transition_to_ssl(self):
if not self.local_context:
certfile = self.server.ca[self.path.split(':')[0]]
self.local_context = ssl.create_default_context(
purpose=ssl.Purpose.CLIENT_AUTH)
self.local_context.load_cert_chain(certfile=certfile)
if "RC4" in ssl._DEFAULT_CIPHERS.upper().replace("!RC4", ""):
raise Exception(
"Python version seems to old (contains RC4 cipher).")
self.request = self.local_context.wrap_socket(self.request,
server_side=True)
def do_CONNECT(self):
self.is_connect = True
try:
# Connect to destination first
self._connect_to_host()
# If successful, let's do this!
self.send_response(200, 'Connection established')
self.end_headers()
#self.request.sendall('%s 200 Connection established\r\n\r\n' % self.request_version)
self._transition_to_ssl()
except Exception, e:
try:
print "hostname:", self.hostname,
print " port:", self.port
except:
print "-"
traceback.print_exc()
self.send_error(500, str(e))
return
# Reload!
self.setup()
self.ssl_host = 'https://%s' % self.path
self.handle_one_request()
if value != antpyshared.NAMENEWFEENMC:
raise Exception("Signed wrong input value? (" + str(vinDiff[0]["value"]) + "NMC). Bailing due to fraud potential.")
# verify name (necessary?)
try:
prevName = antpyshared.get_name(pTx["vout"])
except IndexError:
raise Exception("Multiple names in previous tx. Currently not supported.")
if prevName != self.D["name"]:
raise Exception("Wrong name in previous tx: " + str(prevName) + " Bailing due to fraud potential.")
self.D["hexTxFinal"] = hexTx # only store after it has been checked
def seller_broadcast(self):
return self.rpc_call("sendrawtransaction", [self.D["hexTxFinal"]])
if __name__ == "__main__":
debug = True
rpc = namerpc.CoinRpc(connectionType="client")
#unlockedWallet = antpyshared.UnlockWallet(rpc) # gui
def unlock():
print "unlock wallet <enter>"
raw_input()
apc = AntpyCore(rpc.call)
apc.create_offer('d/nx', decimal.Decimal('1'))
print "available balance:", apc.get_available_balance()