README

txscript

Build Status ISC License GoDoc

Package txscript implements the bitcoin transaction script language. There is a comprehensive test suite.

This package has intentionally been designed so it can be used as a standalone package for any projects needing to use or validate bitcoin transaction scripts.

Bitcoin Scripts

Bitcoin provides a stack-based, FORTH-like language for the scripts in the bitcoin transactions. This language is not turing complete although it is still fairly powerful. A description of the language can be found at https://en.bitcoin.it/wiki/Script

Installation and Updating

$ go get -u github.com/gcash/bchd/txscript

Examples

License

Package txscript is licensed under the copyfree ISC License.

Expand ▾ Collapse ▴

Documentation

Overview

Package txscript implements the bitcoin transaction script language.

A complete description of the script language used by bitcoin cash can be found at https://en.bitcoin.it/wiki/Script. The following only serves as a quick overview to provide information on how to use the package.

This package provides data structures and functions to parse and execute bitcoin transaction scripts.

Script Overview

Bitcoin Cash transaction scripts are written in a stack-base, FORTH-like language.

The bitcoin cash script language consists of a number of opcodes which fall into several categories such pushing and popping data to and from the stack, performing basic and bitwise arithmetic, conditional branching, comparing hashes, and checking cryptographic signatures. Scripts are processed from left to right and intentionally do not provide loops.

The vast majority of Bitcoin Cash scripts at the time of this writing are of several standard forms which consist of a spender providing a public key and a signature which proves the spender owns the associated private key. This information is used to prove the the spender is authorized to perform the transaction.

One benefit of using a scripting language is added flexibility in specifying what conditions must be met in order to spend bitcoins.

Errors

Errors returned by this package are of type txscript.Error. This allows the caller to programmatically determine the specific error by examining the ErrorCode field of the type asserted txscript.Error while still providing rich error messages with contextual information. A convenience function named IsErrorCode is also provided to allow callers to easily check for a specific error code. See ErrorCode in the package documentation for a full list.

Index

Examples

Constants

