bitcoinrb 0.0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96f0a34fb5dcdaef395f91d69a4d9b23b0ef0e9a
-  data.tar.gz: 54cb847c45147461350da5bf2f6f7aa88e129858
+  metadata.gz: a527d6ef43eda02e2ef56d64edb5da7dfa04a956
+  data.tar.gz: b1a7902b2be175f6f771ca3a418cbf869ab9dc7e
 SHA512:
-  metadata.gz: a151846d7ea230bd203dab08181dec34052cce1700c505a123b8220d80f1f7ff7fa296b90bbd5c639a725bb9e756661a0c77449b1731843e60526c793b8436c0
-  data.tar.gz: 87dbd90b24338fb0088f92e5bc1083e2749cdffa5729395433371808e20e74126ed395e01f3eaa5b73e3a35d7211ddd1137c3e7ca77a35c951531f809f32c3f3
+  metadata.gz: ec03a93f28a17efdd812eaf1dd13e3a3f5ad947393bd8e29e6040116558dd9bbfc193419cc1a69bd623b36c4bb141e5957010ec989fca9301d851b461a78f79a
+  data.tar.gz: bb41bbb4b43700e9a587e2e8d157a1ab7be358a14b9bd44ab349fdc19275c124e407ea9093f68b8cb218d61c0800efc348c8b4fbc202884ecb8e0ab0c3baa347

data/bitcoinrb.gemspec

@@ -25,6 +25,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'bech32', '~> 1.0.1'
   spec.add_runtime_dependency 'daemon-spawn'
   spec.add_runtime_dependency 'thor'
+  spec.add_runtime_dependency 'ffi'
 
   spec.add_development_dependency "bundler", "~> 1.11"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/bitcoin/connection.rb

@@ -29,7 +29,7 @@ module Bitcoin
 
     # handle receiving data from remote node.
     def receive_data(data)
-      logger.info "receive data from #{remote_node}, data : #{data}"
+      logger.info "receive data from #{remote_node}"
       handler.handle(data)
     end
 
@@ -43,8 +43,11 @@ module Bitcoin
     def handshake_done
       logger.info 'handshake finished.'
       @connected = true
-      # send_data(Message::SendCmpct.new(0, 1))
+    end
 
+    def send_message(msg)
+      logger.info "send message #{msg.class::COMMAND}"
+      send_data(msg.to_pkt)
     end
 
     private
@@ -56,9 +59,8 @@ module Bitcoin
     # start handshake
     def begin_handshake
       logger.info "begin handshake with #{remote_node}"
-      ver = Bitcoin::Message::Version.new(remote_addr: remote_node, start_height: 1150660)
-      logger.info "send version message. #{ver.to_json}"
-      send_data(ver.to_pkt)
+      ver = Bitcoin::Message::Version.new(remote_addr: remote_node, start_height: 0) # TODO use start_height in wallet
+      send_message(ver)
     end
 
   end

data/lib/bitcoin/constants.rb

