Harding feedback on script

Author: jimmysong

ch06.asciidoc

@@ -18,7 +18,7 @@ It is possible to "split" a key into multiple private keys and use an interactiv
 
 === Bare Multisig
 
-Bare Multisig was the first attempt at creating a transaction that could be signed by multiple parties. To understand Bare Multisig, one must first understand the OP_CHECKMULTISIG operator. As discussed in Chapter 6, SCRIPT has a lot of different OP codes. OP_CHECKMULTISIG is one of them at `ae`. The operator consumes a lot of elements from the stack and returns whether or not a certain number of signatures are valid for this transaction.
+Bare Multisig was the first attempt at creating a transaction that could be signed by multiple parties. To understand Bare Multisig, one must first understand the OP_CHECKMULTISIG operator. As discussed in Chapter 6, SCRIPT has a lot of different opcodes. OP_CHECKMULTISIG is one of them at `ae`. The operator consumes a lot of elements from the stack and returns whether or not a certain number of signatures are valid for this transaction.
 
 The transaction is called "bare" multisig because it's a really long ScriptPubKey. Here's what a ScriptPubKey for a 1-of-2 multisig looks like.
 
@@ -67,7 +67,7 @@ The elements consumed by OP_CHECKMULTISIG are supposed to be:
 
 m, m different signatures, n, n different pubkeys.
 
-The number of elements consumed should be 2 (m and n themselves) + m (signatures) + n (pubkeys). Unfortunately, the OP code actually consumes 1 more element than the m+n+2 that it's supposed to. OP_CHECKMULTISIG consumes m+n+3, so the extra element is added in order to not cause a failure. The OP code does nothing with that extra element and that extra element can be anything.
+The number of elements consumed should be 2 (m and n themselves) + m (signatures) + n (pubkeys). Unfortunately, the opcode actually consumes 1 more element than the m+n+2 that it's supposed to. OP_CHECKMULTISIG consumes m+n+3, so the extra element is added in order to not cause a failure. The opcode does nothing with that extra element and that extra element can be anything.
 
 As a way to combat malleabilty, however, most nodes on the Bitcoin network will not relay the transaction unless that extra element is OP_0. Note that if we had m+n+2 elements, that OP_CHECKMULTISIG will just fail as there are not enough elements to be consumed and the transaction will be invalid.
 ====

ch08.asciidoc

@@ -69,7 +69,7 @@ def parse(cls, s):
                 instructions.append(s.read(data_length))
                 count += data_length + 2
             else:
-                # we have an op code. set the current byte to op_code
+                # we have an opcode. set the current byte to op_code
                 op_code = current_byte
                 # add the op_code to the list of instructions
                 instructions.append(op_code)
@@ -82,15 +82,15 @@ def raw_serialize(self):
         result = b''
         # go through each instruction
         for instruction in self.instructions:
-            # if the instruction is an integer, it's an op code
+            # if the instruction is an integer, it's an opcode
             if type(instruction) == int:
                 # turn the instruction into a single byte integer using int_to_little_endian
                 result += int_to_little_endian(instruction, 1)
             else:
                 # otherwise, this is an element
                 # get the length in bytes
                 length = len(instruction)
-                # for large lengths, we have to use a pushdata op code
+                # for large lengths, we have to use a pushdata opcode
                 if length < 75:
                     # turn the length into a single byte integer
                     result += int_to_little_endian(length, 1)
@@ -124,7 +124,7 @@ def evaluate(self, z):
         while len(instructions) > 0:
             instruction = instructions.pop(0)
             if type(instruction) == int:
-                # do what the op code says
+                # do what the opcode says
                 operation = OP_CODE_FUNCTIONS[instruction]
                 if instruction in (99, 100):
                     # op_if/op_notif require the instructions array

code-ch05/script.py

@@ -143,7 +143,7 @@
     "* a7 = OP_SHA1\n",
     "\n",
     "\n",
-    "#### Hint: Use the Script.parse method and look up what various OP codes do here: \n",
+    "#### Hint: Use the Script.parse method and look up what various opcodes do here: \n",
     "#### https://en.bitcoin.it/wiki/Script"
    ]
   },

code-ch06/Programming Blockchain Chapter 6.ipynb

@@ -72,7 +72,7 @@ def parse(cls, s):
                 instructions.append(s.read(data_length))
                 count += data_length + 2
             else:
-                # we have an op code. set the current byte to op_code
+                # we have an opcode. set the current byte to op_code
                 op_code = current_byte
                 # add the op_code to the list of instructions
                 instructions.append(op_code)
@@ -85,15 +85,15 @@ def raw_serialize(self):
         result = b''
         # go through each instruction
         for instruction in self.instructions:
