#!/usr/bin/env python

# -*- coding: utf-8 -*-

"""

Blockstack-client

~~~~~

copyright: (c) 2014-2015 by Halfmoon Labs, Inc.

copyright: (c) 2016 by Blockstack.org

This file is part of Blockstack-client.

Blockstack-client 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 3 of the License, or

(at your option) any later version.

Blockstack-client is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with Blockstack-client. If not, see <http://www.gnu.org/licenses/>.

"""

import argparse

import sys

import json

import traceback

import types

import socket

import uuid

import os

import importlib

import pprint

import random

import time

import parsing, schemas, storage, drivers, config, spv, utils

import user as user_db

from spv import SPVClient

import pybitcoin

import bitcoin

import binascii

from utilitybelt import is_hex

from config import log, DEBUG, MAX_RPC_LEN, find_missing, BLOCKSTACKD_SERVER, \

BLOCKSTACKD_PORT, BLOCKSTACK_METADATA_DIR, BLOCKSTACK_DEFAULT_STORAGE_DRIVERS, \

FIRST_BLOCK_MAINNET, NAME_OPCODES, OPFIELDS, CONFIG_DIR, SPV_HEADERS_PATH, BLOCKCHAIN_ID_MAGIC, \

NAME_PREORDER, NAME_REGISTRATION, NAME_UPDATE, NAME_TRANSFER, NAMESPACE_PREORDER, NAME_IMPORT

import virtualchain

# default API endpoint proxy to blockstackd

default_proxy = None

# ancillary storage providers

STORAGE_IMPL = None

class BlockstackRPCClient(object):

"""

Not-quite-JSONRPC client for Blockstack.

Blockstack's not-quite-JSONRPC server expects a raw Netstring that encodes

a JSON object with a "method" string and an "args" list. It will ignore

"id" and "version", and will not accept keyword arguments. It also does

not guarantee that the "result" and "error" keywords will be present.

"""

def __init__(self, server, port,

max_rpc_len=MAX_RPC_LEN,

timeout=config.DEFAULT_TIMEOUT):

self.server = server

self.port = port

self.sock = None

self.max_rpc_len = max_rpc_len

self.timeout = timeout

def __getattr__(self, key):

try:

return object.__getattr__(self, key)

except AttributeError:

return self.dispatch(key)

def socket():

return self.sock

def default(self, *args):

self.params = args

return self.request()

def dispatch(self, key):

self.method = key

return self.default

def ensure_connected(self):

if self.sock is None:

self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)

self.sock.settimeout(self.timeout)

self.sock.connect((self.server, self.port))

return True

def request(self):

self.ensure_connected()

request_id = str(uuid.uuid4())

parameters = {

'id': request_id,

'method': self.method,

'params': self.params,

'version': '2.0'

}

data = json.dumps(parameters)

data_netstring = str(len(data)) + ":" + data + ","

# send request

try:

self.sock.sendall(data_netstring)

except Exception, e:

self.sock.close()

self.sock = None

raise e

# get response: expect comma-ending netstring

# get the length first

len_buf = ""

while True:

c = self.sock.recv(1)

if len(c) == 0:

# connection closed

self.sock.close()

self.sock = None

raise Exception("Server closed remote connection")

c = c[0]

if c == ':':

break

else:

len_buf += c

buf_len = 0

# ensure it's an int

try:

buf_len = int(len_buf)

except Exception, e:

# invalid

self.sock.close()

self.sock = None

raise Exception("Invalid response: invalid netstring length")

# ensure it's not too big

if buf_len >= self.max_rpc_len:

self.sock.close()

self.sock = None

raise Exception("Invalid response: message too big")

# receive message

num_received = 0

response = ""

while num_received < buf_len+1:

buf = self.sock.recv(4096)

num_received += len(buf)

response += buf

# ensure that the message is terminated with a comma

if response[-1] != ',':

self.sock.close()

self.sock = None

raise Exception("Invalid response: invalid netstring termination")

# trim ','

response = response[:-1]

result = None

# parse the response

try:

result = json.loads(response)

# Netstrings responds with [{}] instead of {}

result = result[0]

return result

except Exception, e:

# try to clean up

self.sock.close()

self.sock = None

raise Exception("Invalid response: not a JSON string")

