Script (bitcoinj 0.14.7 API)

java.lang.Object
- org.bitcoinj.script.Script

```
public class Script
extends Object
```
Programs embedded inside transactions that control redemption of payments.

Bitcoin transactions don't specify what they do directly. Instead a small binary stack language is used to define programs that when evaluated return whether the transaction "accepts" or rejects the other transactions connected to it.

In SPV mode, scripts are not run, because that would require all transactions to be available and lightweight clients don't have that data. In full mode, this class is used to run the interpreted language. It also has static methods for building scripts.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Script.ScriptType` Enumeration to encapsulate the type of this script.
`static class`	`Script.VerifyFlag` Flags to pass to `correctlySpends(Transaction, long, Script, Set)`.

Field Summary

Fields
Modifier and Type	Field and Description
`static EnumSet<Script.VerifyFlag>`	`ALL_VERIFY_FLAGS`
`protected List<ScriptChunk>`	`chunks`
`static int`	`MAX_P2SH_SIGOPS` Max number of sigops allowed in a standard p2sh redeem script
`static long`	`MAX_SCRIPT_ELEMENT_SIZE`
`protected byte[]`	`program`
`static int`	`SIG_SIZE`

Constructor Summary

Constructors
Constructor and Description
`Script(byte[] programBytes)` Construct a Script that copies and wraps the programBytes array.
`Script(byte[] programBytes, long creationTimeSeconds)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`correctlySpends(Transaction txContainingThis, long scriptSigIndex, Script scriptPubKey)` Deprecated. Use `correctlySpends(org.bitcoinj.core.Transaction, long, org.bitcoinj.script.Script, java.util.Set)` instead so that verification flags do not change as new verification options are added.
`void`	`correctlySpends(Transaction txContainingThis, long scriptSigIndex, Script scriptPubKey, Set<Script.VerifyFlag> verifyFlags)` Verifies that this script (interpreted as a scriptSig) correctly spends the given scriptPubKey.
`Script`	`createEmptyInputScript(ECKey key, Script redeemScript)` Creates an incomplete scriptSig that, once filled with signatures, can redeem output containing this scriptPubKey.
`static byte[]`	`createInputScript(byte[] signature)`
`static byte[]`	`createInputScript(byte[] signature, byte[] pubkey)`
`static byte[]`	`createMultiSigOutputScript(int threshold, List<ECKey> pubkeys)` Creates a program that requires at least N of the given keys to sign, using OP_CHECKMULTISIG.
`boolean`	`equals(Object o)`
`static void`	`executeScript(Transaction txContainingThis, long index, Script script, LinkedList<byte[]> stack, boolean enforceNullDummy)` Deprecated. Use `executeScript(org.bitcoinj.core.Transaction, long, org.bitcoinj.script.Script, java.util.LinkedList, java.util.Set)` instead.
`static void`	`executeScript(Transaction txContainingThis, long index, Script script, LinkedList<byte[]> stack, Set<Script.VerifyFlag> verifyFlags)` Exposes the script interpreter.
`List<ScriptChunk>`	`getChunks()` Returns an immutable list of the scripts parsed form.
`BigInteger`	`getCLTVPaymentChannelExpiry()`
`byte[]`	`getCLTVPaymentChannelRecipientPubKey()` Retrieves the recipient public key from a LOCKTIMEVERIFY transaction
`byte[]`	`getCLTVPaymentChannelSenderPubKey()` Retrieves the sender public key from a LOCKTIMEVERIFY transaction
`long`	`getCreationTimeSeconds()`
`Address`	`getFromAddress(NetworkParameters params)` Deprecated.
`int`	`getNumberOfBytesRequiredToSpend(ECKey pubKey, Script redeemScript)` Returns number of bytes required to spend this script.
`int`	`getNumberOfSignaturesRequiredToSpend()` Returns number of signatures required to satisfy this script.
`static long`	`getP2SHSigOpCount(byte[] scriptSig)` Gets the count of P2SH Sig Ops in the Script scriptSig
`byte[]`	`getProgram()` Returns the serialized program as a newly created byte array.
`byte[]`	`getPubKey()` Returns the public key in this script.
`byte[]`	`getPubKeyHash()` If a program matches the standard template DUP HASH160 <pubkey hash> EQUALVERIFY CHECKSIG then this function retrieves the third element.
`List<ECKey>`	`getPubKeys()` Returns a list of the keys required by this script, assuming a multi-sig script.
`Script`	`getScriptSigWithSignature(Script scriptSig, byte[] sigBytes, int index)` Returns a copy of the given scriptSig with the signature inserted in the given position.
`Script.ScriptType`	`getScriptType()` Get the `Script.ScriptType`.
`int`	`getSigInsertionIndex(Sha256Hash hash, ECKey signingKey)` Returns the index where a signature by the key should be inserted.
`static int`	`getSigOpCount(byte[] program)` Gets the count of regular SigOps in the script program (counting multisig ops as 20)
`Address`	`getToAddress(NetworkParameters params)` Gets the destination address from this script, if it's in the required form (see getPubKey).
`Address`	`getToAddress(NetworkParameters params, boolean forcePayToPubKey)` Gets the destination address from this script, if it's in the required form (see getPubKey).
`int`	`hashCode()`
`boolean`	`isOpReturn()`
`boolean`	`isPayToScriptHash()` Whether or not this is a scriptPubKey representing a pay-to-script-hash output.
`boolean`	`isSentToAddress()` Returns true if this script is of the form DUP HASH160 EQUALVERIFY CHECKSIG, ie, payment to an address like 1VayNert3x1KzbpzMGt2qdqrAThiRovi8.
`boolean`	`isSentToCLTVPaymentChannel()`
`boolean`	`isSentToMultiSig()` Returns whether this script matches the format used for multisig outputs: [n] [keys...] [m] CHECKMULTISIG
`boolean`	`isSentToP2SH()` Deprecated.
`boolean`	`isSentToRawPubKey()` Returns true if this script is of the form OP_CHECKSIG.
`static byte[]`	`removeAllInstancesOf(byte[] inputScript, byte[] chunkToRemove)` Returns the script bytes of inputScript with all instances of the specified script object removed
`static byte[]`	`removeAllInstancesOfOp(byte[] inputScript, int opCode)` Returns the script bytes of inputScript with all instances of the given op code removed
`void`	`setCreationTimeSeconds(long creationTimeSeconds)`
`String`	`toString()` Returns the program opcodes as a string, for example "[1234] DUP HASH160"
`static void`	`writeBytes(OutputStream os, byte[] buf)` Writes out the given byte buffer to the output stream with the correct opcode prefix To write an integer call writeBytes(out, Utils.reverseBytes(Utils.encodeMPI(val, false)));

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - ALL_VERIFY_FLAGS
```
public static final EnumSet<Script.VerifyFlag> ALL_VERIFY_FLAGS
```
  - MAX_SCRIPT_ELEMENT_SIZE
```
public static final long MAX_SCRIPT_ELEMENT_SIZE
```
    See Also:
    
    Constant Field Values
  - SIG_SIZE
```
public static final int SIG_SIZE
```
    See Also:
    
    Constant Field Values
  - MAX_P2SH_SIGOPS
```
public static final int MAX_P2SH_SIGOPS
```
    Max number of sigops allowed in a standard p2sh redeem script
    
    See Also:
    
    Constant Field Values
  - chunks
```
protected List<ScriptChunk> chunks
```
  - program
```
protected byte[] program
```
- Constructor Detail
  - Script
```
public Script(byte[] programBytes)
       throws ScriptException
