bech32 1.5.1 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22cba51d19b0989743f7f679f187311e735ce018dec53880ddfefebee89f688f
-  data.tar.gz: 1cd7be33ab83fd724054202a812f818ed02adb5eb7545baa27e27f6b3358da2e
+  metadata.gz: 535da278f3fe4aa746212b6dbefb7bc34f691fe35cc62af48d7445f20e14510f
+  data.tar.gz: d01f1e5560dc1efcfc9f362b103119d72f74cf04a7cd3b5bb6e1f236ffad2dc1
 SHA512:
-  metadata.gz: dc71997f097a817224b687dc53baf048ba2954cd030f7db50523d7e45121632b7f2edf758ed78298102214c3e3407cf7c7da6b3469a3cde089ade10e8346088d
-  data.tar.gz: 6c246c4107a40193d317738bfa4637ccf6452efb48f1d36532570cec1e09681cc17fd374f47361467017e6546f36c4513f2585ed2d4b767939dcef05047ede46
+  metadata.gz: 3adb0de41823618cded9061c3c7bb4802363eea877d6ca44cf56c02e5bb6f8a7829943d171a9c91419d99ce7ff2abe6652ef3de0c907ecfee8d4b06da87d641a
+  data.tar.gz: bf708f4783d906e79e03dfc4ba420a8a02ed985fe23dc62d1c4024045df9d42c746f421efc9576648eb2e27213e26539606aeca85a04572e4dc2417e0cf7b72f

data/README.md

