bech32 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 368eb6deb6248ddb8f5cbcba18ec90a3ed11b84f60a3de80bb59301eb5c7f1a2
-  data.tar.gz: a0d8654790ab71f8460eecdbf17248e8acd3748bf2011b94afe32dd079b2248b
+  metadata.gz: 535da278f3fe4aa746212b6dbefb7bc34f691fe35cc62af48d7445f20e14510f
+  data.tar.gz: d01f1e5560dc1efcfc9f362b103119d72f74cf04a7cd3b5bb6e1f236ffad2dc1
 SHA512:
-  metadata.gz: f3aad0caf6fce5ce425bd0c4e59e934ecfe96bc6fec30cd5c5c7a6ee73f266824c7f90193f4e008ea24f8a65239d13c3763d35c8211d5fa2485cb8317e56d527
-  data.tar.gz: 4891f6c6f80b6b11cd136637c9fd204070a2fab2b170919b34c976219d9885eb8ed43ba688b2002fcc1db4df4b2755d1b169744cfaea578e64336afa327b4b65
+  metadata.gz: 3adb0de41823618cded9061c3c7bb4802363eea877d6ca44cf56c02e5bb6f8a7829943d171a9c91419d99ce7ff2abe6652ef3de0c907ecfee8d4b06da87d641a
+  data.tar.gz: bf708f4783d906e79e03dfc4ba420a8a02ed985fe23dc62d1c4024045df9d42c746f421efc9576648eb2e27213e26539606aeca85a04572e4dc2417e0cf7b72f

data/.github/workflows/main.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['3.0', '3.1', '3.2', '3.3', '3.4']
+        ruby-version: ['3.2', '3.3', '3.4', '4.0']
 
     steps:
       - uses: actions/checkout@v4
@@ -32,3 +32,16 @@ jobs:
           bundler-cache: true # runs 'bundle install' and caches installed gems automatically
       - name: Run tests
         run: bundle exec rake
+
+  typecheck:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.4'
+          bundler-cache: true
+      - name: Run type check
+        run: bundle exec steep check

data/.ruby-version

@@ -1 +1 @@
-ruby-3.4.1
+ruby-4.0.0

data/Gemfile

@@ -2,3 +2,8 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in bech32.gemspec
 gemspec
+
+group :development do
+  gem 'steep'
+  gem 'rbs'
+end

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/Steepfile

@@ -0,0 +1,19 @@
+# Steepfile
+target :lib do
+  signature "sig"
+
+  check "lib"
+
+  library "stringio"
+
+  # Configure diagnostic severity
+  # These errors are from Ruby code patterns that are runtime-safe but hard to express in RBS
+  configure_code_diagnostics do |hash|
+    # Suppress errors for method calls on potentially nil values
+    # The actual code handles nil cases properly at runtime
+    hash[Steep::Diagnostic::Ruby::NoMethod] = :hint
+    hash[Steep::Diagnostic::Ruby::ArgumentTypeMismatch] = :hint
+    hash[Steep::Diagnostic::Ruby::MethodBodyTypeMismatch] = :hint
+    hash[Steep::Diagnostic::Ruby::UnannotatedEmptyCollection] = :hint
+  end
+end

data/bech32.gemspec

@@ -13,8 +13,10 @@ Gem::Specification.new do |spec|
   spec.description   = %q(The implementation of Bech32 encoder and decoder.)
   spec.homepage      = 'https://github.com/azuchi/bech32rb'
   spec.license       = 'MIT'
+  spec.metadata      = { 'rubygems_mfa_required' => 'true' }
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.files         += Dir['sig/**/*.rbs']
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']

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]
@@ -110,37 +141,45 @@ module Bech32
         buf = ::StringIO.new(data)
         entries = []
         until buf.eof?
-          type, len = buf.read(2).unpack('CC')
+          header = buf.read(2)
+          raise ArgumentError, "Invalid TLV: truncated header." if header.nil? || header.bytesize < 2
+          type, len = header.unpack('CC')
+          value = buf.read(len)
+          raise ArgumentError, "Invalid TLV: truncated value." if value.nil? ? len > 0 : value.bytesize < len
+          value ||= ''
           case type
           when TYPE_SPECIAL # special
             case hrp
             when NIP19::HRP_PROFILE
-              entries << TLVEntry.new(type, buf.read(len).unpack1('H*'), 'pubkey')
+              entries << TLVEntry.new(type, value.unpack1('H*'), 'pubkey')
             when NIP19::HRP_RELAY
-              entries << TLVEntry.new(type, buf.read(len), 'relay')
+              entries << TLVEntry.new(type, value.force_encoding(::Encoding::UTF_8), 'relay')
             when NIP19::HRP_EVENT