def session(conf=None, server_host=BLOCKSTACKD_SERVER, server_port=BLOCKSTACKD_PORT,

storage_drivers=BLOCKSTACK_DEFAULT_STORAGE_DRIVERS,

metadata_dir=BLOCKSTACK_METADATA_DIR, spv_headers_path=SPV_HEADERS_PATH, set_global=False):

"""

Create a blockstack session:

* validate the configuration

* load all storage drivers

* initialize all storage drivers

* load an API proxy to blockstack

conf's fields override specific keyword arguments.

Returns the API proxy object.

"""

global default_proxy

if conf is not None:

missing = find_missing(conf)

if len(missing) > 0:

log.error("Missing blockstack configuration fields: %s" % (", ".join(missing)))

sys.exit(1)

server_host = conf['server']

server_port = conf['port']

storage_drivers = conf['storage_drivers']

metadata_dir = conf['metadata']

if storage_drivers is None:

log.error("No storage driver(s) defined in the config file. Please set 'storage=' to a comma-separated list of %s" % ", ".join(drivers.DRIVERS))

sys.exit(1)

# create proxy

proxy = BlockstackRPCClient(server_host, server_port)

# load all storage drivers

for storage_driver in storage_drivers.split(","):

storage_impl = load_storage(storage_driver)

if storage_impl is None:

log.error("Failed to load storage driver '%s'" % (storage_driver))

sys.exit(1)

rc = register_storage(storage_impl)

if not rc:

log.error("Failed to initialize storage driver '%s'" % (storage_driver))

sys.exit(1)

# initialize SPV

SPVClient.init(spv_headers_path)

proxy.spv_headers_path = spv_headers_path

proxy.conf = conf

if set_global:

default_proxy = proxy

return proxy

def get_default_proxy():

"""

Get the default API proxy to blockstack.

"""

global default_proxy

return default_proxy

def set_default_proxy(proxy):

"""

Set the default API proxy

"""

global default_proxy

default_proxy = proxy

def load_storage(module_name):

"""

Load a storage implementation, given its module name.

Valid options can be found in blockstack.drivers.DRIVERS

"""

if module_name not in drivers.DRIVERS:

raise Exception("Unrecognized storage driver. Valid options are %s" % (", ".join(drivers.DRIVERS)))

try:

storage_impl = importlib.import_module("blockstack_client.drivers.%s" % module_name)

except ImportError, ie:

raise Exception("Failed to import blockstack.drivers.%s. Please verify that it is accessible via your PYTHONPATH" % module_name)

return storage_impl

def register_storage(storage_impl):

"""

Register a storage implementation.

"""

rc = storage.register_storage(storage_impl)

if rc:

rc = storage_impl.storage_init()

return rc

def load_user(record_hash):

"""

Load a user record from the storage implementation with the given hex string hash,

The user record hash should have been loaded from the blockchain, and thereby be the

authentic hash.

Return the user record on success

Return None on error

"""

user_json = storage.get_immutable_data(record_hash)

if user_json is None:

log.error("Failed to load user record '%s'" % record_hash)

return None

# verify integrity

user_record_hash = storage.get_data_hash(user_json)

if user_record_hash != record_hash:

log.error("Profile hash mismatch: expected '%s', got '%s'" % (record_hash, user_record_hash))

return None

user = user_db.parse_user(user_json)

return user

def get_zone_file(name):

# or whatever else we're going to call this

return get_name_record(name)

def get_create_diff(blockchain_record):

"""

Given a blockchain record, find its earliest history diff and its creation block number.

"""

preorder_block_number = blockchain_record['preorder_block_number']

history = blockchain_record['history']

create_block_number = None

if str(preorder_block_number) in history.keys():

# was preordered

create_block_number = preorder_block_number

else:

# was imported

create_block_number = int(sorted(history.keys())[0])

create_diff = history[str(create_block_number)][0]

return (create_block_number, create_diff)

def get_reveal_txid(blockchain_record):

"""

Given a blockchain record, find the transaction ID that revealed it

as well as the associated block number.

"""

history = blockchain_record['history']

reveal_block_number = None

# find the earliest history record with NAME_IMPORT or NAME_REGISTRATION

for block_number_str in sorted(history.keys()):

for i in xrange(0, len(history[block_number_str])):

if history[block_number_str][i].has_key('opcode'):

if str(history[block_number_str][i]['opcode']) in ['NAME_IMPORT', 'NAME_REGISTRATION']:

