~ubuntu-branches/debian/stretch/electrum/stretch

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

# along with this program. If not, see <http://www.gnu.org/licenses/>.

 

import os

import hashlib

import ast

import threading

import random

import time

import json

import copy

from operator import itemgetter

 

 

from bitcoin import *

from account import *

from transaction import Transaction

from plugins import run_hook

import bitcoin

from mnemonic import Mnemonic

 

import paymentrequest

 

# internal ID for imported account

IMPORTED_ACCOUNT = '/x'

 

 

 

    def __init__(self, path):

        self.lock = threading.RLock()

        self.data = {}

        self.path = path

        self.file_exists = False

        if self.path:

            self.read(self.path)

 

                    json.dumps(key)

                    json.dumps(value)

                except:

                    continue

                self.data[key] = value

        self.file_exists = True

                v = default

            else:

                v = copy.deepcopy(v)

 

    def put(self, key, value, save = True):

        try:

            json.dumps(key)

            json.dumps(value)

        except:

            return

        with self.lock:

            if value is not None:

            elif key in self.data:

                self.data.pop(key)

            if save:

                self.write()

 

    def write(self):

        assert not threading.currentThread().isDaemon()

        temp_path = "%s.tmp.%s" % (self.path, os.getpid())

        with open(temp_path, "w") as f:

            f.write(s)

            f.flush()

        if 'ANDROID_DATA' not in os.environ:

            import stat

            os.chmod(self.path,stat.S_IREAD | stat.S_IWRITE)

    """

    Wallet classes are created to handle various address generation methods.

    Completion states (watching-only, single account, no seed, etc) are handled inside classes.

 

        # spv

        self.verifier = None

        self.unverified_tx = {}

        # Verified transactions.  Each value is a (height, timestamp, block_pos) tuple.  Access with self.lock.

        self.verified_tx   = storage.get('verified_tx3',{})

        if self.storage.get('wallet_type') is None:

            self.storage.put('wallet_type', self.wallet_type, True)

 

    @profiler

    def load_transactions(self):

        self.txi = self.storage.get('txi', {})

            tx = Transaction(raw)

            self.transactions[tx_hash] = tx

            if self.txi.get(tx_hash) is None and self.txo.get(tx_hash) is None and (tx_hash not in self.pruned_txo.values()):

                self.transactions.pop(tx_hash)

 

    @profiler

                except:

                    pass

            else:

 

    def synchronize(self):

        pass

                changed = True

 

        if changed:

            self.storage.put('labels', self.labels, True)

 

        return changed

 

    def addresses(self, include_change = True):

        return decrypted

 

    def add_unverified_tx(self, tx_hash, tx_height):

 

    def add_verified_tx(self, tx_hash, info):

        with self.lock:

            self.verified_tx[tx_hash] = info  # (tx_height, timestamp, pos)

        self.storage.put('verified_tx3', self.verified_tx, True)

        self.network.trigger_callback('verified', (tx_hash, conf, timestamp))

 

    def get_unverified_txs(self):

 

    def undo_verifications(self, height):

        '''Used by the verifier when a reorg has happened'''

        "return position, even if the tx is unverified"

        with self.lock:

            x = self.verified_tx.get(tx_hash)

        if x:

            height, timestamp, pos = x

            return height, pos

        for addr, l in dd.items():

            for n, v, is_cb in l:

                if n == prevout_n:

                    return addr

 

    def add_transaction(self, tx_hash, tx):

 

    def remove_transaction(self, tx_hash):

        with self.transaction_lock:

            #tx = self.transactions.pop(tx_hash)

            for ser, hh in self.pruned_txo.items():

                if hh == tx_hash:

                        dd.pop(addr)

                    else:

                        dd[addr] = l

 

    def receive_tx_callback(self, tx_hash, tx, tx_height):

        self.add_transaction(tx_hash, tx)

 

        # fixme: this may happen if history is incomplete

        if balance not in [None, 0]:

            return []

 

        return h2

                    fee = fixed_fee if fixed_fee is not None else self.estimated_fee(tx, fee_per_kb)

                    continue

                break

 

        # change address

        if not change_addr:

            change_amount = total - ( amount + fee )

            if change_amount > DUST_THRESHOLD:

                tx.outputs.append(('address', change_addr, change_amount))

            else:

        else:

 

        # Sort the inputs and outputs deterministically

        tx.BIP_LI01_sort()

 

        return tx

 

    def mktx(self, outputs, password, config, fee=None, change_addr=None, domain=None):

        # Sign

        if keypairs:

            tx.sign(keypairs)

 

    def sendtx(self, tx):

        # synchronous

            return True

        return False

 

        # review transactions that are in the history

        for addr, hist in self.history.items():

            for tx_hash, tx_height in hist:

            vr = self.verified_tx.keys() + self.unverified_tx.keys()

        for tx_hash in self.transactions.keys():

            if tx_hash not in vr:

                self.transactions.pop(tx_hash)

 

    def start_threads(self, network):

        from verifier import SPV

        self.network = network

        if self.network is not None:

            self.verifier = SPV(self.network, self)

        else:

            self.verifier = None

            self.synchronizer = None

 

    def stop_threads(self):

        if self.network:

            self.synchronizer = None

            self.storage.put('stored_height', self.get_local_height(), True)

 

    def restore(self, cb):

                self.next_account = self.get_next_account(None)

                self.storage.put('next_account2', self.next_account)

            except:

        # check pending account

        if self.next_account is not None:

            next_id, next_xpub, next_pubkey, next_address = self.next_account

            if self.address_is_old(next_address):

                self.add_account(next_id, BIP32_Account({'xpub':next_xpub}))

                # here the user should get a notification

                self.next_account = None

                self.storage.put('next_account2', self.next_account)

            elif self.history.get(next_address, []):

                if next_id not in self.accounts:

                    self.accounts[next_id] = PendingAccount({'pending':True, 'address':next_address, 'pubkey':next_pubkey})

                    self.save_accounts()

 

 

        wallet_type = storage.get('wallet_type')

        if wallet_type:

                if t == wallet_type:

                    break

            else:

                if re.match('(\d+)of(\d+)', wallet_type):