@@ -135,7 +135,7 @@ Supports encoding/decoding of Nostr's [NIP-19](https://github.com/nostr-protocol
 ```ruby
 # Decode bare entity
 bech32 = 'npub10elfcs4fr0l0r8af98jlmgdh9c8tcxjvz9qkw038js35mp4dma8qzvjptg'
-entity = Bech32::Nostr::NIP19.parse(bech32)
+entity = Bech32::Nostr::NIP19.decode(bech32)
 entity.hrp
 => 'npub'
 entity.data
@@ -143,7 +143,7 @@ entity.data
 
 # Decode tlv entity
 bech32 = 'nprofile1qqsrhuxx8l9ex335q7he0f09aej04zpazpl0ne2cgukyawd24mayt8gpp4mhxue69uhhytnc9e3k7mgpz4mhxue69uhkg6nzv9ejuumpv34kytnrdaksjlyr9p'
-entity = Bech32::Nostr::NIP19.parse(bech32)
+entity = Bech32::Nostr::NIP19.decode(bech32)
 entity.hrp
 => 'nprofile'
 entity.entries[0].value

data/exe/bech32

@@ -7,13 +7,16 @@ class CLI < Thor
 
   desc 'encode hrp data bech32/bech32m', 'Encoding data to bech32/bech32m string.'
   def encode(hrp, data, type)
-    if type && !['bech32', 'bech32m'].include?(type)
+    unless ['bech32', 'bech32m'].include?(type)
       puts 'Invalid type value. type must be bech32 or bech32m.'
-    else
-      spec = type.nil? || type == 'bech32' ? 1 : 2
-      data = [data].pack('H*').unpack('C*')
-      puts Bech32.encode(hrp, data, spec)
+      exit 1
     end
+    spec = type == 'bech32' ? Bech32::Encoding::BECH32 : Bech32::Encoding::BECH32M
+    data = [data].pack('H*').unpack('C*')
+    puts Bech32.encode(hrp, data, spec)
+  rescue ArgumentError => e
+    puts "Can not encode: #{e.message}"
+    exit 1
   end
 
   desc 'decode "bech32string"', 'Decoding bech32/bech32m string.'
@@ -54,7 +57,11 @@ class CLI < Thor
       end
     else
       puts 'Can not decode.'
+      exit 1
     end
+  rescue ArgumentError => e
+    puts "Can not decode: #{e.message}"
+    exit 1
   end
 
 end

data/lib/bech32/nostr/entity.rb

@@ -1,3 +1,5 @@
+require 'stringio'
+
 module Bech32
   module Nostr
     class BareEntity
@@ -35,15 +37,30 @@ module Bech32
         @label = label
       end
 
+      # Maximum byte length of a TLV value (the length field is 1 byte).
+      MAX_VALUE_LENGTH = 255
+
       # Convert to binary data.
+      # @param [String] hrp human-readable part of the entity this entry belongs to.
+      # It determines whether a special entry's value is a hex string (nprofile, nevent)
+      # or a raw string (nrelay, naddr). If omitted, a special value is treated as hex
+      # only when it looks like a hex string.
       # @return [String] binary data.
-      def to_payload
+      # @raise [ArgumentError] if the value is out of range or longer than MAX_VALUE_LENGTH bytes.
+      def to_payload(hrp = nil)
         data = if value.is_a?(Integer)
+                 unless value.between?(0, 0xffffffff)
+                   raise ArgumentError, "Integer value must be between 0 and #{0xffffffff}."
+                 end
                  [value].pack('N')
+               elsif hex_value?(hrp)
+                 raise ArgumentError, "Value of type #{type} must be a hex string." unless hex_string?(value)
+                 [value].pack('H*')
                else
-                 hex_string?(value) ? [value].pack('H*') : value
+                 value.b
                end
         len = data.bytesize
+        raise ArgumentError, "Value must be at most #{MAX_VALUE_LENGTH} bytes." if len > MAX_VALUE_LENGTH
         [type, len].pack('CC') + data
       end
 
@@ -65,6 +82,20 @@ module Bech32
 
       private
 
+      # Check whether the value of this entry is a hex-encoded string.
+      # @param [String] hrp human-readable part (may be nil).
+      # @return [Boolean]
+      def hex_value?(hrp)
+        case type
+        when TLVEntity::TYPE_AUTHOR
+          true
+        when TLVEntity::TYPE_SPECIAL
+          hrp.nil? ? hex_string?(value) : [NIP19::HRP_PROFILE, NIP19::HRP_EVENT].include?(hrp)
+        else
+          false
+        end
+      end
+
       # Check whether +str+ is hex string or not.
       # @param [String] str string.
       # @return [Boolean]
@@ -122,16 +153,18 @@ module Bech32
             when NIP19::HRP_PROFILE
               entries << TLVEntry.new(type, value.unpack1('H*'), 'pubkey')
             when NIP19::HRP_RELAY
-              entries << TLVEntry.new(type, value, 'relay')
+              entries << TLVEntry.new(type, value.force_encoding(::Encoding::UTF_8), 'relay')
             when NIP19::HRP_EVENT
               entries << TLVEntry.new(type, value.unpack1('H*'), 'id')
             when NIP19::HRP_EVENT_COORDINATE
-              entries << TLVEntry.new(type, value, 'identifier')
+              entries << TLVEntry.new(type, value.force_encoding(::Encoding::UTF_8), 'identifier')
+            else
+              raise ArgumentError, "Type: #{type} does not supported for HRP: #{hrp}"
             end
           when TYPE_RELAY # relay
             case hrp
             when NIP19::HRP_PROFILE, NIP19::HRP_EVENT, NIP19::HRP_EVENT_COORDINATE
-              entries << TLVEntry.new(type, value, 'relay')
+              entries << TLVEntry.new(type, value.force_encoding(::Encoding::UTF_8), 'relay')
             else
               raise ArgumentError, "Type: #{type} does not supported for HRP: #{hrp}"
             end
@@ -145,7 +178,8 @@ module Bech32
           when TYPE_KIND # kind
             case hrp
             when NIP19::HRP_EVENT, NIP19::HRP_EVENT_COORDINATE
-              entries << TLVEntry.new(type, value.unpack1('H*').to_s.to_i(16), 'kind')
+              raise ArgumentError, 'Invalid TLV: kind must be 4 bytes.' unless value.bytesize == 4
+              entries << TLVEntry.new(type, value.unpack1('N'), 'kind')
             else
               raise ArgumentError, "Type: #{type} does not supported for HRP: #{hrp}"
             end
@@ -160,7 +194,7 @@ module Bech32
       # Encode tlv entity to bech32 string.
       # @return [String] bech32 string.
       def encode
-        data = entries.map(&:to_payload).join
+        data = entries.map { |e| e.to_payload(hrp) }.join
         Bech32.encode(hrp, Bech32.convert_bits(data.unpack('C*'), 8, 5), Bech32::Encoding::BECH32)
       end
     end

data/lib/bech32/nostr.rb

@@ -2,6 +2,7 @@ module Bech32
   module Nostr
     autoload :NIP19, 'bech32/nostr/nip19'
     autoload :BareEntity, 'bech32/nostr/entity'
+    autoload :TLVEntry, 'bech32/nostr/entity'
     autoload :TLVEntity, 'bech32/nostr/entity'
   end
 

data/lib/bech32/segwit_addr.rb

@@ -10,6 +10,8 @@ module Bech32
     attr_accessor :ver # witness version
     attr_accessor :prog # witness program
 
+    # @param [String] addr segwit address. If given, it is parsed into hrp, witness version and program.
+    # @raise [ArgumentError] if addr is not a valid segwit address.
     def initialize(addr = nil)
       @hrp = HRP_MAINNET
       parse_addr(addr) if addr
@@ -22,10 +24,26 @@ module Bech32
     end
 
     # parse script pubkey into witness version and witness program
+    # @param [String] script_pubkey segwit script pubkey with hex format.
+    # @raise [ArgumentError] if the script is not a valid segwit script pubkey.
     def script_pubkey=(script_pubkey)
-      values = [script_pubkey].pack('H*').unpack("C*")
-      @ver = values[0] == 0 ? values[0] : values[0] - 0x50
-      @prog = values[2..-1]
+      raise ArgumentError, 'script_pubkey must be String.' unless script_pubkey.is_a?(String)
+      values = [script_pubkey].pack('H*').unpack('C*')
+      raise ArgumentError, 'Invalid segwit script pubkey.' if values.length < 2
+      op, push_len = values[0], values[1]
+      prog = values[2..-1]
+      ver = if op == 0
+              0
+            elsif op.between?(0x51, 0x60) # OP_1..OP_16
+              op - 0x50
+            else
+              raise ArgumentError, 'Invalid segwit script pubkey.'
+            end
+      raise ArgumentError, 'Invalid segwit script pubkey.' unless push_len == prog.length
+      raise ArgumentError, 'Invalid witness program' if prog.length < 2 || prog.length > 40
+      raise ArgumentError, 'Invalid witness program with version 0' if ver == 0 && prog.length != 20 && prog.length != 32
+      @ver = ver
+      @prog = prog
     end
 
     # Returns segwit address string which generated from hrp, witness version and witness program.
@@ -38,13 +56,13 @@ module Bech32
 
     def parse_addr(addr)
       @hrp, data, spec = Bech32.decode(addr)
-      raise 'Invalid address.' if hrp.nil? || data[0].nil? || ![HRP_MAINNET, HRP_TESTNET, HRP_REGTEST].include?(hrp)
+      raise ArgumentError, 'Invalid address.' if hrp.nil? || data[0].nil? || ![HRP_MAINNET, HRP_TESTNET, HRP_REGTEST].include?(hrp)
       @ver = data[0]
-      raise 'Invalid witness version' if @ver > 16
+      raise ArgumentError, 'Invalid witness version' if @ver > 16
       @prog = Bech32.convert_bits(data[1..-1], 5, 8, false)
-      raise 'Invalid witness program' if @prog.nil? || @prog.length < 2 || @prog.length > 40
-      raise 'Invalid witness program with version 0' if @ver == 0 && (@prog.length != 20 && @prog.length != 32)
-      raise 'Witness version and encoding spec do not match' if (@ver == 0 && spec != Bech32::Encoding::BECH32) || (@ver != 0 && spec != Bech32::Encoding::BECH32M)
+      raise ArgumentError, 'Invalid witness program' if @prog.nil? || @prog.length < 2 || @prog.length > 40
+      raise ArgumentError, 'Invalid witness program with version 0' if @ver == 0 && (@prog.length != 20 && @prog.length != 32)
+      raise ArgumentError, 'Witness version and encoding spec do not match' if (@ver == 0 && spec != Bech32::Encoding::BECH32) || (@ver != 0 && spec != Bech32::Encoding::BECH32M)
     end
 
   end

data/lib/bech32/silent_payment_addr.rb

@@ -5,6 +5,9 @@ module Bech32
     HRP_MAINNET = 'sp'
     HRP_TESTNET = 'tsp'
 
+    # Maximum valid version. Version 31 is reserved as invalid by BIP-352.
+    MAX_VERSION = 30
+
     attr_reader :hrp
     attr_reader :version
     attr_reader :scan_key
@@ -18,6 +21,7 @@ module Bech32
     def initialize(hrp, version, scan_key, spend_key)
       raise ArgumentError, "hrp must be sp or tsp." unless [HRP_MAINNET, HRP_TESTNET].include?(hrp)
       raise ArgumentError, "version must be Integer." unless version.is_a?(Integer)
+      raise ArgumentError, "version must be between 0 and #{MAX_VERSION}." unless version.between?(0, MAX_VERSION)
       raise ArgumentError, "scan_key must be String." unless scan_key.is_a?(String)
       raise ArgumentError, "spend_key must be String." unless spend_key.is_a?(String)
       raise ArgumentError, 'scan_key must be 33 bytes.' unless [scan_key].pack('H*').bytesize == 33

data/lib/bech32/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bech32
-  VERSION = '1.5.1'
+  VERSION = '1.6.0'
 end

data/lib/bech32.rb

@@ -15,6 +15,9 @@ module Bech32
 
   BECH32M_CONST = 0x2bc830a3
 
+  # Maximum length of the human-readable part.
+  HRP_MAX_LENGTH = 83
+
   module_function
 
   # Returns the encoded Bech32 string.
@@ -26,7 +29,12 @@ module Bech32
   #   <i>Generates:</i>
   #   'BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4' # bech
   #
+  # @param [String] hrp human-readable part (1 to 83 lowercase characters in the range 33-126).
+  # @param [Array<Integer>] data data values (each 0 to 31).
+  # @param [Integer] spec encoding spec, see Bech32::Encoding.
+  # @raise [ArgumentError] if hrp or data is invalid.
   def encode(hrp, data, spec)
+    validate_encode_args(hrp, data)
     checksummed = data + create_checksum(hrp, data, spec)
     hrp + SEPARATOR + checksummed.map{|i|CHARSET[i]}.join
   end
@@ -117,6 +125,24 @@ module Bech32
     ret
   end
 
+  # Validate arguments of encode.
+  # @param [String] hrp human-readable part.
+  # @param [Array<Integer>] data data values.
+  # @raise [ArgumentError]
+  def validate_encode_args(hrp, data)
+    raise ArgumentError, 'hrp must be String.' unless hrp.is_a?(String)
+    unless hrp.length.between?(1, HRP_MAX_LENGTH)
+      raise ArgumentError, "hrp must be between 1 and #{HRP_MAX_LENGTH} characters."
+    end
+    if hrp.bytes.any? { |b| b < 33 || b > 126 } || hrp != hrp.downcase
+      raise ArgumentError, 'hrp must consist of lowercase characters in the range 33-126.'
+    end
+    raise ArgumentError, 'data must be Array.' unless data.is_a?(Array)
+    unless data.all? { |v| v.is_a?(Integer) && v.between?(0, 31) }
+      raise ArgumentError, 'data values must be Integer between 0 and 31.'
+    end
+  end
+
   # Compute Bech32 checksum
   def polymod(values)
     generator = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]
@@ -129,6 +155,6 @@ module Bech32
     chk
   end
 
-  private_class_method :polymod, :expand_hrp
+  private_class_method :polymod, :expand_hrp, :validate_encode_args
 
 end

data/sig/bech32/bech32.rbs

@@ -9,6 +9,7 @@ module Bech32
   SEPARATOR: String
   CHARSET: Array[String]
   BECH32M_CONST: Integer
+  HRP_MAX_LENGTH: Integer
 
   # Encode hrp and data to bech32/bech32m string.
   def self.encode: (String hrp, Array[Integer] data, Integer spec) -> String
@@ -40,6 +41,10 @@ module Bech32
   # Compute polymod checksum.
   def self.polymod: (Array[Integer] values) -> Integer
 
+  # Validate arguments of encode.
+  def self.validate_encode_args: (String hrp, Array[Integer] data) -> void
+
   def expand_hrp: (String hrp) -> Array[Integer]
   def polymod: (Array[Integer] values) -> Integer
+  def validate_encode_args: (String hrp, Array[Integer] data) -> void
 end

data/sig/bech32/nostr/entity.rbs

@@ -12,6 +12,8 @@ module Bech32
     end
 
     class TLVEntry
+      MAX_VALUE_LENGTH: Integer
+
       attr_reader type: Integer
       attr_reader label: String?
       attr_reader value: String | Integer
@@ -20,13 +22,16 @@ module Bech32
       def initialize: (Integer type, String | Integer value, ?String? label) -> void
 
       # Convert to binary payload.
-      def to_payload: () -> String
+      def to_payload: (?String? hrp) -> String
 
       # String representation.
       def to_s: () -> String
 
       private
 
+      # Check if the value of this entry is hex encoded.
+      def hex_value?: (String? hrp) -> bool
+
       # Check if string is hex encoded.
       def hex_string?: (String str) -> bool
     end

data/sig/bech32/silent_payment_addr.rbs

@@ -3,6 +3,7 @@ module Bech32
   class SilentPaymentAddr
     HRP_MAINNET: String
     HRP_TESTNET: String
+    MAX_VERSION: Integer
 
     attr_reader hrp: String
     attr_reader version: Integer

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bech32
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.6.0
 platform: ruby
 authors:
 - Shigeyuki Azuchi