reveal_block_number = int(block_number_str)

return reveal_block_number, str(history[block_number_str][i]['txid'])

return (None, None)

def get_serial_number(blockchain_record):

"""

Calculate the serial number from a name's blockchain record.

* If the name was preordered, then this is first such $preorder_block-$vtxindex

* If the name was imported, then this is the first such $import_block-$vtxindex

"""

create_block_number, create_diff = get_create_diff(blockchain_record)

create_tx_index = create_diff['vtxindex']

history = blockchain_record['history']

serial_number = None

if str(create_diff['opcode']) == "NAME_PREORDER":

# name was preordered; use preorder block_id/tx_index

# find the oldest registration

update_order = sorted(history.keys())

for block_num in update_order:

for tx_op in history[block_num]:

if tx_op['opcode'] == "NAME_PREORDER":

serial_number = str(tx_op['block_number']) + '-' + str(tx_op['vtxindex'])

break

if serial_number is None:

raise Exception("No NAME_REGISTRATION found for '%s'" % blockchain_record.get('name', 'UNKNOWN_NAME'))

else:

# name was imported.

# serial number is the first NAME_IMPORT block + txindex

serial_number = str(create_block_number) + '-' + str(create_tx_index)

return serial_number

def get_block_from_consensus(consensus_hash, proxy=None):

"""

Get a block ID from a consensus hash

"""

if proxy is None:

proxy = get_default_proxy()

resp = proxy.get_block_from_consensus(consensus_hash)

if type(resp) == list:

if len(resp) == 0:

resp = {'error': 'No data returned'}

else:

resp = resp[0]

return resp

def txid_to_block_data(txid, bitcoind_proxy, proxy=None):

"""

Given a txid, get its block's data.

Use SPV to verify the information we receive from the (untrusted)

bitcoind host.

@bitcoind_proxy must be a BitcoindConnection (from virtualchain.lib.session)

Return the (block hash, block data, txdata) on success

Return (None, None, None) on error

"""

if proxy is None:

proxy = get_default_proxy()

timeout = 1.0

while True:

try:

untrusted_tx_data = bitcoind_proxy.getrawtransaction(txid, 1)

untrusted_block_hash = untrusted_tx_data['blockhash']

untrusted_block_data = bitcoind_proxy.getblock(untrusted_block_hash)

break

except Exception, e:

log.exception(e)

log.error("Unable to obtain block data; retrying...")

time.sleep(timeout)

timeout = timeout * 2 + random.random() * timeout

# first, can we trust this block? is it in the SPV headers?

untrusted_block_header_hex = virtualchain.block_header_to_hex(untrusted_block_data, untrusted_block_data['previousblockhash'])

block_id = SPVClient.block_header_index(proxy.spv_headers_path, (untrusted_block_header_hex + "00").decode('hex'))

if block_id < 0:

# bad header

log.error("Block header '%s' is not in the SPV headers" % untrusted_block_header_hex)

return (None, None, None)

# block header is trusted. Is the transaction data consistent with it?

if not virtualchain.block_verify(untrusted_block_data):

log.error("Block transaction IDs are not consistent with the trusted header's Merkle root")

return (None, None, None)

# verify block hash

if not virtualchain.block_header_verify(untrusted_block_data, untrusted_block_data['previousblockhash'], untrusted_block_hash):

log.error("Block hash is not consistent with block header")

return (None, None, None)

# we trust the block hash, block data, and txids

block_hash = untrusted_block_hash

block_data = untrusted_block_data

tx_data = untrusted_tx_data

return (block_hash, block_data, tx_data)

def txid_to_serial_number(txid, bitcoind_proxy, proxy=None):

"""

Given a transaction ID, convert it into a serial number

(defined as $block_id-$tx_index).

Use SPV to verify the information we receive from the (untrusted)

bitcoind host.

@bitcoind_proxy must be a BitcoindConnection (from virtualchain.lib.session)

Return the serial number on success

Return None on error

"""

if proxy is None:

proxy = get_default_proxy()

block_hash, block_data, _ = txid_to_block_data(txid, bitcoind_proxy, proxy=proxy)

if block_hash is None or block_data is None:

return None

# What's the tx index?

try:

tx_index = block_data['tx'].index(txid)

except:

# not actually present

log.error("Transaction %s is not present in block %s (%s)" % (txid, block_id, block_hash))