```
    Construct a Script that copies and wraps the programBytes array. The array is parsed and checked for syntactic validity.
    
    Parameters:
    
    programBytes - Array of program bytes from a transaction.
    
    Throws:
    
    ScriptException
  - Script
```
public Script(byte[] programBytes,
              long creationTimeSeconds)
       throws ScriptException
```
    Throws:
    
    ScriptException
- Method Detail
  - getCreationTimeSeconds
```
public long getCreationTimeSeconds()
```
  - setCreationTimeSeconds
```
public void setCreationTimeSeconds(long creationTimeSeconds)
```
  - toString
```
public String toString()
```
    Returns the program opcodes as a string, for example "[1234] DUP HASH160"
    
    Overrides:
    
    toString in class Object
  - getProgram
```
public byte[] getProgram()
```
    Returns the serialized program as a newly created byte array.
  - getChunks
```
public List<ScriptChunk> getChunks()
```
    Returns an immutable list of the scripts parsed form. Each chunk is either an opcode or data element.
  - isSentToRawPubKey
```
public boolean isSentToRawPubKey()
```
    Returns true if this script is of the form OP_CHECKSIG. This form was originally intended for transactions where the peers talked to each other directly via TCP/IP, but has fallen out of favor with time due to that mode of operation being susceptible to man-in-the-middle attacks. It is still used in coinbase outputs and can be useful more exotic types of transaction, but today most payments are to addresses.
  - isSentToAddress
```
public boolean isSentToAddress()
```
    Returns true if this script is of the form DUP HASH160 EQUALVERIFY CHECKSIG, ie, payment to an address like 1VayNert3x1KzbpzMGt2qdqrAThiRovi8. This form was originally intended for the case where you wish to send somebody money with a written code because their node is offline, but over time has become the standard way to make payments due to the short and recognizable base58 form addresses come in.
  - isSentToP2SH
```
@Deprecated
public boolean isSentToP2SH()
```
    Deprecated.
    
    An alias for isPayToScriptHash.
  - getPubKeyHash
```
public byte[] getPubKeyHash()
                     throws ScriptException