-            # if the instruction is an integer, it's an op code
+            # if the instruction is an integer, it's an opcode
             if type(instruction) == int:
                 # turn the instruction into a single byte integer using int_to_little_endian
                 result += int_to_little_endian(instruction, 1)
             else:
                 # otherwise, this is an element
                 # get the length in bytes
                 length = len(instruction)
-                # for large lengths, we have to use a pushdata op code
+                # for large lengths, we have to use a pushdata opcode
                 if length < 75:
                     # turn the length into a single byte integer
                     result += int_to_little_endian(length, 1)
@@ -127,7 +127,7 @@ def evaluate(self, z):
         while len(instructions) > 0:
             instruction = instructions.pop(0)
             if type(instruction) == int:
-                # do what the op code says
+                # do what the opcode says
                 operation = OP_CODE_FUNCTIONS[instruction]
                 if instruction in (99, 100):
                     # op_if/op_notif require the instructions array

code-ch06/script.py

@@ -77,7 +77,7 @@ def parse(cls, s):
                 instructions.append(s.read(data_length))
                 count += data_length + 2
             else:
-                # we have an op code. set the current byte to op_code
+                # we have an opcode. set the current byte to op_code
                 op_code = current_byte
                 # add the op_code to the list of instructions
                 instructions.append(op_code)
@@ -90,15 +90,15 @@ def raw_serialize(self):
         result = b''
         # go through each instruction
         for instruction in self.instructions:
-            # if the instruction is an integer, it's an op code
+            # if the instruction is an integer, it's an opcode
             if type(instruction) == int:
                 # turn the instruction into a single byte integer using int_to_little_endian
                 result += int_to_little_endian(instruction, 1)
             else:
                 # otherwise, this is an element
                 # get the length in bytes
                 length = len(instruction)
-                # for large lengths, we have to use a pushdata op code
+                # for large lengths, we have to use a pushdata opcode
                 if length < 75:
                     # turn the length into a single byte integer
                     result += int_to_little_endian(length, 1)
@@ -132,7 +132,7 @@ def evaluate(self, z):
         while len(instructions) > 0:
             instruction = instructions.pop(0)
             if type(instruction) == int:
-                # do what the op code says
+                # do what the opcode says
                 operation = OP_CODE_FUNCTIONS[instruction]
                 if instruction in (99, 100):
                     # op_if/op_notif require the instructions array

code-ch07/script.py

@@ -85,7 +85,7 @@ def parse(cls, s):
                 instructions.append(s.read(data_length))
                 count += data_length + 2
             else:
-                # we have an op code. set the current byte to op_code
+                # we have an opcode. set the current byte to op_code
                 op_code = current_byte
                 # add the op_code to the list of instructions
                 instructions.append(op_code)
@@ -98,15 +98,15 @@ def raw_serialize(self):
         result = b''
         # go through each instruction
         for instruction in self.instructions:
-            # if the instruction is an integer, it's an op code
+            # if the instruction is an integer, it's an opcode
             if type(instruction) == int:
                 # turn the instruction into a single byte integer using int_to_little_endian
                 result += int_to_little_endian(instruction, 1)
             else:
                 # otherwise, this is an element
                 # get the length in bytes
                 length = len(instruction)
-                # for large lengths, we have to use a pushdata op code
+                # for large lengths, we have to use a pushdata opcode
                 if length < 75:
                     # turn the length into a single byte integer
                     result += int_to_little_endian(length, 1)
@@ -140,7 +140,7 @@ def evaluate(self, z):
         while len(instructions) > 0:
             instruction = instructions.pop(0)
             if type(instruction) == int:
-                # do what the op code says
+                # do what the opcode says
                 operation = OP_CODE_FUNCTIONS[instruction]
                 if instruction in (99, 100):
                     # op_if/op_notif require the instructions array
@@ -168,7 +168,7 @@ def evaluate(self, z):
                 if len(instructions) == 3 and instructions[0] == 0xa9 \
                     and type(instructions[1]) == bytes and len(instructions[1]) == 20 \
                     and instructions[2] == 0x87:
-                    # we execute the next three op codes
+                    # we execute the next three opcodes
                     instructions.pop()
                     h160 = instructions.pop()
                     instructions.pop()

code-ch08/script.py

@@ -85,7 +85,7 @@ def parse(cls, s):
                 instructions.append(s.read(data_length))
                 count += data_length + 2
             else:
-                # we have an op code. set the current byte to op_code
+                # we have an opcode. set the current byte to op_code
                 op_code = current_byte
                 # add the op_code to the list of instructions
                 instructions.append(op_code)
@@ -98,15 +98,15 @@ def raw_serialize(self):
         result = b''
         # go through each instruction
         for instruction in self.instructions:
-            # if the instruction is an integer, it's an op code
+            # if the instruction is an integer, it's an opcode
             if type(instruction) == int:
                 # turn the instruction into a single byte integer using int_to_little_endian
                 result += int_to_little_endian(instruction, 1)
             else:
                 # otherwise, this is an element
                 # get the length in bytes
                 length = len(instruction)