return "%s-%s" % (block_id, tx_index)

def serial_number_to_tx(serial_number, bitcoind_proxy, proxy=None):

"""

Convert a serial number into its transaction in the blockchain.

Use an untrusted bitcoind connection to get the list of transactions,

and use trusted SPV headers to ensure that the transaction obtained is on the main chain.

@bitcoind_proxy must be a BitcoindConnection (from virtualchain.lib.session)

Return the SPV-verified transaction object (as a dict) on success

Return None on error

"""

if proxy is None:

proxy = get_default_proxy()

parts = serial_number.split("-")

block_id = int(parts[0])

tx_index = int(parts[1])

timeout = 1.0

while True:

try:

block_hash = bitcoind_proxy.getblockhash(block_id)

block_data = bitcoind_proxy.getblock(block_hash)

break

except Exception, e:

log.error("Unable to obtain block data; retrying...")

time.sleep(timeout)

timeout = timeout * 2 + random.random() * timeout

rc = SPVClient.sync_header_chain(proxy.spv_headers_path, bitcoind_proxy.opts['bitcoind_server'], block_id)

if not rc:

log.error("Failed to synchronize SPV header chain up to %s" % block_id)

return None

# verify block header

rc = SPVClient.block_header_verify(proxy.spv_headers_path, block_id, block_hash, block_data)

if not rc:

log.error("Failed to verify block header for %s against SPV headers" % block_id)

return None

# verify block txs

rc = SPVClient.block_verify(block_data, block_data['tx'])

if not rc:

log.error("Failed to verify block transaction IDs for %s against SPV headers" % block_id)

return None

# sanity check

if tx_index >= len(block_data['tx']):

log.error("Serial number %s references non-existant transaction %s (out of %s txs)" % (serial_number, tx_index, len(block_data['tx'])))

return None

# obtain transaction

txid = block_data['tx'][tx_index]

tx = bitcoind_proxy.getrawtransaction(txid, 1)

# verify tx

rc = SPVClient.tx_verify(block_data['tx'], tx)

if not rc:

log.error("Failed to verify block transaction %s against SPV headers" % txid)

return None

# verify tx index

if tx_index != SPVClient.tx_index(block_data['tx'], tx):

log.error("TX index mismatch: serial number identifies transaction number %s (%s), but got transaction %s" % \

(tx_index, block_data['tx'][tx_index], block_data['tx'][ SPVClient.tx_index(block_data['tx'], tx) ]))

return None

# success!

return tx

def parse_tx_op_return(tx):

"""

Given a transaction, locate its OP_RETURN and parse

out its opcode and payload.

Return (opcode, payload) on success

Return (None, None) if there is no OP_RETURN, or if it's not a blockchain ID operation.

"""

# find OP_RETURN output

op_return = None

outputs = tx['vout']

for out in outputs:

if int(out["scriptPubKey"]['hex'][0:2], 16) == pybitcoin.opcodes.OP_RETURN:

op_return = out['scriptPubKey']['hex'].decode('hex')

break

if op_return is None:

pp = pprint.PrettyPrinter()

pp.pprint(tx)

log.error("transaction has no OP_RETURN output")

return (None, None)

# [0] is OP_RETURN, [1] is the length; [2:4] are 'id', [4] is opcode

magic = op_return[2:4]

if magic != BLOCKCHAIN_ID_MAGIC:

# not a blockchain ID operation

#print SPVClient.tx_hash(tx)

#print op_return.encode('hex')

log.error("OP_RETURN output does not encode a blockchain ID operation")

return (None, None)

opcode = op_return[4]

payload = op_return[5:]

return (opcode, payload)

def get_consensus_hash_from_tx(tx):

"""

Given an SPV-verified transaction, extract its consensus hash.

Only works of the tx encodes a NAME_PREORDER, NAMESPACE_PREORDER,

or NAME_TRANSFER.

Return hex-encoded consensus hash on success.

Return None on error.

"""

opcode, payload = parse_tx_op_return(tx)

if opcode is None or payload is None:

return None

# only present in NAME_PREORDER, NAMESPACE_PREORDER, NAME_TRANSFER

if opcode not in [NAME_PREORDER, NAMESPACE_PREORDER, NAME_TRANSFER]:

log.error("Blockchain ID transaction is not a NAME_PREORDER, NAMESPACE_PROERDER or NAME_TRANSFER")