@@ -0,0 +1,157 @@
+module Bitcoin
+
+  COIN = 100_000_000
+  MAX_MONEY = 21_000_000 * COIN
+
+  # The maximum allowed size for a serialized block, in bytes (only for buffer size limits)
+  MAX_BLOCK_SERIALIZED_SIZE = 4_000_000
+  # The maximum allowed weight for a block, see BIP 141 (network rule)
+  MAX_BLOCK_WEIGHT = 4_000_000
+  # The maximum allowed number of signature check operations in a block (network rule)
+  MAX_BLOCK_SIGOPS_COST = 80_000
+  # Coinbase transaction outputs can only be spent after this number of new blocks (network rule)
+  COINBASE_MATURITY = 100
+  WITNESS_SCALE_FACTOR = 4
+
+  # 60 is the lower bound for the size of a valid serialized Tx
+  MIN_TRANSACTION_WEIGHT = WITNESS_SCALE_FACTOR * 60
+  # 10 is the lower bound for the size of a serialized Tx
+  MIN_SERIALIZABLE_TRANSACTION_WEIGHT = WITNESS_SCALE_FACTOR * 10
+
+  # Flags for nSequence and nLockTime locks
+  LOCKTIME_VERIFY_SEQUENCE = (1 << 0)
+  LOCKTIME_MEDIAN_TIME_PAST = (1 << 1)
+
+  # script verify flags
+  SCRIPT_VERIFY_NONE      = 0
+  SCRIPT_VERIFY_P2SH      = (1 << 0)
+  SCRIPT_VERIFY_STRICTENC = (1 << 1)
+  SCRIPT_VERIFY_DERSIG    = (1 << 2)
+  SCRIPT_VERIFY_LOW_S     = (1 << 3)
+  SCRIPT_VERIFY_NULLDUMMY = (1 << 4)
+  SCRIPT_VERIFY_SIGPUSHONLY = (1 << 5)
+  SCRIPT_VERIFY_MINIMALDATA = (1 << 6)
+  SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS = (1 << 7)
+  SCRIPT_VERIFY_CLEANSTACK = (1 << 8)
+  SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY = (1 << 9) # Verify CHECKLOCKTIMEVERIFY (BIP-65)
+  SCRIPT_VERIFY_CHECKSEQUENCEVERIFY = (1 << 10) # support CHECKSEQUENCEVERIFY opcode (BIP-112)
+  SCRIPT_VERIFY_WITNESS = (1 << 11) # Support segregated witness
+  SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM = (1 << 12) # Making v1-v16 witness program non-standard
+  SCRIPT_VERIFY_MINIMALIF = (1 << 13) # Segwit script only: Require the argument of OP_IF/NOTIF to be exactly 0x01 or empty vector
+  SCRIPT_VERIFY_NULLFAIL = (1 << 14) # Signature(s) must be empty vector if an CHECK(MULTI)SIG operation failed
+  SCRIPT_VERIFY_WITNESS_PUBKEYTYPE = (1 << 15) # Public keys in segregated witness scripts must be compressed
+
+  MANDATORY_SCRIPT_VERIFY_FLAGS = SCRIPT_VERIFY_P2SH
+
+  # Standard script verification flags that standard transactions will comply with.
+  STANDARD_SCRIPT_VERIFY_FLAGS = [MANDATORY_SCRIPT_VERIFY_FLAGS,
+                                  SCRIPT_VERIFY_DERSIG,
+                                  SCRIPT_VERIFY_STRICTENC,
+                                  SCRIPT_VERIFY_MINIMALDATA,
+                                  SCRIPT_VERIFY_NULLDUMMY,
+                                  SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS,
+                                  SCRIPT_VERIFY_CLEANSTACK,
+                                  SCRIPT_VERIFY_MINIMALIF,
+                                  SCRIPT_VERIFY_NULLFAIL,
+                                  SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY,
+                                  SCRIPT_VERIFY_CHECKSEQUENCEVERIFY,
+                                  SCRIPT_VERIFY_LOW_S,
+                                  SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM]
+
+  # for script
+
+  # witness version
+  WITNESS_VERSION = 0x00
+
+  # Maximum script length in bytes
+  MAX_SCRIPT_SIZE = 10000
+
+  # Maximum number of public keys per multisig
+  MAX_PUBKEYS_PER_MULTISIG = 20
+
+  # Maximum number of non-push operations per script
+  MAX_OPS_PER_SCRIPT = 201
+
+  # Maximum number of bytes pushable to the stack
+  MAX_SCRIPT_ELEMENT_SIZE = 520
+
+  # Maximum number of size in the stack
+  MAX_STACK_SIZE = 1000
+
+  # Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
+  LOCKTIME_THRESHOLD = 500000000
+
+  # Signature hash types/flags
+  SIGHASH_TYPE = { all: 1, none: 2, single: 3, anyonecanpay: 128 }
+
+  # Maximum number length in bytes
+  DEFAULT_MAX_NUM_SIZE = 4
+
+  # 80 bytes of data, +1 for OP_RETURN, +2 for the pushdata opcodes.
+  MAX_OP_RETURN_RELAY = 83
+
+  SIG_VERSION = [:base, :witness_v0]
+
+  # for script error
+  SCRIPT_ERR_OK = 0
+  SCRIPT_ERR_UNKNOWN_ERROR = 1
+  SCRIPT_ERR_EVAL_FALSE = 2
+  SCRIPT_ERR_OP_RETURN = 3
+
+  # Max sizes
+  SCRIPT_ERR_SCRIPT_SIZE = 10
+  SCRIPT_ERR_PUSH_SIZE = 11
+  SCRIPT_ERR_OP_COUNT = 12
+  SCRIPT_ERR_STACK_SIZE = 13
+  SCRIPT_ERR_SIG_COUNT = 14
+  SCRIPT_ERR_PUBKEY_COUNT = 15
+
+  # Failed verify operations
+  SCRIPT_ERR_VERIFY = 20
+  SCRIPT_ERR_EQUALVERIFY = 21
+  SCRIPT_ERR_CHECKMULTISIGVERIFY = 22
+  SCRIPT_ERR_CHECKSIGVERIFY = 23
+  SCRIPT_ERR_NUMEQUALVERIFY = 24
+
+  # Logical/Format/Canonical errors
+  SCRIPT_ERR_BAD_OPCODE = 30
+  SCRIPT_ERR_DISABLED_OPCODE = 31
+  SCRIPT_ERR_INVALID_STACK_OPERATION = 32
+  SCRIPT_ERR_INVALID_ALTSTACK_OPERATION = 33
+  SCRIPT_ERR_UNBALANCED_CONDITIONAL = 34
+
+  # CHECKLOCKTIMEVERIFY and CHECKSEQUENCEVERIFY
+  SCRIPT_ERR_NEGATIVE_LOCKTIME = 40
+  SCRIPT_ERR_UNSATISFIED_LOCKTIME = 41
+
+  # Malleability
+  SCRIPT_ERR_SIG_HASHTYPE = 50
+  SCRIPT_ERR_SIG_DER = 51
+  SCRIPT_ERR_MINIMALDATA = 52
+  SCRIPT_ERR_SIG_PUSHONLY = 53
+  SCRIPT_ERR_SIG_HIGH_S = 54
+  SCRIPT_ERR_SIG_NULLDUMMY = 55
+  SCRIPT_ERR_PUBKEYTYPE = 56
+  SCRIPT_ERR_CLEANSTACK = 56
+  SCRIPT_ERR_MINIMALIF = 57
+  SCRIPT_ERR_SIG_NULLFAIL = 58
+
+  # softfork safeness
+  SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS = 60
+  SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM = 61
+
+  # segregated witness
+  SCRIPT_ERR_WITNESS_PROGRAM_WRONG_LENGTH = 70
+  SCRIPT_ERR_WITNESS_PROGRAM_WITNESS_EMPTY = 71
+  SCRIPT_ERR_WITNESS_PROGRAM_MISMATCH = 72
+  SCRIPT_ERR_WITNESS_MALLEATED = 73
+  SCRIPT_ERR_WITNESS_MALLEATED_P2SH = 74
+  SCRIPT_ERR_WITNESS_UNEXPECTED = 75
+  SCRIPT_ERR_WITNESS_PUBKEYTYPE = 76
+
+  SCRIPT_ERR_ERROR_COUNT = 80
+
+  ERRCODES_MAP = Hash[*constants.grep(/^SCRIPT_ERR_/).map { |c| [const_get(c), c.to_s] }.flatten]
+  NAME_MAP = Hash[*constants.grep(/^SCRIPT_ERR_/).map { |c| [c.to_s, const_get(c)] }.flatten]
+
+end

