Bitcoin.Script.Run

Bitcoin script interpreter

types

type Entry = ByteString

Stack entry

data InterpreterConfig

Constructors

Cfg

Fields

• _newTx :: !(Tx RawScript RawScript)

  the new tx we are running (containing the scriptSigs which are combined with the previous tx's pubKeyScripts)

• _curTxInIdx :: !Int

  the index of the current transaction input (within the new tx) we are checking

Instances

Show InterpreterConfig

Methods

showsPrec :: Int -> InterpreterConfig -> ShowS

show :: InterpreterConfig -> String

showList :: [InterpreterConfig] -> ShowS

data InterpreterState

Two stacks, an opcode stream (the latter necessary for the somewhat convoluted IF parsing, and also for OP_CHECKSIG)

Constructors

St

Fields

• _mainStack :: [Entry]

  the main stack

• _altStack :: [Entry]

  the alt stack

• _opcodeStream :: Stream

  the opcode stream

Instances

Show InterpreterState

Methods

showsPrec :: Int -> InterpreterState -> ShowS

show :: InterpreterState -> String

showList :: [InterpreterState] -> ShowS

type ScriptMonad a = ExceptT String (StateT InterpreterState (ReaderT InterpreterConfig Identity)) a

Interpreter monad

high level functions

checkTransaction :: forall a. Tx (Tx a RawScript, RawScript) RawScript -> Either String Bool

Given a transaction together with its inputs, we check if it is valid or not. This is done by combining the input scripts of this transaction with the output scripts of the previous transactions, and running the resulting scripts

If any of the scripts fails, the cause of failure is returned; if the scripts runs correctly, the result is returned (which should be True for valid transactions)

medium level functions

isDisabledOpcode :: Opcode -> Bool

initialState :: InterpreterState

Empty stacks, empty script

executeScript :: [Opcode] -> ScriptMonad ()

Executes a list of opcodes

runScriptPre :: InterpreterConfig -> InterpreterState -> Script -> (Either String (), InterpreterState)

Runs the scriptSig

runScriptFinal :: InterpreterConfig -> InterpreterState -> Script -> (Either String Bool, InterpreterState)

Runs the scriptPubKey

scriptStep :: ScriptMonad Bool

Execute a single (except in case of conditionals) opcode

"The stacks hold byte vectors. Byte vectors are interpreted as little-endian variable-length integers with the most significant bit determining the sign of the integer. Thus 0x81 represents -1. 0x80 is another representation of zero (so called negative 0). Byte vectors are interpreted as Booleans where False is represented by any representation of zero, and True is represented by any representation of non-zero."

Returns True if the script finished.

scriptStep' :: Opcode -> ScriptMonad ()

isFalse :: Entry -> Bool

isTrue :: Entry -> Bool

internal types

data Stream

An opcode stream consist of a zipper of opcodes, and a Context which describes (possibly recursively) what is on the left and right side of this zipper. This is used for executing (possibly nested) OP_IF blocks.

This may be overly complicated :)

Constructors

Stream

Fields

• _streamContext :: Context
• _streamZipper :: Zipper Opcode

Instances

Show Stream

Methods

showsPrec :: Int -> Stream -> ShowS

show :: Stream -> String

showList :: [Stream] -> ShowS

data Context

A context of opcodes and (nested) if blocks

Constructors

CtxEmpty

we are the full opcode stream

CtxHole Context [Opcode] IfType Hole [Opcode]

a hole has an outer context, opcodes on the left and right, and an if block in the middle

Instances

Show Context

Methods

showsPrec :: Int -> Context -> ShowS

show :: Context -> String

showList :: [Context] -> ShowS

data Hole

Constructors

HoleThen

we are in the "then" branch

Fields

• _elsePart :: Maybe [Opcode]

HoleElse

we are in the "else" branch (which may not physically exists - this is important when reconstructing)

Fields

• _thenPart :: [Opcode]
• _elseExists :: Bool

Instances

Show Hole

Methods

showsPrec :: Int -> Hole -> ShowS

show :: Hole -> String

showList :: [Hole] -> ShowS

data IfBranch

Constructors

IfBranch

"if-then"

ElseBranch

"else"

Instances

Eq IfBranch

Methods

(==) :: IfBranch -> IfBranch -> Bool

(/=) :: IfBranch -> IfBranch -> Bool

Show IfBranch

Methods

showsPrec :: Int -> IfBranch -> ShowS

show :: IfBranch -> String

showList :: [IfBranch] -> ShowS

data IfType

Constructors

If

OP_IF

NotIf

OP_NOTIF

Instances

Show IfType

Methods

showsPrec :: Int -> IfType -> ShowS

show :: IfType -> String

showList :: [IfType] -> ShowS

data IfBlock

Constructors

IfBlock

Fields

• _ifType :: IfType
• _ifBranch :: [Opcode]
• _elseBranch :: Maybe [Opcode]

Instances

Show IfBlock

Methods

showsPrec :: Int -> IfBlock -> ShowS

show :: IfBlock -> String

showList :: [IfBlock] -> ShowS

some internal functions

streamMoveRight :: Stream -> Either Stream (Opcode, Stream)

Even where there is nothing on the right, we can change the stream itself during the discovery of this fact!

fetchOpcode :: ScriptMonad (Maybe Opcode)

Fetches an opcode, possibly exiting the current context

fetchOpcodeWithinContext :: ScriptMonad (Maybe Opcode)

Fetches an opcode, but does not exit the current context

fetchIfBlock :: IfType -> IfBranch -> ScriptMonad IfBlock

We fetch an if block *and* take the given branch (second argument)

Note: if blocks can be nested...

reconstructIfBlock :: IfBlock -> [Opcode]

script monad

invalid :: String -> ScriptMonad a

getState :: ScriptMonad InterpreterState

putState :: InterpreterState -> ScriptMonad ()

push/pop

pushData :: Entry -> ScriptMonad ()

popData :: ScriptMonad Entry

pushAltData :: Entry -> ScriptMonad ()

popAltData :: ScriptMonad Entry

pushInteger :: Integer -> ScriptMonad ()

popInteger :: ScriptMonad Integer

pushBool :: Bool -> ScriptMonad ()

popBool :: ScriptMonad Bool

parsing (should be elsewhere)

parseTxScripts :: Tx RawScript RawScript -> Either String (Tx Script Script)

Tries to parse all scripts, both input and output. Since the output scripts can fail to parse (see below), this may also fail.

parseTxInScripts :: Tx RawScript a -> Either String (Tx Script a)

Tries to parse all input scripts. This shouldn't fail for a valid transaction.

parseTxOutScripts :: Tx a RawScript -> Either String (Tx a Script)

Tries to parse all output scripts. This may fail because invalid output scripts are allowed, just unspendable... :(

parseSingleTxOutScript :: Int -> Tx a RawScript -> Either String (Tx a (Either RawScript Script))

Parses only a single output script, leaves the rest (reason: tx validation shouldn't fail just because there are other invalid scripts in the prev tx unrelated to this one).