return None

else:

consensus_hash = payload[-16:].encode('hex')

return consensus_hash

def verify_consensus_hash_from_tx(tx, fqname, candidate_consensus_hash):

"""

Given the SPV-verified transaction that encodes a consensus hash-bearing OP_RETURN,

the fully qualified name, and the list of candidate consensus hashes from Blockstack,

verify the consensus hash against the transaction.

Return the consensus hash on success

Return None if there was no OP_RETURN output in the tx, or the OP_RETURN output

does not encode one of the valid opcodes, or there is a mismatch.

"""

opcode, payload = parse_tx_op_return(tx)

if opcode is None or payload is None:

return None

if opcode not in [NAME_PREORDER, NAMESPACE_PREORDER, NAME_UPDATE, NAME_TRANSFER]:

# no consensus hash will be present

log.error("Blockchain ID transaction is not a NAME_PREORDER, NAMESPACE_PROERDER, NAME_UPDATE, or NAME_TRANSFER")

return None

elif opcode != NAME_UPDATE:

# in all but NAME_UPDATE, the consensus hash is the last 16 bytes

consensus_hash = payload[-16:].encode('hex')

if str(consensus_hash) == str(candidate_consensus_hash):

return consensus_hash

else:

# nope

log.error("Consensus hash mismatch: expected %s, got %s" % (candidate_consensus_hash, consensus_hash))

return None

else:

# In NAME_UPDATE, the consensus hash *at the time of the operation* is mixed with the name,

# truncated to 16 bytes, and appended after the opcode.

name_consensus_hash_mix = pybitcoin.hash.bin_sha256(fqname + candidate_consensus_hash)[0:16]

tx_name_consensus_hash_mix = payload[0:16]

if name_consensus_hash_mix == tx_name_consensus_hash_mix:

return candidate_consensus_hash

log.error("NAME_UPDATE consensus hash mix mismatch: expected %s from %s, got %s" % (name_consensus_hash_mix.encode('hex'), candidate_consensus_hash, tx_name_consensus_hash_mix.encode('hex')))

return None

def get_name_creation_consensus_info(name, blockchain_record, bitcoind_proxy, proxy=None, serial_number=None):

"""

Given the result of a call to get_name_blockchain_record,

obtain the creation consensus hash, type, and block number.

Verify them with SPV.

On success, return a dict with:

* type: if the name was preordered, then this is NAME_PREORDER. If the name was instead

imported, then this is NAME_IMPORT.

* block_id: the block ID of the NAME_PREORDER or NAME_IMPORT

* anchor: an object containing:

* consensus_hash: if the name was preordered, then this is the consensus hash at the time

the preorder operation was issued. Otherwise, if the name was imported, then this is

the consensus hash at the time the namespace preorder of the namespace into which the

was imported was issued. Note that in both cases, this is the consensus hash

from the block *at the time of issue*--this is NOT the block at which the name

operation was incorporated into the blockchain.

* block_id: the block id from which the consensus hash was taken. Note that this

is *not* the block at which the name operation was incorporated into the blockchain

(i.e. this block ID may *not* match the serial number).

* txid: the transaction ID that contains the consensus hash

'anchor' will not be given on NAMESPACE_PREORDER

On error, return a dict with 'error' defined as a key, mapped to an error message.

"""

create_block_number, create_diff = get_create_diff(blockchain_record)

create_consensus_tx = None

# consensus info for when the name was created (NAMESPACE_PREORDER or NAME_PREORDER)

creation_consensus_hash = None

creation_consensus_type = str(create_diff['opcode'])

# find preorder consensus hash, if preordered

if creation_consensus_type == "NAME_PREORDER":

creation_consensus_hash = create_diff['consensus_hash']

# transaction with the consensus hash comes from the NAME_PREORDER

preorder_serial_number = None

if serial_number is None:

preorder_serial_number = get_serial_number(blockchain_record)

else:

preorder_serial_number = serial_number

create_consensus_tx = serial_number_to_tx(preorder_serial_number, bitcoind_proxy, proxy=proxy)

if create_consensus_tx is None:

return {'error': 'Failed to verify name creation consensus-bearing transaction against SPV headers'}

# we can trust that the consensus-bearing transaction is on the blockchain.

# now, what's the creation consensus hash's block number?