data/lib/bitcoin/key.rb

@@ -6,9 +6,10 @@ module Bitcoin
     attr_accessor :priv_key
     attr_accessor :pubkey
     attr_accessor :compressed
+    attr_reader :secp256k1_module
 
     def initialize(priv_key: nil, pubkey: nil, compressed: true)
-      extend Bitcoin.secp_impl
+      @secp256k1_module =  Bitcoin.secp_impl
       @priv_key = priv_key
       if pubkey
         @pubkey = pubkey
@@ -40,7 +41,7 @@ module Bitcoin
 
     # sign +data+ with private key
     def sign(data)
-      sign_data(data, priv_key)
+      secp256k1_module.sign_data(data, priv_key)
     end
 
     # verify signature using public key
@@ -48,7 +49,7 @@ module Bitcoin
     # @param [String] origin original message
     # @return [Boolean] verify result
     def verify(sig, origin)
-      verify_sig(origin, sig, pubkey)
+      secp256k1_module.verify_sig(origin, sig, pubkey)
     end
 
     # get pay to pubkey hash address
@@ -126,6 +127,17 @@ module Bitcoin
       0
     end
 
+    # generate publick key from private key
+    # @param [String] privkey a private key with string format
+    # @param [Boolean] compressed pubkey compressed?
+    # @return [String] a pubkey which generate from privkey
+    def generate_pubkey(privkey, compressed: true)
+      private_key = ECDSA::Format::IntegerOctetString.decode(privkey.htb)
+      public_key = ECDSA::Group::Secp256k1.generator.multiply_by_scalar(private_key)
+      pubkey = ECDSA::Format::PointOctetString.encode(public_key, compression: compressed)
+      pubkey.bth
+    end
+
   end
 
 end