```
    If a program matches the standard template DUP HASH160 <pubkey hash> EQUALVERIFY CHECKSIG then this function retrieves the third element. In this case, this is useful for fetching the destination address of a transaction.
    
    If a program matches the standard template HASH160 <script hash> EQUAL then this function retrieves the second element. In this case, this is useful for fetching the hash of the redeem script of a transaction.
    
    Otherwise it throws a ScriptException.
    
    Throws:
    
    ScriptException
  - getPubKey
```
public byte[] getPubKey()
                 throws ScriptException
```
    Returns the public key in this script. If a script contains two constants and nothing else, it is assumed to be a scriptSig (input) for a pay-to-address output and the second constant is returned (the first is the signature). If a script contains a constant and an OP_CHECKSIG opcode, the constant is returned as it is assumed to be a direct pay-to-key scriptPubKey (output) and the first constant is the public key.
    
    Throws:
    
    ScriptException - if the script is none of the named forms.
  - getCLTVPaymentChannelSenderPubKey
```
public byte[] getCLTVPaymentChannelSenderPubKey()
                                         throws ScriptException
```
    Retrieves the sender public key from a LOCKTIMEVERIFY transaction
    
    Returns:
    
    Throws:
    
    ScriptException
  - getCLTVPaymentChannelRecipientPubKey
```
public byte[] getCLTVPaymentChannelRecipientPubKey()
                                            throws ScriptException
```
    Retrieves the recipient public key from a LOCKTIMEVERIFY transaction
    
    Returns:
    
    Throws:
    
    ScriptException
  - getCLTVPaymentChannelExpiry
```
public BigInteger getCLTVPaymentChannelExpiry()
```
  - getFromAddress
```
@Deprecated
public Address getFromAddress(NetworkParameters params)
                                   throws ScriptException
```
    Deprecated.
    
    For 2-element [input] scripts assumes that the paid-to-address can be derived from the public key. The concept of a "from address" isn't well defined in Bitcoin and you should not assume the sender of a transaction can actually receive coins on it. This method may be removed in future.
    
    Throws:
    
    ScriptException
  - getToAddress
```
public Address getToAddress(NetworkParameters params)
                     throws ScriptException
```
    Gets the destination address from this script, if it's in the required form (see getPubKey).
    
    Throws:
    
    ScriptException
  - getToAddress
```
public Address getToAddress(NetworkParameters params,
                            boolean forcePayToPubKey)
                     throws ScriptException
```
    Gets the destination address from this script, if it's in the required form (see getPubKey).
    
    Parameters:
    
    forcePayToPubKey - If true, allow payToPubKey to be casted to the corresponding address. This is useful if you prefer showing addresses rather than pubkeys.
    
    Throws:
    
    ScriptException
  - writeBytes
```
public static void writeBytes(OutputStream os,
                              byte[] buf)
                       throws IOException
```
    Writes out the given byte buffer to the output stream with the correct opcode prefix To write an integer call writeBytes(out, Utils.reverseBytes(Utils.encodeMPI(val, false)));
    
    Throws:
    
    IOException
  - createMultiSigOutputScript
```
public static byte[] createMultiSigOutputScript(int threshold,
                                                List<ECKey> pubkeys)