# (NOTE: this trusts Blockstack)

creation_consensus_block_id = get_block_from_consensus(creation_consensus_hash, proxy=proxy)

if type(creation_consensus_hash_id) == dict and 'error' in ret:

return ret

# verify that the given consensus hash is present in the trusted consensus-bearing transaction

tx_consensus_hash = verify_consensus_hash_from_tx(create_consensus_tx, name, creation_consensus_hash)

if tx_consensus_hash is None:

# !!! Blockstackd lied to us--we got the wrong consensus hash

return {'error': 'Blockstack consensus hash does not match the SPV block headers'}

creation_info = {

'type': creation_consensus_type,

'block_id': create_block_number,

}

if creation_consensus_type == 'NAME_PREORDER':

# have trust anchor

creation_info['anchor'] = {

'consensus_hash': creation_consensus_hash,

'block_id': creation_consensus_block_id,

'txid': create_consensus_tx['txid']

}

return creation_info

def get_name_reveal_consensus_info(name, blockchain_record, bitcoind_proxy, proxy=None):

"""

Given a name, its blockchain record, and a bitcoind proxy, get information

about the name's revelation (i.e. the Blockstack state transition that exposed

the name's plaintext). That is, get information about a name's NAME_REGISTRATION,

or its NAME_IMPORT.

The transaction that performed the revelation will be fetched

from the underlying blockchain, and verified with SPV.

Return a dict with the following:

* type: either NAME_REGISTRATION or NAME_IMPORT

* block_id: the block ID of the name op that revealed the name

* txid: the transaction ID of the revelation

"""

reveal_block_number, reveal_txid = get_reveal_txid(blockchain_record)

# consensus info for when the name was revealed to the world (NAME_IMPORT or NAME_REGISTRATION)

reveal_consensus_tx = None

reveal_consensus_hash = None

reveal_consensus_type = None

# get verified name revelation data

reveal_block_hash, reveal_block_data, reveal_tx = txid_to_block_data(reveal_txid, bitcoind_proxy, proxy=proxy)

if reveal_block_hash is None or reveal_block_data is None:

return {'error': 'Failed to look up name revelation information'}

reveal_op, reveal_payload = parse_tx_op_return(reveal_tx)

if reveal_op is None or reveal_payload is None:

return {'error': 'Transaction is not a valid Blockstack operation'}

if reveal_op not in [NAME_REGISTRATION, NAME_IMPORT]:

return {'error': 'Transaction is not a NAME_REGISTRATION or a NAME_IMPORT'}

if reveal_payload != name:

log.error("Reveal payload is '%s'; expected '%s'" % (reveal_payload, name))

return {'error': 'Transaction does not reveal the given name'}

# NOTE: trusts Blockstack

if reveal_op == NAME_REGISTRATION:

reveal_op = "NAME_REGISTRATION"

elif reveal_op == NAME_IMPORT:

reveal_op = "NAME_IMPORT"

else:

return {'error': 'Unrecognized reveal opcode'}

ret = {

'type': reveal_op,

'block_id': reveal_block_number,

'txid': reveal_tx['txid']

}

return ret

def find_last_historical_op(history, opcode):

"""

Given the blockchain history of a name, and the desired opcode name,

find the last history record for the opcode. This returns a dict of the

old values for the fields.

Return (block number, dict of records that changed at that block number) on success.

block number will be -1 if the dict of records is the oldest historical record, which

indicates that the caller should use the preorder_block_number field as the block to

which the history record applies.

Return (None, None) on error

"""

prev_blocks = sorted(history.keys())[::-1] + [-1]

prev_opcode = None

for i in xrange(0, len(prev_blocks)-1):

prev_block = prev_blocks[i]

prev_ops = history[prev_block]

for prev_op in reversed(prev_ops):

if prev_op.has_key('opcode'):

prev_opcode = str(prev_op['opcode'])

if prev_opcode == opcode:

return (int(prev_blocks[i + 1]), prev_op)

return (None, None)

def get_name_update_consensus_info(name, blockchain_record, bitcoind_proxy, proxy=None):

