diff --git a/txscript/engine.go b/txscript/engine.go
index 0f0000c5..5fa26f5e 100644
--- a/txscript/engine.go
+++ b/txscript/engine.go
@@ -84,8 +84,8 @@ type Engine struct {
 	scriptIdx       int
 	scriptOff       int
 	lastcodesep     int
-	dstack          Stack // data stack
-	astack          Stack // alt stack
+	dstack          stack // data stack
+	astack          stack // alt stack
 	tx              wire.MsgTx
 	txIdx           int
 	condStack       []int
@@ -444,7 +444,7 @@ func (vm *Engine) checkSignatureEncoding(sig []byte) error {
 }
 
 // getStack returns the contents of stack as a byte array bottom up
-func getStack(stack *Stack) [][]byte {
+func getStack(stack *stack) [][]byte {
 	array := make([][]byte, stack.Depth())
 	for i := range array {
 		// PeekByteArry can't fail due to overflow, already checked
@@ -455,7 +455,7 @@ func getStack(stack *Stack) [][]byte {
 
 // setStack sets the stack to the contents of the array where the last item in
 // the array is the top item in the stack.
-func setStack(stack *Stack, data [][]byte) {
+func setStack(stack *stack, data [][]byte) {
 	// This can not error. Only errors are for invalid arguments.
 	_ = stack.DropN(stack.Depth())
 
diff --git a/txscript/stack.go b/txscript/stack.go
index 6e096c56..6f4c67e6 100644
--- a/txscript/stack.go
+++ b/txscript/stack.go
@@ -96,17 +96,18 @@ func fromBool(v bool) []byte {
 	return []byte{0}
 }
 
-// Stack represents a stack of immutable objects to be used with bitcoin scripts
-// Objects may be shared,  therefore in usage if a value is to be changed it
-// *must* be deep-copied first to avoid changing other values on the stack.
-type Stack struct {
+// stack represents a stack of immutable objects to be used with bitcoin
+// scripts.  Objects may be shared, therefore in usage if a value is to be
+// changed it *must* be deep-copied first to avoid changing other values on the
+// stack.
+type stack struct {
 	stk               [][]byte
 	verifyMinimalData bool
 }
 
 // checkMinimalData returns whether or not the passed byte array adheres to
 // the minimal encoding requirements, if enabled.
-func (s *Stack) checkMinimalData(so []byte) error {
+func (s *stack) checkMinimalData(so []byte) error {
 	if !s.verifyMinimalData || len(so) == 0 {
 		return nil
 	}
@@ -131,30 +132,30 @@ func (s *Stack) checkMinimalData(so []byte) error {
 }
 
 // PushByteArray adds the given back array to the top of the stack.
-func (s *Stack) PushByteArray(so []byte) {
+func (s *stack) PushByteArray(so []byte) {
 	s.stk = append(s.stk, so)
 }
 
 // PushInt converts the provided bignum to a suitable byte array then pushes
 // it onto the top of the stack.
-func (s *Stack) PushInt(val *big.Int) {
+func (s *stack) PushInt(val *big.Int) {
 	s.PushByteArray(fromInt(val))
 }
 
 // PushBool converts the provided boolean to a suitable byte array then pushes
 // it onto the top of the stack.
-func (s *Stack) PushBool(val bool) {
+func (s *stack) PushBool(val bool) {
 	s.PushByteArray(fromBool(val))
 }
 
 // PopByteArray pops the value off the top of the stack and returns it.
-func (s *Stack) PopByteArray() ([]byte, error) {
+func (s *stack) PopByteArray() ([]byte, error) {
 	return s.nipN(0)
 }
 
 // PopInt pops the value off the top of the stack, converts it into a bignum and
 // returns it.
-func (s *Stack) PopInt() (*big.Int, error) {
+func (s *stack) PopInt() (*big.Int, error) {
 	so, err := s.PopByteArray()
 	if err != nil {
 		return nil, err
@@ -169,7 +170,7 @@ func (s *Stack) PopInt() (*big.Int, error) {
 
 // PopBool pops the value off the top of the stack, converts it into a bool and
 // returns it.
-func (s *Stack) PopBool() (bool, error) {
+func (s *stack) PopBool() (bool, error) {
 	so, err := s.PopByteArray()
 	if err != nil {
 		return false, err
@@ -178,7 +179,7 @@ func (s *Stack) PopBool() (bool, error) {
 }
 
 // PeekByteArray returns the nth item on the stack without removing it.
-func (s *Stack) PeekByteArray(idx int) (so []byte, err error) {
+func (s *stack) PeekByteArray(idx int) (so []byte, err error) {
 	sz := len(s.stk)
 	if idx < 0 || idx >= sz {
 		return nil, ErrStackUnderflow
@@ -187,7 +188,7 @@ func (s *Stack) PeekByteArray(idx int) (so []byte, err error) {
 }
 
 // PeekInt returns the nth item on the stack as a bignum without removing it.
-func (s *Stack) PeekInt(idx int) (i *big.Int, err error) {
+func (s *stack) PeekInt(idx int) (i *big.Int, err error) {
 	so, err := s.PeekByteArray(idx)
 	if err != nil {
 		return nil, err
@@ -201,7 +202,7 @@ func (s *Stack) PeekInt(idx int) (i *big.Int, err error) {
 }
 
 // PeekBool returns the nth item on the stack as a bool without removing it.
-func (s *Stack) PeekBool(idx int) (i bool, err error) {
+func (s *stack) PeekBool(idx int) (i bool, err error) {
 	so, err := s.PeekByteArray(idx)
 	if err != nil {
 		return false, err
@@ -211,7 +212,7 @@ func (s *Stack) PeekBool(idx int) (i bool, err error) {
 
 // nipN is an internal function that removes the nth item on the stack and
 // returns it.
-func (s *Stack) nipN(idx int) (so []byte, err error) {
+func (s *stack) nipN(idx int) (so []byte, err error) {
 	sz := len(s.stk)
 	if idx < 0 || idx > sz-1 {
 		err = ErrStackUnderflow
@@ -233,14 +234,14 @@ func (s *Stack) nipN(idx int) (so []byte, err error) {
 }
 
 // NipN removes the Nth object on the stack
-func (s *Stack) NipN(idx int) error {
+func (s *stack) NipN(idx int) error {
 	_, err := s.nipN(idx)
 	return err
 }
 
 // Tuck copies the item at the top of the stack and inserts it before the 2nd
 // to top item. e.g.: 2,1 -> 2,1,2
-func (s *Stack) Tuck() error {
+func (s *stack) Tuck() error {
 	so2, err := s.PopByteArray()
 	if err != nil {
 		return err
@@ -257,7 +258,7 @@ func (s *Stack) Tuck() error {
 }
 
 // Depth returns the number of items on the stack.
-func (s *Stack) Depth() (sz int) {
+func (s *stack) Depth() (sz int) {
 	sz = len(s.stk)
 	return
 }
@@ -266,7 +267,7 @@ func (s *Stack) Depth() (sz int) {
 // e.g.
 // DropN(1): 1,2,3 -> 1,2
 // DropN(2): 1,2,3 -> 1
-func (s *Stack) DropN(n int) error {
+func (s *stack) DropN(n int) error {
 	if n < 1 {
 		return ErrStackInvalidArgs
 	}
@@ -283,7 +284,7 @@ func (s *Stack) DropN(n int) error {
 // e.g.
 // DupN(1): 1,2,3 -> 1,2,3,3
 // DupN(2): 1,2,3 -> 1,2,3,2,3
-func (s *Stack) DupN(n int) error {
+func (s *stack) DupN(n int) error {
 	if n < 1 {
 		return ErrStackInvalidArgs
 	}
@@ -303,7 +304,7 @@ func (s *Stack) DupN(n int) error {
 // RotN rotates the top 3N items on the stack to the left
 // e.g.
 // RotN(1): 1,2,3 -> 2,3,1
-func (s *Stack) RotN(n int) error {
+func (s *stack) RotN(n int) error {
 	if n < 1 {
 		return ErrStackInvalidArgs
 	}
@@ -325,7 +326,7 @@ func (s *Stack) RotN(n int) error {
 // E.g.:
 // SwapN(1): 1,2 -> 2,1
 // SwapN(2): 1,2,3,4 -> 3,4,1,2
-func (s *Stack) SwapN(n int) error {
+func (s *stack) SwapN(n int) error {
 	if n < 1 {
 		return ErrStackInvalidArgs
 	}
@@ -346,7 +347,7 @@ func (s *Stack) SwapN(n int) error {
 // e.g.:
 // OverN(1): 1,2 -> 1,2,1
 // OverN(2): 1,2,3,4 -> 1,2,3,4,1,2
-func (s *Stack) OverN(n int) error {
+func (s *stack) OverN(n int) error {
 	if n < 1 {
 		return ErrStackInvalidArgs
 	}
@@ -368,7 +369,7 @@ func (s *Stack) OverN(n int) error {
 // e.g.:
 // PickN(1): 1,2,3 -> 1,2,3,2
 // PickN(2): 1,2,3 -> 1,2,3,1
-func (s *Stack) PickN(n int) error {
+func (s *stack) PickN(n int) error {
 	so, err := s.PeekByteArray(n)
 	if err != nil {
 		return err
@@ -383,7 +384,7 @@ func (s *Stack) PickN(n int) error {
 // e.g.:
 // RollN(1): 1,2,3 -> 1,3,2
 // RollN(2): 1,2,3 -> 2,3,1
-func (s *Stack) RollN(n int) error {
+func (s *stack) RollN(n int) error {
 	so, err := s.nipN(n)
 	if err != nil {
 		return err
@@ -395,7 +396,7 @@ func (s *Stack) RollN(n int) error {
 }
 
 // String returns the stack in a readable format.
-func (s *Stack) String() string {
+func (s *stack) String() string {
 	var result string
 
 	for _, stack := range s.stk {
diff --git a/txscript/stack_test.go b/txscript/stack_test.go
index 63dab488..96edd5e5 100644
--- a/txscript/stack_test.go
+++ b/txscript/stack_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package txscript_test
+package txscript
 
 import (
 	"bytes"
@@ -10,8 +10,6 @@ import (
 	"fmt"
 	"math/big"
 	"testing"
-
-	"github.com/btcsuite/btcd/txscript"
 )
 
 // TestStack tests that all of the stack operations work as expected.
@@ -21,14 +19,14 @@ func TestStack(t *testing.T) {
 	tests := []struct {
 		name           string
 		before         [][]byte
-		operation      func(*txscript.Stack) error
+		operation      func(*stack) error
 		expectedReturn error
 		after          [][]byte
 	}{
 		{
 			"noop",
 			[][]byte{{1}, {2}, {3}, {4}, {5}},
-			func(stack *txscript.Stack) error {
+			func(s *stack) error {
 				return nil
 			},
 			nil,
@@ -37,43 +35,43 @@ func TestStack(t *testing.T) {
 		{
 			"peek underflow (byte)",
 			[][]byte{{1}, {2}, {3}, {4}, {5}},
-			func(stack *txscript.Stack) error {
-				_, err := stack.PeekByteArray(5)
+			func(s *stack) error {
+				_, err := s.PeekByteArray(5)
 				return err
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{},
 		},
 		{
 			"peek underflow (int)",
 			[][]byte{{1}, {2}, {3}, {4}, {5}},
-			func(stack *txscript.Stack) error {
-				_, err := stack.PeekInt(5)
+			func(s *stack) error {
+				_, err := s.PeekInt(5)
 				return err
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{},
 		},
 		{
 			"peek underflow (bool)",
 			[][]byte{{1}, {2}, {3}, {4}, {5}},
-			func(stack *txscript.Stack) error {
-				_, err := stack.PeekBool(5)
+			func(s *stack) error {
+				_, err := s.PeekBool(5)
 				return err
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{},
 		},
 		{
 			"pop",
 			[][]byte{{1}, {2}, {3}, {4}, {5}},
-			func(stack *txscript.Stack) error {
-				val, err := stack.PopByteArray()
+			func(s *stack) error {
+				val, err := s.PopByteArray()
 				if err != nil {
 					return err
 				}
 				if !bytes.Equal(val, []byte{5}) {
-					return errors.New("not equal!")
+					return errors.New("not equal")
 				}
 				return err
 			},
@@ -83,13 +81,13 @@ func TestStack(t *testing.T) {
 		{
 			"pop",
 			[][]byte{{1}, {2}, {3}, {4}, {5}},
-			func(stack *txscript.Stack) error {
-				val, err := stack.PopByteArray()
+			func(s *stack) error {
+				val, err := s.PopByteArray()
 				if err != nil {
 					return err
 				}
 				if !bytes.Equal(val, []byte{5}) {
-					return errors.New("not equal!")
+					return errors.New("not equal")
 				}
 				return err
 			},
@@ -99,9 +97,9 @@ func TestStack(t *testing.T) {
 		{
 			"pop everything",
 			[][]byte{{1}, {2}, {3}, {4}, {5}},
-			func(stack *txscript.Stack) error {
+			func(s *stack) error {
 				for i := 0; i < 5; i++ {
-					_, err := stack.PopByteArray()
+					_, err := s.PopByteArray()
 					if err != nil {
 						return err
 					}
@@ -114,23 +112,23 @@ func TestStack(t *testing.T) {
 		{
 			"pop underflow",
 			[][]byte{{1}, {2}, {3}, {4}, {5}},
-			func(stack *txscript.Stack) error {
+			func(s *stack) error {
 				for i := 0; i < 6; i++ {
-					_, err := stack.PopByteArray()
+					_, err := s.PopByteArray()
 					if err != nil {
 						return err
 					}
 				}
 				return nil
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{},
 		},
 		{
 			"pop bool",
 			[][]byte{{0}},
-			func(stack *txscript.Stack) error {
-				val, err := stack.PopBool()
+			func(s *stack) error {
+				val, err := s.PopBool()
 				if err != nil {
 					return err
 				}
@@ -146,8 +144,8 @@ func TestStack(t *testing.T) {
 		{
 			"pop bool",
 			[][]byte{{1}},
-			func(stack *txscript.Stack) error {
-				val, err := stack.PopBool()
+			func(s *stack) error {
+				val, err := s.PopBool()
 				if err != nil {
 					return err
 				}
@@ -163,22 +161,22 @@ func TestStack(t *testing.T) {
 		{
 			"pop bool",
 			[][]byte{},
-			func(stack *txscript.Stack) error {
-				_, err := stack.PopBool()
+			func(s *stack) error {
+				_, err := s.PopBool()
 				if err != nil {
 					return err
 				}
 
 				return nil
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{},
 		},
 		{
 			"popInt 0",
 			[][]byte{{0x0}},
-			func(stack *txscript.Stack) error {
-				v, err := stack.PopInt()
+			func(s *stack) error {
+				v, err := s.PopInt()
 				if err != nil {
 					return err
 				}
@@ -193,8 +191,8 @@ func TestStack(t *testing.T) {
 		{
 			"popInt -0",
 			[][]byte{{0x80}},
-			func(stack *txscript.Stack) error {
-				v, err := stack.PopInt()
+			func(s *stack) error {
+				v, err := s.PopInt()
 				if err != nil {
 					return err
 				}
@@ -209,8 +207,8 @@ func TestStack(t *testing.T) {
 		{
 			"popInt 1",
 			[][]byte{{0x01}},
-			func(stack *txscript.Stack) error {
-				v, err := stack.PopInt()
+			func(s *stack) error {
+				v, err := s.PopInt()
 				if err != nil {
 					return err
 				}
@@ -225,8 +223,8 @@ func TestStack(t *testing.T) {
 		{
 			"popInt 1 leading 0",
 			[][]byte{{0x01, 0x00, 0x00, 0x00}},
-			func(stack *txscript.Stack) error {
-				v, err := stack.PopInt()
+			func(s *stack) error {
+				v, err := s.PopInt()
 				if err != nil {
 					return err
 				}
@@ -242,8 +240,8 @@ func TestStack(t *testing.T) {
 		{
 			"popInt -1",
 			[][]byte{{0x81}},
-			func(stack *txscript.Stack) error {
-				v, err := stack.PopInt()
+			func(s *stack) error {
+				v, err := s.PopInt()
 				if err != nil {
 					return err
 				}
@@ -258,8 +256,8 @@ func TestStack(t *testing.T) {
 		{
 			"popInt -1 leading 0",
 			[][]byte{{0x01, 0x00, 0x00, 0x80}},
-			func(stack *txscript.Stack) error {
-				v, err := stack.PopInt()
+			func(s *stack) error {
+				v, err := s.PopInt()
 				if err != nil {
 					return err
 				}
@@ -276,8 +274,8 @@ func TestStack(t *testing.T) {
 		{
 			"popInt -513",
 			[][]byte{{0x1, 0x82}},
-			func(stack *txscript.Stack) error {
-				v, err := stack.PopInt()
+			func(s *stack) error {
+				v, err := s.PopInt()
 				if err != nil {
 					return err
 				}
@@ -294,8 +292,8 @@ func TestStack(t *testing.T) {
 		{
 			"peekint nomodify -1",
 			[][]byte{{0x01, 0x00, 0x00, 0x80}},
-			func(stack *txscript.Stack) error {
-				v, err := stack.PeekInt(0)
+			func(s *stack) error {
+				v, err := s.PeekInt(0)
 				if err != nil {
 					return err
 				}
@@ -311,8 +309,8 @@ func TestStack(t *testing.T) {
 		{
 			"PushInt 0",
 			[][]byte{},
-			func(stack *txscript.Stack) error {
-				stack.PushInt(big.NewInt(0))
+			func(s *stack) error {
+				s.PushInt(big.NewInt(0))
 				return nil
 			},
 			nil,
@@ -321,8 +319,8 @@ func TestStack(t *testing.T) {
 		{
 			"PushInt 1",
 			[][]byte{},
-			func(stack *txscript.Stack) error {
-				stack.PushInt(big.NewInt(1))
+			func(s *stack) error {
+				s.PushInt(big.NewInt(1))
 				return nil
 			},
 			nil,
@@ -331,8 +329,8 @@ func TestStack(t *testing.T) {
 		{
 			"PushInt -1",
 			[][]byte{},
-			func(stack *txscript.Stack) error {
-				stack.PushInt(big.NewInt(-1))
+			func(s *stack) error {
+				s.PushInt(big.NewInt(-1))
 				return nil
 			},
 			nil,
@@ -341,8 +339,8 @@ func TestStack(t *testing.T) {
 		{
 			"PushInt two bytes",
 			[][]byte{},
-			func(stack *txscript.Stack) error {
-				stack.PushInt(big.NewInt(256))
+			func(s *stack) error {
+				s.PushInt(big.NewInt(256))
 				return nil
 			},
 			nil,
@@ -352,9 +350,9 @@ func TestStack(t *testing.T) {
 		{
 			"PushInt leading zeros",
 			[][]byte{},
-			func(stack *txscript.Stack) error {
+			func(s *stack) error {
 				// this will have the highbit set
-				stack.PushInt(big.NewInt(128))
+				s.PushInt(big.NewInt(128))
 				return nil
 			},
 			nil,
@@ -363,8 +361,8 @@ func TestStack(t *testing.T) {
 		{
 			"dup",
 			[][]byte{{1}},
-			func(stack *txscript.Stack) error {
-				err := stack.DupN(1)
+			func(s *stack) error {
+				err := s.DupN(1)
 				if err != nil {
 					return err
 				}
@@ -377,8 +375,8 @@ func TestStack(t *testing.T) {
 		{
 			"dup2",
 			[][]byte{{1}, {2}},
-			func(stack *txscript.Stack) error {
-				err := stack.DupN(2)
+			func(s *stack) error {
+				err := s.DupN(2)
 				if err != nil {
 					return err
 				}
@@ -391,8 +389,8 @@ func TestStack(t *testing.T) {
 		{
 			"dup3",
 			[][]byte{{1}, {2}, {3}},
-			func(stack *txscript.Stack) error {
-				err := stack.DupN(3)
+			func(s *stack) error {
+				err := s.DupN(3)
 				if err != nil {
 					return err
 				}
@@ -405,64 +403,64 @@ func TestStack(t *testing.T) {
 		{
 			"dup0",
 			[][]byte{{1}},
-			func(stack *txscript.Stack) error {
-				err := stack.DupN(0)
+			func(s *stack) error {
+				err := s.DupN(0)
 				if err != nil {
 					return err
 				}
 
 				return nil
 			},
-			txscript.ErrStackInvalidArgs,
+			ErrStackInvalidArgs,
 			[][]byte{},
 		},
 		{
 			"dup-1",
 			[][]byte{{1}},
-			func(stack *txscript.Stack) error {
-				err := stack.DupN(-1)
+			func(s *stack) error {
+				err := s.DupN(-1)
 				if err != nil {
 					return err
 				}
 
 				return nil
 			},
-			txscript.ErrStackInvalidArgs,
+			ErrStackInvalidArgs,
 			[][]byte{},
 		},
 		{
 			"dup too much",
 			[][]byte{{1}},
-			func(stack *txscript.Stack) error {
-				err := stack.DupN(2)
+			func(s *stack) error {
+				err := s.DupN(2)
 				if err != nil {
 					return err
 				}
 
 				return nil
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{},
 		},
 		{
 			"dup-1",
 			[][]byte{{1}},
-			func(stack *txscript.Stack) error {
-				err := stack.DupN(-1)
+			func(s *stack) error {
+				err := s.DupN(-1)
 				if err != nil {
 					return err
 				}
 
 				return nil
 			},
-			txscript.ErrStackInvalidArgs,
+			ErrStackInvalidArgs,
 			[][]byte{},
 		},
 		{
 			"PushBool true",
 			[][]byte{},
-			func(stack *txscript.Stack) error {
-				stack.PushBool(true)
+			func(s *stack) error {
+				s.PushBool(true)
 
 				return nil
 			},
@@ -472,8 +470,8 @@ func TestStack(t *testing.T) {
 		{
 			"PushBool false",
 			[][]byte{},
-			func(stack *txscript.Stack) error {
-				stack.PushBool(false)
+			func(s *stack) error {
+				s.PushBool(false)
 
 				return nil
 			},
@@ -483,9 +481,9 @@ func TestStack(t *testing.T) {
 		{
 			"PushBool PopBool",
 			[][]byte{},
-			func(stack *txscript.Stack) error {
-				stack.PushBool(true)
-				val, err := stack.PopBool()
+			func(s *stack) error {
+				s.PushBool(true)
+				val, err := s.PopBool()
 				if err != nil {
 					return err
 				}
@@ -501,9 +499,9 @@ func TestStack(t *testing.T) {
 		{
 			"PushBool PopBool 2",
 			[][]byte{},
-			func(stack *txscript.Stack) error {
-				stack.PushBool(false)
-				val, err := stack.PopBool()
+			func(s *stack) error {
+				s.PushBool(false)
+				val, err := s.PopBool()
 				if err != nil {
 					return err
 				}
@@ -519,9 +517,9 @@ func TestStack(t *testing.T) {
 		{
 			"PushInt PopBool",
 			[][]byte{},
-			func(stack *txscript.Stack) error {
-				stack.PushInt(big.NewInt(1))
-				val, err := stack.PopBool()
+			func(s *stack) error {
+				s.PushInt(big.NewInt(1))
+				val, err := s.PopBool()
 				if err != nil {
 					return err
 				}
@@ -537,9 +535,9 @@ func TestStack(t *testing.T) {
 		{
 			"PushInt PopBool 2",
 			[][]byte{},
-			func(stack *txscript.Stack) error {
-				stack.PushInt(big.NewInt(0))
-				val, err := stack.PopBool()
+			func(s *stack) error {
+				s.PushInt(big.NewInt(0))
+				val, err := s.PopBool()
 				if err != nil {
 					return err
 				}
@@ -555,9 +553,9 @@ func TestStack(t *testing.T) {
 		{
 			"PushInt PopBool 2",
 			[][]byte{},
-			func(stack *txscript.Stack) error {
-				stack.PushInt(big.NewInt(0))
-				val, err := stack.PopBool()
+			func(s *stack) error {
+				s.PushInt(big.NewInt(0))
+				val, err := s.PopBool()
 				if err != nil {
 					return err
 				}
@@ -573,8 +571,8 @@ func TestStack(t *testing.T) {
 		{
 			"Nip top",
 			[][]byte{{1}, {2}, {3}},
-			func(stack *txscript.Stack) error {
-				return stack.NipN(0)
+			func(s *stack) error {
+				return s.NipN(0)
 			},
 			nil,
 			[][]byte{{1}, {2}},
@@ -582,8 +580,8 @@ func TestStack(t *testing.T) {
 		{
 			"Nip middle",
 			[][]byte{{1}, {2}, {3}},
-			func(stack *txscript.Stack) error {
-				return stack.NipN(1)
+			func(s *stack) error {
+				return s.NipN(1)
 			},
 			nil,
 			[][]byte{{1}, {3}},
@@ -591,8 +589,8 @@ func TestStack(t *testing.T) {
 		{
 			"Nip low",
 			[][]byte{{1}, {2}, {3}},
-			func(stack *txscript.Stack) error {
-				return stack.NipN(2)
+			func(s *stack) error {
+				return s.NipN(2)
 			},
 			nil,
 			[][]byte{{2}, {3}},
@@ -600,28 +598,28 @@ func TestStack(t *testing.T) {
 		{
 			"Nip too much",
 			[][]byte{{1}, {2}, {3}},
-			func(stack *txscript.Stack) error {
+			func(s *stack) error {
 				// bite off more than we can chew
-				return stack.NipN(3)
+				return s.NipN(3)
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{{2}, {3}},
 		},
 		{
 			"Nip too much",
 			[][]byte{{1}, {2}, {3}},
-			func(stack *txscript.Stack) error {
+			func(s *stack) error {
 				// bite off more than we can chew
-				return stack.NipN(3)
+				return s.NipN(3)
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{{2}, {3}},
 		},
 		{
 			"keep on tucking",
 			[][]byte{{1}, {2}, {3}},
-			func(stack *txscript.Stack) error {
-				return stack.Tuck()
+			func(s *stack) error {
+				return s.Tuck()
 			},
 			nil,
 			[][]byte{{1}, {3}, {2}, {3}},
@@ -629,26 +627,26 @@ func TestStack(t *testing.T) {
 		{
 			"a little tucked up",
 			[][]byte{{1}}, // too few arguments for tuck
-			func(stack *txscript.Stack) error {
-				return stack.Tuck()
+			func(s *stack) error {
+				return s.Tuck()
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{},
 		},
 		{
 			"all tucked up",
 			[][]byte{}, // too few arguments  for tuck
-			func(stack *txscript.Stack) error {
-				return stack.Tuck()
+			func(s *stack) error {
+				return s.Tuck()
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{},
 		},
 		{
 			"drop 1",
 			[][]byte{{1}, {2}, {3}, {4}},
-			func(stack *txscript.Stack) error {
-				return stack.DropN(1)
+			func(s *stack) error {
+				return s.DropN(1)
 			},
 			nil,
 			[][]byte{{1}, {2}, {3}},
@@ -656,8 +654,8 @@ func TestStack(t *testing.T) {
 		{
 			"drop 2",
 			[][]byte{{1}, {2}, {3}, {4}},
-			func(stack *txscript.Stack) error {
-				return stack.DropN(2)
+			func(s *stack) error {
+				return s.DropN(2)
 			},
 			nil,
 			[][]byte{{1}, {2}},
@@ -665,8 +663,8 @@ func TestStack(t *testing.T) {
 		{
 			"drop 3",
 			[][]byte{{1}, {2}, {3}, {4}},
-			func(stack *txscript.Stack) error {
-				return stack.DropN(3)
+			func(s *stack) error {
+				return s.DropN(3)
 			},
 			nil,
 			[][]byte{{1}},
@@ -674,8 +672,8 @@ func TestStack(t *testing.T) {
 		{
 			"drop 4",
 			[][]byte{{1}, {2}, {3}, {4}},
-			func(stack *txscript.Stack) error {
-				return stack.DropN(4)
+			func(s *stack) error {
+				return s.DropN(4)
 			},
 			nil,
 			[][]byte{},
@@ -683,26 +681,26 @@ func TestStack(t *testing.T) {
 		{
 			"drop 4/5",
 			[][]byte{{1}, {2}, {3}, {4}},
-			func(stack *txscript.Stack) error {
-				return stack.DropN(5)
+			func(s *stack) error {
+				return s.DropN(5)
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{},
 		},
 		{
 			"drop invalid",
 			[][]byte{{1}, {2}, {3}, {4}},
-			func(stack *txscript.Stack) error {
-				return stack.DropN(0)
+			func(s *stack) error {
+				return s.DropN(0)
 			},
-			txscript.ErrStackInvalidArgs,
+			ErrStackInvalidArgs,
 			[][]byte{},
 		},
 		{
 			"Rot1",
 			[][]byte{{1}, {2}, {3}, {4}},
-			func(stack *txscript.Stack) error {
-				return stack.RotN(1)
+			func(s *stack) error {
+				return s.RotN(1)
 			},
 			nil,
 			[][]byte{{1}, {3}, {4}, {2}},
@@ -710,8 +708,8 @@ func TestStack(t *testing.T) {
 		{
 			"Rot2",
 			[][]byte{{1}, {2}, {3}, {4}, {5}, {6}},
-			func(stack *txscript.Stack) error {
-				return stack.RotN(2)
+			func(s *stack) error {
+				return s.RotN(2)
 			},
 			nil,
 			[][]byte{{3}, {4}, {5}, {6}, {1}, {2}},
@@ -719,26 +717,26 @@ func TestStack(t *testing.T) {
 		{
 			"Rot too little",
 			[][]byte{{1}, {2}},
-			func(stack *txscript.Stack) error {
-				return stack.RotN(1)
+			func(s *stack) error {
+				return s.RotN(1)
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{},
 		},
 		{
 			"Rot0",
 			[][]byte{{1}, {2}, {3}},
-			func(stack *txscript.Stack) error {
-				return stack.RotN(0)
+			func(s *stack) error {
+				return s.RotN(0)
 			},
-			txscript.ErrStackInvalidArgs,
+			ErrStackInvalidArgs,
 			[][]byte{},
 		},
 		{
 			"Swap1",
 			[][]byte{{1}, {2}, {3}, {4}},
-			func(stack *txscript.Stack) error {
-				return stack.SwapN(1)
+			func(s *stack) error {
+				return s.SwapN(1)
 			},
 			nil,
 			[][]byte{{1}, {2}, {4}, {3}},
@@ -746,8 +744,8 @@ func TestStack(t *testing.T) {
 		{
 			"Swap2",
 			[][]byte{{1}, {2}, {3}, {4}},
-			func(stack *txscript.Stack) error {
-				return stack.SwapN(2)
+			func(s *stack) error {
+				return s.SwapN(2)
 			},
 			nil,
 			[][]byte{{3}, {4}, {1}, {2}},
@@ -755,26 +753,26 @@ func TestStack(t *testing.T) {
 		{
 			"Swap too little",
 			[][]byte{{1}},
-			func(stack *txscript.Stack) error {
-				return stack.SwapN(1)
+			func(s *stack) error {
+				return s.SwapN(1)
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{},
 		},
 		{
 			"Swap0",
 			[][]byte{{1}, {2}, {3}},
-			func(stack *txscript.Stack) error {
-				return stack.SwapN(0)
+			func(s *stack) error {
+				return s.SwapN(0)
 			},
-			txscript.ErrStackInvalidArgs,
+			ErrStackInvalidArgs,
 			[][]byte{},
 		},
 		{
 			"Over1",
 			[][]byte{{1}, {2}, {3}, {4}},
-			func(stack *txscript.Stack) error {
-				return stack.OverN(1)
+			func(s *stack) error {
+				return s.OverN(1)
 			},
 			nil,
 			[][]byte{{1}, {2}, {3}, {4}, {3}},
@@ -782,8 +780,8 @@ func TestStack(t *testing.T) {
 		{
 			"Over2",
 			[][]byte{{1}, {2}, {3}, {4}},
-			func(stack *txscript.Stack) error {
-				return stack.OverN(2)
+			func(s *stack) error {
+				return s.OverN(2)
 			},
 			nil,
 			[][]byte{{1}, {2}, {3}, {4}, {1}, {2}},
@@ -791,26 +789,26 @@ func TestStack(t *testing.T) {
 		{
 			"Over too little",
 			[][]byte{{1}},
-			func(stack *txscript.Stack) error {
-				return stack.OverN(1)
+			func(s *stack) error {
+				return s.OverN(1)
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{},
 		},
 		{
 			"Over0",
 			[][]byte{{1}, {2}, {3}},
-			func(stack *txscript.Stack) error {
-				return stack.OverN(0)
+			func(s *stack) error {
+				return s.OverN(0)
 			},
-			txscript.ErrStackInvalidArgs,
+			ErrStackInvalidArgs,
 			[][]byte{},
 		},
 		{
 			"Pick1",
 			[][]byte{{1}, {2}, {3}, {4}},
-			func(stack *txscript.Stack) error {
-				return stack.PickN(1)
+			func(s *stack) error {
+				return s.PickN(1)
 			},
 			nil,
 			[][]byte{{1}, {2}, {3}, {4}, {3}},
@@ -818,8 +816,8 @@ func TestStack(t *testing.T) {
 		{
 			"Pick2",
 			[][]byte{{1}, {2}, {3}, {4}},
-			func(stack *txscript.Stack) error {
-				return stack.PickN(2)
+			func(s *stack) error {
+				return s.PickN(2)
 			},
 			nil,
 			[][]byte{{1}, {2}, {3}, {4}, {2}},
@@ -827,17 +825,17 @@ func TestStack(t *testing.T) {
 		{
 			"Pick too little",
 			[][]byte{{1}},
-			func(stack *txscript.Stack) error {
-				return stack.PickN(1)
+			func(s *stack) error {
+				return s.PickN(1)
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{},
 		},
 		{
 			"Roll1",
 			[][]byte{{1}, {2}, {3}, {4}},
-			func(stack *txscript.Stack) error {
-				return stack.RollN(1)
+			func(s *stack) error {
+				return s.RollN(1)
 			},
 			nil,
 			[][]byte{{1}, {2}, {4}, {3}},
@@ -845,8 +843,8 @@ func TestStack(t *testing.T) {
 		{
 			"Roll2",
 			[][]byte{{1}, {2}, {3}, {4}},
-			func(stack *txscript.Stack) error {
-				return stack.RollN(2)
+			func(s *stack) error {
+				return s.RollN(2)
 			},
 			nil,
 			[][]byte{{1}, {3}, {4}, {2}},
@@ -854,19 +852,19 @@ func TestStack(t *testing.T) {
 		{
 			"Roll too little",
 			[][]byte{{1}},
-			func(stack *txscript.Stack) error {
-				return stack.RollN(1)
+			func(s *stack) error {
+				return s.RollN(1)
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{},
 		},
 		{
 			"Peek bool",
 			[][]byte{{1}},
-			func(stack *txscript.Stack) error {
+			func(s *stack) error {
 				// Peek bool is otherwise pretty well tested,
 				// just check it works.
-				val, err := stack.PeekBool(0)
+				val, err := s.PeekBool(0)
 				if err != nil {
 					return err
 				}
@@ -881,10 +879,10 @@ func TestStack(t *testing.T) {
 		{
 			"Peek bool 2",
 			[][]byte{{0}},
-			func(stack *txscript.Stack) error {
+			func(s *stack) error {
 				// Peek bool is otherwise pretty well tested,
 				// just check it works.
-				val, err := stack.PeekBool(0)
+				val, err := s.PeekBool(0)
 				if err != nil {
 					return err
 				}
@@ -899,10 +897,10 @@ func TestStack(t *testing.T) {
 		{
 			"Peek int",
 			[][]byte{{1}},
-			func(stack *txscript.Stack) error {
+			func(s *stack) error {
 				// Peek int is otherwise pretty well tested,
 				// just check it works.
-				val, err := stack.PeekInt(0)
+				val, err := s.PeekInt(0)
 				if err != nil {
 					return err
 				}
@@ -917,10 +915,10 @@ func TestStack(t *testing.T) {
 		{
 			"Peek int 2",
 			[][]byte{{0}},
-			func(stack *txscript.Stack) error {
+			func(s *stack) error {
 				// Peek int is otherwise pretty well tested,
 				// just check it works.
-				val, err := stack.PeekInt(0)
+				val, err := s.PeekInt(0)
 				if err != nil {
 					return err
 				}
@@ -935,11 +933,11 @@ func TestStack(t *testing.T) {
 		{
 			"pop int",
 			[][]byte{},
-			func(stack *txscript.Stack) error {
-				stack.PushInt(big.NewInt(1))
+			func(s *stack) error {
+				s.PushInt(big.NewInt(1))
 				// Peek int is otherwise pretty well tested,
 				// just check it works.
-				val, err := stack.PopInt()
+				val, err := s.PopInt()
 				if err != nil {
 					return err
 				}
@@ -954,24 +952,24 @@ func TestStack(t *testing.T) {
 		{
 			"pop empty",
 			[][]byte{},
-			func(stack *txscript.Stack) error {
+			func(s *stack) error {
 				// Peek int is otherwise pretty well tested,
 				// just check it works.
-				_, err := stack.PopInt()
+				_, err := s.PopInt()
 				return err
 			},
-			txscript.ErrStackUnderflow,
+			ErrStackUnderflow,
 			[][]byte{},
 		},
 	}
 
 	for _, test := range tests {
-		stack := txscript.Stack{}
+		s := stack{}
 
 		for i := range test.before {
-			stack.PushByteArray(test.before[i])
+			s.PushByteArray(test.before[i])
 		}
-		err := test.operation(&stack)
+		err := test.operation(&s)
 		if err != test.expectedReturn {
 			t.Errorf("%s: operation return not what expected: %v "+
 				"vs %v", test.name, err, test.expectedReturn)
@@ -980,14 +978,14 @@ func TestStack(t *testing.T) {
 			continue
 		}
 
-		if len(test.after) != stack.Depth() {
+		if len(test.after) != s.Depth() {
 			t.Errorf("%s: stack depth doesn't match expected: %v "+
 				"vs %v", test.name, len(test.after),
-				stack.Depth())
+				s.Depth())
 		}
 
 		for i := range test.after {
-			val, err := stack.PeekByteArray(stack.Depth() - i - 1)
+			val, err := s.PeekByteArray(s.Depth() - i - 1)
 			if err != nil {
 				t.Errorf("%s: can't peek %dth stack entry: %v",
 					test.name, i, err)