data/lib/bitcoin/message/base.rb

@@ -22,18 +22,6 @@ module Bitcoin
         raise 'to_payload must be implemented in a child class.'
       end
 
-      def to_json
-        to_h.to_json
-      end
-
-      def to_h
-        instance_variables.inject({}) do |result, var|
-          key = var.to_s
-          key.slice!(0) if key.start_with?('@')
-          result.update(key => instance_variable_get(var))
-        end
-      end
-
     end
 
   end

data/lib/bitcoin/message/handler.rb

@@ -58,6 +58,8 @@ module Bitcoin
           on_version(Version.parse_from_payload(payload))
         when VerAck::COMMAND
           on_ver_ack
+        when GetAddr::COMMAND
+          on_get_addr
         when Addr::COMMAND
           on_addr(Addr.parse_from_payload(payload))
         when SendHeaders::COMMAND
@@ -84,6 +86,8 @@ module Bitcoin
           on_reject(Reject.parse_from_payload(payload))
         when SendCmpct::COMMAND
           on_send_cmpct(SendCmpct.parse_from_payload(payload))
+        when Inv::COMMAND
+          on_inv(Inv.parse_from_payload(payload))
         else
           logger.warn("unsupported command received. #{command}")
           conn.close("with command #{command}")
@@ -91,8 +95,8 @@ module Bitcoin
       end
 
       def on_version(version)
-        logger.info("receive version message. #{version.to_json}")
-        conn.send_data(VerAck.new.to_pkt)
+        logger.info("receive version message. #{version.build_json}")
+        conn.send_message(VerAck.new)
       end
 
       def on_ver_ack
@@ -100,8 +104,12 @@ module Bitcoin
         conn.handshake_done
       end
 
+      def on_get_addr
+        logger.info('receive getaddr message.')
+      end
+
       def on_addr(addr)
-        logger.info("receive addr message. #{addr.to_json}")
+        logger.info("receive addr message. #{addr.build_json}")
         # TODO
       end
 
@@ -111,42 +119,42 @@ module Bitcoin
       end
 
       def on_fee_filter(fee_filter)
-        logger.info("receive feefilter message. #{fee_filter.to_json}")
+        logger.info("receive feefilter message. #{fee_filter.build_json}")
         conn.fee_rate = fee_filter.fee_rate
       end
 
       def on_ping(ping)
-        logger.info("receive ping message. #{ping.to_json}")
-        conn.send_data(ping.to_response)
+        logger.info("receive ping message. #{ping.build_json}")
+        conn.send_message(ping.to_response)
       end
 
       def on_pong(pong)
-        logger.info("receive pong message. #{pong.to_json}")
+        logger.info("receive pong message. #{pong.build_json}")
         # TODO calculate response
       end
 
       def on_get_headers(headers)
-        logger.info("receive getheaders message. #{headers.to_json}")
+        logger.info("receive getheaders message. #{headers.build_json}")
         # TODO
       end
 
       def on_headers(headers)