"""

Given the result of a call to get_name_blockchain_record (an untrusted database record for a name),

obtain the last-modification consensus hash, type, and block number. Use SPV to verify that

(1) the consensus hash is in the blockchain,

(2)

On success, and the name was modified since it was registered, return a dict with:

* type: NAME_UPDATE

* anchor: an object with:

* consensus_hash: the consensus hash obtained from the NAME_UPDATE transaction. Note

that this is the consensus hash *at the time of issue*--it is *not* guaranteed to

correspond to the block at which the NAME_UPDATE was incorporated into the blockchain.

* block_id: the block id at which the operation was issued (*not* the block ID

at which the NAME_UPDATE was incorporated into the blockchain).

If the name has never been updated, then return None.

On error, return a dict with 'error' defined as a key, mapped to an error message.

"""

update_consensus_hash = None

update_record = None

update_block_id = None

update_consensus_block_id = None

# find the latest NAME_UPDATE

if str(blockchain_record['opcode']) == "NAME_UPDATE":

update_consensus_hash = str(blockchain_record['consensus_hash'])

update_record = blockchain_record

update_block_id = int(sorted(blockchain_record['history'].keys())[-1])

else:

update_block_id, update_record = find_last_historical_op(blockchain_record['history'], "NAME_UPDATE")

if update_record is not None:

update_consensus_hash = str(update_record['consensus_hash'])

if update_consensus_hash is None:

# never updated

return None

# get update tx data and verify it via SPV

update_serial = "%s-%s" % (update_block_id, update_record['vtxindex'])

update_tx = serial_number_to_tx(update_serial, bitcoind_proxy, proxy=proxy)

# update_tx is now known to be on the main blockchain.

tx_consensus_hash = None

# the consensus hash will be between when we accepted the update (update_block_id), and up to BLOCKS_CONSENSUS_HASH_IS_VALID blocks in the past.

candidate_consensus_hashes = get_consensus_range(update_block_id, update_block_id - virtualchain.lib.BLOCKS_CONSENSUS_HASH_IS_VALID)

for i in xrange(0, len(candidate_consensus_hashes)):

ch = candidate_consensus_hashes[i]

tx_consensus_hash = verify_consensus_hash_from_tx(update_tx, name, ch)

if tx_consensus_hash is not None:

# the update_tx contains the untrusted consensus hash.

# success!

update_consensus_block_id = update_block_id + i

break

if tx_consensus_hash is None:

# !!! Blockstackd lied to us--we got the wrong consensus hash

return {'error': 'Blockstack consensus hash does not match the SPV block headers'}

else:

update_info = {

'type': 'NAME_UPDATE',

'block_id': update_block_id,

'anchor': {

'consensus_hash': update_consensus_hash,

'block_id': update_consensus_block_id,

'txid': update_tx['txid']

}

}

return update_info

def lookup(name, proxy=None):

"""

Get the name and (some) blockchain data:

* zone file

* serial number

* consensus hash at block of creation (NAME_IMPORT or NAME_PREORDER)

* consensus hash at block of last modification

* address

Use SPV to verify that we're getting the right consensus hash.

"""

if proxy is None:

proxy = get_default_proxy()

bitcoind_proxy = virtualchain.connect_bitcoind(proxy.conf)

# get zonefile data

zone_file = get_zone_file(name)

if 'error' in zone_file:

return zone_file

# get blockchain-obtained data

blockchain_result = get_name_blockchain_record(name, proxy=proxy)

# get creation consensus data

creation_info = get_name_creation_consensus_info(name, blockchain_result, bitcoind_proxy, proxy=proxy)

if 'error' in creation_info:

return creation_info

# get revelation consensus data

reveal_info = get_name_reveal_consensus_info(name, blockchain_result, bitcoind_proxy, proxy=proxy)

if reveal_info is not None and 'error' in reveal_info:

return reveal_info

# get update consensus data

update_info = get_name_update_consensus_info(name, blockchain_result, bitcoind_proxy, proxy=proxy)

if update_info is not None and 'error' in update_info:

return update_info

# get serial number

serial_number = get_serial_number(blockchain_result)

# fill in serial number, address

result = {

'blockchain_id': name,

'zone_file': zone_file,

'serial_number': serial_number,

'address': blockchain_result.get('address', None),

'created': creation_info

}

if reveal_info is not None:

result['revealed'] = reveal_info

if update_info is not None:

result['updated'] = update_info

return result

def get_name_record(name, create_if_absent=False, proxy=None,

check_only_blockchain=False):

"""

Given the name of the user, look up the user's record hash,

and then get the record itself from storage.