-              entries << TLVEntry.new(type, buf.read(len).unpack1('H*'), 'id')
+              entries << TLVEntry.new(type, value.unpack1('H*'), 'id')
             when NIP19::HRP_EVENT_COORDINATE
-              entries << TLVEntry.new(type, buf.read(len), '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, buf.read(len), 'relay')
+              entries << TLVEntry.new(type, value.force_encoding(::Encoding::UTF_8), 'relay')
             else
               raise ArgumentError, "Type: #{type} does not supported for HRP: #{hrp}"
             end
           when TYPE_AUTHOR # author
             case hrp
             when NIP19::HRP_EVENT, NIP19::HRP_EVENT_COORDINATE
-              entries << TLVEntry.new(type, buf.read(len).unpack1('H*'), 'author')
+              entries << TLVEntry.new(type, value.unpack1('H*'), 'author')
             else
               raise ArgumentError, "Type: #{type} does not supported for HRP: #{hrp}"
             end
           when TYPE_KIND # kind
             case hrp
             when NIP19::HRP_EVENT, NIP19::HRP_EVENT_COORDINATE
-              entries << TLVEntry.new(type, buf.read(len).unpack1('H*').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
@@ -155,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/nip19.rb

@@ -28,7 +28,9 @@ module Bech32
         raise ArgumentError, 'Invalid nip19 string.' if hrp.nil?
         raise ArgumentError, 'Invalid bech32 spec.' unless spec == Bech32::Encoding::BECH32
 
-        entity = Bech32.convert_bits(data, 5, 8, false).pack('C*')
+        converted = Bech32.convert_bits(data, 5, 8, false)
+        raise ArgumentError, 'Invalid data.' if converted.nil?
+        entity = converted.pack('C*')
         raise ArgumentError, "Data whose HRP is #{hrp} must be 32 bytes." if BARE_PREFIXES.include?(hrp) && entity.bytesize != 32
         if BARE_PREFIXES.include?(hrp)
           BareEntity.new(hrp, entity.unpack1('H*'))

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
@@ -38,7 +42,9 @@ module Bech32
       raise ArgumentError, "addr must be encoded with bech32m." unless spec == Bech32::Encoding::BECH32M
       raise ArgumentError, 'Invalid hrp.' if hrp.nil? || data[0].nil? || ![HRP_MAINNET, HRP_TESTNET].include?(hrp)
       version = data[0]
-      keys = Bech32.convert_bits(data[1..-1], 5, 8, false).pack('C*').unpack1('H*')
+      converted = Bech32.convert_bits(data[1..-1], 5, 8, false)
+      raise ArgumentError, "Invalid data." if converted.nil?
+      keys = converted.pack('C*').unpack1('H*')
       raise ArgumentError, "Invalid key size." unless keys.length == 132
       scan = keys[0...66]
       spend = keys[66..-1]

data/lib/bech32/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bech32
-  VERSION = '1.5.0'
+  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
@@ -50,7 +58,7 @@ module Bech32
     bech = bech.downcase
     # check data length
     pos = bech.rindex(SEPARATOR)
-    return nil if pos.nil? || pos + 7 > bech.length || bech.length > max_length
+    return nil if pos.nil? || pos < 1 || pos + 7 > bech.length || bech.length > max_length
     # check valid charset
     bech[pos+1..-1].each_char{|c|return nil unless CHARSET.include?(c)}
     # split hrp and data
@@ -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

@@ -0,0 +1,50 @@
+module Bech32
+  VERSION: String
+
+  module Encoding
+    BECH32: Integer
+    BECH32M: Integer
+  end
+
+  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
+
+  # Decode bech32/bech32m string. Returns nil if invalid.
+  def self.decode: (String bech, ?Integer max_length) -> [String, Array[Integer], Integer]?
+
+  # Convert bits from one base to another.
+  def self.convert_bits: (Array[Integer] data, Integer from, Integer to, ?bool padding) -> Array[Integer]?
+
+  # Create checksum for hrp and data.
+  def self.create_checksum: (String hrp, Array[Integer] data, Integer spec) -> Array[Integer]
+
+  # Verify checksum. Returns encoding spec if valid, nil otherwise.
+  def self.verify_checksum: (String hrp, Array[Integer] data) -> Integer?
+
+  # module_function methods are also available as instance methods
+  def encode: (String hrp, Array[Integer] data, Integer spec) -> String
+  def decode: (String bech, ?Integer max_length) -> [String, Array[Integer], Integer]?
+  def convert_bits: (Array[Integer] data, Integer from, Integer to, ?bool padding) -> Array[Integer]?
+  def create_checksum: (String hrp, Array[Integer] data, Integer spec) -> Array[Integer]
+  def verify_checksum: (String hrp, Array[Integer] data) -> Integer?
+
+  private
+
+  # Expand HRP for checksum computation.
+  def self.expand_hrp: (String hrp) -> Array[Integer]
+
+  # 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

@@ -0,0 +1,59 @@
+module Bech32
+  module Nostr
+    class BareEntity
+      attr_reader hrp: String
+      attr_reader data: String
+
+      # Initialize bare entity.
+      def initialize: (String hrp, String data) -> void
+
+      # Encode to bech32 string.
+      def encode: () -> String
+    end
+
+    class TLVEntry
+      MAX_VALUE_LENGTH: Integer
+
+      attr_reader type: Integer
+      attr_reader label: String?
+      attr_reader value: String | Integer
+
+      # Initialize TLV entry.
+      def initialize: (Integer type, String | Integer value, ?String? label) -> void
+
+      # Convert to binary payload.
+      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
+
+    class TLVEntity
+      TYPE_SPECIAL: Integer
+      TYPE_RELAY: Integer
+      TYPE_AUTHOR: Integer
+      TYPE_KIND: Integer
+      TYPES: Array[Integer]
+
+      attr_reader hrp: String
+      attr_reader entries: Array[TLVEntry]
+
+      # Initialize TLV entity.
+      def initialize: (String hrp, Array[TLVEntry] entries) -> void
+
+      # Parse TLV entity from binary data.
+      def self.parse: (String hrp, String data) -> TLVEntity
+
+      # Encode to bech32 string.
+      def encode: () -> String
+    end
+  end
+end

data/sig/bech32/nostr/nip19.rbs

@@ -0,0 +1,23 @@
+module Bech32
+  module Nostr
+    module NIP19
+      HRP_PUBKEY: String
+      HRP_PRIVATE_KEY: String
+      HRP_NOTE_ID: String
+      HRP_PROFILE: String
+      HRP_EVENT: String
+      HRP_RELAY: String
+      HRP_EVENT_COORDINATE: String
+
+      BARE_PREFIXES: Array[String]
+      TLV_PREFIXES: Array[String]
+      ALL_PREFIXES: Array[String]
+
+      # Decode NIP-19 bech32 string.
+      def self.decode: (String string) -> (BareEntity | TLVEntity)
+
+      # module_function methods are also available as instance methods
+      def decode: (String string) -> (BareEntity | TLVEntity)
+    end
+  end
+end

data/sig/bech32/segwit_addr.rbs

@@ -0,0 +1,28 @@
+module Bech32
+  class SegwitAddr
+    HRP_MAINNET: String
+    HRP_TESTNET: String
+    HRP_REGTEST: String
+
+    attr_accessor hrp: String
+    attr_accessor ver: Integer?
+    attr_accessor prog: Array[Integer]?
+
+    # Initialize SegwitAddr. Optionally parse from address string.
+    def initialize: (?String? addr) -> void
+
+    # Generate script pubkey from witness version and program.
+    def to_script_pubkey: () -> String
+
+    # Parse script pubkey into witness version and program.
+    def script_pubkey=: (String script_pubkey) -> void
+
+    # Generate bech32/bech32m address string.
+    def addr: () -> String
+
+    private
+
+    # Parse address string into hrp, version and program.
+    def parse_addr: (String addr) -> void
+  end
+end

data/sig/bech32/silent_payment_addr.rbs

@@ -0,0 +1,22 @@
+module Bech32
+  # BIP-352 silent payment address.
+  class SilentPaymentAddr
+    HRP_MAINNET: String
+    HRP_TESTNET: String
+    MAX_VERSION: Integer
+
+    attr_reader hrp: String
+    attr_reader version: Integer
+    attr_reader scan_key: String
+    attr_reader spend_key: String
+
+    # Initialize SilentPaymentAddr.
+    def initialize: (String hrp, Integer version, String scan_key, String spend_key) -> void
+
+    # Parse silent payment address string.
+    def self.parse: (String addr) -> SilentPaymentAddr
+
+    # Generate silent payment address string.
+    def to_s: () -> String
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: bech32
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Shigeyuki Azuchi
 bindir: exe
 cert_chain: []
-date: 2025-03-25 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -69,6 +69,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- Steepfile
 - bech32.gemspec
 - bin/console
 - bin/setup
@@ -80,10 +81,16 @@ files:
 - lib/bech32/segwit_addr.rb
 - lib/bech32/silent_payment_addr.rb
 - lib/bech32/version.rb
+- sig/bech32/bech32.rbs
+- sig/bech32/nostr/entity.rbs
+- sig/bech32/nostr/nip19.rbs
+- sig/bech32/segwit_addr.rbs
+- sig/bech32/silent_payment_addr.rbs
 homepage: https://github.com/azuchi/bech32rb
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -98,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 4.0.3
 specification_version: 4
 summary: The implementation of Bech32 encoder and decoder.
 test_files: []