```
    Creates a program that requires at least N of the given keys to sign, using OP_CHECKMULTISIG.
  - createInputScript
```
public static byte[] createInputScript(byte[] signature,
                                       byte[] pubkey)
```
  - createInputScript
```
public static byte[] createInputScript(byte[] signature)
```
  - createEmptyInputScript
```
public Script createEmptyInputScript(@Nullable
                                     ECKey key,
                                     @Nullable
                                     Script redeemScript)
```
    Creates an incomplete scriptSig that, once filled with signatures, can redeem output containing this scriptPubKey. Instead of the signatures resulting script has OP_0. Having incomplete input script allows to pass around partially signed tx. It is expected that this program later on will be updated with proper signatures.
  - getScriptSigWithSignature
```
public Script getScriptSigWithSignature(Script scriptSig,
                                        byte[] sigBytes,
                                        int index)
```
    Returns a copy of the given scriptSig with the signature inserted in the given position.
  - getSigInsertionIndex
```
public int getSigInsertionIndex(Sha256Hash hash,
                                ECKey signingKey)
```
    Returns the index where a signature by the key should be inserted. Only applicable to a P2SH scriptSig.
  - getPubKeys
```
public List<ECKey> getPubKeys()
```
    Returns a list of the keys required by this script, assuming a multi-sig script.
    
    Throws:
    
    ScriptException - if the script type is not understood or is pay to address or is P2SH (run this method on the "Redeem script" instead).
  - getSigOpCount
```
public static int getSigOpCount(byte[] program)
                         throws ScriptException
```
    Gets the count of regular SigOps in the script program (counting multisig ops as 20)
    
    Throws:
    
    ScriptException
  - getP2SHSigOpCount
```
public static long getP2SHSigOpCount(byte[] scriptSig)
                              throws ScriptException
```
    Gets the count of P2SH Sig Ops in the Script scriptSig
    
    Throws:
    
    ScriptException
  - getNumberOfSignaturesRequiredToSpend
```
public int getNumberOfSignaturesRequiredToSpend()
```
    Returns number of signatures required to satisfy this script.
  - getNumberOfBytesRequiredToSpend
```
public int getNumberOfBytesRequiredToSpend(@Nullable
                                           ECKey pubKey,
                                           @Nullable
                                           Script redeemScript)
```
    Returns number of bytes required to spend this script. It accepts optional ECKey and redeemScript that may be required for certain types of script to estimate target size.
  - isPayToScriptHash
```
public boolean isPayToScriptHash()
```
    Whether or not this is a scriptPubKey representing a pay-to-script-hash output. In such outputs, the logic that controls reclamation is not actually in the output at all. Instead there's just a hash, and it's up to the spending input to provide a program matching that hash. This rule is "soft enforced" by the network as it does not exist in Bitcoin Core. It means blocks containing P2SH transactions that don't match correctly are considered valid, but won't be mined upon, so they'll be rapidly re-orgd out of the chain. This logic is defined by BIP 16.
    
    bitcoinj does not support creation of P2SH transactions today. The goal of P2SH is to allow short addresses even for complex scripts (eg, multi-sig outputs) so they are convenient to work with in things like QRcodes or with copy/paste, and also to minimize the size of the unspent output set (which improves performance of the Bitcoin system).
  - isSentToMultiSig
```
public boolean isSentToMultiSig()
```
    Returns whether this script matches the format used for multisig outputs: [n] [keys...] [m] CHECKMULTISIG
  - isSentToCLTVPaymentChannel
```
public boolean isSentToCLTVPaymentChannel()
```
  - removeAllInstancesOf
```
public static byte[] removeAllInstancesOf(byte[] inputScript,
                                          byte[] chunkToRemove)
```
    Returns the script bytes of inputScript with all instances of the specified script object removed
  - removeAllInstancesOfOp
```
public static byte[] removeAllInstancesOfOp(byte[] inputScript,
                                            int opCode)
```
    Returns the script bytes of inputScript with all instances of the given op code removed
  - isOpReturn
```
public boolean isOpReturn()
```
  - executeScript
```
@Deprecated
public static void executeScript(@Nullable
                                             Transaction txContainingThis,
                                             long index,
                                             Script script,
                                             LinkedList<byte[]> stack,
                                             boolean enforceNullDummy)
                                      throws ScriptException