-        logger.info("receive headers message. #{headers.to_json}")
+        logger.info("receive headers message. #{headers.build_json}")
         # TODO
       end
 
       def on_block(block)
-        logger.info("receive block message. #{block.to_json}")
+        logger.info("receive block message. #{block.build_json}")
         # TODO
       end
 
       def on_tx(tx)
-        logger.info("receive tx message. #{tx.to_json}")
+        logger.info("receive tx message. #{tx.build_json}")
         # TODO
       end
 
       def on_not_found(not_found)
-        logger.info("receive notfound message. #{not_found.to_json}")
+        logger.info("receive notfound message. #{not_found.build_json}")
         # TODO
       end
 
@@ -156,15 +164,20 @@ module Bitcoin
       end
 
       def on_reject(reject)
-        logger.warn("receive reject message. #{reject.to_json}")
+        logger.warn("receive reject message. #{reject.build_json}")
         # TODO
       end
 
       def on_send_cmpct(cmpct)
-        logger.info("receive sendcmpct message. #{cmpct.to_json}")
+        logger.info("receive sendcmpct message. #{cmpct.build_json}")
         # TODO if mode is high and version is 1, relay block with cmpctblock message
       end
 
+      def on_inv(inv)
+        logger.info("receive inv message. #{inv.build_json}")
+        # TODO
+      end
+
     end
   end
 end

data/lib/bitcoin/message/version.rb

@@ -19,7 +19,7 @@ module Bitcoin
 
       def initialize(opts = {})
         @version = Bitcoin.chain_params.protocol_version
-        @services = Bitcoin::Message::SERVICE_FLAGS[:network]
+        @services = DEFAULT_SERVICE_FLAGS
         @timestamp = Time.now.to_i
         @local_addr = "127.0.0.1:#{Bitcoin.chain_params.default_port}"
         @remote_addr = "127.0.0.1:#{Bitcoin.chain_params.default_port}"

data/lib/bitcoin/message.rb

@@ -34,7 +34,16 @@ module Bitcoin
     HEADER_SIZE = 24
     USER_AGENT = "/bitcoinrb:#{Bitcoin::VERSION}/"
 
-    SERVICE_FLAGS = {none: 0, network: 1 << 0, getutxo: 1 << 1, bloom: 1 << 2, witness: 1 << 3, xthin: 1 << 4}
+    SERVICE_FLAGS = {
+        none: 0,
+        network: 1 << 0,  # the node is capable of serving the block chain. It is currently set by all Bitcoin Core nodes, and is unset by SPV clients or other peers that just want network services but don't provide them.
+        # getutxo: 1 << 1, # BIP-64. not implemented in Bitcoin Core.
+        bloom: 1 << 2,    # the node is capable and willing to handle bloom-filtered connections. Bitcoin Core nodes used to support this by default, without advertising this bit, but no longer do as of protocol version 70011 (= NO_BLOOM_VERSION)
+        witness: 1 << 3,  # the node can be asked for blocks and transactions including witness data.
+        # xthin: 1 << 4 # support Xtreme Thinblocks. not implemented in Bitcoin Core
+    }
+
+    DEFAULT_SERVICE_FLAGS = SERVICE_FLAGS[:network] | SERVICE_FLAGS[:bloom] | SERVICE_FLAGS[:witness]
 
     DEFAULT_STOP_HASH = "00"*32
 

data/lib/bitcoin/opcodes.rb

@@ -116,8 +116,8 @@ module Bitcoin
     OP_CHECKMULTISIGVERIFY = 0xaf
 
     # https://en.bitcoin.it/wiki/Script#Locktime
-    OP_CHECKLOCKTIMEVERIFY = OP_NOP2 = 0xb1
-    OP_CHECKSEQUENCEVERIFY = OP_NOP3 = 0xb2
+    OP_NOP2 = OP_CHECKLOCKTIMEVERIFY = 0xb1
+    OP_NOP3 = OP_CHECKSEQUENCEVERIFY = 0xb2
 
     # https://en.bitcoin.it/wiki/Script#Reserved_words
     OP_RESERVED = 0x50

data/lib/bitcoin/out_point.rb

@@ -9,7 +9,7 @@ module Bitcoin
     attr_reader :hash
     attr_reader :index
 