-                # for large lengths, we have to use a pushdata op code
+                # for large lengths, we have to use a pushdata opcode
                 if length < 75:
                     # turn the length into a single byte integer
                     result += int_to_little_endian(length, 1)
@@ -140,7 +140,7 @@ def evaluate(self, z):
         while len(instructions) > 0:
             instruction = instructions.pop(0)
             if type(instruction) == int:
-                # do what the op code says
+                # do what the opcode says
                 operation = OP_CODE_FUNCTIONS[instruction]
                 if instruction in (99, 100):
                     # op_if/op_notif require the instructions array
@@ -168,7 +168,7 @@ def evaluate(self, z):
                 if len(instructions) == 3 and instructions[0] == 0xa9 \
                     and type(instructions[1]) == bytes and len(instructions[1]) == 20 \
                     and instructions[2] == 0x87:
-                    # we execute the next three op codes
+                    # we execute the next three opcodes
                     instructions.pop()
                     h160 = instructions.pop()
                     instructions.pop()

code-ch09/script.py

@@ -85,7 +85,7 @@ def parse(cls, s):
                 instructions.append(s.read(data_length))
                 count += data_length + 2
             else:
-                # we have an op code. set the current byte to op_code
+                # we have an opcode. set the current byte to op_code
                 op_code = current_byte
                 # add the op_code to the list of instructions
                 instructions.append(op_code)
@@ -98,15 +98,15 @@ def raw_serialize(self):
         result = b''
         # go through each instruction
         for instruction in self.instructions:
-            # if the instruction is an integer, it's an op code
+            # if the instruction is an integer, it's an opcode
             if type(instruction) == int:
                 # turn the instruction into a single byte integer using int_to_little_endian
                 result += int_to_little_endian(instruction, 1)
             else:
                 # otherwise, this is an element
                 # get the length in bytes
                 length = len(instruction)
-                # for large lengths, we have to use a pushdata op code
+                # for large lengths, we have to use a pushdata opcode
                 if length < 75:
                     # turn the length into a single byte integer
                     result += int_to_little_endian(length, 1)
@@ -140,7 +140,7 @@ def evaluate(self, z):
         while len(instructions) > 0:
             instruction = instructions.pop(0)
             if type(instruction) == int:
-                # do what the op code says
+                # do what the opcode says
                 operation = OP_CODE_FUNCTIONS[instruction]
                 if instruction in (99, 100):
                     # op_if/op_notif require the instructions array
@@ -168,7 +168,7 @@ def evaluate(self, z):
                 if len(instructions) == 3 and instructions[0] == 0xa9 \
                     and type(instructions[1]) == bytes and len(instructions[1]) == 20 \
                     and instructions[2] == 0x87:
-                    # we execute the next three op codes
+                    # we execute the next three opcodes
                     instructions.pop()
                     h160 = instructions.pop()
                     instructions.pop()

code-ch10/script.py

@@ -85,7 +85,7 @@ def parse(cls, s):
                 instructions.append(s.read(data_length))
                 count += data_length + 2
             else:
-                # we have an op code. set the current byte to op_code
+                # we have an opcode. set the current byte to op_code
                 op_code = current_byte
                 # add the op_code to the list of instructions
                 instructions.append(op_code)
@@ -98,15 +98,15 @@ def raw_serialize(self):
         result = b''
         # go through each instruction
         for instruction in self.instructions:
-            # if the instruction is an integer, it's an op code
+            # if the instruction is an integer, it's an opcode
             if type(instruction) == int:
                 # turn the instruction into a single byte integer using int_to_little_endian
                 result += int_to_little_endian(instruction, 1)
             else:
                 # otherwise, this is an element
                 # get the length in bytes
                 length = len(instruction)
-                # for large lengths, we have to use a pushdata op code
+                # for large lengths, we have to use a pushdata opcode
                 if length < 75:
                     # turn the length into a single byte integer
                     result += int_to_little_endian(length, 1)
@@ -140,7 +140,7 @@ def evaluate(self, z):
         while len(instructions) > 0:
             instruction = instructions.pop(0)
             if type(instruction) == int:
-                # do what the op code says
+                # do what the opcode says
                 operation = OP_CODE_FUNCTIONS[instruction]
                 if instruction in (99, 100):
                     # op_if/op_notif require the instructions array
@@ -168,7 +168,7 @@ def evaluate(self, z):
                 if len(instructions) == 3 and instructions[0] == 0xa9 \
                     and type(instructions[1]) == bytes and len(instructions[1]) == 20 \
                     and instructions[2] == 0x87:
-                    # we execute the next three op codes
+                    # we execute the next three opcodes
                     instructions.pop()
                     h160 = instructions.pop()
                     instructions.pop()