```
    Deprecated. Use executeScript(org.bitcoinj.core.Transaction, long, org.bitcoinj.script.Script, java.util.LinkedList, java.util.Set) instead.
    
    Exposes the script interpreter. Normally you should not use this directly, instead use TransactionInput.verify(org.bitcoinj.core.TransactionOutput) or correctlySpends(org.bitcoinj.core.Transaction, long, Script). This method is useful if you need more precise control or access to the final state of the stack. This interface is very likely to change in future.
    
    Throws:
    
    ScriptException
  - executeScript
```
public static void executeScript(@Nullable
                                 Transaction txContainingThis,
                                 long index,
                                 Script script,
                                 LinkedList<byte[]> stack,
                                 Set<Script.VerifyFlag> verifyFlags)
                          throws ScriptException
```
    Exposes the script interpreter. Normally you should not use this directly, instead use TransactionInput.verify(org.bitcoinj.core.TransactionOutput) or correctlySpends(org.bitcoinj.core.Transaction, long, Script). This method is useful if you need more precise control or access to the final state of the stack. This interface is very likely to change in future.
    
    Throws:
    
    ScriptException
  - correctlySpends
```
@Deprecated
public void correctlySpends(Transaction txContainingThis,
                                        long scriptSigIndex,
                                        Script scriptPubKey)
                                 throws ScriptException
```
    Deprecated. Use correctlySpends(org.bitcoinj.core.Transaction, long, org.bitcoinj.script.Script, java.util.Set) instead so that verification flags do not change as new verification options are added.
    
    Verifies that this script (interpreted as a scriptSig) correctly spends the given scriptPubKey, enabling all validation rules.
    
    Parameters:
    
    txContainingThis - The transaction in which this input scriptSig resides. Accessing txContainingThis from another thread while this method runs results in undefined behavior.
    
    scriptSigIndex - The index in txContainingThis of the scriptSig (note: NOT the index of the scriptPubKey).
    
    scriptPubKey - The connected scriptPubKey containing the conditions needed to claim the value.
    
    Throws:
    
    ScriptException
  - correctlySpends
```
public void correctlySpends(Transaction txContainingThis,
                            long scriptSigIndex,
                            Script scriptPubKey,
                            Set<Script.VerifyFlag> verifyFlags)
                     throws ScriptException
```
    Verifies that this script (interpreted as a scriptSig) correctly spends the given scriptPubKey.
    
    Parameters:
    
    txContainingThis - The transaction in which this input scriptSig resides. Accessing txContainingThis from another thread while this method runs results in undefined behavior.
    
    scriptSigIndex - The index in txContainingThis of the scriptSig (note: NOT the index of the scriptPubKey).
    
    scriptPubKey - The connected scriptPubKey containing the conditions needed to claim the value.
    
    verifyFlags - Each flag enables one validation rule. If in doubt, use correctlySpends(Transaction, long, Script) which sets all flags.
    
    Throws:
    
    ScriptException
  - getScriptType
```
public Script.ScriptType getScriptType()
```
    Get the Script.ScriptType.
    
    Returns:
    
    The script type.
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object

Class Script

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ALL_VERIFY_FLAGS

MAX_SCRIPT_ELEMENT_SIZE

SIG_SIZE

MAX_P2SH_SIGOPS

chunks

program

Constructor Detail

Script

Script

Method Detail

getCreationTimeSeconds

setCreationTimeSeconds

toString

getProgram

getChunks

isSentToRawPubKey

isSentToAddress

isSentToP2SH

getPubKeyHash

getPubKey

getCLTVPaymentChannelSenderPubKey

getCLTVPaymentChannelRecipientPubKey

getCLTVPaymentChannelExpiry

getFromAddress

getToAddress

getToAddress

writeBytes

createMultiSigOutputScript

createInputScript

createInputScript

createEmptyInputScript

getScriptSigWithSignature

getSigInsertionIndex

getPubKeys

getSigOpCount

getP2SHSigOpCount

getNumberOfSignaturesRequiredToSpend

getNumberOfBytesRequiredToSpend

isPayToScriptHash

isSentToMultiSig

isSentToCLTVPaymentChannel

removeAllInstancesOf

removeAllInstancesOfOp

isOpReturn

executeScript

executeScript

correctlySpends

correctlySpends

getScriptType

equals

hashCode