def import_abandon(self, txid, nout):
        logger.info("importing abandon txid:{}, nout:{} ".format(txid, nout))
        """ handle abandoned claims """
        claim_id = self.get_claim_id_from_outpoint(txid, nout)
        claim_name = self.get_claim_name(claim_id)

        undo_info = self._get_undo_info('abandon', claim_id, claim_name, txid,
                                        nout)
        self.db_outpoint_to_claim.delete(txid + int_to_hex(nout, 4))

        self.db_claim_outpoint.delete(claim_id)
        self.db_claim_values.delete(claim_id)
        self.db_claim_height.delete(claim_id)
        self.db_claim_addrs.delete(claim_id)
        self.db_claim_names.delete(claim_id)

        claims_in_db = self.db_claim_order.get(claim_name)
        claims_for_name = {} if not claims_in_db else msgpack.unpackb(
            claims_in_db)
        claim_n = claims_for_name[claim_id]
        del claims_for_name[claim_id]

        for cid, cn in claims_for_name.iteritems():
            if cn > claim_n:
                claims_for_name[cid] = cn - 1

        self.db_claim_order.delete(claim_name)
        self.db_claim_order.put(claim_name, msgpack.packb(claims_for_name))

        undo_info = self.import_signed_abandon(claim_id, undo_info)
        return undo_info
    def import_claim(self, claim, claim_id, claim_address, txid, nout, amount,
                     block_height):
        logger.info(
            "importing claim {}, claim id:{}, txid:{}, nout:{} ".format(
                claim.name, claim_id, txid, nout))

        undo_info = self._get_undo_info('claim', claim_id, claim.name, txid,
                                        nout)

        claims_for_name = self.get_claims_for_name(claim.name)
        if not claims_for_name:
            claim_n = 1
        else:
            claim_n = max(i for i in claims_for_name.itervalues()) + 1

        claims_for_name[claim_id] = claim_n
        self.write_claims_for_name(claim.name, claims_for_name)

        self.write_outpoint_from_claim_id(claim_id, txid, nout, amount)
        self.write_claim_id_from_outpoint(txid, nout, claim_id)
        self.db_claim_names.put(claim_id, claim.name)
        self.db_claim_values.put(claim_id, claim.value)
        self.db_claim_height.put(claim_id, str(block_height))
        self.db_claim_addrs.put(claim_id, claim_address)

        undo_info = self.import_signed_claim_transaction(
            claim, claim_id, undo_info)
        return undo_info
    def import_update(self, claim, claim_id, claim_address, txid, nout, amount,
                      block_height):
        logger.info(
            "importing update {}, claim id:{}, txid:{}, nout:{} ".format(
                claim.name, claim_id, txid, nout))

        undo_info = self._get_undo_info('update', claim_id, claim.name, txid,
                                        nout)

        txid_orig_claim, nout_orig_claim, amount = self.get_outpoint_from_claim_id(
            claim_id)
        self.db_outpoint_to_claim.delete(txid_orig_claim +
                                         int_to_hex(nout_orig_claim, 4))
        self.write_claim_id_from_outpoint(txid, nout, claim_id)

        self.write_outpoint_from_claim_id(claim_id, txid, nout, amount)
        self.db_claim_values.put(claim_id, claim.value)
        self.db_claim_height.put(claim_id, str(block_height))
        self.db_claim_addrs.put(claim_id, claim_address)

        undo_info = self.import_signed_claim_transaction(
            claim, claim_id, undo_info)
        return undo_info
    def revert_claim_transaction(self, undo_infos):
        logger.info('reverting claim:{}'.format(undo_infos))
        """ revert claim transaction using undo information"""
        for undo_info in undo_infos:
            claim_id = undo_info['claim_id']
            claim_name = undo_info['claim_name']
            claim_type = undo_info['claim_type']
            if claim_type == 'update':
                self.db_claim_outpoint.put(claim_id,
                                           undo_info['claim_outpoint'])
                self.db_claim_names.put(claim_id, undo_info['claim_names'])
                self.db_claim_values.put(claim_id, undo_info['claim_values'])
                self.db_claim_height.put(claim_id, undo_info['claim_height'])
                self.db_claim_addrs.put(claim_id, undo_info['claim_addrs'])
                self.db_claim_order.put(claim_name, undo_info['claim_order'])
                self.db_outpoint_to_claim.delete(
                    undo_info['outpoint_to_claim'])
                self.db_outpoint_to_claim.put(
                    undo_info['claim_outpoint'][0:72], claim_id)

                # updated to signed claim
                if 'cert_to_claims' in undo_info:
                    cert_id = undo_info['cert_to_claims'][0]
                    claims = undo_info['cert_to_claims'][1]
                    self.write_claims_signed_by(cert_id, claims)
                    self.db_claim_to_cert.delete(claim_id)
                # updated from signed claim
                if 'prev_cert_to_claims' in undo_info:
                    prev_cert_id = undo_info['prev_cert_to_claims'][0]
                    prev_claims = undo_info['prev_cert_to_claims'][1]
                    self.write_claims_signed_by(prev_cert_id, prev_claims)
                    self.db_claim_to_cert.put(claim_id,
                                              undo_info['claim_to_cert'])

            elif claim_type == 'claim':
                self.db_claim_outpoint.delete(claim_id)
                self.db_claim_names.delete(claim_id)
                self.db_claim_values.delete(claim_id)
                self.db_claim_height.delete(claim_id)
                self.db_claim_addrs.delete(claim_id)
                self.db_outpoint_to_claim.delete(
                    undo_info['outpoint_to_claim'])
                if undo_info['claim_order'] is not None:
                    self.db_claim_order.put(claim_name,
                                            undo_info['claim_order'])
                else:
                    self.db_claim_order.delete(claim_name)

                if 'cert_to_claims' in undo_info:
                    cert_id = undo_info['cert_to_claims'][0]
                    claims = undo_info['cert_to_claims'][1]
                    self.write_claims_signed_by(cert_id, claims)
                    self.db_claim_to_cert.delete(claim_id)

            elif claim_type == 'abandon':
                self.db_claim_outpoint.put(claim_id,
                                           undo_info['claim_outpoint'])
                self.db_claim_names.put(claim_id, undo_info['claim_names'])
                self.db_claim_values.put(claim_id, undo_info['claim_values'])
                self.db_claim_height.put(claim_id, undo_info['claim_height'])
                self.db_claim_addrs.put(claim_id, undo_info['claim_addrs'])
                self.db_claim_order.put(claim_name, undo_info['claim_order'])
                self.db_outpoint_to_claim.put(undo_info['outpoint_to_claim'],
                                              claim_id)
                if 'cert_to_claims' in undo_info:
                    cert_id = undo_info['cert_to_claims'][0]
                    claims = undo_info['cert_to_claims'][1]
                    self.write_claims_signed_by(cert_id, claims)
                    self.db_claim_to_cert.put(claim_id,
                                              undo_info['claim_to_cert'])

            else:
                raise Exception('unhandled claim_type:{}'.format(claim_type))