-    def initialize(hash, index)
+    def initialize(hash, index = -1)
       @hash = hash
       @index = index
     end
@@ -26,6 +26,10 @@ module Bitcoin
       new(COINBASE_HASH, COINBASE_INDEX)
     end
 
+    def valid?
+      index >= 0 && (!coinbase? && hash != COINBASE_HASH)
+    end
+
   end
 
 end

data/lib/bitcoin/script/script.rb

@@ -4,33 +4,6 @@ module Bitcoin
   class Script
     include Bitcoin::Opcodes
 
-    # witness version
-    WITNESS_VERSION = 0x00
-
-    # Maximum script length in bytes
-    MAX_SCRIPT_SIZE = 10000
-
-    # Maximum number of public keys per multisig
-    MAX_PUBKEYS_PER_MULTISIG = 20
-
-    # Maximum number of non-push operations per script
-    MAX_OPS_PER_SCRIPT = 201
-
-    # Maximum number of bytes pushable to the stack
-    MAX_SCRIPT_ELEMENT_SIZE = 520
-
-    # Maximum number of size in the stack
-    MAX_STACK_SIZE = 1000
-
-    # Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
-    LOCKTIME_THRESHOLD = 500000000
-
-    # Signature hash types/flags
-    SIGHASH_TYPE = { all: 1, none: 2, single: 3, anyonecanpay: 128 }
-
-    # Maximum number length in bytes
-    DEFAULT_MAX_NUM_SIZE = 4
-
     attr_accessor :chunks
 
     def initialize
@@ -53,8 +26,13 @@ module Bitcoin
     # @return [Script, Script] first element is p2sh script, second one is redeem script.
     def self.to_p2sh_multisig_script(m, pubkeys)
       redeem_script = to_multisig_script(m, pubkeys)
-      p2sh_script = new << OP_HASH160 << redeem_script.to_hash160 << OP_EQUAL
-      [p2sh_script, redeem_script]
+      [redeem_script.to_p2sh, redeem_script]
+    end
+
+    # generate p2sh script with this as a redeem script
+    # @return [Script] P2SH script
+    def to_p2sh
+      Script.new << OP_HASH160 << to_hash160 << OP_EQUAL
     end
 
     # generate m of n multisig script
@@ -93,17 +71,27 @@ module Bitcoin
         opcode = buf.read(1)
         if opcode.pushdata?
           pushcode = opcode.ord
+          packed_size = nil
           len = case pushcode
                   when OP_PUSHDATA1
-                    buf.read(1).unpack('C').first
+                    packed_size = buf.read(1)
+                    packed_size.unpack('C').first
                   when OP_PUSHDATA2
-                    buf.read(2).unpack('v').first
+                    packed_size = buf.read(2)
+                    packed_size.unpack('v').first
                   when OP_PUSHDATA4
-                    buf.read(4).unpack('V').first
+                    packed_size = buf.read(4)
+                    packed_size.unpack('V').first
                   else
                     pushcode if pushcode < OP_PUSHDATA1
                 end
-          s << buf.read(len).bth if len
+          if len
+            s.chunks << [len].pack('C') if buf.eof?
+            unless buf.eof?
+              chunk = (packed_size ? (opcode + packed_size) : (opcode)) + buf.read(len)
+              s.chunks << chunk
+            end
+          end
         else
           s << opcode.ord
         end
@@ -115,6 +103,10 @@ module Bitcoin
       chunks.join
     end
 
+    def to_hex
+      to_payload.bth
+    end
+
     def to_addr
       return p2pkh_addr if p2pkh?
       return p2wpkh_addr if p2wpkh?
@@ -122,6 +114,11 @@ module Bitcoin
       return p2sh_addr if p2sh?
     end
 
+    # check whether standard script.
+    def standard?
+      p2pkh? | p2sh? | p2wpkh? | p2wsh? | multisig? | standard_op_return?
+    end
+
     # whether this script is a P2PKH format script.
     def p2pkh?
       return false unless chunks.size == 5
@@ -145,8 +142,25 @@ module Bitcoin
       OP_HASH160 == chunks[0].ord && OP_EQUAL == chunks[2].ord && chunks[1].bytesize == 21
     end
 