View Source
const (
	// MaxStackSize is the maximum combined height of stack and alt stack
	// during execution.
	MaxStackSize = 1000

	// MaxScriptSize is the maximum allowed length of a raw script.
	MaxScriptSize = 10000
)
View Source
const (
	OP_0                   = 0x00 // 0
	OP_FALSE               = 0x00 // 0 - AKA OP_0
	OP_DATA_1              = 0x01 // 1
	OP_DATA_2              = 0x02 // 2
	OP_DATA_3              = 0x03 // 3
	OP_DATA_4              = 0x04 // 4
	OP_DATA_5              = 0x05 // 5
	OP_DATA_6              = 0x06 // 6
	OP_DATA_7              = 0x07 // 7
	OP_DATA_8              = 0x08 // 8
	OP_DATA_9              = 0x09 // 9
	OP_DATA_10             = 0x0a // 10
	OP_DATA_11             = 0x0b // 11
	OP_DATA_12             = 0x0c // 12
	OP_DATA_13             = 0x0d // 13
	OP_DATA_14             = 0x0e // 14
	OP_DATA_15             = 0x0f // 15
	OP_DATA_16             = 0x10 // 16
	OP_DATA_17             = 0x11 // 17
	OP_DATA_18             = 0x12 // 18
	OP_DATA_19             = 0x13 // 19
	OP_DATA_20             = 0x14 // 20
	OP_DATA_21             = 0x15 // 21
	OP_DATA_22             = 0x16 // 22
	OP_DATA_23             = 0x17 // 23
	OP_DATA_24             = 0x18 // 24
	OP_DATA_25             = 0x19 // 25
	OP_DATA_26             = 0x1a // 26
	OP_DATA_27             = 0x1b // 27
	OP_DATA_28             = 0x1c // 28
	OP_DATA_29             = 0x1d // 29
	OP_DATA_30             = 0x1e // 30
	OP_DATA_31             = 0x1f // 31
	OP_DATA_32             = 0x20 // 32
	OP_DATA_33             = 0x21 // 33
	OP_DATA_34             = 0x22 // 34
	OP_DATA_35             = 0x23 // 35
	OP_DATA_36             = 0x24 // 36
	OP_DATA_37             = 0x25 // 37
	OP_DATA_38             = 0x26 // 38
	OP_DATA_39             = 0x27 // 39
	OP_DATA_40             = 0x28 // 40
	OP_DATA_41             = 0x29 // 41
	OP_DATA_42             = 0x2a // 42
	OP_DATA_43             = 0x2b // 43
	OP_DATA_44             = 0x2c // 44
	OP_DATA_45             = 0x2d // 45
	OP_DATA_46             = 0x2e // 46
	OP_DATA_47             = 0x2f // 47
	OP_DATA_48             = 0x30 // 48
	OP_DATA_49             = 0x31 // 49
	OP_DATA_50             = 0x32 // 50
	OP_DATA_51             = 0x33 // 51
	OP_DATA_52             = 0x34 // 52
	OP_DATA_53             = 0x35 // 53
	OP_DATA_54             = 0x36 // 54
	OP_DATA_55             = 0x37 // 55
	OP_DATA_56             = 0x38 // 56
	OP_DATA_57             = 0x39 // 57
	OP_DATA_58             = 0x3a // 58
	OP_DATA_59             = 0x3b // 59
	OP_DATA_60             = 0x3c // 60
	OP_DATA_61             = 0x3d // 61
	OP_DATA_62             = 0x3e // 62
	OP_DATA_63             = 0x3f // 63
	OP_DATA_64             = 0x40 // 64
	OP_DATA_65             = 0x41 // 65
	OP_DATA_66             = 0x42 // 66
	OP_DATA_67             = 0x43 // 67
	OP_DATA_68             = 0x44 // 68
	OP_DATA_69             = 0x45 // 69
	OP_DATA_70             = 0x46 // 70
	OP_DATA_71             = 0x47 // 71
	OP_DATA_72             = 0x48 // 72
	OP_DATA_73             = 0x49 // 73
	OP_DATA_74             = 0x4a // 74
	OP_DATA_75             = 0x4b // 75
	OP_PUSHDATA1           = 0x4c // 76
	OP_PUSHDATA2           = 0x4d // 77
	OP_PUSHDATA4           = 0x4e // 78
	OP_1NEGATE             = 0x4f // 79
	OP_RESERVED            = 0x50 // 80
	OP_1                   = 0x51 // 81 - AKA OP_TRUE
	OP_TRUE                = 0x51 // 81
	OP_2                   = 0x52 // 82
	OP_3                   = 0x53 // 83
	OP_4                   = 0x54 // 84
	OP_5                   = 0x55 // 85
	OP_6                   = 0x56 // 86
	OP_7                   = 0x57 // 87
	OP_8                   = 0x58 // 88
	OP_9                   = 0x59 // 89
	OP_10                  = 0x5a // 90
	OP_11                  = 0x5b // 91
	OP_12                  = 0x5c // 92
	OP_13                  = 0x5d // 93
	OP_14                  = 0x5e // 94
	OP_15                  = 0x5f // 95
	OP_16                  = 0x60 // 96
	OP_NOP                 = 0x61 // 97
	OP_VER                 = 0x62 // 98
	OP_IF                  = 0x63 // 99
	OP_NOTIF               = 0x64 // 100
	OP_VERIF               = 0x65 // 101
	OP_VERNOTIF            = 0x66 // 102
	OP_ELSE                = 0x67 // 103
	OP_ENDIF               = 0x68 // 104
	OP_VERIFY              = 0x69 // 105
	OP_RETURN              = 0x6a // 106
	OP_TOALTSTACK          = 0x6b // 107
	OP_FROMALTSTACK        = 0x6c // 108
	OP_2DROP               = 0x6d // 109
	OP_2DUP                = 0x6e // 110
	OP_3DUP                = 0x6f // 111
	OP_2OVER               = 0x70 // 112
	OP_2ROT                = 0x71 // 113
	OP_2SWAP               = 0x72 // 114
	OP_IFDUP               = 0x73 // 115
	OP_DEPTH               = 0x74 // 116
	OP_DROP                = 0x75 // 117
	OP_DUP                 = 0x76 // 118
	OP_NIP                 = 0x77 // 119
	OP_OVER                = 0x78 // 120
	OP_PICK                = 0x79 // 121
	OP_ROLL                = 0x7a // 122
	OP_ROT                 = 0x7b // 123
	OP_SWAP                = 0x7c // 124
	OP_TUCK                = 0x7d // 125
	OP_CAT                 = 0x7e // 126
	OP_SPLIT               = 0x7f // 127
	OP_NUM2BIN             = 0x80 // 128
	OP_BIN2NUM             = 0x81 // 129
	OP_SIZE                = 0x82 // 130
	OP_INVERT              = 0x83 // 131
	OP_AND                 = 0x84 // 132
	OP_OR                  = 0x85 // 133
	OP_XOR                 = 0x86 // 134
	OP_EQUAL               = 0x87 // 135
	OP_EQUALVERIFY         = 0x88 // 136
	OP_RESERVED1           = 0x89 // 137
	OP_RESERVED2           = 0x8a // 138
	OP_1ADD                = 0x8b // 139
	OP_1SUB                = 0x8c // 140
	OP_2MUL                = 0x8d // 141
	OP_2DIV                = 0x8e // 142
	OP_NEGATE              = 0x8f // 143
	OP_ABS                 = 0x90 // 144
	OP_NOT                 = 0x91 // 145
	OP_0NOTEQUAL           = 0x92 // 146
	OP_ADD                 = 0x93 // 147
	OP_SUB                 = 0x94 // 148
	OP_MUL                 = 0x95 // 149
	OP_DIV                 = 0x96 // 150
	OP_MOD                 = 0x97 // 151
	OP_LSHIFT              = 0x98 // 152
	OP_RSHIFT              = 0x99 // 153
	OP_BOOLAND             = 0x9a // 154
	OP_BOOLOR              = 0x9b // 155
	OP_NUMEQUAL            = 0x9c // 156
	OP_NUMEQUALVERIFY      = 0x9d // 157
	OP_NUMNOTEQUAL         = 0x9e // 158
	OP_LESSTHAN            = 0x9f // 159
	OP_GREATERTHAN         = 0xa0 // 160
	OP_LESSTHANOREQUAL     = 0xa1 // 161
	OP_GREATERTHANOREQUAL  = 0xa2 // 162
	OP_MIN                 = 0xa3 // 163
	OP_MAX                 = 0xa4 // 164
	OP_WITHIN              = 0xa5 // 165
	OP_RIPEMD160           = 0xa6 // 166
	OP_SHA1                = 0xa7 // 167
	OP_SHA256              = 0xa8 // 168
	OP_HASH160             = 0xa9 // 169
	OP_HASH256             = 0xaa // 170
	OP_CODESEPARATOR       = 0xab // 171
	OP_CHECKSIG            = 0xac // 172
	OP_CHECKSIGVERIFY      = 0xad // 173
	OP_CHECKMULTISIG       = 0xae // 174
	OP_CHECKMULTISIGVERIFY = 0xaf // 175
	OP_NOP1                = 0xb0 // 176
	OP_NOP2                = 0xb1 // 177
	OP_CHECKLOCKTIMEVERIFY = 0xb1 // 177 - AKA OP_NOP2
	OP_NOP3                = 0xb2 // 178
	OP_CHECKSEQUENCEVERIFY = 0xb2 // 178 - AKA OP_NOP3
	OP_NOP4                = 0xb3 // 179
	OP_NOP5                = 0xb4 // 180
	OP_NOP6                = 0xb5 // 181
	OP_NOP7                = 0xb6 // 182
	OP_NOP8                = 0xb7 // 183
	OP_NOP9                = 0xb8 // 184
	OP_NOP10               = 0xb9 // 185
	OP_CHECKDATASIG        = 0xba // 186
	OP_CHECKDATASIGVERIFY  = 0xbb // 187
	OP_REVERSEBYTES        = 0xbc // 188
	OP_UNKNOWN189          = 0xbd // 189
	OP_UNKNOWN190          = 0xbe // 190
	OP_UNKNOWN191          = 0xbf // 191
	OP_UNKNOWN192          = 0xc0 // 192
	OP_UNKNOWN193          = 0xc1 // 193
	OP_UNKNOWN194          = 0xc2 // 194
	OP_UNKNOWN195          = 0xc3 // 195
	OP_UNKNOWN196          = 0xc4 // 196
	OP_UNKNOWN197          = 0xc5 // 197
	OP_UNKNOWN198          = 0xc6 // 198
	OP_UNKNOWN199          = 0xc7 // 199
	OP_UNKNOWN200          = 0xc8 // 200
	OP_UNKNOWN201          = 0xc9 // 201
	OP_UNKNOWN202          = 0xca // 202
	OP_UNKNOWN203          = 0xcb // 203
	OP_UNKNOWN204          = 0xcc // 204
	OP_UNKNOWN205          = 0xcd // 205
	OP_UNKNOWN206          = 0xce // 206
	OP_UNKNOWN207          = 0xcf // 207
	OP_UNKNOWN208          = 0xd0 // 208
	OP_UNKNOWN209          = 0xd1 // 209
	OP_UNKNOWN210          = 0xd2 // 210
	OP_UNKNOWN211          = 0xd3 // 211
	OP_UNKNOWN212          = 0xd4 // 212
	OP_UNKNOWN213          = 0xd5 // 213
	OP_UNKNOWN214          = 0xd6 // 214
	OP_UNKNOWN215          = 0xd7 // 215
	OP_UNKNOWN216          = 0xd8 // 216
	OP_UNKNOWN217          = 0xd9 // 217
	OP_UNKNOWN218          = 0xda // 218
	OP_UNKNOWN219          = 0xdb // 219
	OP_UNKNOWN220          = 0xdc // 220
	OP_UNKNOWN221          = 0xdd // 221
	OP_UNKNOWN222          = 0xde // 222
	OP_UNKNOWN223          = 0xdf // 223
	OP_UNKNOWN224          = 0xe0 // 224
	OP_UNKNOWN225          = 0xe1 // 225
	OP_UNKNOWN226          = 0xe2 // 226
	OP_UNKNOWN227          = 0xe3 // 227
	OP_UNKNOWN228          = 0xe4 // 228
	OP_UNKNOWN229          = 0xe5 // 229
	OP_UNKNOWN230          = 0xe6 // 230
	OP_UNKNOWN231          = 0xe7 // 231
	OP_UNKNOWN232          = 0xe8 // 232
	OP_UNKNOWN233          = 0xe9 // 233
	OP_UNKNOWN234          = 0xea // 234
	OP_UNKNOWN235          = 0xeb // 235
	OP_UNKNOWN236          = 0xec // 236
	OP_UNKNOWN237          = 0xed // 237
	OP_UNKNOWN238          = 0xee // 238
	OP_UNKNOWN239          = 0xef // 239
	OP_UNKNOWN240          = 0xf0 // 240
	OP_UNKNOWN241          = 0xf1 // 241
	OP_UNKNOWN242          = 0xf2 // 242
	OP_UNKNOWN243          = 0xf3 // 243
	OP_UNKNOWN244          = 0xf4 // 244
	OP_UNKNOWN245          = 0xf5 // 245
	OP_UNKNOWN246          = 0xf6 // 246
	OP_UNKNOWN247          = 0xf7 // 247
	OP_UNKNOWN248          = 0xf8 // 248
	OP_UNKNOWN249          = 0xf9 // 249
	OP_SMALLINTEGER        = 0xfa // 250 - bitcoin core internal
	OP_PUBKEYS             = 0xfb // 251 - bitcoin core internal
	OP_UNKNOWN252          = 0xfc // 252
	OP_PUBKEYHASH          = 0xfd // 253 - bitcoin core internal
	OP_PUBKEY              = 0xfe // 254 - bitcoin core internal
	OP_INVALIDOPCODE       = 0xff // 255 - bitcoin core internal
)

    These constants are the values of the official opcodes used on the bch wiki, in bitcoin core and in most if not all other references and software related to handling BCH scripts.

    View Source
    const (
    	OpCondFalse = 0
    	OpCondTrue  = 1
    	OpCondSkip  = 2
    )

      Conditional execution constants.

      View Source
      const (
      	MaxOpsPerScript       = 201 // Max number of non-push operations.
      	MaxPubKeysPerMultiSig = 20  // Multisig can't have more sigs than this.
      	MaxScriptElementSize  = 520 // Max bytes pushable to the stack.
      )

        These are the constants specified for maximums in individual scripts.

        View Source
        const (
        	// MaxDataCarrierSize is the maximum number of bytes allowed in pushed
        	// data to be considered a nulldata transaction
        	MaxDataCarrierSize = 223
        
        	// StandardVerifyFlags are the script flags which are used when
        	// executing transaction scripts to enforce additional checks which
        	// are required for the script to be considered standard.  These checks
        	// help reduce issues related to transaction malleability as well as
        	// allow pay-to-script hash transactions.  Note these flags are
        	// different than what is required for the consensus rules in that they
        	// are more strict.
        	//
        	// TODO: This definition does not belong here.  It belongs in a policy
        	// package.
        	StandardVerifyFlags = ScriptBip16 |
        		ScriptVerifyDERSignatures |
        		ScriptVerifyStrictEncoding |
        		ScriptVerifyMinimalData |
        		ScriptStrictMultiSig |
        		ScriptDiscourageUpgradableNops |
        		ScriptVerifyCleanStack |
        		ScriptVerifyNullFail |
        		ScriptVerifyCheckLockTimeVerify |
        		ScriptVerifyCheckSequenceVerify |
        		ScriptVerifyLowS |
        		ScriptStrictMultiSig |
        		ScriptVerifyBip143SigHash |
        		ScriptVerifySigPushOnly |
        		ScriptVerifyCheckDataSig |
        		ScriptVerifySchnorr |
        		ScriptVerifySchnorrMultisig |
        		ScriptVerifyReverseBytes |
        		ScriptReportSigChecks |
        		ScriptVerifyInputSigChecks
        )
        View Source
        const (
        	// LockTimeThreshold is the number below which a lock time is
        	// interpreted to be a block number.  Since an average of one block
        	// is generated per 10 minutes, this allows blocks for about 9,512
        	// years.
        	LockTimeThreshold = 5e8 // Tue Nov 5 00:53:20 1985 UTC
        )

        Variables

        View Source
        var Bip16Activation = time.Unix(1333238400, 0)

          Bip16Activation is the timestamp where BIP0016 is valid to use in the blockchain. To be used to determine if BIP0016 should be called for or not. This timestamp corresponds to Sun Apr 1 00:00:00 UTC 2012.

          View Source
          var (
          	// ErrUnsupportedScriptType is an error returned when we attempt to
          	// parse/re-compute an output script into a PkScript struct.
          	ErrUnsupportedScriptType = errors.New("unsupported script type")
          )
          View Source
          var OpcodeByName = make(map[string]byte)

            OpcodeByName is a map that can be used to lookup an opcode by its human-readable name (OP_CHECKMULTISIG, OP_CHECKSIG, etc).

            Functions

            func CalcMultiSigStats

            func CalcMultiSigStats(script []byte) (int, int, error)

              CalcMultiSigStats returns the number of public keys and signatures from a multi-signature transaction script. The passed script MUST already be known to be a multi-signature script.

              func CalcSignatureHash

              func CalcSignatureHash(script []byte, sigHashes *TxSigHashes, hType SigHashType,
              	tx *wire.MsgTx, idx int, amt int64, useBip143SigHashAlgo bool) ([]byte, error)

                CalcSignatureHash returns a signature hash which can then be signed by the input. Since Bitcoin Cash uses a different signature hashing algorithm before and after the Uahf fork, the 'useBip143SigHashAlgo' bool is used to specify which algorithm to use.

                func DisableLog

                func DisableLog()

                  DisableLog disables all library log output. Logging output is disabled by default until UseLogger is called.

                  func DisasmString

                  func DisasmString(buf []byte) (string, error)

                    DisasmString formats a disassembled script for one line printing. When the script fails to parse, the returned string will contain the disassembled script up to the point the failure occurred along with the string '[error]' appended. In addition, the reason the script failed to parse is returned if the caller wants more information about the failure.

                    func ExtractDataElements

                    func ExtractDataElements(script []byte) ([][]byte, error)

                      ExtractDataElements returns a slice of all the data elements in the given script.

                      func ExtractRedeemScript

                      func ExtractRedeemScript(script []byte) ([]byte, error)

                        ExtractRedeemScript attempts to extract the redeem script from a signature script. In practice this amount to just returning the last popped element as we don't know for sure if it's a redeem script.

                        func IsErrorCode

                        func IsErrorCode(err error, c ErrorCode) bool

                          IsErrorCode returns whether or not the provided error is a script error with the provided error code.

                          func IsPayToScriptHash

                          func IsPayToScriptHash(script []byte) bool

                            IsPayToScriptHash returns true if the script is in the standard pay-to-script-hash (P2SH) format, false otherwise.

                            func IsPushOnlyScript

                            func IsPushOnlyScript(script []byte) bool

                              IsPushOnlyScript returns whether or not the passed script only pushes data.

                              False will be returned when the script does not parse.

                              func IsUnspendable

                              func IsUnspendable(pkScript []byte) bool

                                IsUnspendable returns whether the passed public key script is unspendable, or guaranteed to fail at execution. This allows outputs to be pruned instantly when entering the UTXO set.

                                func LegacySignatureScript

                                func LegacySignatureScript(tx *wire.MsgTx, idx int, subscript []byte,
                                	hashType SigHashType, privKey *bchec.PrivateKey, compress bool) ([]byte, error)

                                  LegacySignatureScript is the same as SignatureScript except it uses the legacy signature hashing algorithm.

                                  func LegacyTxInSignature

                                  func LegacyTxInSignature(tx *wire.MsgTx, idx int, subScript []byte,
                                  	hashType SigHashType, key *bchec.PrivateKey) ([]byte, error)

                                    LegacyTxInSignature generates a signature using the pre-uahf signature hashing algorithm

                                    func MultiSigScript

                                    func MultiSigScript(pubkeys []*bchutil.AddressPubKey, nrequired int) ([]byte, error)

                                      MultiSigScript returns a valid script for a multisignature redemption where nrequired of the keys in pubkeys are required to have signed the transaction for success. An Error with the error code ErrTooManyRequiredSigs will be returned if nrequired is larger than the number of keys provided.

                                      func NullDataScript

                                      func NullDataScript(data []byte) ([]byte, error)

                                        NullDataScript creates a provably-prunable script containing OP_RETURN followed by the passed data. An Error with the error code ErrTooMuchNullData will be returned if the length of the passed data exceeds MaxDataCarrierSize.

                                        func PayToAddrScript

                                        func PayToAddrScript(addr bchutil.Address) ([]byte, error)

                                          PayToAddrScript creates a new script to pay a transaction output to a the specified address.

                                          Example

                                            This example demonstrates creating a script which pays to a bitcoin address. It also prints the created script hex and uses the DisasmString function to display the disassembled script.

                                            Output:
                                            
                                            Script Hex: 76a914128004ff2fcaf13b2b91eb654b1dc2b674f7ec6188ac
                                            Script Disassembly: OP_DUP OP_HASH160 128004ff2fcaf13b2b91eb654b1dc2b674f7ec61 OP_EQUALVERIFY OP_CHECKSIG
                                            

                                            func PushedData

                                            func PushedData(script []byte) ([][]byte, error)

                                              PushedData returns an array of byte slices containing any pushed data found in the passed script. This includes OP_0, but not OP_1 - OP_16.

                                              func RawTxInECDSASignature

                                              func RawTxInECDSASignature(tx *wire.MsgTx, idx int, subScript []byte,
                                              	hashType SigHashType, key *bchec.PrivateKey, amt int64) ([]byte, error)

                                                RawTxInECDSASignature returns the serialized ECDSA signature for the input idx of the given transaction, with hashType appended to it.

                                                func RawTxInSchnorrSignature

                                                func RawTxInSchnorrSignature(tx *wire.MsgTx, idx int, subScript []byte,
                                                	hashType SigHashType, key *bchec.PrivateKey, amt int64) ([]byte, error)

                                                  RawTxInSchnorrSignature returns the serialized Schnorr signature for the input idx of the given transaction, with hashType appended to it.

                                                  func SignTxOutput

                                                  func SignTxOutput(chainParams *chaincfg.Params, tx *wire.MsgTx, idx int,
                                                  	amt int64, pkScript []byte, hashType SigHashType, kdb KeyDB, sdb ScriptDB,
                                                  	previousScript []byte) ([]byte, error)

                                                    SignTxOutput signs output idx of the given tx to resolve the script given in pkScript with a signature type of hashType. Any keys required will be looked up by calling getKey() with the string of the given address. Any pay-to-script-hash signatures will be similarly looked up by calling getScript. If previousScript is provided then the results in previousScript will be merged in a type-dependent manner with the newly generated. signature script.

                                                    Example

                                                      This example demonstrates manually creating and signing a redeem transaction.

                                                      Output:
                                                      
                                                      Transaction successfully signed
                                                      

                                                      func SignatureScript

                                                      func SignatureScript(tx *wire.MsgTx, idx int, amt int64, subscript []byte,
                                                      	hashType SigHashType, privKey *bchec.PrivateKey, compress bool) ([]byte, error)

                                                        SignatureScript creates an input signature script for tx to spend BCH sent from a previous output to the owner of privKey. tx must include all transaction inputs and outputs, however txin scripts are allowed to be filled or empty. The returned script is calculated to be used as the idx'th txin sigscript for tx. subscript is the PkScript of the previous output being used as the idx'th input. privKey is serialized in either a compressed or uncompressed format based on compress. This format must match the same format used to generate the payment address, or the script validation will fail.

                                                        func UseLogger

                                                        func UseLogger(logger bchlog.Logger)

                                                          UseLogger uses a specified Logger to output package logging info.

                                                          Types

                                                          type AtomicSwapDataPushes

                                                          type AtomicSwapDataPushes struct {
                                                          	RecipientHash160 [20]byte
                                                          	RefundHash160    [20]byte
                                                          	SecretHash       [32]byte
                                                          	SecretSize       int64
                                                          	LockTime         int64
                                                          }

                                                            AtomicSwapDataPushes houses the data pushes found in atomic swap contracts.

                                                            func ExtractAtomicSwapDataPushes

                                                            func ExtractAtomicSwapDataPushes(version uint16, pkScript []byte) (*AtomicSwapDataPushes, error)

                                                              ExtractAtomicSwapDataPushes returns the data pushes from an atomic swap contract. If the script is not an atomic swap contract, ExtractAtomicSwapDataPushes returns (nil, nil). Non-nil errors are returned for unparsable scripts.

                                                              NOTE: Atomic swaps are not considered standard script types by the dcrd mempool policy and should be used with P2SH. The atomic swap format is also expected to change to use a more secure hash function in the future.

                                                              This function is only defined in the txscript package due to API limitations which prevent callers using txscript to parse nonstandard scripts.

                                                              type Engine

                                                              type Engine struct {
                                                              	// contains filtered or unexported fields
                                                              }

                                                                Engine is the virtual machine that executes scripts.

                                                                func NewEngine

                                                                func NewEngine(scriptPubKey []byte, tx *wire.MsgTx, txIdx int, flags ScriptFlags,
                                                                	sigCache *SigCache, hashCache *TxSigHashes, inputAmount int64) (*Engine, error)

                                                                  NewEngine returns a new script engine for the provided public key script, transaction, and input index. The flags modify the behavior of the script engine according to the description provided by each flag.

                                                                  func (*Engine) CheckErrorCondition

                                                                  func (vm *Engine) CheckErrorCondition(finalScript bool) error

                                                                    CheckErrorCondition returns nil if the running script has ended and was successful, leaving a a true boolean on the stack. An error otherwise, including if the script has not finished.

                                                                    func (*Engine) Clone

                                                                    func (vm *Engine) Clone() *Engine

                                                                      Clone deep copies the state of the vm into a new instance and returns it.

                                                                      func (*Engine) DisasmPC

                                                                      func (vm *Engine) DisasmPC() (string, error)

                                                                        DisasmPC returns the string for the disassembly of the opcode that will be next to execute when Step() is called.

                                                                        func (*Engine) DisasmScript

                                                                        func (vm *Engine) DisasmScript(idx int) (string, error)

                                                                          DisasmScript returns the disassembly string for the script at the requested offset index. Index 0 is the signature script and 1 is the public key script.

                                                                          func (*Engine) Execute

                                                                          func (vm *Engine) Execute() (err error)

                                                                            Execute will execute all scripts in the script engine and return either nil for successful validation or an error if one occurred.

                                                                            func (*Engine) GetAltStack

                                                                            func (vm *Engine) GetAltStack() [][]byte

                                                                              GetAltStack returns the contents of the alternate stack as an array where the last item in the array is the top of the stack.

                                                                              func (*Engine) GetStack

                                                                              func (vm *Engine) GetStack() [][]byte

                                                                                GetStack returns the contents of the primary stack as an array. where the last item in the array is the top of the stack.

                                                                                func (*Engine) IsBranchExecuting

                                                                                func (vm *Engine) IsBranchExecuting() bool

                                                                                  IsBranchExecuting returns whether or not the current conditional branch is actively executing. For example, when the data stack has an OP_FALSE on it and an OP_IF is encountered, the branch is inactive until an OP_ELSE or OP_ENDIF is encountered. It properly handles nested conditionals.

                                                                                  func (*Engine) SetAltStack

                                                                                  func (vm *Engine) SetAltStack(data [][]byte)

                                                                                    SetAltStack sets the contents of the alternate stack to the contents of the provided array where the last item in the array will be the top of the stack.

                                                                                    func (*Engine) SetStack

                                                                                    func (vm *Engine) SetStack(data [][]byte)

                                                                                      SetStack sets the contents of the primary stack to the contents of the provided array where the last item in the array will be the top of the stack.

                                                                                      func (*Engine) SigChecks

                                                                                      func (vm *Engine) SigChecks() int

                                                                                        SigChecks returns the number of SigChecks accumulated during execution. Note this will return the number at the specific step the engine is currently on. If you want the total number of SigChecks this must be called after script execution has finished.

                                                                                        func (*Engine) Step

                                                                                        func (vm *Engine) Step() (done bool, err error)

                                                                                          Step will execute the next instruction and move the program counter to the next opcode in the script, or the next script if the current has ended. Step will return true in the case that the last opcode was successfully executed.

                                                                                          The result of calling Step or any other method is undefined if an error is returned.

                                                                                          type ErrScriptNotCanonical

                                                                                          type ErrScriptNotCanonical string

                                                                                            ErrScriptNotCanonical identifies a non-canonical script. The caller can use a type assertion to detect this error type.

                                                                                            func (ErrScriptNotCanonical) Error

                                                                                            func (e ErrScriptNotCanonical) Error() string

                                                                                              Error implements the error interface.

                                                                                              type Error

                                                                                              type Error struct {
                                                                                              	ErrorCode   ErrorCode
                                                                                              	Description string
                                                                                              }

                                                                                                Error identifies a script-related error. It is used to indicate three classes of errors: 1) Script execution failures due to violating one of the many requirements

                                                                                                imposed by the script engine or evaluating to false
                                                                                                

                                                                                                2) Improper API usage by callers 3) Internal consistency check failures

                                                                                                The caller can use type assertions on the returned errors to access the ErrorCode field to ascertain the specific reason for the error. As an additional convenience, the caller may make use of the IsErrorCode function to check for a specific error code.

                                                                                                func (Error) Error

                                                                                                func (e Error) Error() string

                                                                                                  Error satisfies the error interface and prints human-readable errors.

                                                                                                  type ErrorCode

                                                                                                  type ErrorCode int

                                                                                                    ErrorCode identifies a kind of script error.

                                                                                                    const (
                                                                                                    	// ErrInternal is returned if internal consistency checks fail.  In
                                                                                                    	// practice this error should never be seen as it would mean there is an
                                                                                                    	// error in the engine logic.
                                                                                                    	ErrInternal ErrorCode = iota
                                                                                                    
                                                                                                    	// ErrInvalidFlags is returned when the passed flags to NewEngine
                                                                                                    	// contain an invalid combination.
                                                                                                    	ErrInvalidFlags
                                                                                                    
                                                                                                    	// ErrInvalidIndex is returned when an out-of-bounds index is passed to
                                                                                                    	// a function.
                                                                                                    	ErrInvalidIndex
                                                                                                    
                                                                                                    	// ErrUnsupportedAddress is returned when a concrete type that
                                                                                                    	// implements a bchutil.Address is not a supported type.
                                                                                                    	ErrUnsupportedAddress
                                                                                                    
                                                                                                    	// ErrNotMultisigScript is returned from CalcMultiSigStats when the
                                                                                                    	// provided script is not a multisig script.
                                                                                                    	ErrNotMultisigScript
                                                                                                    
                                                                                                    	// ErrTooManyRequiredSigs is returned from MultiSigScript when the
                                                                                                    	// specified number of required signatures is larger than the number of
                                                                                                    	// provided public keys.
                                                                                                    	ErrTooManyRequiredSigs
                                                                                                    
                                                                                                    	// ErrTooMuchNullData is returned from NullDataScript when the length of
                                                                                                    	// the provided data exceeds MaxDataCarrierSize.
                                                                                                    	ErrTooMuchNullData
                                                                                                    
                                                                                                    	// ErrEarlyReturn is returned when OP_RETURN is executed in the script.
                                                                                                    	ErrEarlyReturn
                                                                                                    
                                                                                                    	// ErrEmptyStack is returned when the script evaluated without error,
                                                                                                    	// but terminated with an empty top stack element.
                                                                                                    	ErrEmptyStack
                                                                                                    
                                                                                                    	// ErrEvalFalse is returned when the script evaluated without error but
                                                                                                    	// terminated with a false top stack element.
                                                                                                    	ErrEvalFalse
                                                                                                    
                                                                                                    	// ErrScriptUnfinished is returned when CheckErrorCondition is called on
                                                                                                    	// a script that has not finished executing.
                                                                                                    	ErrScriptUnfinished
                                                                                                    
                                                                                                    	// ErrScriptDone is returned when an attempt to execute an opcode is
                                                                                                    	// made once all of them have already been executed.  This can happen
                                                                                                    	// due to things such as a second call to Execute or calling Step after
                                                                                                    	// all opcodes have already been executed.
                                                                                                    	ErrInvalidProgramCounter
                                                                                                    
                                                                                                    	// ErrScriptTooBig is returned if a script is larger than MaxScriptSize.
                                                                                                    	ErrScriptTooBig
                                                                                                    
                                                                                                    	// ErrElementTooBig is returned if the size of an element to be pushed
                                                                                                    	// to the stack is over MaxScriptElementSize.
                                                                                                    	ErrElementTooBig
                                                                                                    
                                                                                                    	// ErrTooManyOperations is returned if a script has more than
                                                                                                    	// MaxOpsPerScript opcodes that do not push data.
                                                                                                    	ErrTooManyOperations
                                                                                                    
                                                                                                    	// ErrStackOverflow is returned when stack and altstack combined depth
                                                                                                    	// is over the limit.
                                                                                                    	ErrStackOverflow
                                                                                                    
                                                                                                    	// ErrInvalidPubKeyCount is returned when the number of public keys
                                                                                                    	// specified for a multsig is either negative or greater than
                                                                                                    	// MaxPubKeysPerMultiSig.
                                                                                                    	ErrInvalidPubKeyCount
                                                                                                    
                                                                                                    	// ErrInvalidSignatureCount is returned when the number of signatures
                                                                                                    	// specified for a multisig is either negative or greater than the
                                                                                                    	// number of public keys.
                                                                                                    	ErrInvalidSignatureCount
                                                                                                    
                                                                                                    	// ErrNumberTooBig is returned when the argument for an opcode that
                                                                                                    	// expects numeric input is larger than the expected maximum number of
                                                                                                    	// bytes.  For the most part, opcodes that deal with stack manipulation
                                                                                                    	// via offsets, arithmetic, numeric comparison, and boolean logic are
                                                                                                    	// those that this applies to.  However, any opcode that expects numeric
                                                                                                    	// input may fail with this code.
                                                                                                    	ErrNumberTooBig
                                                                                                    
                                                                                                    	// ErrNumberTooSmall is returned when the argument for an opcode that
                                                                                                    	// expects numeric input is smaller than the expected maximum number of
                                                                                                    	// bytes.  For the most part, opcodes that deal with stack manipulation
                                                                                                    	// via offsets, arithmetic, numeric comparison, and boolean logic are
                                                                                                    	// those that this applies to.  However, any opcode that expects numeric
                                                                                                    	// input may fail with this code.
                                                                                                    	ErrNumberTooSmall
                                                                                                    
                                                                                                    	// ErrVerify is returned when OP_VERIFY is encountered in a script and
                                                                                                    	// the top item on the data stack does not evaluate to true.
                                                                                                    	ErrVerify
                                                                                                    
                                                                                                    	// ErrEqualVerify is returned when OP_EQUALVERIFY is encountered in a
                                                                                                    	// script and the top item on the data stack does not evaluate to true.
                                                                                                    	ErrEqualVerify
                                                                                                    
                                                                                                    	// ErrNumEqualVerify is returned when OP_NUMEQUALVERIFY is encountered
                                                                                                    	// in a script and the top item on the data stack does not evaluate to
                                                                                                    	// true.
                                                                                                    	ErrNumEqualVerify
                                                                                                    
                                                                                                    	// ErrCheckSigVerify is returned when OP_CHECKSIGVERIFY is encountered
                                                                                                    	// in a script and the top item on the data stack does not evaluate to
                                                                                                    	// true.
                                                                                                    	ErrCheckSigVerify
                                                                                                    
                                                                                                    	// ErrCheckSigVerify is returned when OP_CHECKMULTISIGVERIFY is
                                                                                                    	// encountered in a script and the top item on the data stack does not
                                                                                                    	// evaluate to true.
                                                                                                    	ErrCheckMultiSigVerify
                                                                                                    
                                                                                                    	// ErrCheckDataSigVerify is returned when OP_CHECKDATASIGVERIFY is
                                                                                                    	// encountered in a script and the top item on the data stack does not
                                                                                                    	// evaluate to true.
                                                                                                    	ErrCheckDataSigVerify
                                                                                                    
                                                                                                    	// ErrDisabledOpcode is returned when a disabled opcode is encountered
                                                                                                    	// in a script.
                                                                                                    	ErrDisabledOpcode
                                                                                                    
                                                                                                    	// ErrReservedOpcode is returned when an opcode marked as reserved
                                                                                                    	// is encountered in a script.
                                                                                                    	ErrReservedOpcode
                                                                                                    
                                                                                                    	// ErrMalformedPush is returned when a data push opcode tries to push
                                                                                                    	// more bytes than are left in the script.
                                                                                                    	ErrMalformedPush
                                                                                                    
                                                                                                    	// ErrInvalidStackOperation is returned when a stack operation is
                                                                                                    	// attempted with a number that is invalid for the current stack size.
                                                                                                    	ErrInvalidStackOperation
                                                                                                    
                                                                                                    	// ErrUnbalancedConditional is returned when an OP_ELSE or OP_ENDIF is
                                                                                                    	// encountered in a script without first having an OP_IF or OP_NOTIF or
                                                                                                    	// the end of script is reached without encountering an OP_ENDIF when
                                                                                                    	// an OP_IF or OP_NOTIF was previously encountered.
                                                                                                    	ErrUnbalancedConditional
                                                                                                    
                                                                                                    	// ErrInvalidInputLength is returned when an input to an opcode is not
                                                                                                    	// the correct length as required by that opcode.
                                                                                                    	ErrInvalidInputLength
                                                                                                    
                                                                                                    	// ErrMinimalData is returned when the ScriptVerifyMinimalData flag
                                                                                                    	// is set and the script contains push operations that do not use
                                                                                                    	// the minimal opcode required.
                                                                                                    	ErrMinimalData
                                                                                                    
                                                                                                    	// ErrMinimalIf is returned when the ScriptVerifyMinimalIf flag
                                                                                                    	// is set and the script contains an if or notif that does not use
                                                                                                    	// the minimal if encoding.
                                                                                                    	ErrMinimalIf
                                                                                                    
                                                                                                    	// ErrInvalidSigHashType is returned when a signature hash type is not
                                                                                                    	// one of the supported types.
                                                                                                    	ErrInvalidSigHashType
                                                                                                    
                                                                                                    	// ErrSigTooShort is returned when a signature that should be a
                                                                                                    	// canonically-encoded DER signature is too short.
                                                                                                    	ErrSigTooShort
                                                                                                    
                                                                                                    	// ErrSigTooLong is returned when a signature that should be a
                                                                                                    	// canonically-encoded DER signature is too long.
                                                                                                    	ErrSigTooLong
                                                                                                    
                                                                                                    	// ErrSigInvalidSeqID is returned when a signature that should be a
                                                                                                    	// canonically-encoded DER signature does not have the expected ASN.1
                                                                                                    	// sequence ID.
                                                                                                    	ErrSigInvalidSeqID
                                                                                                    
                                                                                                    	// ErrSigInvalidDataLen is returned a signature that should be a
                                                                                                    	// canonically-encoded DER signature does not specify the correct number
                                                                                                    	// of remaining bytes for the R and S portions.
                                                                                                    	ErrSigInvalidDataLen
                                                                                                    
                                                                                                    	// ErrSigMissingSTypeID is returned a signature that should be a
                                                                                                    	// canonically-encoded DER signature does not provide the ASN.1 type ID
                                                                                                    	// for S.
                                                                                                    	ErrSigMissingSTypeID
                                                                                                    
                                                                                                    	// ErrSigMissingSLen is returned when a signature that should be a
                                                                                                    	// canonically-encoded DER signature does not provide the length of S.
                                                                                                    	ErrSigMissingSLen
                                                                                                    
                                                                                                    	// ErrSigInvalidSLen is returned a signature that should be a
                                                                                                    	// canonically-encoded DER signature does not specify the correct number
                                                                                                    	// of bytes for the S portion.
                                                                                                    	ErrSigInvalidSLen
                                                                                                    
                                                                                                    	// ErrSigInvalidRIntID is returned when a signature that should be a
                                                                                                    	// canonically-encoded DER signature does not have the expected ASN.1
                                                                                                    	// integer ID for R.
                                                                                                    	ErrSigInvalidRIntID
                                                                                                    
                                                                                                    	// ErrSigZeroRLen is returned when a signature that should be a
                                                                                                    	// canonically-encoded DER signature has an R length of zero.
                                                                                                    	ErrSigZeroRLen
                                                                                                    
                                                                                                    	// ErrSigNegativeR is returned when a signature that should be a
                                                                                                    	// canonically-encoded DER signature has a negative value for R.
                                                                                                    	ErrSigNegativeR
                                                                                                    
                                                                                                    	// ErrSigTooMuchRPadding is returned when a signature that should be a
                                                                                                    	// canonically-encoded DER signature has too much padding for R.
                                                                                                    	ErrSigTooMuchRPadding
                                                                                                    
                                                                                                    	// ErrSigInvalidSIntID is returned when a signature that should be a
                                                                                                    	// canonically-encoded DER signature does not have the expected ASN.1
                                                                                                    	// integer ID for S.
                                                                                                    	ErrSigInvalidSIntID
                                                                                                    
                                                                                                    	// ErrSigZeroSLen is returned when a signature that should be a
                                                                                                    	// canonically-encoded DER signature has an S length of zero.
                                                                                                    	ErrSigZeroSLen
                                                                                                    
                                                                                                    	// ErrSigNegativeS is returned when a signature that should be a
                                                                                                    	// canonically-encoded DER signature has a negative value for S.
                                                                                                    	ErrSigNegativeS
                                                                                                    
                                                                                                    	// ErrSigTooMuchSPadding is returned when a signature that should be a
                                                                                                    	// canonically-encoded DER signature has too much padding for S.
                                                                                                    	ErrSigTooMuchSPadding
                                                                                                    
                                                                                                    	// ErrSigHighS is returned when the ScriptVerifyLowS flag is set and the
                                                                                                    	// script contains any signatures whose S values are higher than the
                                                                                                    	// half order.
                                                                                                    	ErrSigHighS
                                                                                                    
                                                                                                    	// ErrNotPushOnly is returned when a script that is required to only
                                                                                                    	// push data to the stack performs other operations.  A couple of cases
                                                                                                    	// where this applies is for a pay-to-script-hash signature script when
                                                                                                    	// bip16 is active and when the ScriptVerifySigPushOnly flag is set.
                                                                                                    	ErrNotPushOnly
                                                                                                    
                                                                                                    	// ErrSigNullDummy is returned when the ScriptStrictMultiSig flag is set
                                                                                                    	// and a multisig script has anything other than 0 for the extra dummy
                                                                                                    	// argument.
                                                                                                    	ErrSigNullDummy
                                                                                                    
                                                                                                    	// ErrPubKeyType is returned when the ScriptVerifyStrictEncoding
                                                                                                    	// flag is set and the script contains invalid public keys.
                                                                                                    	ErrPubKeyType
                                                                                                    
                                                                                                    	// ErrCleanStack is returned when the ScriptVerifyCleanStack flag
                                                                                                    	// is set, and after evalution, the stack does not contain only a
                                                                                                    	// single element.
                                                                                                    	ErrCleanStack
                                                                                                    
                                                                                                    	// ErrNullFail is returned when the ScriptVerifyNullFail flag is
                                                                                                    	// set and signatures are not empty on failed checksig or checkmultisig
                                                                                                    	// operations.
                                                                                                    	ErrNullFail
                                                                                                    
                                                                                                    	// ErrDiscourageUpgradableNOPs is returned when the
                                                                                                    	// ScriptDiscourageUpgradableNops flag is set and a NOP opcode is
                                                                                                    	// encountered in a script.
                                                                                                    	ErrDiscourageUpgradableNOPs
                                                                                                    
                                                                                                    	// ErrNegativeLockTime is returned when a script contains an opcode that
                                                                                                    	// interprets a negative lock time.
                                                                                                    	ErrNegativeLockTime
                                                                                                    
                                                                                                    	// ErrUnsatisfiedLockTime is returned when a script contains an opcode
                                                                                                    	// that involves a lock time and the required lock time has not been
                                                                                                    	// reached.
                                                                                                    	ErrUnsatisfiedLockTime
                                                                                                    
                                                                                                    	// ErrInvalidDummy is returned when the schnorr dummy element is not
                                                                                                    	// encoded correctly. For example, if it has more bytes than necessary
                                                                                                    	// to encode the selected pubkeys.
                                                                                                    	ErrInvalidDummy
                                                                                                    
                                                                                                    	// ErrInvalidBitCount is returned when the schnorr dummy element does
                                                                                                    	// not contain the correct number of bits.
                                                                                                    	ErrInvalidBitCount
                                                                                                    
                                                                                                    	// ErrInputSigChecks is returned when the script exceeds the maximum
                                                                                                    	// allowed signature density.
                                                                                                    	ErrInputSigChecks
                                                                                                    )

                                                                                                      These constants are used to identify a specific Error.

                                                                                                      func (ErrorCode) String

                                                                                                      func (e ErrorCode) String() string

                                                                                                        String returns the ErrorCode as a human-readable name.

                                                                                                        type HashCache

                                                                                                        type HashCache struct {
                                                                                                        	sync.RWMutex
                                                                                                        	// contains filtered or unexported fields
                                                                                                        }

                                                                                                          HashCache houses a set of partial sighashes keyed by txid. The set of partial sighashes are those introduced within BIP0143 by the new more efficient sighash digest calculation algorithm. Using this threadsafe shared cache, multiple goroutines can safely re-use the pre-computed partial sighashes speeding up validation time amongst all inputs found within a block.

                                                                                                          func NewHashCache

                                                                                                          func NewHashCache(maxSize uint) *HashCache

                                                                                                            NewHashCache returns a new instance of the HashCache given a maximum number of entries which may exist within it at anytime.

                                                                                                            func (*HashCache) AddSigHashes

                                                                                                            func (h *HashCache) AddSigHashes(tx *wire.MsgTx)

                                                                                                              AddSigHashes computes, then adds the partial sighashes for the passed transaction.

                                                                                                              func (*HashCache) ContainsHashes

                                                                                                              func (h *HashCache) ContainsHashes(txid *chainhash.Hash) bool

                                                                                                                ContainsHashes returns true if the partial sighashes for the passed transaction currently exist within the HashCache, and false otherwise.

                                                                                                                func (*HashCache) GetSigHashes

                                                                                                                func (h *HashCache) GetSigHashes(txid *chainhash.Hash) (*TxSigHashes, bool)

                                                                                                                  GetSigHashes possibly returns the previously cached partial sighashes for the passed transaction. This function also returns an additional boolean value indicating if the sighashes for the passed transaction were found to be present within the HashCache.

                                                                                                                  func (*HashCache) PurgeSigHashes

                                                                                                                  func (h *HashCache) PurgeSigHashes(txid *chainhash.Hash)

                                                                                                                    PurgeSigHashes removes all partial sighashes from the HashCache belonging to the passed transaction.

                                                                                                                    type KeyClosure

                                                                                                                    type KeyClosure func(bchutil.Address) (*bchec.PrivateKey, bool, error)

                                                                                                                      KeyClosure implements KeyDB with a closure.

                                                                                                                      func (KeyClosure) GetKey

                                                                                                                      func (kc KeyClosure) GetKey(address bchutil.Address) (*bchec.PrivateKey,
                                                                                                                      	bool, error)

                                                                                                                        GetKey implements KeyDB by returning the result of calling the closure.

                                                                                                                        type KeyDB

                                                                                                                        type KeyDB interface {
                                                                                                                        	GetKey(bchutil.Address) (*bchec.PrivateKey, bool, error)
                                                                                                                        }

                                                                                                                          KeyDB is an interface type provided to SignTxOutput, it encapsulates any user state required to get the private keys for an address.

                                                                                                                          type PkScript

                                                                                                                          type PkScript struct {
                                                                                                                          	// contains filtered or unexported fields
                                                                                                                          }

                                                                                                                            PkScript is a wrapper struct around a byte array, allowing it to be used as a map index.

                                                                                                                            func ComputePkScript

                                                                                                                            func ComputePkScript(sigScript []byte) (PkScript, error)

                                                                                                                              ComputePkScript computes the pkScript of an transaction output by looking at the transaction input's signature script.

                                                                                                                              NOTE: Only P2PKH, and P2SH redeem scripts are supported.

                                                                                                                              func ParsePkScript

                                                                                                                              func ParsePkScript(pkScript []byte, chainParams *chaincfg.Params) (PkScript, error)

                                                                                                                                ParsePkScript parses an output script into the PkScript struct. ErrUnsupportedScriptType is returned when attempting to parse an unsupported script type.

                                                                                                                                func (PkScript) Address

                                                                                                                                func (s PkScript) Address(chainParams *chaincfg.Params) (bchutil.Address, error)

                                                                                                                                  Address encodes the script into an address for the given chain.

                                                                                                                                  func (PkScript) Class

                                                                                                                                  func (s PkScript) Class() ScriptClass

                                                                                                                                    Class returns the script type.

                                                                                                                                    func (PkScript) Script

                                                                                                                                    func (s PkScript) Script() []byte

                                                                                                                                      Script returns the script as a byte slice without any padding.

                                                                                                                                      func (PkScript) String

                                                                                                                                      func (s PkScript) String() string

                                                                                                                                        String returns a hex-encoded string representation of the script.

                                                                                                                                        type ScriptBuilder

                                                                                                                                        type ScriptBuilder struct {
                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                        }

                                                                                                                                          ScriptBuilder provides a facility for building custom scripts. It allows you to push opcodes, ints, and data while respecting canonical encoding. In general it does not ensure the script will execute correctly, however any data pushes which would exceed the maximum allowed script engine limits and are therefore guaranteed not to execute will not be pushed and will result in the Script function returning an error.

                                                                                                                                          For example, the following would build a 2-of-3 multisig script for usage in a pay-to-script-hash (although in this situation MultiSigScript() would be a better choice to generate the script):

                                                                                                                                          builder := txscript.NewScriptBuilder()
                                                                                                                                          builder.AddOp(txscript.OP_2).AddData(pubKey1).AddData(pubKey2)
                                                                                                                                          builder.AddData(pubKey3).AddOp(txscript.OP_3)
                                                                                                                                          builder.AddOp(txscript.OP_CHECKMULTISIG)
                                                                                                                                          script, err := builder.Script()
                                                                                                                                          if err != nil {
                                                                                                                                          	// Handle the error.
                                                                                                                                          	return
                                                                                                                                          }
                                                                                                                                          fmt.Printf("Final multi-sig script: %x\n", script)
                                                                                                                                          

                                                                                                                                          func NewScriptBuilder

                                                                                                                                          func NewScriptBuilder() *ScriptBuilder

                                                                                                                                            NewScriptBuilder returns a new instance of a script builder. See ScriptBuilder for details.

                                                                                                                                            func (*ScriptBuilder) AddData

                                                                                                                                            func (b *ScriptBuilder) AddData(data []byte) *ScriptBuilder

                                                                                                                                              AddData pushes the passed data to the end of the script. It automatically chooses canonical opcodes depending on the length of the data. A zero length buffer will lead to a push of empty data onto the stack (OP_0) and any push of data greater than MaxScriptElementSize will not modify the script since that is not allowed by the script engine. Also, the script will not be modified if pushing the data would cause the script to exceed the maximum allowed script engine size.

                                                                                                                                              func (*ScriptBuilder) AddFullData

                                                                                                                                              func (b *ScriptBuilder) AddFullData(data []byte) *ScriptBuilder

                                                                                                                                                AddFullData should not typically be used by ordinary users as it does not include the checks which prevent data pushes larger than the maximum allowed sizes which leads to scripts that can't be executed. This is provided for testing purposes such as regression tests where sizes are intentionally made larger than allowed.

                                                                                                                                                Use AddData instead.

                                                                                                                                                func (*ScriptBuilder) AddInt64

                                                                                                                                                func (b *ScriptBuilder) AddInt64(val int64) *ScriptBuilder

                                                                                                                                                  AddInt64 pushes the passed integer to the end of the script. The script will not be modified if pushing the data would cause the script to exceed the maximum allowed script engine size.

                                                                                                                                                  func (*ScriptBuilder) AddOp

                                                                                                                                                  func (b *ScriptBuilder) AddOp(opcode byte) *ScriptBuilder

                                                                                                                                                    AddOp pushes the passed opcode to the end of the script. The script will not be modified if pushing the opcode would cause the script to exceed the maximum allowed script engine size.

                                                                                                                                                    func (*ScriptBuilder) AddOps

                                                                                                                                                    func (b *ScriptBuilder) AddOps(opcodes []byte) *ScriptBuilder

                                                                                                                                                      AddOps pushes the passed opcodes to the end of the script. The script will not be modified if pushing the opcodes would cause the script to exceed the maximum allowed script engine size.

                                                                                                                                                      func (*ScriptBuilder) Reset

                                                                                                                                                      func (b *ScriptBuilder) Reset() *ScriptBuilder

                                                                                                                                                        Reset resets the script so it has no content.

                                                                                                                                                        func (*ScriptBuilder) Script

                                                                                                                                                        func (b *ScriptBuilder) Script() ([]byte, error)

                                                                                                                                                          Script returns the currently built script. When any errors occurred while building the script, the script will be returned up the point of the first error along with the error.

                                                                                                                                                          type ScriptClass

                                                                                                                                                          type ScriptClass byte

                                                                                                                                                            ScriptClass is an enumeration for the list of standard types of script.

                                                                                                                                                            const (
                                                                                                                                                            	NonStandardTy ScriptClass = iota // None of the recognized forms.
                                                                                                                                                            	PubKeyTy                         // Pay pubkey.
                                                                                                                                                            	PubKeyHashTy                     // Pay pubkey hash.
                                                                                                                                                            	ScriptHashTy                     // Pay to script hash.
                                                                                                                                                            	MultiSigTy                       // Multi signature.
                                                                                                                                                            	NullDataTy                       // Empty data-only (provably prunable).
                                                                                                                                                            )

                                                                                                                                                              Classes of script payment known about in the blockchain.

                                                                                                                                                              func ExtractPkScriptAddrs

                                                                                                                                                              func ExtractPkScriptAddrs(pkScript []byte, chainParams *chaincfg.Params) (ScriptClass, []bchutil.Address, int, error)

                                                                                                                                                                ExtractPkScriptAddrs returns the type of script, addresses and required signatures associated with the passed PkScript. Note that it only works for 'standard' transaction script types. Any data such as public keys which are invalid are omitted from the results.

                                                                                                                                                                Example

                                                                                                                                                                  This example demonstrates extracting information from a standard public key script.

                                                                                                                                                                  Output:
                                                                                                                                                                  
                                                                                                                                                                  Script Class: pubkeyhash
                                                                                                                                                                  Addresses: [qqfgqp8l9l90zwetj84k2jcac2m8falvvydrpuu45u]
                                                                                                                                                                  Required Signatures: 1
                                                                                                                                                                  

                                                                                                                                                                  func GetScriptClass

                                                                                                                                                                  func GetScriptClass(script []byte) ScriptClass

                                                                                                                                                                    GetScriptClass returns the class of the script passed.

                                                                                                                                                                    NonStandardTy will be returned when the script does not parse.

                                                                                                                                                                    func (ScriptClass) String

                                                                                                                                                                    func (t ScriptClass) String() string

                                                                                                                                                                      String implements the Stringer interface by returning the name of the enum script class. If the enum is invalid then "Invalid" will be returned.

                                                                                                                                                                      type ScriptClosure

                                                                                                                                                                      type ScriptClosure func(bchutil.Address) ([]byte, error)

                                                                                                                                                                        ScriptClosure implements ScriptDB with a closure.

                                                                                                                                                                        func (ScriptClosure) GetScript

                                                                                                                                                                        func (sc ScriptClosure) GetScript(address bchutil.Address) ([]byte, error)

                                                                                                                                                                          GetScript implements ScriptDB by returning the result of calling the closure.

                                                                                                                                                                          type ScriptDB

                                                                                                                                                                          type ScriptDB interface {
                                                                                                                                                                          	GetScript(bchutil.Address) ([]byte, error)
                                                                                                                                                                          }

                                                                                                                                                                            ScriptDB is an interface type provided to SignTxOutput, it encapsulates any user state required to get the scripts for an pay-to-script-hash address.

                                                                                                                                                                            type ScriptFlags

                                                                                                                                                                            type ScriptFlags uint32

                                                                                                                                                                              ScriptFlags is a bitmask defining additional operations or tests that will be done when executing a script pair.

                                                                                                                                                                              const (
                                                                                                                                                                              	// ScriptBip16 defines whether the bip16 threshold has passed and thus
                                                                                                                                                                              	// pay-to-script hash transactions will be fully validated.
                                                                                                                                                                              	ScriptBip16 ScriptFlags = 1 << iota
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptStrictMultiSig defines whether to verify the stack item
                                                                                                                                                                              	// used by CHECKMULTISIG is zero length.
                                                                                                                                                                              	ScriptStrictMultiSig
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptDiscourageUpgradableNops defines whether to verify that
                                                                                                                                                                              	// NOP1 through NOP10 are reserved for future soft-fork upgrades.  This
                                                                                                                                                                              	// flag must not be used for consensus critical code nor applied to
                                                                                                                                                                              	// blocks as this flag is only for stricter standard transaction
                                                                                                                                                                              	// checks.  This flag is only applied when the above opcodes are
                                                                                                                                                                              	// executed.
                                                                                                                                                                              	ScriptDiscourageUpgradableNops
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifyCheckLockTimeVerify defines whether to verify that
                                                                                                                                                                              	// a transaction output is spendable based on the locktime.
                                                                                                                                                                              	// This is BIP0065.
                                                                                                                                                                              	ScriptVerifyCheckLockTimeVerify
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifyCheckSequenceVerify defines whether to allow execution
                                                                                                                                                                              	// pathways of a script to be restricted based on the age of the output
                                                                                                                                                                              	// being spent.  This is BIP0112.
                                                                                                                                                                              	ScriptVerifyCheckSequenceVerify
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifyCleanStack defines that the stack must contain only
                                                                                                                                                                              	// one stack element after evaluation and that the element must be
                                                                                                                                                                              	// true if interpreted as a boolean.  This is rule 6 of BIP0062.
                                                                                                                                                                              	// This flag should never be used without the ScriptBip16 flag nor the
                                                                                                                                                                              	// ScriptVerifyWitness flag.
                                                                                                                                                                              	ScriptVerifyCleanStack
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifyDERSignatures defines that signatures are required
                                                                                                                                                                              	// to compily with the DER format.
                                                                                                                                                                              	ScriptVerifyDERSignatures
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifyLowS defines that signtures are required to comply with
                                                                                                                                                                              	// the DER format and whose S value is <= order / 2.  This is rule 5
                                                                                                                                                                              	// of BIP0062.
                                                                                                                                                                              	ScriptVerifyLowS
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifyMinimalData defines that signatures must use the smallest
                                                                                                                                                                              	// push operator. This is both rules 3 and 4 of BIP0062.
                                                                                                                                                                              	ScriptVerifyMinimalData
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifyMinimalIf requires the argument of OP_IF/NOTIF to be exactly
                                                                                                                                                                              	// 0x01 or empty vector
                                                                                                                                                                              	ScriptVerifyMinimalIf
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifyNullFail defines that signatures must be empty if
                                                                                                                                                                              	// a CHECKSIG or CHECKMULTISIG operation fails.
                                                                                                                                                                              	ScriptVerifyNullFail
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifySigPushOnly defines that signature scripts must contain
                                                                                                                                                                              	// only pushed data.  This is rule 2 of BIP0062.
                                                                                                                                                                              	ScriptVerifySigPushOnly
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifyStrictEncoding defines that signature scripts and
                                                                                                                                                                              	// public keys must follow the strict encoding requirements.
                                                                                                                                                                              	ScriptVerifyStrictEncoding
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifyCompressedPubkey defines that public keys must be in the
                                                                                                                                                                              	// compressed format.
                                                                                                                                                                              	ScriptVerifyCompressedPubkey
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifyBip143SigHash defines that signature hashes should
                                                                                                                                                                              	// be calculated using the bip0143 signature hashing algorithm.
                                                                                                                                                                              	ScriptVerifyBip143SigHash
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifyCheckDataSig enables verification of the OP_CHECKDATASIG
                                                                                                                                                                              	// OP_CHECKDATASIGVERIFY opcodes. Without this flag the opcodes will
                                                                                                                                                                              	// behave as if they are disabled.
                                                                                                                                                                              	ScriptVerifyCheckDataSig
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifySchnorr enables verification of schnorr signatures,
                                                                                                                                                                              	// in addition to ECDSA signatures, in OP_CHECKSIG, OP_CHECKSIGVEERIFY,
                                                                                                                                                                              	// OP_CHECKDATASIG, and OP_CHECKDATASIGVERIFY.
                                                                                                                                                                              	ScriptVerifySchnorr
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifyAllowSegwitRecovery enables an exemption to
                                                                                                                                                                              	// ScriptVerifyCleanStack which allows certain outputs to be exempted
                                                                                                                                                                              	// from the rule in order to allow users who accidentally sent funds to
                                                                                                                                                                              	// segwit addresses to recover them.
                                                                                                                                                                              	ScriptVerifyAllowSegwitRecovery
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifySchnorrMultisig enables the use of schnorr signatures
                                                                                                                                                                              	// with OP_CHECKMULTISIG. When active the dummy element signals the
                                                                                                                                                                              	// use of schnorr or ECDSA.
                                                                                                                                                                              	ScriptVerifySchnorrMultisig
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptReportSigChecks is used to signal that the sig checks reported
                                                                                                                                                                              	// by the vm need to be checked against the consensus rules.
                                                                                                                                                                              	ScriptReportSigChecks
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifyInputSigChecks verifies that the sig check density in
                                                                                                                                                                              	// the input script is less than the max.
                                                                                                                                                                              	ScriptVerifyInputSigChecks
                                                                                                                                                                              
                                                                                                                                                                              	// ScriptVerifyReverseBytes enables the use of OP_REVERSEBYTES in the
                                                                                                                                                                              	// script.
                                                                                                                                                                              	ScriptVerifyReverseBytes
                                                                                                                                                                              )

                                                                                                                                                                              func (ScriptFlags) HasFlag

                                                                                                                                                                              func (scriptFlags ScriptFlags) HasFlag(flag ScriptFlags) bool

                                                                                                                                                                                HasFlag returns whether the ScriptFlags has the passed flag set.

                                                                                                                                                                                type ScriptInfo

                                                                                                                                                                                type ScriptInfo struct {
                                                                                                                                                                                	// PkScriptClass is the class of the public key script and is equivalent
                                                                                                                                                                                	// to calling GetScriptClass on it.
                                                                                                                                                                                	PkScriptClass ScriptClass
                                                                                                                                                                                
                                                                                                                                                                                	// NumInputs is the number of inputs provided by the public key script.
                                                                                                                                                                                	NumInputs int
                                                                                                                                                                                
                                                                                                                                                                                	// ExpectedInputs is the number of outputs required by the signature
                                                                                                                                                                                	// script and any pay-to-script-hash scripts. The number will be -1 if
                                                                                                                                                                                	// unknown.
                                                                                                                                                                                	ExpectedInputs int
                                                                                                                                                                                }

                                                                                                                                                                                  ScriptInfo houses information about a script pair that is determined by CalcScriptInfo.

                                                                                                                                                                                  func CalcScriptInfo

                                                                                                                                                                                  func CalcScriptInfo(sigScript, pkScript []byte, scriptFlags ScriptFlags) (*ScriptInfo, error)

                                                                                                                                                                                    CalcScriptInfo returns a structure providing data about the provided script pair. It will error if the pair is in someway invalid such that they can not be analysed, i.e. if they do not parse or the pkScript is not a push-only script

                                                                                                                                                                                    type SigCache

                                                                                                                                                                                    type SigCache struct {
                                                                                                                                                                                    	sync.RWMutex
                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                    }

                                                                                                                                                                                      SigCache implements an ECDSA signature verification cache with a randomized entry eviction policy. Only valid signatures will be added to the cache. The benefits of SigCache are two fold. Firstly, usage of SigCache mitigates a DoS attack wherein an attack causes a victim's client to hang due to worst-case behavior triggered while processing attacker crafted invalid transactions. A detailed description of the mitigated DoS attack can be found here: https://bitslog.wordpress.com/2013/01/23/fixed-bitcoin-vulnerability-explanation-why-the-signature-cache-is-a-dos-protection/. Secondly, usage of the SigCache introduces a signature verification optimization which speeds up the validation of transactions within a block, if they've already been seen and verified within the mempool.

                                                                                                                                                                                      func NewSigCache

                                                                                                                                                                                      func NewSigCache(maxEntries uint) *SigCache

                                                                                                                                                                                        NewSigCache creates and initializes a new instance of SigCache. Its sole parameter 'maxEntries' represents the maximum number of entries allowed to exist in the SigCache at any particular moment. Random entries are evicted to make room for new entries that would cause the number of entries in the cache to exceed the max.

                                                                                                                                                                                        func (*SigCache) Add

                                                                                                                                                                                        func (s *SigCache) Add(sigHash chainhash.Hash, sig *bchec.Signature, pubKey *bchec.PublicKey)

                                                                                                                                                                                          Add adds an entry for a signature over 'sigHash' under public key 'pubKey' to the signature cache. In the event that the SigCache is 'full', an existing entry is randomly chosen to be evicted in order to make space for the new entry.

                                                                                                                                                                                          NOTE: This function is safe for concurrent access. Writers will block simultaneous readers until function execution has concluded.

                                                                                                                                                                                          func (*SigCache) Exists

                                                                                                                                                                                          func (s *SigCache) Exists(sigHash chainhash.Hash, sig *bchec.Signature, pubKey *bchec.PublicKey) bool

                                                                                                                                                                                            Exists returns true if an existing entry of 'sig' over 'sigHash' for public key 'pubKey' is found within the SigCache. Otherwise, false is returned.

                                                                                                                                                                                            NOTE: This function is safe for concurrent access. Readers won't be blocked unless there exists a writer, adding an entry to the SigCache.

                                                                                                                                                                                            type SigHashType

                                                                                                                                                                                            type SigHashType uint32

                                                                                                                                                                                              SigHashType represents hash type bits at the end of a signature.

                                                                                                                                                                                              const (
                                                                                                                                                                                              	SigHashOld          SigHashType = 0x0
                                                                                                                                                                                              	SigHashAll          SigHashType = 0x1
                                                                                                                                                                                              	SigHashNone         SigHashType = 0x2
                                                                                                                                                                                              	SigHashSingle       SigHashType = 0x3
                                                                                                                                                                                              	SigHashAnyOneCanPay SigHashType = 0x80
                                                                                                                                                                                              
                                                                                                                                                                                              	// SigHashForkID is the replay protected signature hash flag
                                                                                                                                                                                              	// used by the Uahf hardfork.
                                                                                                                                                                                              	SigHashForkID SigHashType = 0x40
                                                                                                                                                                                              )

                                                                                                                                                                                                Hash type bits from the end of a signature.

                                                                                                                                                                                                type TxSigHashes

                                                                                                                                                                                                type TxSigHashes struct {
                                                                                                                                                                                                	HashPrevOuts chainhash.Hash
                                                                                                                                                                                                	HashSequence chainhash.Hash
                                                                                                                                                                                                	HashOutputs  chainhash.Hash
                                                                                                                                                                                                }

                                                                                                                                                                                                  TxSigHashes houses the partial set of sighashes introduced within BIP0143. This partial set of sighashes may be re-used within each input across a transaction when validating all inputs. As a result, validation complexity for SigHashAll can be reduced by a polynomial factor.

                                                                                                                                                                                                  func NewTxSigHashes

                                                                                                                                                                                                  func NewTxSigHashes(tx *wire.MsgTx) *TxSigHashes

                                                                                                                                                                                                    NewTxSigHashes computes, and returns the cached sighashes of the given transaction.