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()