+    def multisig?
+      return false if chunks.size < 4 || chunks.last.ord != OP_CHECKMULTISIG
+      pubkey_count = Opcodes.opcode_to_small_int(chunks[-2].opcode)
+      sig_count = Opcodes.opcode_to_small_int(chunks[0].opcode)
+      return false unless pubkey_count || sig_count
+      sig_count < pubkey_count
+    end
+
+    def op_return?
+      chunks.size >= 1 && chunks[0].ord == OP_RETURN
+    end
+
+    def standard_op_return?
+      op_return? && size <= MAX_OP_RETURN_RELAY &&
+          (chunks.size == 1 || chunks[1].opcode <= OP_16)
+    end
+
     # whether data push only script which dose not include other opcode
-    def data_only?
+    def push_only?
       chunks.each do |c|
         return false if !c.opcode.nil? && c.opcode > OP_16
       end
@@ -156,11 +170,30 @@ module Bitcoin
     # A witness program is any valid Script that consists of a 1-byte push opcode followed by a data push between 2 and 40 bytes.
     def witness_program?
       return false if size < 4 || size > 42 || chunks.size < 2
+
       opcode = chunks[0].opcode
+
       return false if opcode != OP_0 && (opcode < OP_1 || opcode > OP_16)
       return false unless chunks[1].pushdata?
-      program_size = chunks[1].pushed_data.bytesize
-      program_size >= 2 && program_size <= 40
+
+      if size == (chunks[1][0].unpack('C').first + 2)
+        program_size = chunks[1].pushed_data.bytesize
+        return program_size >= 2 && program_size <= 40
+      end
+
+      false
+    end
+
+    # If this script is witness program, return its script code,
+    # otherwise returns the self payload. ScriptInterpreter does not use this.
+    def to_script_code(skip_separator_index = 0)
+      payload = to_payload
+      if p2wpkh?
+        payload = Script.to_p2pkh(chunks[1].pushed_data.bth).to_payload
+      elsif skip_separator_index > 0
+        payload = subscript_codeseparator(skip_separator_index)
+      end
+      Bitcoin.pack_var_string(payload)
     end
 
     # get witness version and witness program
@@ -295,8 +328,54 @@ module Bitcoin
     # removes chunks matching subscript byte-for-byte and returns as a new object.
     def find_and_delete(subscript)
       raise ArgumentError, 'subscript must be Bitcoin::Script' unless subscript.is_a?(Script)
-      diff = to_payload.bth.gsub(subscript.to_payload.bth, '')
-      Script.parse_from_payload(diff.htb)
+      return self if subscript.chunks.empty?
+      buf = []
+      i = 0
+      result = Script.new
+      chunks.each do |chunk|
+        sub_chunk = subscript.chunks[i]
+        if chunk.start_with?(sub_chunk)
+          if chunk == sub_chunk
+            buf << chunk
+            i += 1
+            (i = 0; buf.clear) if i == subscript.chunks.size # matched the whole subscript
+          else # matched the part of head
+            i = 0
+            tmp = chunk.dup
+            tmp.slice!(sub_chunk)
+            result.chunks << tmp
+          end
+        else
+          result.chunks << buf.join unless buf.empty?
+          if buf.first == chunk
+            i = 1
+            buf = [chunk]
+          else
+            i = 0
+            result.chunks << chunk
+          end
+        end
+      end
+      result
+    end
+
+    # remove all occurences of opcode. Typically it's OP_CODESEPARATOR.
+    def delete_opcode(opcode)
+      @chunks = chunks.select{|chunk| chunk.ord != opcode}
+      self
+    end
+
+    # Returns a script that deleted the script before the index specified by separator_index.
+    def subscript_codeseparator(separator_index)
+      buf = []
+      process_separator_index = 0
+      chunks.each{|chunk|
+        buf << chunk if process_separator_index == separator_index
+        if chunk.ord == OP_CODESEPARATOR && process_separator_index < separator_index
+          process_separator_index += 1
+        end
+      }
+      buf.join
     end
 
     def ==(other)