diff --git a/core/src/bitcoin.proto b/core/src/bitcoin.proto
index 4223513e..5fac069d 100644
--- a/core/src/bitcoin.proto
+++ b/core/src/bitcoin.proto
@@ -77,6 +77,14 @@ message Key {
   optional int64 creation_timestamp = 5;
 }
 
+message Script {
+    required bytes program = 1;
+
+    // Timestamp stored as millis since epoch. Useful for skipping block bodies before this point
+    // when watching for scripts on the blockchain.
+    required int64 creation_timestamp = 2;
+}
+
 message TransactionInput {
   // Hash of the transaction this input is using.
   required bytes transaction_out_point_hash = 1;
@@ -257,6 +265,7 @@ message Wallet {
 
   repeated Key key = 3;
   repeated Transaction transaction = 4;
+  repeated Script watched_script = 15;
 
   optional EncryptionType encryption_type = 5 [default=UNENCRYPTED];
   optional ScryptParameters encryption_parameters = 6;
@@ -280,5 +289,5 @@ message Wallet {
   // can be used to recover a compromised wallet, or just as part of preventative defence-in-depth measures.
   optional uint64 key_rotation_time = 13;
 
-  // Next tag: 15
+  // Next tag: 16
 }
diff --git a/core/src/main/java/com/google/bitcoin/core/AbstractWalletEventListener.java b/core/src/main/java/com/google/bitcoin/core/AbstractWalletEventListener.java
index af7a5701..60cf24aa 100644
--- a/core/src/main/java/com/google/bitcoin/core/AbstractWalletEventListener.java
+++ b/core/src/main/java/com/google/bitcoin/core/AbstractWalletEventListener.java
@@ -16,6 +16,8 @@
 
 package com.google.bitcoin.core;
 
+import com.google.bitcoin.script.Script;
+
 import java.math.BigInteger;
 import java.util.List;
 
@@ -48,6 +50,11 @@ public abstract class AbstractWalletEventListener implements WalletEventListener
         onChange();
     }
 
+    @Override
+    public void onScriptsAdded(Wallet wallet, List<Script> scripts) {
+        onChange();
+    }
+
     @Override
     public void onWalletChanged(Wallet wallet) {
         onChange();
diff --git a/core/src/main/java/com/google/bitcoin/core/PeerFilterProvider.java b/core/src/main/java/com/google/bitcoin/core/PeerFilterProvider.java
index 4354db1e..108945ac 100644
--- a/core/src/main/java/com/google/bitcoin/core/PeerFilterProvider.java
+++ b/core/src/main/java/com/google/bitcoin/core/PeerFilterProvider.java
@@ -40,4 +40,6 @@ public interface PeerFilterProvider {
      * Default value should be an empty bloom filter with the given size, falsePositiveRate, and nTweak.
      */
     public BloomFilter getBloomFilter(int size, double falsePositiveRate, long nTweak);
+
+    boolean isRequiringUpdateAllBloomFilter();
 }
diff --git a/core/src/main/java/com/google/bitcoin/core/PeerGroup.java b/core/src/main/java/com/google/bitcoin/core/PeerGroup.java
index 312e0ddc..58923f50 100644
--- a/core/src/main/java/com/google/bitcoin/core/PeerGroup.java
+++ b/core/src/main/java/com/google/bitcoin/core/PeerGroup.java
@@ -20,6 +20,7 @@ package com.google.bitcoin.core;
 import com.google.bitcoin.core.Peer.PeerHandler;
 import com.google.bitcoin.discovery.PeerDiscovery;
 import com.google.bitcoin.discovery.PeerDiscoveryException;
+import com.google.bitcoin.script.Script;
 import com.google.bitcoin.utils.ListenerRegistration;
 import com.google.bitcoin.utils.Threading;
 import com.google.common.base.Preconditions;
@@ -131,6 +132,7 @@ public class PeerGroup extends AbstractIdleService implements TransactionBroadca
         private void onChanged() {
             recalculateFastCatchupAndFilter();
         }
+        @Override public void onScriptsAdded(Wallet wallet, List<Script> scripts) { onChanged(); }
         @Override public void onKeysAdded(Wallet wallet, List<ECKey> keys) { onChanged(); }
         @Override public void onCoinsReceived(Wallet wallet, Transaction tx, BigInteger prevBalance, BigInteger newBalance) { onChanged(); }
         @Override public void onCoinsSent(Wallet wallet, Transaction tx, BigInteger prevBalance, BigInteger newBalance) { onChanged(); }
@@ -678,9 +680,11 @@ public class PeerGroup extends AbstractIdleService implements TransactionBroadca
                 return;
             long earliestKeyTimeSecs = Long.MAX_VALUE;
             int elements = 0;
+            boolean requiresUpdateAll = false;
             for (PeerFilterProvider p : peerFilterProviders) {
                 earliestKeyTimeSecs = Math.min(earliestKeyTimeSecs, p.getEarliestKeyCreationTime());
                 elements += p.getBloomFilterElementCount();
+                requiresUpdateAll = requiresUpdateAll || p.isRequiringUpdateAllBloomFilter();
             }
 
             if (elements > 0) {
@@ -689,7 +693,9 @@ public class PeerGroup extends AbstractIdleService implements TransactionBroadca
                 // The constant 100 here is somewhat arbitrary, but makes sense for small to medium wallets -
                 // it will likely mean we never need to create a filter with different parameters.
                 lastBloomFilterElementCount = elements > lastBloomFilterElementCount ? elements + 100 : lastBloomFilterElementCount;
-                BloomFilter filter = new BloomFilter(lastBloomFilterElementCount, bloomFilterFPRate, bloomFilterTweak);
+                BloomFilter.BloomUpdate bloomFlags =
+                        requiresUpdateAll ? BloomFilter.BloomUpdate.UPDATE_ALL : BloomFilter.BloomUpdate.UPDATE_P2PUBKEY_ONLY;
+                BloomFilter filter = new BloomFilter(lastBloomFilterElementCount, bloomFilterFPRate, bloomFilterTweak, bloomFlags);
                 for (PeerFilterProvider p : peerFilterProviders)
                     filter.merge(p.getBloomFilter(lastBloomFilterElementCount, bloomFilterFPRate, bloomFilterTweak));
                 if (!filter.equals(bloomFilter)) {
diff --git a/core/src/main/java/com/google/bitcoin/core/Transaction.java b/core/src/main/java/com/google/bitcoin/core/Transaction.java
index 4a13e4bd..8d3656ef 100644
--- a/core/src/main/java/com/google/bitcoin/core/Transaction.java
+++ b/core/src/main/java/com/google/bitcoin/core/Transaction.java
@@ -219,7 +219,7 @@ public class Transaction extends ChildMessage implements Serializable {
         // This is tested in WalletTest.
         BigInteger v = BigInteger.ZERO;
         for (TransactionOutput o : outputs) {
-            if (!o.isMine(wallet)) continue;
+            if (!o.isMineOrWatched(wallet)) continue;
             if (!includeSpent && !o.isAvailableForSpending()) continue;
             v = v.add(o.getValue());
         }
@@ -234,7 +234,7 @@ public class Transaction extends ChildMessage implements Serializable {
         boolean isActuallySpent = true;
         for (TransactionOutput o : outputs) {
             if (o.isAvailableForSpending()) {
-                if (o.isMine(wallet)) isActuallySpent = false;
+                if (o.isMineOrWatched(wallet)) isActuallySpent = false;
                 if (o.getSpentBy() != null) {
                     log.error("isAvailableForSpending != spentBy");
                     return false;
@@ -340,7 +340,7 @@ public class Transaction extends ChildMessage implements Serializable {
                 continue;
             // The connected output may be the change to the sender of a previous input sent to this wallet. In this
             // case we ignore it.
-            if (!connected.isMine(wallet))
+            if (!connected.isMineOrWatched(wallet))
                 continue;
             v = v.add(connected.getValue());
         }
@@ -405,7 +405,7 @@ public class Transaction extends ChildMessage implements Serializable {
     public boolean isEveryOwnedOutputSpent(Wallet wallet) {
         maybeParse();
         for (TransactionOutput output : outputs) {
-            if (output.isAvailableForSpending() && output.isMine(wallet))
+            if (output.isAvailableForSpending() && output.isMineOrWatched(wallet))
                 return false;
         }
         return true;
diff --git a/core/src/main/java/com/google/bitcoin/core/TransactionOutput.java b/core/src/main/java/com/google/bitcoin/core/TransactionOutput.java
index 74574143..242b7b92 100644
--- a/core/src/main/java/com/google/bitcoin/core/TransactionOutput.java
+++ b/core/src/main/java/com/google/bitcoin/core/TransactionOutput.java
@@ -250,6 +250,27 @@ public class TransactionOutput extends ChildMessage implements Serializable {
         return scriptBytes;
     }
 
+    /**
+     * Returns true if this output is to a key in the wallet or to an address/script we are watching.
+     */
+    public boolean isMineOrWatched(Wallet wallet) {
+        return isMine(wallet) || isWatched(wallet);
+    }
+
+    /**
+     * Returns true if this output is to a key, or an address we have the keys for, in the wallet.
+     */
+    public boolean isWatched(Wallet wallet) {
+        try {
+            Script script = getScriptPubKey();
+            return wallet.isWatchedScript(script);
+        } catch (ScriptException e) {
+            // Just means we didn't understand the output of this transaction: ignore it.
+            log.debug("Could not parse tx output script: {}", e.toString());
+            return false;
+        }
+    }
+
     /**
      * Returns true if this output is to a key, or an address we have the keys for, in the wallet.
      */
diff --git a/core/src/main/java/com/google/bitcoin/core/Wallet.java b/core/src/main/java/com/google/bitcoin/core/Wallet.java
index f186dc98..e53d2629 100644
--- a/core/src/main/java/com/google/bitcoin/core/Wallet.java
+++ b/core/src/main/java/com/google/bitcoin/core/Wallet.java
@@ -21,6 +21,9 @@ import com.google.bitcoin.core.WalletTransaction.Pool;
 import com.google.bitcoin.crypto.KeyCrypter;
 import com.google.bitcoin.crypto.KeyCrypterException;
 import com.google.bitcoin.crypto.KeyCrypterScrypt;
+import com.google.bitcoin.script.Script;
+import com.google.bitcoin.script.ScriptBuilder;
+import com.google.bitcoin.script.ScriptChunk;
 import com.google.bitcoin.store.UnreadableWalletException;
 import com.google.bitcoin.store.WalletProtobufSerializer;
 import com.google.bitcoin.utils.ListenerRegistration;
@@ -94,6 +97,7 @@ import static com.google.common.base.Preconditions.*;
 public class Wallet implements Serializable, BlockChainListener, PeerFilterProvider {
     private static final Logger log = LoggerFactory.getLogger(Wallet.class);
     private static final long serialVersionUID = 2L;
+    private static final int MINIMUM_BLOOM_DATA_LENGTH = 8;
 
     protected final ReentrantLock lock = Threading.lock("wallet");
 
@@ -127,6 +131,9 @@ public class Wallet implements Serializable, BlockChainListener, PeerFilterProvi
     // A list of public/private EC keys owned by this user. Access it using addKey[s], hasKey[s] and findPubKeyFromHash.
     private ArrayList<ECKey> keychain;
 
+    // A list of scripts watched by this wallet.
+    private Set<Script> watchedScripts;
+
     private final NetworkParameters params;
 
     private Sha256Hash lastBlockSeenHash;
@@ -192,6 +199,7 @@ public class Wallet implements Serializable, BlockChainListener, PeerFilterProvi
         this.keyCrypter = keyCrypter;
         this.params = checkNotNull(params);
         keychain = new ArrayList<ECKey>();
+        watchedScripts = Sets.newHashSet();
         unspent = new HashMap<Sha256Hash, Transaction>();
         spent = new HashMap<Sha256Hash, Transaction>();
         pending = new HashMap<Sha256Hash, Transaction>();
@@ -245,6 +253,18 @@ public class Wallet implements Serializable, BlockChainListener, PeerFilterProvi
         }
     }
 
+    /**
+     * Returns a snapshot of the watched scripts. This view is not live.
+     */
+    public List<Script> getWatchedScripts() {
+        lock.lock();
+        try {
+            return new ArrayList<Script>(watchedScripts);
+        } finally {
+            lock.unlock();
+        }
+    }
+
     /**
      * Removes the given key from the keychain. Be very careful with this - losing a private key <b>destroys the
      * money associated with it</b>.
@@ -1922,6 +1942,29 @@ public class Wallet implements Serializable, BlockChainListener, PeerFilterProvi
         }
     }
 
+    public LinkedList<TransactionOutput> getWatchedOutputs(boolean excludeImmatureCoinbases) {
+        lock.lock();
+        try {
+            LinkedList<TransactionOutput> candidates = Lists.newLinkedList();
+            for (Transaction tx : Iterables.concat(unspent.values(), pending.values())) {
+                if (excludeImmatureCoinbases && !tx.isMature()) continue;
+                for (TransactionOutput output : tx.getOutputs()) {
+                    if (!output.isAvailableForSpending()) continue;
+                    try {
+                        Script scriptPubKey = output.getScriptPubKey();
+                        if (!watchedScripts.contains(scriptPubKey)) continue;
+                        candidates.add(output);
+                    } catch (ScriptException e) {
+                        // Ignore
+                    }
+                }
+            }
+            return candidates;
+        } finally {
+            lock.unlock();
+        }
+    }
+
     /** Returns the address used for change outputs. Note: this will probably go away in future. */
     public Address getChangeAddress() {
         lock.lock();
@@ -1980,6 +2023,75 @@ public class Wallet implements Serializable, BlockChainListener, PeerFilterProvi
         }
     }
 
+    /**
+     * Return true if we are watching this address.
+     */
+    public boolean isAddressWatched(Address address) {
+        Script script = ScriptBuilder.createOutputScript(address);
+        return isWatchedScript(script);
+    }
+
+    /** See {@link #addWatchedAddress(Address, long)} */
+    public boolean addWatchedAddress(final Address address) {
+        long now = Utils.now().getTime() / 1000;
+        return addWatchedAddresses(Lists.newArrayList(address), now) == 1;
+    }
+
+    /**
+     * Adds the given address to the wallet to be watched. Outputs can be retrieved
+     * by {@link #getWatchedOutputs(boolean)}.
+     *
+     * @param creationTime creation time in seconds since the epoch, for scanning the blockchain
+     *
+     * @return whether the address was added successfully (not already present)
+     */
+    public boolean addWatchedAddress(final Address address, long creationTime) {
+        return addWatchedAddresses(Lists.newArrayList(address), creationTime) == 1;
+    }
+
+    /**
+     * Adds the given address to the wallet to be watched. Outputs can be retrieved
+     * by {@link #getWatchedOutputs(boolean)}.
+     *
+     * @return how many addresses were added successfully
+     */
+    public int addWatchedAddresses(final List<Address> addresses, long creationTime) {
+        List<Script> scripts = Lists.newArrayList();
+
+        for (Address address : addresses) {
+            Script script = ScriptBuilder.createOutputScript(address);
+            script.setCreationTimeSeconds(creationTime);
+            scripts.add(script);
+        }
+
+        return addWatchedScripts(scripts);
+    }
+
+    /**
+     * Adds the given output scripts to the wallet to be watched. Outputs can be retrieved
+     * by {@link #getWatchedOutputs(boolean)}.
+     *
+     * @return how many scripts were added successfully
+     */
+    public int addWatchedScripts(final List<Script> scripts) {
+        lock.lock();
+        try {
+            int added = 0;
+            for (final Script script : scripts) {
+                if (watchedScripts.contains(script)) continue;
+
+                watchedScripts.add(script);
+                added++;
+            }
+
+            queueOnScriptsAdded(scripts);
+            saveNow();
+            return added;
+        } finally {
+            lock.unlock();
+        }
+    }
+
     /**
      * Locates a keypair from the keychain given the hash of the public key. This is needed when finding out which
      * key we need to use to redeem a transaction output.
@@ -2015,6 +2127,16 @@ public class Wallet implements Serializable, BlockChainListener, PeerFilterProvi
         return findKeyFromPubHash(pubkeyHash) != null;
     }
 
+    /** Returns true if this wallet is watching transactions for outputs with the script. */
+    public boolean isWatchedScript(Script script) {
+        lock.lock();
+        try {
+            return watchedScripts.contains(script);
+        } finally {
+            lock.unlock();
+        }
+    }
+
     /**
      * Locates a keypair from the keychain given the raw public key bytes.
      * @return ECKey or null if no such key was found.
@@ -2107,6 +2229,27 @@ public class Wallet implements Serializable, BlockChainListener, PeerFilterProvi
         }
     }
 
+    /** Returns the available balance, including any unspent balance at watched addresses */
+    public BigInteger getWatchedBalance() {
+        return getWatchedBalance(coinSelector);
+    }
+
+     /**
+     * Returns the balance that would be considered spendable by the given coin selector, including
+     * any unspent balance at watched addresses.
+     */
+    public BigInteger getWatchedBalance(CoinSelector selector) {
+        lock.lock();
+        try {
+            checkNotNull(selector);
+            LinkedList<TransactionOutput> candidates = getWatchedOutputs(true);
+            CoinSelection selection = selector.select(NetworkParameters.MAX_MONEY, candidates);
+            return selection.valueGathered;
+        } finally {
+            lock.unlock();
+        }
+    }
+
     @Override
     public String toString() {
         return toString(false, true, true, null);
@@ -2395,8 +2538,8 @@ public class Wallet implements Serializable, BlockChainListener, PeerFilterProvi
     }
 
     /**
-     * Returns the earliest creation time of the keys in this wallet, in seconds since the epoch, ie the min of 
-     * {@link com.google.bitcoin.core.ECKey#getCreationTimeSeconds()}. This can return zero if at least one key does
+     * Returns the earliest creation time of keys or watched scripts in this wallet, in seconds since the epoch, ie the min
+     * of {@link com.google.bitcoin.core.ECKey#getCreationTimeSeconds()}. This can return zero if at least one key does
      * not have that data (was created before key timestamping was implemented). <p>
      *     
      * This method is most often used in conjunction with {@link PeerGroup#setFastCatchupTimeSecs(long)} in order to
@@ -2410,13 +2553,13 @@ public class Wallet implements Serializable, BlockChainListener, PeerFilterProvi
     public long getEarliestKeyCreationTime() {
         lock.lock();
         try {
-            if (keychain.size() == 0) {
-                return Utils.now().getTime() / 1000;
-            }
             long earliestTime = Long.MAX_VALUE;
-            for (ECKey key : keychain) {
+            for (ECKey key : keychain)
                 earliestTime = Math.min(key.getCreationTimeSeconds(), earliestTime);
-            }
+            for (Script script : watchedScripts)
+                earliestTime = Math.min(script.getCreationTimeSeconds(), earliestTime);
+            if (earliestTime == Long.MAX_VALUE)
+                return Utils.now().getTime() / 1000;
             return earliestTime;
         } finally {
             lock.unlock();
@@ -2805,9 +2948,24 @@ public class Wallet implements Serializable, BlockChainListener, PeerFilterProvi
                 }
             }
         }
+
+        // Some scripts may have more than one bloom element.  That should normally be okay,
+        // because under-counting just increases false-positive rate.
+        size += watchedScripts.size();
+
         return size;
     }
-    
+
+    /**
+     * If we are watching any scripts, the bloom filter must update on peers whenever an output is
+     * identified.  This is because we don't necessarily have the associated pubkey, so we can't
+     * watch for it on spending transactions.
+     */
+    @Override
+    public boolean isRequiringUpdateAllBloomFilter() {
+        return !watchedScripts.isEmpty();
+    }
+
     /**
      * Gets a bloom filter that contains all of the public keys from this wallet, and which will provide the given
      * false-positive rate. See the docs for {@link BloomFilter} for a brief explanation of anonymity when using filters.
@@ -2815,7 +2973,7 @@ public class Wallet implements Serializable, BlockChainListener, PeerFilterProvi
     public BloomFilter getBloomFilter(double falsePositiveRate) {
         return getBloomFilter(getBloomFilterElementCount(), falsePositiveRate, (long)(Math.random()*Long.MAX_VALUE));
     }
-    
+
     /**
      * Gets a bloom filter that contains all of the public keys from this wallet,
      * and which will provide the given false-positive rate if it has size elements.
@@ -2835,6 +2993,17 @@ public class Wallet implements Serializable, BlockChainListener, PeerFilterProvi
                 filter.insert(key.getPubKey());
                 filter.insert(key.getPubKeyHash());
             }
+
+            for (Script script : watchedScripts) {
+                for (ScriptChunk chunk : script.getChunks()) {
+                    // Only add long (at least 64 bit) data to the bloom filter.
+                    // If any long constants become popular in scripts, we will need logic
+                    // here to exclude them.
+                    if (!chunk.isOpCode() && chunk.data.length >= MINIMUM_BLOOM_DATA_LENGTH) {
+                        filter.insert(chunk.data);
+                    }
+                }
+            }
         } finally {
             lock.unlock();
         }
@@ -2842,7 +3011,8 @@ public class Wallet implements Serializable, BlockChainListener, PeerFilterProvi
             for (int i = 0; i < tx.getOutputs().size(); i++) {
                 TransactionOutput out = tx.getOutputs().get(i);
                 try {
-                    if (out.isMine(this) && out.getScriptPubKey().isSentToRawPubKey()) {
+                    if ((out.isMine(this) && out.getScriptPubKey().isSentToRawPubKey()) ||
+                            out.isWatched(this)) {
                         TransactionOutPoint outPoint = new TransactionOutPoint(params, i, tx);
                         filter.insert(outPoint.bitcoinSerialize());
                     }
@@ -2851,6 +3021,7 @@ public class Wallet implements Serializable, BlockChainListener, PeerFilterProvi
                 }
             }
         }
+
         return filter;
     }
 
@@ -3110,6 +3281,18 @@ public class Wallet implements Serializable, BlockChainListener, PeerFilterProvi
         }
     }
 
+    private void queueOnScriptsAdded(final List<Script> scripts) {
+        checkState(lock.isHeldByCurrentThread());
+        for (final ListenerRegistration<WalletEventListener> registration : eventListeners) {
+            registration.executor.execute(new Runnable() {
+                @Override
+                public void run() {
+                    registration.listener.onScriptsAdded(Wallet.this, scripts);
+                }
+            });
+        }
+    }
+
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //
     // Fee calculation code.
diff --git a/core/src/main/java/com/google/bitcoin/core/WalletEventListener.java b/core/src/main/java/com/google/bitcoin/core/WalletEventListener.java
index 7e96baa3..95946fe6 100644
--- a/core/src/main/java/com/google/bitcoin/core/WalletEventListener.java
+++ b/core/src/main/java/com/google/bitcoin/core/WalletEventListener.java
@@ -16,6 +16,8 @@
 
 package com.google.bitcoin.core;
 
+import com.google.bitcoin.script.Script;
+
 import java.math.BigInteger;
 import java.util.List;
 
@@ -119,4 +121,7 @@ public interface WalletEventListener {
      * or due to some other automatic derivation.
      */
     void onKeysAdded(Wallet wallet, List<ECKey> keys);
+
+    /** Called whenever a new watched script is added to the wallet. */
+    void onScriptsAdded(Wallet wallet, List<Script> scripts);
 }
diff --git a/core/src/main/java/com/google/bitcoin/jni/NativeWalletEventListener.java b/core/src/main/java/com/google/bitcoin/jni/NativeWalletEventListener.java
index 0afc11ef..7c1c6dcc 100644
--- a/core/src/main/java/com/google/bitcoin/jni/NativeWalletEventListener.java
+++ b/core/src/main/java/com/google/bitcoin/jni/NativeWalletEventListener.java
@@ -20,6 +20,7 @@ import com.google.bitcoin.core.ECKey;
 import com.google.bitcoin.core.Transaction;
 import com.google.bitcoin.core.Wallet;
 import com.google.bitcoin.core.WalletEventListener;
+import com.google.bitcoin.script.Script;
 
 import java.math.BigInteger;
 import java.util.List;
@@ -49,4 +50,7 @@ public class NativeWalletEventListener implements WalletEventListener {
 
     @Override
     public native void onKeysAdded(Wallet wallet, List<ECKey> keys);
+
+    @Override
+    public native void onScriptsAdded(Wallet wallet, List<Script> scripts);
 }
diff --git a/core/src/main/java/com/google/bitcoin/script/Script.java b/core/src/main/java/com/google/bitcoin/script/Script.java
index 06ed6c29..9f5f237b 100644
--- a/core/src/main/java/com/google/bitcoin/script/Script.java
+++ b/core/src/main/java/com/google/bitcoin/script/Script.java
@@ -61,6 +61,9 @@ public class Script {
     // must preserve the exact bytes that we read off the wire, along with the parsed form.
     protected byte[] program;
 
+    // Creation time of the associated keys in seconds since the epoch.
+    private long creationTimeSeconds;
+
     /** Creates an empty script that serializes to nothing. */
     private Script() {
         chunks = Lists.newArrayList();
@@ -69,6 +72,7 @@ public class Script {
     // Used from ScriptBuilder.
     Script(List<ScriptChunk> chunks) {
         this.chunks = Collections.unmodifiableList(new ArrayList<ScriptChunk>(chunks));
+        creationTimeSeconds = Utils.now().getTime() / 1000;
     }
 
     /**
@@ -79,6 +83,21 @@ public class Script {
     public Script(byte[] programBytes) throws ScriptException {
         program = programBytes;
         parse(programBytes);
+        creationTimeSeconds = Utils.now().getTime() / 1000;
+    }
+
+    public Script(byte[] programBytes, long creationTimeSeconds) throws ScriptException {
+        program = programBytes;
+        parse(programBytes);
+        this.creationTimeSeconds = creationTimeSeconds;
+    }
+
+    public long getCreationTimeSeconds() {
+        return creationTimeSeconds;
+    }
+
+    public void setCreationTimeSeconds(long creationTimeSeconds) {
+        this.creationTimeSeconds = creationTimeSeconds;
     }
 
     /**
@@ -97,6 +116,11 @@ public class Script {
                 buf.append("] ");
             }
         }
+
+        if (creationTimeSeconds != 0) {
+            buf.append(" timestamp:").append(creationTimeSeconds);
+        }
+
         return buf.toString();
     }
 
@@ -110,7 +134,8 @@ public class Script {
             for (ScriptChunk chunk : chunks) {
                 chunk.write(bos);
             }
-            return bos.toByteArray();
+            program = bos.toByteArray();
+            return program;
         } catch (IOException e) {
             throw new RuntimeException(e);  // Cannot happen.
         }
@@ -1241,4 +1266,25 @@ public class Script {
                 throw new ScriptException("P2SH script execution resulted in a non-true stack");
         }
     }
+
+    // Utility that doesn't copy for internal use
+    private byte[] getQuickProgram() {
+        if (program != null)
+            return program;
+        return getProgram();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Script))
+            return false;
+        Script s = (Script)obj;
+        return Arrays.equals(getQuickProgram(), s.getQuickProgram());
+    }
+
+    @Override
+    public int hashCode() {
+        byte[] bytes = getQuickProgram();
+        return Arrays.hashCode(bytes);
+    }
 }
diff --git a/core/src/main/java/com/google/bitcoin/store/WalletProtobufSerializer.java b/core/src/main/java/com/google/bitcoin/store/WalletProtobufSerializer.java
index fa012540..745e62ed 100644
--- a/core/src/main/java/com/google/bitcoin/store/WalletProtobufSerializer.java
+++ b/core/src/main/java/com/google/bitcoin/store/WalletProtobufSerializer.java
@@ -21,6 +21,8 @@ import com.google.bitcoin.core.TransactionConfidence.ConfidenceType;
 import com.google.bitcoin.crypto.EncryptedPrivateKey;
 import com.google.bitcoin.crypto.KeyCrypter;
 import com.google.bitcoin.crypto.KeyCrypterScrypt;
+import com.google.bitcoin.script.Script;
+import com.google.common.collect.Lists;
 import com.google.protobuf.ByteString;
 import com.google.protobuf.TextFormat;
 import org.bitcoinj.wallet.Protos;
@@ -36,6 +38,7 @@ import java.net.InetAddress;
 import java.net.UnknownHostException;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.List;
 import java.util.ListIterator;
 import java.util.Map;
 
@@ -83,7 +86,7 @@ public class WalletProtobufSerializer {
 
     /**
      * Formats the given wallet (transactions and keys) to the given output stream in protocol buffer format.<p>
-     *     
+     *
      * Equivalent to <tt>walletToProto(wallet).writeTo(output);</tt>
      */
     public void writeWallet(Wallet wallet, OutputStream output) throws IOException {
@@ -154,6 +157,16 @@ public class WalletProtobufSerializer {
             walletBuilder.addKey(keyBuilder);
         }
 
+        for (Script script : wallet.getWatchedScripts()) {
+            Protos.Script protoScript =
+                    Protos.Script.newBuilder()
+                            .setProgram(ByteString.copyFrom(script.getProgram()))
+                            .setCreationTimestamp(script.getCreationTimeSeconds() * 1000)
+                            .build();
+
+            walletBuilder.addWatchedScript(protoScript);
+        }
+
         // Populate the lastSeenBlockHash field.
         Sha256Hash lastSeenBlockHash = wallet.getLastBlockSeenHash();
         if (lastSeenBlockHash != null) {
@@ -403,6 +416,20 @@ public class WalletProtobufSerializer {
             wallet.addKey(ecKey);
         }
 
+        List<Script> scripts = Lists.newArrayList();
+        for (Protos.Script protoScript : walletProto.getWatchedScriptList()) {
+            try {
+                Script script =
+                        new Script(protoScript.getProgram().toByteArray(),
+                                protoScript.getCreationTimestamp() / 1000);
+                scripts.add(script);
+            } catch (ScriptException e) {
+                throw new UnreadableWalletException("Unparseable script in wallet");
+            }
+        }
+
+        wallet.addWatchedScripts(scripts);
+
         // Read all transactions and insert into the txMap.
         for (Protos.Transaction txProto : walletProto.getTransactionList()) {
             readTransaction(txProto, wallet.getParams());
diff --git a/core/src/main/java/org/bitcoinj/wallet/Protos.java b/core/src/main/java/org/bitcoinj/wallet/Protos.java
index cc3f9e52..d39728da 100644
--- a/core/src/main/java/org/bitcoinj/wallet/Protos.java
+++ b/core/src/main/java/org/bitcoinj/wallet/Protos.java
@@ -2550,6 +2550,542 @@ public final class Protos {
     // @@protoc_insertion_point(class_scope:wallet.Key)
   }
 
+  public interface ScriptOrBuilder
+      extends com.google.protobuf.MessageOrBuilder {
+
+    // required bytes program = 1;
+    /**
+     * <code>required bytes program = 1;</code>
+     */
+    boolean hasProgram();
+    /**
+     * <code>required bytes program = 1;</code>
+     */
+    com.google.protobuf.ByteString getProgram();
+
+    // required int64 creation_timestamp = 2;
+    /**
+     * <code>required int64 creation_timestamp = 2;</code>
+     *
+     * <pre>
+     * Timestamp stored as millis since epoch. Useful for skipping block bodies before this point
+     * when watching for scripts on the blockchain.
+     * </pre>
+     */
+    boolean hasCreationTimestamp();
+    /**
+     * <code>required int64 creation_timestamp = 2;</code>
+     *
+     * <pre>
+     * Timestamp stored as millis since epoch. Useful for skipping block bodies before this point
+     * when watching for scripts on the blockchain.
+     * </pre>
+     */
+    long getCreationTimestamp();
+  }
+  /**
+   * Protobuf type {@code wallet.Script}
+   */
+  public static final class Script extends
+      com.google.protobuf.GeneratedMessage
+      implements ScriptOrBuilder {
+    // Use Script.newBuilder() to construct.
+    private Script(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+      super(builder);
+      this.unknownFields = builder.getUnknownFields();
+    }
+    private Script(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+    private static final Script defaultInstance;
+    public static Script getDefaultInstance() {
+      return defaultInstance;
+    }
+
+    public Script getDefaultInstanceForType() {
+      return defaultInstance;
+    }
+
+    private final com.google.protobuf.UnknownFieldSet unknownFields;
+    @java.lang.Override
+    public final com.google.protobuf.UnknownFieldSet
+        getUnknownFields() {
+      return this.unknownFields;
+    }
+    private Script(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      initFields();
+      int mutable_bitField0_ = 0;
+      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+          com.google.protobuf.UnknownFieldSet.newBuilder();
+      try {
+        boolean done = false;
+        while (!done) {
+          int tag = input.readTag();
+          switch (tag) {
+            case 0:
+              done = true;
+              break;
+            default: {
+              if (!parseUnknownField(input, unknownFields,
+                                     extensionRegistry, tag)) {
+                done = true;
+              }
+              break;
+            }
+            case 10: {
+              bitField0_ |= 0x00000001;
+              program_ = input.readBytes();
+              break;
+            }
+            case 16: {
+              bitField0_ |= 0x00000002;
+              creationTimestamp_ = input.readInt64();
+              break;
+            }
+          }
+        }
+      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+        throw e.setUnfinishedMessage(this);
+      } catch (java.io.IOException e) {
+        throw new com.google.protobuf.InvalidProtocolBufferException(
+            e.getMessage()).setUnfinishedMessage(this);
+      } finally {
+        this.unknownFields = unknownFields.build();
+        makeExtensionsImmutable();
+      }
+    }
+    public static final com.google.protobuf.Descriptors.Descriptor
+        getDescriptor() {
+      return org.bitcoinj.wallet.Protos.internal_static_wallet_Script_descriptor;
+    }
+
+    protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+        internalGetFieldAccessorTable() {
+      return org.bitcoinj.wallet.Protos.internal_static_wallet_Script_fieldAccessorTable
+          .ensureFieldAccessorsInitialized(
+              org.bitcoinj.wallet.Protos.Script.class, org.bitcoinj.wallet.Protos.Script.Builder.class);
+    }
+
+    public static com.google.protobuf.Parser<Script> PARSER =
+        new com.google.protobuf.AbstractParser<Script>() {
+      public Script parsePartialFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws com.google.protobuf.InvalidProtocolBufferException {
+        return new Script(input, extensionRegistry);
+      }
+    };
+
+    @java.lang.Override
+    public com.google.protobuf.Parser<Script> getParserForType() {
+      return PARSER;
+    }
+
+    private int bitField0_;
+    // required bytes program = 1;
+    public static final int PROGRAM_FIELD_NUMBER = 1;
+    private com.google.protobuf.ByteString program_;
+    /**
+     * <code>required bytes program = 1;</code>
+     */
+    public boolean hasProgram() {
+      return ((bitField0_ & 0x00000001) == 0x00000001);
+    }
+    /**
+     * <code>required bytes program = 1;</code>
+     */
+    public com.google.protobuf.ByteString getProgram() {
+      return program_;
+    }
+
+    // required int64 creation_timestamp = 2;
+    public static final int CREATION_TIMESTAMP_FIELD_NUMBER = 2;
+    private long creationTimestamp_;
+    /**
+     * <code>required int64 creation_timestamp = 2;</code>
+     *
+     * <pre>
+     * Timestamp stored as millis since epoch. Useful for skipping block bodies before this point
+     * when watching for scripts on the blockchain.
+     * </pre>
+     */
+    public boolean hasCreationTimestamp() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    /**
+     * <code>required int64 creation_timestamp = 2;</code>
+     *
+     * <pre>
+     * Timestamp stored as millis since epoch. Useful for skipping block bodies before this point
+     * when watching for scripts on the blockchain.
+     * </pre>
+     */
+    public long getCreationTimestamp() {
+      return creationTimestamp_;
+    }
+
+    private void initFields() {
+      program_ = com.google.protobuf.ByteString.EMPTY;
+      creationTimestamp_ = 0L;
+    }
+    private byte memoizedIsInitialized = -1;
+    public final boolean isInitialized() {
+      byte isInitialized = memoizedIsInitialized;
+      if (isInitialized != -1) return isInitialized == 1;
+
+      if (!hasProgram()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      if (!hasCreationTimestamp()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
+      memoizedIsInitialized = 1;
+      return true;
+    }
+
+    public void writeTo(com.google.protobuf.CodedOutputStream output)
+                        throws java.io.IOException {
+      getSerializedSize();
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        output.writeBytes(1, program_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        output.writeInt64(2, creationTimestamp_);
+      }
+      getUnknownFields().writeTo(output);
+    }
+
+    private int memoizedSerializedSize = -1;
+    public int getSerializedSize() {
+      int size = memoizedSerializedSize;
+      if (size != -1) return size;
+
+      size = 0;
+      if (((bitField0_ & 0x00000001) == 0x00000001)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(1, program_);
+      }
+      if (((bitField0_ & 0x00000002) == 0x00000002)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeInt64Size(2, creationTimestamp_);
+      }
+      size += getUnknownFields().getSerializedSize();
+      memoizedSerializedSize = size;
+      return size;
+    }
+
+    private static final long serialVersionUID = 0L;
+    @java.lang.Override
+    protected java.lang.Object writeReplace()
+        throws java.io.ObjectStreamException {
+      return super.writeReplace();
+    }
+
+    public static org.bitcoinj.wallet.Protos.Script parseFrom(
+        com.google.protobuf.ByteString data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.bitcoinj.wallet.Protos.Script parseFrom(
+        com.google.protobuf.ByteString data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.bitcoinj.wallet.Protos.Script parseFrom(byte[] data)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data);
+    }
+    public static org.bitcoinj.wallet.Protos.Script parseFrom(
+        byte[] data,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws com.google.protobuf.InvalidProtocolBufferException {
+      return PARSER.parseFrom(data, extensionRegistry);
+    }
+    public static org.bitcoinj.wallet.Protos.Script parseFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.bitcoinj.wallet.Protos.Script parseFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+    public static org.bitcoinj.wallet.Protos.Script parseDelimitedFrom(java.io.InputStream input)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input);
+    }
+    public static org.bitcoinj.wallet.Protos.Script parseDelimitedFrom(
+        java.io.InputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseDelimitedFrom(input, extensionRegistry);
+    }
+    public static org.bitcoinj.wallet.Protos.Script parseFrom(
+        com.google.protobuf.CodedInputStream input)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input);
+    }
+    public static org.bitcoinj.wallet.Protos.Script parseFrom(
+        com.google.protobuf.CodedInputStream input,
+        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+        throws java.io.IOException {
+      return PARSER.parseFrom(input, extensionRegistry);
+    }
+
+    public static Builder newBuilder() { return Builder.create(); }
+    public Builder newBuilderForType() { return newBuilder(); }
+    public static Builder newBuilder(org.bitcoinj.wallet.Protos.Script prototype) {
+      return newBuilder().mergeFrom(prototype);
+    }
+    public Builder toBuilder() { return newBuilder(this); }
+
+    @java.lang.Override
+    protected Builder newBuilderForType(
+        com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+      Builder builder = new Builder(parent);
+      return builder;
+    }
+    /**
+     * Protobuf type {@code wallet.Script}
+     */
+    public static final class Builder extends
+        com.google.protobuf.GeneratedMessage.Builder<Builder>
+       implements org.bitcoinj.wallet.Protos.ScriptOrBuilder {
+      public static final com.google.protobuf.Descriptors.Descriptor
+          getDescriptor() {
+        return org.bitcoinj.wallet.Protos.internal_static_wallet_Script_descriptor;
+      }
+
+      protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+          internalGetFieldAccessorTable() {
+        return org.bitcoinj.wallet.Protos.internal_static_wallet_Script_fieldAccessorTable
+            .ensureFieldAccessorsInitialized(
+                org.bitcoinj.wallet.Protos.Script.class, org.bitcoinj.wallet.Protos.Script.Builder.class);
+      }
+
+      // Construct using org.bitcoinj.wallet.Protos.Script.newBuilder()
+      private Builder() {
+        maybeForceBuilderInitialization();
+      }
+
+      private Builder(
+          com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+        super(parent);
+        maybeForceBuilderInitialization();
+      }
+      private void maybeForceBuilderInitialization() {
+        if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+        }
+      }
+      private static Builder create() {
+        return new Builder();
+      }
+
+      public Builder clear() {
+        super.clear();
+        program_ = com.google.protobuf.ByteString.EMPTY;
+        bitField0_ = (bitField0_ & ~0x00000001);
+        creationTimestamp_ = 0L;
+        bitField0_ = (bitField0_ & ~0x00000002);
+        return this;
+      }
+
+      public Builder clone() {
+        return create().mergeFrom(buildPartial());
+      }
+
+      public com.google.protobuf.Descriptors.Descriptor
+          getDescriptorForType() {
+        return org.bitcoinj.wallet.Protos.internal_static_wallet_Script_descriptor;
+      }
+
+      public org.bitcoinj.wallet.Protos.Script getDefaultInstanceForType() {
+        return org.bitcoinj.wallet.Protos.Script.getDefaultInstance();
+      }
+
+      public org.bitcoinj.wallet.Protos.Script build() {
+        org.bitcoinj.wallet.Protos.Script result = buildPartial();
+        if (!result.isInitialized()) {
+          throw newUninitializedMessageException(result);
+        }
+        return result;
+      }
+
+      public org.bitcoinj.wallet.Protos.Script buildPartial() {
+        org.bitcoinj.wallet.Protos.Script result = new org.bitcoinj.wallet.Protos.Script(this);
+        int from_bitField0_ = bitField0_;
+        int to_bitField0_ = 0;
+        if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+          to_bitField0_ |= 0x00000001;
+        }
+        result.program_ = program_;
+        if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
+          to_bitField0_ |= 0x00000002;
+        }
+        result.creationTimestamp_ = creationTimestamp_;
+        result.bitField0_ = to_bitField0_;
+        onBuilt();
+        return result;
+      }
+
+      public Builder mergeFrom(com.google.protobuf.Message other) {
+        if (other instanceof org.bitcoinj.wallet.Protos.Script) {
+          return mergeFrom((org.bitcoinj.wallet.Protos.Script)other);
+        } else {
+          super.mergeFrom(other);
+          return this;
+        }
+      }
+
+      public Builder mergeFrom(org.bitcoinj.wallet.Protos.Script other) {
+        if (other == org.bitcoinj.wallet.Protos.Script.getDefaultInstance()) return this;
+        if (other.hasProgram()) {
+          setProgram(other.getProgram());
+        }
+        if (other.hasCreationTimestamp()) {
+          setCreationTimestamp(other.getCreationTimestamp());
+        }
+        this.mergeUnknownFields(other.getUnknownFields());
+        return this;
+      }
+
+      public final boolean isInitialized() {
+        if (!hasProgram()) {
+          
+          return false;
+        }
+        if (!hasCreationTimestamp()) {
+          
+          return false;
+        }
+        return true;
+      }
+
+      public Builder mergeFrom(
+          com.google.protobuf.CodedInputStream input,
+          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+          throws java.io.IOException {
+        org.bitcoinj.wallet.Protos.Script parsedMessage = null;
+        try {
+          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+          parsedMessage = (org.bitcoinj.wallet.Protos.Script) e.getUnfinishedMessage();
+          throw e;
+        } finally {
+          if (parsedMessage != null) {
+            mergeFrom(parsedMessage);
+          }
+        }
+        return this;
+      }
+      private int bitField0_;
+
+      // required bytes program = 1;
+      private com.google.protobuf.ByteString program_ = com.google.protobuf.ByteString.EMPTY;
+      /**
+       * <code>required bytes program = 1;</code>
+       */
+      public boolean hasProgram() {
+        return ((bitField0_ & 0x00000001) == 0x00000001);
+      }
+      /**
+       * <code>required bytes program = 1;</code>
+       */
+      public com.google.protobuf.ByteString getProgram() {
+        return program_;
+      }
+      /**
+       * <code>required bytes program = 1;</code>
+       */
+      public Builder setProgram(com.google.protobuf.ByteString value) {
+        if (value == null) {
+    throw new NullPointerException();
+  }
+  bitField0_ |= 0x00000001;
+        program_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required bytes program = 1;</code>
+       */
+      public Builder clearProgram() {
+        bitField0_ = (bitField0_ & ~0x00000001);
+        program_ = getDefaultInstance().getProgram();
+        onChanged();
+        return this;
+      }
+
+      // required int64 creation_timestamp = 2;
+      private long creationTimestamp_ ;
+      /**
+       * <code>required int64 creation_timestamp = 2;</code>
+       *
+       * <pre>
+       * Timestamp stored as millis since epoch. Useful for skipping block bodies before this point
+       * when watching for scripts on the blockchain.
+       * </pre>
+       */
+      public boolean hasCreationTimestamp() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      /**
+       * <code>required int64 creation_timestamp = 2;</code>
+       *
+       * <pre>
+       * Timestamp stored as millis since epoch. Useful for skipping block bodies before this point
+       * when watching for scripts on the blockchain.
+       * </pre>
+       */
+      public long getCreationTimestamp() {
+        return creationTimestamp_;
+      }
+      /**
+       * <code>required int64 creation_timestamp = 2;</code>
+       *
+       * <pre>
+       * Timestamp stored as millis since epoch. Useful for skipping block bodies before this point
+       * when watching for scripts on the blockchain.
+       * </pre>
+       */
+      public Builder setCreationTimestamp(long value) {
+        bitField0_ |= 0x00000002;
+        creationTimestamp_ = value;
+        onChanged();
+        return this;
+      }
+      /**
+       * <code>required int64 creation_timestamp = 2;</code>
+       *
+       * <pre>
+       * Timestamp stored as millis since epoch. Useful for skipping block bodies before this point
+       * when watching for scripts on the blockchain.
+       * </pre>
+       */
+      public Builder clearCreationTimestamp() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        creationTimestamp_ = 0L;
+        onChanged();
+        return this;
+      }
+
+      // @@protoc_insertion_point(builder_scope:wallet.Script)
+    }
+
+    static {
+      defaultInstance = new Script(true);
+      defaultInstance.initFields();
+    }
+
+    // @@protoc_insertion_point(class_scope:wallet.Script)
+  }
+
   public interface TransactionInputOrBuilder
       extends com.google.protobuf.MessageOrBuilder {
 
@@ -10124,6 +10660,31 @@ public final class Protos {
     org.bitcoinj.wallet.Protos.TransactionOrBuilder getTransactionOrBuilder(
         int index);
 
+    // repeated .wallet.Script watched_script = 15;
+    /**
+     * <code>repeated .wallet.Script watched_script = 15;</code>
+     */
+    java.util.List<org.bitcoinj.wallet.Protos.Script> 
+        getWatchedScriptList();
+    /**
+     * <code>repeated .wallet.Script watched_script = 15;</code>
+     */
+    org.bitcoinj.wallet.Protos.Script getWatchedScript(int index);
+    /**
+     * <code>repeated .wallet.Script watched_script = 15;</code>
+     */
+    int getWatchedScriptCount();
+    /**
+     * <code>repeated .wallet.Script watched_script = 15;</code>
+     */
+    java.util.List<? extends org.bitcoinj.wallet.Protos.ScriptOrBuilder> 
+        getWatchedScriptOrBuilderList();
+    /**
+     * <code>repeated .wallet.Script watched_script = 15;</code>
+     */
+    org.bitcoinj.wallet.Protos.ScriptOrBuilder getWatchedScriptOrBuilder(
+        int index);
+
     // optional .wallet.Wallet.EncryptionType encryption_type = 5 [default = UNENCRYPTED];
     /**
      * <code>optional .wallet.Wallet.EncryptionType encryption_type = 5 [default = UNENCRYPTED];</code>
@@ -10353,9 +10914,9 @@ public final class Protos {
               break;
             }
             case 82: {
-              if (!((mutable_bitField0_ & 0x00000200) == 0x00000200)) {
+              if (!((mutable_bitField0_ & 0x00000400) == 0x00000400)) {
                 extension_ = new java.util.ArrayList<org.bitcoinj.wallet.Protos.Extension>();
-                mutable_bitField0_ |= 0x00000200;
+                mutable_bitField0_ |= 0x00000400;
               }
               extension_.add(input.readMessage(org.bitcoinj.wallet.Protos.Extension.PARSER, extensionRegistry));
               break;
@@ -10380,6 +10941,14 @@ public final class Protos {
               lastSeenBlockTimeSecs_ = input.readInt64();
               break;
             }
+            case 122: {
+              if (!((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
+                watchedScript_ = new java.util.ArrayList<org.bitcoinj.wallet.Protos.Script>();
+                mutable_bitField0_ |= 0x00000040;
+              }
+              watchedScript_.add(input.readMessage(org.bitcoinj.wallet.Protos.Script.PARSER, extensionRegistry));
+              break;
+            }
           }
         }
       } catch (com.google.protobuf.InvalidProtocolBufferException e) {
@@ -10394,9 +10963,12 @@ public final class Protos {
         if (((mutable_bitField0_ & 0x00000020) == 0x00000020)) {
           transaction_ = java.util.Collections.unmodifiableList(transaction_);
         }
-        if (((mutable_bitField0_ & 0x00000200) == 0x00000200)) {
+        if (((mutable_bitField0_ & 0x00000400) == 0x00000400)) {
           extension_ = java.util.Collections.unmodifiableList(extension_);
         }
+        if (((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
+          watchedScript_ = java.util.Collections.unmodifiableList(watchedScript_);
+        }
         this.unknownFields = unknownFields.build();
         makeExtensionsImmutable();
       }
@@ -10727,6 +11299,42 @@ public final class Protos {
       return transaction_.get(index);
     }
 
+    // repeated .wallet.Script watched_script = 15;
+    public static final int WATCHED_SCRIPT_FIELD_NUMBER = 15;
+    private java.util.List<org.bitcoinj.wallet.Protos.Script> watchedScript_;
+    /**
+     * <code>repeated .wallet.Script watched_script = 15;</code>
+     */
+    public java.util.List<org.bitcoinj.wallet.Protos.Script> getWatchedScriptList() {
+      return watchedScript_;
+    }
+    /**
+     * <code>repeated .wallet.Script watched_script = 15;</code>
+     */
+    public java.util.List<? extends org.bitcoinj.wallet.Protos.ScriptOrBuilder> 
+        getWatchedScriptOrBuilderList() {
+      return watchedScript_;
+    }
+    /**
+     * <code>repeated .wallet.Script watched_script = 15;</code>
+     */
+    public int getWatchedScriptCount() {
+      return watchedScript_.size();
+    }
+    /**
+     * <code>repeated .wallet.Script watched_script = 15;</code>
+     */
+    public org.bitcoinj.wallet.Protos.Script getWatchedScript(int index) {
+      return watchedScript_.get(index);
+    }
+    /**
+     * <code>repeated .wallet.Script watched_script = 15;</code>
+     */
+    public org.bitcoinj.wallet.Protos.ScriptOrBuilder getWatchedScriptOrBuilder(
+        int index) {
+      return watchedScript_.get(index);
+    }
+
     // optional .wallet.Wallet.EncryptionType encryption_type = 5 [default = UNENCRYPTED];
     public static final int ENCRYPTION_TYPE_FIELD_NUMBER = 5;
     private org.bitcoinj.wallet.Protos.Wallet.EncryptionType encryptionType_;
@@ -10917,6 +11525,7 @@ public final class Protos {
       lastSeenBlockTimeSecs_ = 0L;
       key_ = java.util.Collections.emptyList();
       transaction_ = java.util.Collections.emptyList();
+      watchedScript_ = java.util.Collections.emptyList();
       encryptionType_ = org.bitcoinj.wallet.Protos.Wallet.EncryptionType.UNENCRYPTED;
       encryptionParameters_ = org.bitcoinj.wallet.Protos.ScryptParameters.getDefaultInstance();
       version_ = 0;
@@ -10945,6 +11554,12 @@ public final class Protos {
           return false;
         }
       }
+      for (int i = 0; i < getWatchedScriptCount(); i++) {
+        if (!getWatchedScript(i).isInitialized()) {
+          memoizedIsInitialized = 0;
+          return false;
+        }
+      }
       if (hasEncryptionParameters()) {
         if (!getEncryptionParameters().isInitialized()) {
           memoizedIsInitialized = 0;
@@ -11000,6 +11615,9 @@ public final class Protos {
       if (((bitField0_ & 0x00000008) == 0x00000008)) {
         output.writeInt64(14, lastSeenBlockTimeSecs_);
       }
+      for (int i = 0; i < watchedScript_.size(); i++) {
+        output.writeMessage(15, watchedScript_.get(i));
+      }
       getUnknownFields().writeTo(output);
     }
 
@@ -11057,6 +11675,10 @@ public final class Protos {
         size += com.google.protobuf.CodedOutputStream
           .computeInt64Size(14, lastSeenBlockTimeSecs_);
       }
+      for (int i = 0; i < watchedScript_.size(); i++) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeMessageSize(15, watchedScript_.get(i));
+      }
       size += getUnknownFields().getSerializedSize();
       memoizedSerializedSize = size;
       return size;
@@ -11171,6 +11793,7 @@ public final class Protos {
         if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
           getKeyFieldBuilder();
           getTransactionFieldBuilder();
+          getWatchedScriptFieldBuilder();
           getEncryptionParametersFieldBuilder();
           getExtensionFieldBuilder();
         }
@@ -11201,26 +11824,32 @@ public final class Protos {
         } else {
           transactionBuilder_.clear();
         }
+        if (watchedScriptBuilder_ == null) {
+          watchedScript_ = java.util.Collections.emptyList();
+          bitField0_ = (bitField0_ & ~0x00000040);
+        } else {
+          watchedScriptBuilder_.clear();
+        }
         encryptionType_ = org.bitcoinj.wallet.Protos.Wallet.EncryptionType.UNENCRYPTED;
-        bitField0_ = (bitField0_ & ~0x00000040);
+        bitField0_ = (bitField0_ & ~0x00000080);
         if (encryptionParametersBuilder_ == null) {
           encryptionParameters_ = org.bitcoinj.wallet.Protos.ScryptParameters.getDefaultInstance();
         } else {
           encryptionParametersBuilder_.clear();
         }
-        bitField0_ = (bitField0_ & ~0x00000080);
-        version_ = 0;
         bitField0_ = (bitField0_ & ~0x00000100);
+        version_ = 0;
+        bitField0_ = (bitField0_ & ~0x00000200);
         if (extensionBuilder_ == null) {
           extension_ = java.util.Collections.emptyList();
-          bitField0_ = (bitField0_ & ~0x00000200);
+          bitField0_ = (bitField0_ & ~0x00000400);
         } else {
           extensionBuilder_.clear();
         }
         description_ = "";
-        bitField0_ = (bitField0_ & ~0x00000400);
-        keyRotationTime_ = 0L;
         bitField0_ = (bitField0_ & ~0x00000800);
+        keyRotationTime_ = 0L;
+        bitField0_ = (bitField0_ & ~0x00001000);
         return this;
       }
 
@@ -11283,11 +11912,20 @@ public final class Protos {
         } else {
           result.transaction_ = transactionBuilder_.build();
         }
-        if (((from_bitField0_ & 0x00000040) == 0x00000040)) {
+        if (watchedScriptBuilder_ == null) {
+          if (((bitField0_ & 0x00000040) == 0x00000040)) {
+            watchedScript_ = java.util.Collections.unmodifiableList(watchedScript_);
+            bitField0_ = (bitField0_ & ~0x00000040);
+          }
+          result.watchedScript_ = watchedScript_;
+        } else {
+          result.watchedScript_ = watchedScriptBuilder_.build();
+        }
+        if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
           to_bitField0_ |= 0x00000010;
         }
         result.encryptionType_ = encryptionType_;
-        if (((from_bitField0_ & 0x00000080) == 0x00000080)) {
+        if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
           to_bitField0_ |= 0x00000020;
         }
         if (encryptionParametersBuilder_ == null) {
@@ -11295,24 +11933,24 @@ public final class Protos {
         } else {
           result.encryptionParameters_ = encryptionParametersBuilder_.build();
         }
-        if (((from_bitField0_ & 0x00000100) == 0x00000100)) {
+        if (((from_bitField0_ & 0x00000200) == 0x00000200)) {
           to_bitField0_ |= 0x00000040;
         }
         result.version_ = version_;
         if (extensionBuilder_ == null) {
-          if (((bitField0_ & 0x00000200) == 0x00000200)) {
+          if (((bitField0_ & 0x00000400) == 0x00000400)) {
             extension_ = java.util.Collections.unmodifiableList(extension_);
-            bitField0_ = (bitField0_ & ~0x00000200);
+            bitField0_ = (bitField0_ & ~0x00000400);
           }
           result.extension_ = extension_;
         } else {
           result.extension_ = extensionBuilder_.build();
         }
-        if (((from_bitField0_ & 0x00000400) == 0x00000400)) {
+        if (((from_bitField0_ & 0x00000800) == 0x00000800)) {
           to_bitField0_ |= 0x00000080;
         }
         result.description_ = description_;
-        if (((from_bitField0_ & 0x00000800) == 0x00000800)) {
+        if (((from_bitField0_ & 0x00001000) == 0x00001000)) {
           to_bitField0_ |= 0x00000100;
         }
         result.keyRotationTime_ = keyRotationTime_;
@@ -11398,6 +12036,32 @@ public final class Protos {
             }
           }
         }
+        if (watchedScriptBuilder_ == null) {
+          if (!other.watchedScript_.isEmpty()) {
+            if (watchedScript_.isEmpty()) {
+              watchedScript_ = other.watchedScript_;
+              bitField0_ = (bitField0_ & ~0x00000040);
+            } else {
+              ensureWatchedScriptIsMutable();
+              watchedScript_.addAll(other.watchedScript_);
+            }
+            onChanged();
+          }
+        } else {
+          if (!other.watchedScript_.isEmpty()) {
+            if (watchedScriptBuilder_.isEmpty()) {
+              watchedScriptBuilder_.dispose();
+              watchedScriptBuilder_ = null;
+              watchedScript_ = other.watchedScript_;
+              bitField0_ = (bitField0_ & ~0x00000040);
+              watchedScriptBuilder_ = 
+                com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
+                   getWatchedScriptFieldBuilder() : null;
+            } else {
+              watchedScriptBuilder_.addAllMessages(other.watchedScript_);
+            }
+          }
+        }
         if (other.hasEncryptionType()) {
           setEncryptionType(other.getEncryptionType());
         }
@@ -11411,7 +12075,7 @@ public final class Protos {
           if (!other.extension_.isEmpty()) {
             if (extension_.isEmpty()) {
               extension_ = other.extension_;
-              bitField0_ = (bitField0_ & ~0x00000200);
+              bitField0_ = (bitField0_ & ~0x00000400);
             } else {
               ensureExtensionIsMutable();
               extension_.addAll(other.extension_);
@@ -11424,7 +12088,7 @@ public final class Protos {
               extensionBuilder_.dispose();
               extensionBuilder_ = null;
               extension_ = other.extension_;
-              bitField0_ = (bitField0_ & ~0x00000200);
+              bitField0_ = (bitField0_ & ~0x00000400);
               extensionBuilder_ = 
                 com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
                    getExtensionFieldBuilder() : null;
@@ -11434,7 +12098,7 @@ public final class Protos {
           }
         }
         if (other.hasDescription()) {
-          bitField0_ |= 0x00000400;
+          bitField0_ |= 0x00000800;
           description_ = other.description_;
           onChanged();
         }
@@ -11462,6 +12126,12 @@ public final class Protos {
             return false;
           }
         }
+        for (int i = 0; i < getWatchedScriptCount(); i++) {
+          if (!getWatchedScript(i).isInitialized()) {
+            
+            return false;
+          }
+        }
         if (hasEncryptionParameters()) {
           if (!getEncryptionParameters().isInitialized()) {
             
@@ -12208,13 +12878,253 @@ public final class Protos {
         return transactionBuilder_;
       }
 
+      // repeated .wallet.Script watched_script = 15;
+      private java.util.List<org.bitcoinj.wallet.Protos.Script> watchedScript_ =
+        java.util.Collections.emptyList();
+      private void ensureWatchedScriptIsMutable() {
+        if (!((bitField0_ & 0x00000040) == 0x00000040)) {
+          watchedScript_ = new java.util.ArrayList<org.bitcoinj.wallet.Protos.Script>(watchedScript_);
+          bitField0_ |= 0x00000040;
+         }
+      }
+
+      private com.google.protobuf.RepeatedFieldBuilder<
+          org.bitcoinj.wallet.Protos.Script, org.bitcoinj.wallet.Protos.Script.Builder, org.bitcoinj.wallet.Protos.ScriptOrBuilder> watchedScriptBuilder_;
+
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public java.util.List<org.bitcoinj.wallet.Protos.Script> getWatchedScriptList() {
+        if (watchedScriptBuilder_ == null) {
+          return java.util.Collections.unmodifiableList(watchedScript_);
+        } else {
+          return watchedScriptBuilder_.getMessageList();
+        }
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public int getWatchedScriptCount() {
+        if (watchedScriptBuilder_ == null) {
+          return watchedScript_.size();
+        } else {
+          return watchedScriptBuilder_.getCount();
+        }
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public org.bitcoinj.wallet.Protos.Script getWatchedScript(int index) {
+        if (watchedScriptBuilder_ == null) {
+          return watchedScript_.get(index);
+        } else {
+          return watchedScriptBuilder_.getMessage(index);
+        }
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public Builder setWatchedScript(
+          int index, org.bitcoinj.wallet.Protos.Script value) {
+        if (watchedScriptBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureWatchedScriptIsMutable();
+          watchedScript_.set(index, value);
+          onChanged();
+        } else {
+          watchedScriptBuilder_.setMessage(index, value);
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public Builder setWatchedScript(
+          int index, org.bitcoinj.wallet.Protos.Script.Builder builderForValue) {
+        if (watchedScriptBuilder_ == null) {
+          ensureWatchedScriptIsMutable();
+          watchedScript_.set(index, builderForValue.build());
+          onChanged();
+        } else {
+          watchedScriptBuilder_.setMessage(index, builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public Builder addWatchedScript(org.bitcoinj.wallet.Protos.Script value) {
+        if (watchedScriptBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureWatchedScriptIsMutable();
+          watchedScript_.add(value);
+          onChanged();
+        } else {
+          watchedScriptBuilder_.addMessage(value);
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public Builder addWatchedScript(
+          int index, org.bitcoinj.wallet.Protos.Script value) {
+        if (watchedScriptBuilder_ == null) {
+          if (value == null) {
+            throw new NullPointerException();
+          }
+          ensureWatchedScriptIsMutable();
+          watchedScript_.add(index, value);
+          onChanged();
+        } else {
+          watchedScriptBuilder_.addMessage(index, value);
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public Builder addWatchedScript(
+          org.bitcoinj.wallet.Protos.Script.Builder builderForValue) {
+        if (watchedScriptBuilder_ == null) {
+          ensureWatchedScriptIsMutable();
+          watchedScript_.add(builderForValue.build());
+          onChanged();
+        } else {
+          watchedScriptBuilder_.addMessage(builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public Builder addWatchedScript(
+          int index, org.bitcoinj.wallet.Protos.Script.Builder builderForValue) {
+        if (watchedScriptBuilder_ == null) {
+          ensureWatchedScriptIsMutable();
+          watchedScript_.add(index, builderForValue.build());
+          onChanged();
+        } else {
+          watchedScriptBuilder_.addMessage(index, builderForValue.build());
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public Builder addAllWatchedScript(
+          java.lang.Iterable<? extends org.bitcoinj.wallet.Protos.Script> values) {
+        if (watchedScriptBuilder_ == null) {
+          ensureWatchedScriptIsMutable();
+          super.addAll(values, watchedScript_);
+          onChanged();
+        } else {
+          watchedScriptBuilder_.addAllMessages(values);
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public Builder clearWatchedScript() {
+        if (watchedScriptBuilder_ == null) {
+          watchedScript_ = java.util.Collections.emptyList();
+          bitField0_ = (bitField0_ & ~0x00000040);
+          onChanged();
+        } else {
+          watchedScriptBuilder_.clear();
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public Builder removeWatchedScript(int index) {
+        if (watchedScriptBuilder_ == null) {
+          ensureWatchedScriptIsMutable();
+          watchedScript_.remove(index);
+          onChanged();
+        } else {
+          watchedScriptBuilder_.remove(index);
+        }
+        return this;
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public org.bitcoinj.wallet.Protos.Script.Builder getWatchedScriptBuilder(
+          int index) {
+        return getWatchedScriptFieldBuilder().getBuilder(index);
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public org.bitcoinj.wallet.Protos.ScriptOrBuilder getWatchedScriptOrBuilder(
+          int index) {
+        if (watchedScriptBuilder_ == null) {
+          return watchedScript_.get(index);  } else {
+          return watchedScriptBuilder_.getMessageOrBuilder(index);
+        }
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public java.util.List<? extends org.bitcoinj.wallet.Protos.ScriptOrBuilder> 
+           getWatchedScriptOrBuilderList() {
+        if (watchedScriptBuilder_ != null) {
+          return watchedScriptBuilder_.getMessageOrBuilderList();
+        } else {
+          return java.util.Collections.unmodifiableList(watchedScript_);
+        }
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public org.bitcoinj.wallet.Protos.Script.Builder addWatchedScriptBuilder() {
+        return getWatchedScriptFieldBuilder().addBuilder(
+            org.bitcoinj.wallet.Protos.Script.getDefaultInstance());
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public org.bitcoinj.wallet.Protos.Script.Builder addWatchedScriptBuilder(
+          int index) {
+        return getWatchedScriptFieldBuilder().addBuilder(
+            index, org.bitcoinj.wallet.Protos.Script.getDefaultInstance());
+      }
+      /**
+       * <code>repeated .wallet.Script watched_script = 15;</code>
+       */
+      public java.util.List<org.bitcoinj.wallet.Protos.Script.Builder> 
+           getWatchedScriptBuilderList() {
+        return getWatchedScriptFieldBuilder().getBuilderList();
+      }
+      private com.google.protobuf.RepeatedFieldBuilder<
+          org.bitcoinj.wallet.Protos.Script, org.bitcoinj.wallet.Protos.Script.Builder, org.bitcoinj.wallet.Protos.ScriptOrBuilder> 
+          getWatchedScriptFieldBuilder() {
+        if (watchedScriptBuilder_ == null) {
+          watchedScriptBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
+              org.bitcoinj.wallet.Protos.Script, org.bitcoinj.wallet.Protos.Script.Builder, org.bitcoinj.wallet.Protos.ScriptOrBuilder>(
+                  watchedScript_,
+                  ((bitField0_ & 0x00000040) == 0x00000040),
+                  getParentForChildren(),
+                  isClean());
+          watchedScript_ = null;
+        }
+        return watchedScriptBuilder_;
+      }
+
       // optional .wallet.Wallet.EncryptionType encryption_type = 5 [default = UNENCRYPTED];
       private org.bitcoinj.wallet.Protos.Wallet.EncryptionType encryptionType_ = org.bitcoinj.wallet.Protos.Wallet.EncryptionType.UNENCRYPTED;
       /**
        * <code>optional .wallet.Wallet.EncryptionType encryption_type = 5 [default = UNENCRYPTED];</code>
        */
       public boolean hasEncryptionType() {
-        return ((bitField0_ & 0x00000040) == 0x00000040);
+        return ((bitField0_ & 0x00000080) == 0x00000080);
       }
       /**
        * <code>optional .wallet.Wallet.EncryptionType encryption_type = 5 [default = UNENCRYPTED];</code>
@@ -12229,7 +13139,7 @@ public final class Protos {
         if (value == null) {
           throw new NullPointerException();
         }
-        bitField0_ |= 0x00000040;
+        bitField0_ |= 0x00000080;
         encryptionType_ = value;
         onChanged();
         return this;
@@ -12238,7 +13148,7 @@ public final class Protos {
        * <code>optional .wallet.Wallet.EncryptionType encryption_type = 5 [default = UNENCRYPTED];</code>
        */
       public Builder clearEncryptionType() {
-        bitField0_ = (bitField0_ & ~0x00000040);
+        bitField0_ = (bitField0_ & ~0x00000080);
         encryptionType_ = org.bitcoinj.wallet.Protos.Wallet.EncryptionType.UNENCRYPTED;
         onChanged();
         return this;
@@ -12252,7 +13162,7 @@ public final class Protos {
        * <code>optional .wallet.ScryptParameters encryption_parameters = 6;</code>
        */
       public boolean hasEncryptionParameters() {
-        return ((bitField0_ & 0x00000080) == 0x00000080);
+        return ((bitField0_ & 0x00000100) == 0x00000100);
       }
       /**
        * <code>optional .wallet.ScryptParameters encryption_parameters = 6;</code>
@@ -12277,7 +13187,7 @@ public final class Protos {
         } else {
           encryptionParametersBuilder_.setMessage(value);
         }
-        bitField0_ |= 0x00000080;
+        bitField0_ |= 0x00000100;
         return this;
       }
       /**
@@ -12291,7 +13201,7 @@ public final class Protos {
         } else {
           encryptionParametersBuilder_.setMessage(builderForValue.build());
         }
-        bitField0_ |= 0x00000080;
+        bitField0_ |= 0x00000100;
         return this;
       }
       /**
@@ -12299,7 +13209,7 @@ public final class Protos {
        */
       public Builder mergeEncryptionParameters(org.bitcoinj.wallet.Protos.ScryptParameters value) {
         if (encryptionParametersBuilder_ == null) {
-          if (((bitField0_ & 0x00000080) == 0x00000080) &&
+          if (((bitField0_ & 0x00000100) == 0x00000100) &&
               encryptionParameters_ != org.bitcoinj.wallet.Protos.ScryptParameters.getDefaultInstance()) {
             encryptionParameters_ =
               org.bitcoinj.wallet.Protos.ScryptParameters.newBuilder(encryptionParameters_).mergeFrom(value).buildPartial();
@@ -12310,7 +13220,7 @@ public final class Protos {
         } else {
           encryptionParametersBuilder_.mergeFrom(value);
         }
-        bitField0_ |= 0x00000080;
+        bitField0_ |= 0x00000100;
         return this;
       }
       /**
@@ -12323,14 +13233,14 @@ public final class Protos {
         } else {
           encryptionParametersBuilder_.clear();
         }
-        bitField0_ = (bitField0_ & ~0x00000080);
+        bitField0_ = (bitField0_ & ~0x00000100);
         return this;
       }
       /**
        * <code>optional .wallet.ScryptParameters encryption_parameters = 6;</code>
        */
       public org.bitcoinj.wallet.Protos.ScryptParameters.Builder getEncryptionParametersBuilder() {
-        bitField0_ |= 0x00000080;
+        bitField0_ |= 0x00000100;
         onChanged();
         return getEncryptionParametersFieldBuilder().getBuilder();
       }
@@ -12372,7 +13282,7 @@ public final class Protos {
        * </pre>
        */
       public boolean hasVersion() {
-        return ((bitField0_ & 0x00000100) == 0x00000100);
+        return ((bitField0_ & 0x00000200) == 0x00000200);
       }
       /**
        * <code>optional int32 version = 7;</code>
@@ -12394,7 +13304,7 @@ public final class Protos {
        * </pre>
        */
       public Builder setVersion(int value) {
-        bitField0_ |= 0x00000100;
+        bitField0_ |= 0x00000200;
         version_ = value;
         onChanged();
         return this;
@@ -12408,7 +13318,7 @@ public final class Protos {
        * </pre>
        */
       public Builder clearVersion() {
-        bitField0_ = (bitField0_ & ~0x00000100);
+        bitField0_ = (bitField0_ & ~0x00000200);
         version_ = 0;
         onChanged();
         return this;
@@ -12418,9 +13328,9 @@ public final class Protos {
       private java.util.List<org.bitcoinj.wallet.Protos.Extension> extension_ =
         java.util.Collections.emptyList();
       private void ensureExtensionIsMutable() {
-        if (!((bitField0_ & 0x00000200) == 0x00000200)) {
+        if (!((bitField0_ & 0x00000400) == 0x00000400)) {
           extension_ = new java.util.ArrayList<org.bitcoinj.wallet.Protos.Extension>(extension_);
-          bitField0_ |= 0x00000200;
+          bitField0_ |= 0x00000400;
          }
       }
 
@@ -12569,7 +13479,7 @@ public final class Protos {
       public Builder clearExtension() {
         if (extensionBuilder_ == null) {
           extension_ = java.util.Collections.emptyList();
-          bitField0_ = (bitField0_ & ~0x00000200);
+          bitField0_ = (bitField0_ & ~0x00000400);
           onChanged();
         } else {
           extensionBuilder_.clear();
@@ -12646,7 +13556,7 @@ public final class Protos {
           extensionBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
               org.bitcoinj.wallet.Protos.Extension, org.bitcoinj.wallet.Protos.Extension.Builder, org.bitcoinj.wallet.Protos.ExtensionOrBuilder>(
                   extension_,
-                  ((bitField0_ & 0x00000200) == 0x00000200),
+                  ((bitField0_ & 0x00000400) == 0x00000400),
                   getParentForChildren(),
                   isClean());
           extension_ = null;
@@ -12664,7 +13574,7 @@ public final class Protos {
        * </pre>
        */
       public boolean hasDescription() {
-        return ((bitField0_ & 0x00000400) == 0x00000400);
+        return ((bitField0_ & 0x00000800) == 0x00000800);
       }
       /**
        * <code>optional string description = 11;</code>
@@ -12716,7 +13626,7 @@ public final class Protos {
         if (value == null) {
     throw new NullPointerException();
   }
-  bitField0_ |= 0x00000400;
+  bitField0_ |= 0x00000800;
         description_ = value;
         onChanged();
         return this;
@@ -12729,7 +13639,7 @@ public final class Protos {
        * </pre>
        */
       public Builder clearDescription() {
-        bitField0_ = (bitField0_ & ~0x00000400);
+        bitField0_ = (bitField0_ & ~0x00000800);
         description_ = getDefaultInstance().getDescription();
         onChanged();
         return this;
@@ -12746,7 +13656,7 @@ public final class Protos {
         if (value == null) {
     throw new NullPointerException();
   }
-  bitField0_ |= 0x00000400;
+  bitField0_ |= 0x00000800;
         description_ = value;
         onChanged();
         return this;
@@ -12764,7 +13674,7 @@ public final class Protos {
        * </pre>
        */
       public boolean hasKeyRotationTime() {
-        return ((bitField0_ & 0x00000800) == 0x00000800);
+        return ((bitField0_ & 0x00001000) == 0x00001000);
       }
       /**
        * <code>optional uint64 key_rotation_time = 13;</code>
@@ -12788,7 +13698,7 @@ public final class Protos {
        * </pre>
        */
       public Builder setKeyRotationTime(long value) {
-        bitField0_ |= 0x00000800;
+        bitField0_ |= 0x00001000;
         keyRotationTime_ = value;
         onChanged();
         return this;
@@ -12803,7 +13713,7 @@ public final class Protos {
        * </pre>
        */
       public Builder clearKeyRotationTime() {
-        bitField0_ = (bitField0_ & ~0x00000800);
+        bitField0_ = (bitField0_ & ~0x00001000);
         keyRotationTime_ = 0L;
         onChanged();
         return this;
@@ -12835,6 +13745,11 @@ public final class Protos {
   private static
     com.google.protobuf.GeneratedMessage.FieldAccessorTable
       internal_static_wallet_Key_fieldAccessorTable;
+  private static com.google.protobuf.Descriptors.Descriptor
+    internal_static_wallet_Script_descriptor;
+  private static
+    com.google.protobuf.GeneratedMessage.FieldAccessorTable
+      internal_static_wallet_Script_fieldAccessorTable;
   private static com.google.protobuf.Descriptors.Descriptor
     internal_static_wallet_TransactionInput_descriptor;
   private static
@@ -12889,54 +13804,56 @@ public final class Protos {
       "ryptedPrivateKey\022\022\n\npublic_key\030\003 \001(\014\022\r\n\005" +
       "label\030\004 \001(\t\022\032\n\022creation_timestamp\030\005 \001(\003\"" +
       ".\n\004Type\022\014\n\010ORIGINAL\020\001\022\030\n\024ENCRYPTED_SCRYP",
-      "T_AES\020\002\"\203\001\n\020TransactionInput\022\"\n\032transact" +
-      "ion_out_point_hash\030\001 \002(\014\022#\n\033transaction_" +
-      "out_point_index\030\002 \002(\r\022\024\n\014script_bytes\030\003 " +
-      "\002(\014\022\020\n\010sequence\030\004 \001(\r\"\177\n\021TransactionOutp" +
-      "ut\022\r\n\005value\030\001 \002(\003\022\024\n\014script_bytes\030\002 \002(\014\022" +
-      "!\n\031spent_by_transaction_hash\030\003 \001(\014\022\"\n\032sp" +
-      "ent_by_transaction_index\030\004 \001(\005\"\234\003\n\025Trans" +
-      "actionConfidence\0220\n\004type\030\001 \001(\0162\".wallet." +
-      "TransactionConfidence.Type\022\032\n\022appeared_a" +
-      "t_height\030\002 \001(\005\022\036\n\026overriding_transaction",
-      "\030\003 \001(\014\022\r\n\005depth\030\004 \001(\005\022\021\n\twork_done\030\005 \001(\003" +
-      "\022)\n\014broadcast_by\030\006 \003(\0132\023.wallet.PeerAddr" +
-      "ess\0224\n\006source\030\007 \001(\0162$.wallet.Transaction" +
-      "Confidence.Source\"O\n\004Type\022\013\n\007UNKNOWN\020\000\022\014" +
-      "\n\010BUILDING\020\001\022\013\n\007PENDING\020\002\022\025\n\021NOT_IN_BEST" +
-      "_CHAIN\020\003\022\010\n\004DEAD\020\004\"A\n\006Source\022\022\n\016SOURCE_U" +
-      "NKNOWN\020\000\022\022\n\016SOURCE_NETWORK\020\001\022\017\n\013SOURCE_S" +
-      "ELF\020\002\"\236\004\n\013Transaction\022\017\n\007version\030\001 \002(\005\022\014" +
-      "\n\004hash\030\002 \002(\014\022&\n\004pool\030\003 \001(\0162\030.wallet.Tran" +
-      "saction.Pool\022\021\n\tlock_time\030\004 \001(\r\022\022\n\nupdat",
-      "ed_at\030\005 \001(\003\0223\n\021transaction_input\030\006 \003(\0132\030" +
-      ".wallet.TransactionInput\0225\n\022transaction_" +
-      "output\030\007 \003(\0132\031.wallet.TransactionOutput\022" +
-      "\022\n\nblock_hash\030\010 \003(\014\022 \n\030block_relativity_" +
-      "offsets\030\013 \003(\005\0221\n\nconfidence\030\t \001(\0132\035.wall" +
-      "et.TransactionConfidence\0225\n\007purpose\030\n \001(" +
-      "\0162\033.wallet.Transaction.Purpose:\007UNKNOWN\"" +
-      "Y\n\004Pool\022\013\n\007UNSPENT\020\004\022\t\n\005SPENT\020\005\022\014\n\010INACT" +
-      "IVE\020\002\022\010\n\004DEAD\020\n\022\013\n\007PENDING\020\020\022\024\n\020PENDING_" +
-      "INACTIVE\020\022\":\n\007Purpose\022\013\n\007UNKNOWN\020\000\022\020\n\014US",
-      "ER_PAYMENT\020\001\022\020\n\014KEY_ROTATION\020\002\"N\n\020Scrypt" +
-      "Parameters\022\014\n\004salt\030\001 \002(\014\022\020\n\001n\030\002 \001(\003:\005163" +
-      "84\022\014\n\001r\030\003 \001(\005:\0018\022\014\n\001p\030\004 \001(\005:\0011\"8\n\tExtens" +
-      "ion\022\n\n\002id\030\001 \002(\t\022\014\n\004data\030\002 \002(\014\022\021\n\tmandato" +
-      "ry\030\003 \002(\010\"\353\003\n\006Wallet\022\032\n\022network_identifie" +
-      "r\030\001 \002(\t\022\034\n\024last_seen_block_hash\030\002 \001(\014\022\036\n" +
-      "\026last_seen_block_height\030\014 \001(\r\022!\n\031last_se" +
-      "en_block_time_secs\030\016 \001(\003\022\030\n\003key\030\003 \003(\0132\013." +
-      "wallet.Key\022(\n\013transaction\030\004 \003(\0132\023.wallet" +
-      ".Transaction\022C\n\017encryption_type\030\005 \001(\0162\035.",
-      "wallet.Wallet.EncryptionType:\013UNENCRYPTE" +
-      "D\0227\n\025encryption_parameters\030\006 \001(\0132\030.walle" +
-      "t.ScryptParameters\022\017\n\007version\030\007 \001(\005\022$\n\te" +
-      "xtension\030\n \003(\0132\021.wallet.Extension\022\023\n\013des" +
-      "cription\030\013 \001(\t\022\031\n\021key_rotation_time\030\r \001(" +
-      "\004\";\n\016EncryptionType\022\017\n\013UNENCRYPTED\020\001\022\030\n\024" +
-      "ENCRYPTED_SCRYPT_AES\020\002B\035\n\023org.bitcoinj.w" +
-      "alletB\006Protos"
+      "T_AES\020\002\"5\n\006Script\022\017\n\007program\030\001 \002(\014\022\032\n\022cr" +
+      "eation_timestamp\030\002 \002(\003\"\203\001\n\020TransactionIn" +
+      "put\022\"\n\032transaction_out_point_hash\030\001 \002(\014\022" +
+      "#\n\033transaction_out_point_index\030\002 \002(\r\022\024\n\014" +
+      "script_bytes\030\003 \002(\014\022\020\n\010sequence\030\004 \001(\r\"\177\n\021" +
+      "TransactionOutput\022\r\n\005value\030\001 \002(\003\022\024\n\014scri" +
+      "pt_bytes\030\002 \002(\014\022!\n\031spent_by_transaction_h" +
+      "ash\030\003 \001(\014\022\"\n\032spent_by_transaction_index\030" +
+      "\004 \001(\005\"\234\003\n\025TransactionConfidence\0220\n\004type\030" +
+      "\001 \001(\0162\".wallet.TransactionConfidence.Typ",
+      "e\022\032\n\022appeared_at_height\030\002 \001(\005\022\036\n\026overrid" +
+      "ing_transaction\030\003 \001(\014\022\r\n\005depth\030\004 \001(\005\022\021\n\t" +
+      "work_done\030\005 \001(\003\022)\n\014broadcast_by\030\006 \003(\0132\023." +
+      "wallet.PeerAddress\0224\n\006source\030\007 \001(\0162$.wal" +
+      "let.TransactionConfidence.Source\"O\n\004Type" +
+      "\022\013\n\007UNKNOWN\020\000\022\014\n\010BUILDING\020\001\022\013\n\007PENDING\020\002" +
+      "\022\025\n\021NOT_IN_BEST_CHAIN\020\003\022\010\n\004DEAD\020\004\"A\n\006Sou" +
+      "rce\022\022\n\016SOURCE_UNKNOWN\020\000\022\022\n\016SOURCE_NETWOR" +
+      "K\020\001\022\017\n\013SOURCE_SELF\020\002\"\236\004\n\013Transaction\022\017\n\007" +
+      "version\030\001 \002(\005\022\014\n\004hash\030\002 \002(\014\022&\n\004pool\030\003 \001(",
+      "\0162\030.wallet.Transaction.Pool\022\021\n\tlock_time" +
+      "\030\004 \001(\r\022\022\n\nupdated_at\030\005 \001(\003\0223\n\021transactio" +
+      "n_input\030\006 \003(\0132\030.wallet.TransactionInput\022" +
+      "5\n\022transaction_output\030\007 \003(\0132\031.wallet.Tra" +
+      "nsactionOutput\022\022\n\nblock_hash\030\010 \003(\014\022 \n\030bl" +
+      "ock_relativity_offsets\030\013 \003(\005\0221\n\nconfiden" +
+      "ce\030\t \001(\0132\035.wallet.TransactionConfidence\022" +
+      "5\n\007purpose\030\n \001(\0162\033.wallet.Transaction.Pu" +
+      "rpose:\007UNKNOWN\"Y\n\004Pool\022\013\n\007UNSPENT\020\004\022\t\n\005S" +
+      "PENT\020\005\022\014\n\010INACTIVE\020\002\022\010\n\004DEAD\020\n\022\013\n\007PENDIN",
+      "G\020\020\022\024\n\020PENDING_INACTIVE\020\022\":\n\007Purpose\022\013\n\007" +
+      "UNKNOWN\020\000\022\020\n\014USER_PAYMENT\020\001\022\020\n\014KEY_ROTAT" +
+      "ION\020\002\"N\n\020ScryptParameters\022\014\n\004salt\030\001 \002(\014\022" +
+      "\020\n\001n\030\002 \001(\003:\00516384\022\014\n\001r\030\003 \001(\005:\0018\022\014\n\001p\030\004 \001" +
+      "(\005:\0011\"8\n\tExtension\022\n\n\002id\030\001 \002(\t\022\014\n\004data\030\002" +
+      " \002(\014\022\021\n\tmandatory\030\003 \002(\010\"\223\004\n\006Wallet\022\032\n\022ne" +
+      "twork_identifier\030\001 \002(\t\022\034\n\024last_seen_bloc" +
+      "k_hash\030\002 \001(\014\022\036\n\026last_seen_block_height\030\014" +
+      " \001(\r\022!\n\031last_seen_block_time_secs\030\016 \001(\003\022" +
+      "\030\n\003key\030\003 \003(\0132\013.wallet.Key\022(\n\013transaction",
+      "\030\004 \003(\0132\023.wallet.Transaction\022&\n\016watched_s" +
+      "cript\030\017 \003(\0132\016.wallet.Script\022C\n\017encryptio" +
+      "n_type\030\005 \001(\0162\035.wallet.Wallet.EncryptionT" +
+      "ype:\013UNENCRYPTED\0227\n\025encryption_parameter" +
+      "s\030\006 \001(\0132\030.wallet.ScryptParameters\022\017\n\007ver" +
+      "sion\030\007 \001(\005\022$\n\textension\030\n \003(\0132\021.wallet.E" +
+      "xtension\022\023\n\013description\030\013 \001(\t\022\031\n\021key_rot" +
+      "ation_time\030\r \001(\004\";\n\016EncryptionType\022\017\n\013UN" +
+      "ENCRYPTED\020\001\022\030\n\024ENCRYPTED_SCRYPT_AES\020\002B\035\n" +
+      "\023org.bitcoinj.walletB\006Protos"
     };
     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
@@ -12961,48 +13878,54 @@ public final class Protos {
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_wallet_Key_descriptor,
               new java.lang.String[] { "Type", "PrivateKey", "EncryptedPrivateKey", "PublicKey", "Label", "CreationTimestamp", });
-          internal_static_wallet_TransactionInput_descriptor =
+          internal_static_wallet_Script_descriptor =
             getDescriptor().getMessageTypes().get(3);
+          internal_static_wallet_Script_fieldAccessorTable = new
+            com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+              internal_static_wallet_Script_descriptor,
+              new java.lang.String[] { "Program", "CreationTimestamp", });
+          internal_static_wallet_TransactionInput_descriptor =
+            getDescriptor().getMessageTypes().get(4);
           internal_static_wallet_TransactionInput_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_wallet_TransactionInput_descriptor,
               new java.lang.String[] { "TransactionOutPointHash", "TransactionOutPointIndex", "ScriptBytes", "Sequence", });
           internal_static_wallet_TransactionOutput_descriptor =
-            getDescriptor().getMessageTypes().get(4);
+            getDescriptor().getMessageTypes().get(5);
           internal_static_wallet_TransactionOutput_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_wallet_TransactionOutput_descriptor,
               new java.lang.String[] { "Value", "ScriptBytes", "SpentByTransactionHash", "SpentByTransactionIndex", });
           internal_static_wallet_TransactionConfidence_descriptor =
-            getDescriptor().getMessageTypes().get(5);
+            getDescriptor().getMessageTypes().get(6);
           internal_static_wallet_TransactionConfidence_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_wallet_TransactionConfidence_descriptor,
               new java.lang.String[] { "Type", "AppearedAtHeight", "OverridingTransaction", "Depth", "WorkDone", "BroadcastBy", "Source", });
           internal_static_wallet_Transaction_descriptor =
-            getDescriptor().getMessageTypes().get(6);
+            getDescriptor().getMessageTypes().get(7);
           internal_static_wallet_Transaction_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_wallet_Transaction_descriptor,
               new java.lang.String[] { "Version", "Hash", "Pool", "LockTime", "UpdatedAt", "TransactionInput", "TransactionOutput", "BlockHash", "BlockRelativityOffsets", "Confidence", "Purpose", });
           internal_static_wallet_ScryptParameters_descriptor =
-            getDescriptor().getMessageTypes().get(7);
+            getDescriptor().getMessageTypes().get(8);
           internal_static_wallet_ScryptParameters_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_wallet_ScryptParameters_descriptor,
               new java.lang.String[] { "Salt", "N", "R", "P", });
           internal_static_wallet_Extension_descriptor =
-            getDescriptor().getMessageTypes().get(8);
+            getDescriptor().getMessageTypes().get(9);
           internal_static_wallet_Extension_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_wallet_Extension_descriptor,
               new java.lang.String[] { "Id", "Data", "Mandatory", });
           internal_static_wallet_Wallet_descriptor =
-            getDescriptor().getMessageTypes().get(9);
+            getDescriptor().getMessageTypes().get(10);
           internal_static_wallet_Wallet_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_wallet_Wallet_descriptor,
-              new java.lang.String[] { "NetworkIdentifier", "LastSeenBlockHash", "LastSeenBlockHeight", "LastSeenBlockTimeSecs", "Key", "Transaction", "EncryptionType", "EncryptionParameters", "Version", "Extension", "Description", "KeyRotationTime", });
+              new java.lang.String[] { "NetworkIdentifier", "LastSeenBlockHash", "LastSeenBlockHeight", "LastSeenBlockTimeSecs", "Key", "Transaction", "WatchedScript", "EncryptionType", "EncryptionParameters", "Version", "Extension", "Description", "KeyRotationTime", });
           return null;
         }
       };
diff --git a/core/src/test/java/com/google/bitcoin/core/BitcoindComparisonTool.java b/core/src/test/java/com/google/bitcoin/core/BitcoindComparisonTool.java
index d4c109f5..a1240d94 100644
--- a/core/src/test/java/com/google/bitcoin/core/BitcoindComparisonTool.java
+++ b/core/src/test/java/com/google/bitcoin/core/BitcoindComparisonTool.java
@@ -127,6 +127,11 @@ public class BitcoindComparisonTool {
                 return 1;
             }
 
+            @Override
+            public boolean isRequiringUpdateAllBloomFilter() {
+                return false;
+            }
+
             @Override public BloomFilter getBloomFilter(int size, double falsePositiveRate, long nTweak) {
                 BloomFilter filter = new BloomFilter(1, 0.99, 0);
                 filter.setMatchAll();
diff --git a/core/src/test/java/com/google/bitcoin/core/WalletTest.java b/core/src/test/java/com/google/bitcoin/core/WalletTest.java
index 2c750ec9..772cbca6 100644
--- a/core/src/test/java/com/google/bitcoin/core/WalletTest.java
+++ b/core/src/test/java/com/google/bitcoin/core/WalletTest.java
@@ -648,7 +648,7 @@ public class WalletTest extends TestWithWallet {
         assertEquals(send1, eventDead[0]);
         assertEquals(send2, eventReplacement[0]);
         assertEquals(TransactionConfidence.ConfidenceType.DEAD,
-                     send1.getConfidence().getConfidenceType());
+                send1.getConfidence().getConfidenceType());
         assertEquals(send2, received.getOutput(0).getSpentBy().getParentTransaction());
 
         TestUtils.DoubleSpends doubleSpends = TestUtils.createFakeDoubleSpendTxns(params, myAddress);
@@ -659,7 +659,7 @@ public class WalletTest extends TestWithWallet {
         sendMoneyToWallet(doubleSpends.t2, AbstractBlockChain.NewBlockType.BEST_CHAIN);
         Threading.waitForUserCode();
         assertEquals(TransactionConfidence.ConfidenceType.DEAD,
-                     doubleSpends.t1.getConfidence().getConfidenceType());
+                doubleSpends.t1.getConfidence().getConfidenceType());
         assertEquals(doubleSpends.t2, doubleSpends.t1.getConfidence().getOverridingTransaction());
         assertEquals(5, eventWalletChanged[0]);
     }
@@ -831,7 +831,7 @@ public class WalletTest extends TestWithWallet {
         // Check we got them back in order.
         List<Transaction> transactions = wallet.getTransactionsByTime();
         assertEquals(tx2, transactions.get(0));
-        assertEquals(tx1,  transactions.get(1));
+        assertEquals(tx1, transactions.get(1));
         assertEquals(2, transactions.size());
         // Check we get only the last transaction if we request a subrage.
         transactions = wallet.getRecentTransactions(1, false);
@@ -873,6 +873,20 @@ public class WalletTest extends TestWithWallet {
         assertEquals(now + 60, wallet.getEarliestKeyCreationTime());
     }
 
+    @Test
+    public void scriptCreationTime() throws Exception {
+        wallet = new Wallet(params);
+        long now = Utils.rollMockClock(0).getTime() / 1000;  // Fix the mock clock.
+        // No keys returns current time.
+        assertEquals(now, wallet.getEarliestKeyCreationTime());
+        Utils.rollMockClock(60);
+        wallet.addWatchedAddress(new ECKey().toAddress(params));
+
+        Utils.rollMockClock(60);
+        wallet.addKey(new ECKey());
+        assertEquals(now + 60, wallet.getEarliestKeyCreationTime());
+    }
+
     @Test
     public void spendToSameWallet() throws Exception {
         // Test that a spend to the same wallet is dealt with correctly.
@@ -950,6 +964,73 @@ public class WalletTest extends TestWithWallet {
         log.info(t2.toString(chain));
     }
 
+    @Test
+    public void watchingScripts() throws Exception {
+        // Verify that pending transactions to watched addresses are relevant
+        ECKey key = new ECKey();
+        Address watchedAddress = key.toAddress(params);
+        wallet.addWatchedAddress(watchedAddress);
+        BigInteger value = toNanoCoins(5, 0);
+        Transaction t1 = createFakeTx(params, value, watchedAddress);
+        assertTrue(wallet.isPendingTransactionRelevant(t1));
+    }
+
+    @Test
+    public void watchingScriptsConfirmed() throws Exception {
+        ECKey key = new ECKey();
+        Address watchedAddress = key.toAddress(params);
+        wallet.addWatchedAddress(watchedAddress);
+        Transaction t1 = createFakeTx(params, CENT, watchedAddress);
+        StoredBlock b3 = createFakeBlock(blockStore, t1).storedBlock;
+        wallet.receiveFromBlock(t1, b3, BlockChain.NewBlockType.BEST_CHAIN, 0);
+        assertEquals(BigInteger.ZERO, wallet.getBalance());
+        assertEquals(CENT, wallet.getWatchedBalance());
+
+        // We can't spend watched balances
+        Address notMyAddr = new ECKey().toAddress(params);
+        assertNull(wallet.createSend(notMyAddr, CENT));
+    }
+
+    @Test
+    public void watchingScriptsSentFrom() throws Exception {
+        ECKey key = new ECKey();
+        ECKey notMyAddr = new ECKey();
+        Address watchedAddress = key.toAddress(params);
+        wallet.addWatchedAddress(watchedAddress);
+        Transaction t1 = createFakeTx(params, CENT, watchedAddress);
+        Transaction t2 = createFakeTx(params, COIN, notMyAddr);
+        StoredBlock b1 = createFakeBlock(blockStore, t1).storedBlock;
+        Transaction st2 = new Transaction(params);
+        st2.addOutput(CENT, notMyAddr);
+        st2.addOutput(COIN, notMyAddr);
+        st2.addInput(t1.getOutput(0));
+        st2.addInput(t2.getOutput(0));
+        wallet.receiveFromBlock(t1, b1, BlockChain.NewBlockType.BEST_CHAIN, 0);
+        wallet.receiveFromBlock(st2, b1, BlockChain.NewBlockType.BEST_CHAIN, 0);
+        assertEquals(CENT, st2.getValueSentFromMe(wallet));
+    }
+
+    @Test
+    public void watchingScriptsBloomFilter() throws Exception {
+        assertFalse(wallet.isRequiringUpdateAllBloomFilter());
+
+        ECKey key = new ECKey();
+        Address watchedAddress = key.toAddress(params);
+        wallet.addWatchedAddress(watchedAddress);
+
+        assertTrue(wallet.isRequiringUpdateAllBloomFilter());
+        Transaction t1 = createFakeTx(params, CENT, watchedAddress);
+        StoredBlock b1 = createFakeBlock(blockStore, t1).storedBlock;
+
+        TransactionOutPoint outPoint = new TransactionOutPoint(params, 0, t1);
+
+        // Note that this has a 1e-12 chance of failing this unit test due to a false positive
+        assertFalse(wallet.getBloomFilter(1e-12).contains(outPoint.bitcoinSerialize()));
+
+        wallet.receiveFromBlock(t1, b1, BlockChain.NewBlockType.BEST_CHAIN, 0);
+        assertTrue(wallet.getBloomFilter(1e-12).contains(outPoint.bitcoinSerialize()));
+    }
+
     @Test
     public void autosaveImmediate() throws Exception {
         // Test that the wallet will save itself automatically when it changes.
diff --git a/core/src/test/java/com/google/bitcoin/store/WalletProtobufSerializerTest.java b/core/src/test/java/com/google/bitcoin/store/WalletProtobufSerializerTest.java
index f9be16db..d1b43c12 100644
--- a/core/src/test/java/com/google/bitcoin/store/WalletProtobufSerializerTest.java
+++ b/core/src/test/java/com/google/bitcoin/store/WalletProtobufSerializerTest.java
@@ -5,6 +5,7 @@ import com.google.bitcoin.core.*;
 import com.google.bitcoin.core.TransactionConfidence.ConfidenceType;
 import com.google.bitcoin.params.MainNetParams;
 import com.google.bitcoin.params.UnitTestParams;
+import com.google.bitcoin.script.ScriptBuilder;
 import com.google.bitcoin.utils.BriefLogFormatter;
 import com.google.bitcoin.utils.TestUtils;
 import com.google.bitcoin.utils.Threading;
@@ -18,6 +19,7 @@ import java.io.ByteArrayOutputStream;
 import java.math.BigInteger;
 import java.net.InetAddress;
 import java.util.ArrayList;
+import java.util.Date;
 import java.util.Iterator;
 import java.util.Set;
 
@@ -27,19 +29,24 @@ import static org.junit.Assert.*;
 public class WalletProtobufSerializerTest {
     static final NetworkParameters params = UnitTestParams.get();
     private ECKey myKey;
+    private ECKey myWatchedKey;
     private Address myAddress;
     private Wallet myWallet;
 
     public static String WALLET_DESCRIPTION  = "The quick brown fox lives in \u4f26\u6566"; // Beijing in Chinese
+    private long mScriptCreationTime;
 
     @Before
     public void setUp() throws Exception {
         BriefLogFormatter.initVerbose();
+        myWatchedKey = new ECKey();
         myKey = new ECKey();
         myKey.setCreationTimeSeconds(123456789L);
         myAddress = myKey.toAddress(params);
         myWallet = new Wallet(params);
         myWallet.addKey(myKey);
+        mScriptCreationTime = new Date().getTime() / 1000 - 1234;
+        myWallet.addWatchedAddress(myWatchedKey.toAddress(params), mScriptCreationTime);
         myWallet.setDescription(WALLET_DESCRIPTION);
     }
 
@@ -55,6 +62,11 @@ public class WalletProtobufSerializerTest {
                 wallet1.findKeyFromPubHash(myKey.getPubKeyHash()).getPrivKeyBytes());
         assertEquals(myKey.getCreationTimeSeconds(),
                 wallet1.findKeyFromPubHash(myKey.getPubKeyHash()).getCreationTimeSeconds());
+        assertEquals(mScriptCreationTime,
+                wallet1.getWatchedScripts().get(0).getCreationTimeSeconds());
+        assertEquals(1, wallet1.getWatchedScripts().size());
+        assertEquals(ScriptBuilder.createOutputScript(myWatchedKey.toAddress(params)),
+                wallet1.getWatchedScripts().get(0));
         assertEquals(WALLET_DESCRIPTION, wallet1.getDescription());
     }