merkle 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bce04358fd44b062aa388fdc8bb834a33e6dc082ae522e097f7a90a777cceb7d
+  data.tar.gz: e9cdee4066043760ecd72b89bc355060cb47273ae13a4b1c379e7ecca494fb62
+SHA512:
+  metadata.gz: 7f5719c3393e13411152b2207ad1c3c109c468d0611d9c5d5c83d1430ee427dbfe914aa427145052a7bc8a55f8ebb71aaa809d45516b61243981f50a58388165
+  data.tar.gz: 7dac36c4c6aaa55107f8ca2b7c7b06efba49c59f66017e50a225c463d17f4635f13f5401b640a0735c2893ac819574589655ec9f5e5eeed0ffaf2a1704a0a7f8

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.ruby-gemset

@@ -0,0 +1 @@
+merkle

data/.ruby-version

@@ -0,0 +1 @@
+ruby-3.4.5

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 azuchi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,108 @@
+# Merkle
+
+A Ruby library for Merkle tree construction and proof generation with support for multiple tree structures and hashing algorithms.
+
+## Features
+
+- **Multiple tree structures**: Binary Tree (Bitcoin-compatible) and Adaptive Tree implementations
+- **Flexible configuration**: Support for different hash algorithms (SHA256, Double SHA256) and tagged hashing
+- **Proof generation and verification**: Generate and verify Merkle proofs for any leaf
+- **Sorted hashing support**: Optional lexicographical sorting for deterministic tree construction
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'merkle'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install merkle
+
+## Usage
+
+### Basic Example
+
+```ruby
+require 'merkle'
+
+# Create configuration
+config = Merkle::Config.new(hash_type: :sha256)
+
+# Prepare leaves (hex strings)
+leaves = [
+  'a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3',
+  'b3a8e0e1f9ab1bfe3a36f231f676f78bb30a519d2b21e6c530c0eee8ebb4a5d0',
+  'c3c9bc9a6c7c5b4e8c3b6b5a2a8c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c'
+]
+
+# Create binary tree (Bitcoin-compatible)
+tree = Merkle::BinaryTree.new(config: config, leaves: leaves)
+
+# Compute merkle root
+root = tree.compute_root
+puts "Merkle root: #{root}"
+
+# Generate proof for leaf at index 1
+proof = tree.generate_proof(1)
+puts "Proof siblings: #{proof.siblings}"
+puts "Proof directions: #{proof.directions}"
+
+# Verify proof
+puts "Proof valid: #{proof.valid?}"
+```
+
+### Adaptive Tree Example
+
+```ruby
+# Create adaptive tree for better performance with frequently accessed leaves
+adaptive_tree = Merkle::AdaptiveTree.new(config: config, leaves: leaves)
+
+root = adaptive_tree.compute_root
+proof = adaptive_tree.generate_proof(0)
+puts "Adaptive tree proof valid: #{proof.valid?}"
+```
+
+### Configuration Options
+
+```ruby
+# Bitcoin-compatible configuration with double SHA256
+bitcoin_config = Merkle::Config.new(hash_type: :double_sha256)
+
+# Configuration with tagged hashing (Taproot-style)
+taproot_config = Merkle::Config.taptree
+
+# Configuration with sorted hashing (no directions needed in proofs)
+sorted_config = Merkle::Config.new(
+  hash_type: :sha256,
+  sort_hashes: true
+)
+```
+
+## Architecture
+
+### Tree Structures
+
+- **BinaryTree**: Bitcoin-compatible merkle tree that duplicates odd nodes
+- **AdaptiveTree**: Unbalanced tree that promotes odd nodes to higher levels for optimized access patterns
+
+### Proof System
+
+The library generates compact Merkle proofs that include:
+- `siblings`: Array of sibling hashes needed for verification
+- `directions`: Array indicating left (0) or right (1) position at each level
+- `root`: The merkle root hash
+- `leaf`: The original leaf value
+
+### Verification
+
+```ruby
+proof = tree.generate_proof(leaf_index)
+is_valid = proof.valid? # Returns true/false
+```

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/merkle/abstract_tree.rb

@@ -0,0 +1,72 @@
+require 'digest'
+
+module Merkle
+  # Base class for Merkle tree implementations
+  class AbstractTree
+    include Util
+
+    attr_reader :config, :leaves
+
+    # Constructor
+    # @param [Merkle::Config] config Configuration for merkle tree.
+    # @param [Array] leaves An array of leaves.
+    # @raise [ArgumentError]
+    def initialize(config:, leaves: [])
+      raise ArgumentError, 'config must be Merkle::Config' unless config.is_a?(Merkle::Config)
+      raise ArgumentError, 'leaves must be Array' unless leaves.is_a?(Array)
+      @config = config
+      @leaves = leaves
+    end
+
+    # Compute merkle root.
+    # @return [String] merkle root (hex value). For Bitcoin, the endianness of this value must be reversed.
+    # @raise [Merkle::Error] If leaves is empty.
+    def compute_root
+      raise Error, 'leaves is empty' if leaves.empty?
+      # nodes = leaves
+      nodes = leaves.map {|leaf| hex_to_bin(leaf) }
+      while nodes.length > 1
+        nodes = build_next_level(nodes)
+      end
+      root = nodes.first
+      root.unpack1('H*')
+    end
+
+    # Generates a merkle proof for the specified +leaf_index+.
+    # @param [Integer] leaf_index The leaf index.
+    # @return [Merkle::Proof] The merkle proof.
+    # @raise [ArgumentError] If invalid +leaf_index+ specified.
+    def generate_proof(leaf_index)
+      raise ArgumentError, 'leaf_index must be Integer' unless leaf_index.is_a?(Integer)
+      raise ArgumentError, 'leaf_index out of range' if leaf_index < 0 || leaves.length <= leaf_index
+
+      siblings, directions = siblings_with_directions(leaf_index)
+      siblings = siblings.map{|sibling| hex_string?(sibling) ? sibling : sibling.unpack1('H*')}
+      directions = [] if config.sort_hashes
+      Proof.new(config: config, root: compute_root, leaf: leaves[leaf_index], siblings: siblings, directions: directions)
+    end
+
+    private
+
+    # Gets the siblings that corresponds to +leaf_index+ and its directions (if necessary).
+    # @param [Integer] leaf_index The leaf index.
+    # @return [Array] An array of siblings and directions.
+    def siblings_with_directions(leaf_index)
+      raise NotImplementedError
+    end
+
+    # Get branch hash.
+    # @param [String] data The data to be hashed.
+    # @return [String] Branch hash value.
+    def branch_hash(data)
+      config.tagged_hash(data)
+    end
+
+    # Build next level in tree.
+    # @param [Array] nodes Current level nodes in tree.
+    # @return [Array] An array of next level nodes in tree.
+    def build_next_level(nodes)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/merkle/adaptive_tree.rb

@@ -0,0 +1,60 @@
+module Merkle
+  # The AdaptiveTree class implements an unbalanced binary tree structure for Merkle tree construction,
+  # optimized for scenarios where frequently used scripts should be placed at shallower depths.
+  # Unlike the standard Bitcoin Merkle tree which maintains a complete binary tree by duplicating odd elements,
+  # AdaptiveTree promotes odd nodes to higher levels, creating variable-depth paths.
+  class AdaptiveTree < AbstractTree
+
+    private
+
+    def siblings_with_directions(leaf_index)
+      siblings = []
+      directions = []
+      
+      current_index = leaf_index
+      nodes = leaves.map {|leaf| hex_to_bin(leaf) }
+      
+      while nodes.length > 1
+        # For adaptive tree, odd nodes are promoted to next level
+        if current_index.even? && current_index + 1 < nodes.length
+          # Current node has a right sibling
+          sibling_index = current_index + 1
+          directions << 1  # sibling is on the right
+          siblings << nodes[sibling_index]
+          current_index = current_index / 2
+        elsif current_index.odd?
+          # Current node has a left sibling
+          sibling_index = current_index - 1
+          directions << 0  # sibling is on the left
+          siblings << nodes[sibling_index]
+          current_index = current_index / 2
+        else
+          # Current node is the last node (odd), no sibling at this level
+          # It gets promoted to the next level
+          # Find its new index in the next level
+          current_index = nodes.length / 2
+        end
+        
+        # Move to next level
+        nodes = build_next_level(nodes)
+      end
+
+      [siblings, directions]
+    end
+
+    def build_next_level(nodes)
+      next_level = []
+      nodes.each_slice(2) do |left, right|
+        if right
+          combined = combine_sorted(config, left, right)
+          parent_hash = branch_hash(combined)
+          next_level << parent_hash
+        else
+          next_level << left
+        end
+      end
+
+      next_level
+    end
+  end
+end

data/lib/merkle/binary_tree.rb

@@ -0,0 +1,56 @@
+module Merkle
+  # Merkle trees take the same approach as Bitcoin to construct a complete binary tree.
+  # If the number of hashes in the list at a given level is odd,
+  # the last one is duplicated before computing the next level (which is unusual in Merkle trees).
+  # So keep in mind that this following merkle tree algorithm has a serious flaw related to duplicate elements,
+  # resulting in a vulnerability (CVE-2012-2459).
+  class BinaryTree < AbstractTree
+
+    private
+
+    def siblings_with_directions(leaf_index)
+      siblings = []
+      directions = []
+      
+      current_index = leaf_index
+      nodes = leaves.map {|leaf| hex_to_bin(leaf) }
+      
+      while nodes.length > 1
+        # If odd number of nodes, duplicate the last one
+        nodes << nodes.last if nodes.length.odd?
+        
+        # Determine sibling index and direction (0=left, 1=right)
+        if current_index.even?
+          sibling_index = current_index + 1
+          directions << 1  # sibling is on the right
+        else
+          sibling_index = current_index - 1
+          directions << 0  # sibling is on the left
+        end
+        
+        # Add sibling to the list
+        siblings << nodes[sibling_index]
+        
+        # Move to next level
+        current_index = current_index / 2
+        nodes = build_next_level(nodes)
+      end
+      
+      [siblings, directions]
+    end
+
+    def build_next_level(nodes)
+      next_level = []
+      nodes = nodes + [nodes.last] if nodes.length.odd?
+      nodes.each_slice(2) do |left, right|
+        combined = combine_sorted(config, left, right)
+        parent_hash = branch_hash(combined)
+        next_level << parent_hash
+      end
+
+      next_level
+    end
+
+  end
+
+end

data/lib/merkle/config.rb

@@ -0,0 +1,59 @@
+module Merkle
+  # Merkle tree configuration class.
+  class Config
+    include Util
+
+    # Supported Hash type.
+    HASH_TYPES = [:sha256, :double_sha256]
+
+    attr_reader :hash_type, :branch_tag, :sort_hashes
+
+    # Constructor
+    # @param [Symbol] hash_type The hashing algorithm used to hash the internal nodes.
+    # @param [String] branch_tag Tags to use when hashing internal nodes.
+    # @param [Boolean] sort_hashes Whether to sort internal nodes in lexicographical order and hash them.
+    # If you enable this, Merkle::Proof's directions are not required.
+    # @raise [ArgumentError]
+    def initialize(hash_type: :sha256, branch_tag: '', sort_hashes: false)
+      raise ArgumentError, "hash_type #{hash_type} does not supported." unless HASH_TYPES.include?(hash_type)
+      raise ArgumentError, "internal_tag must be string." unless branch_tag.is_a?(String)
+      raise ArgumentError, "sort_hashes must be boolean." unless sort_hashes.is_a?(TrueClass) || sort_hashes.is_a?(FalseClass)
+      @hash_type = hash_type
+      @branch_tag = branch_tag
+      @sort_hashes = sort_hashes
+    end
+
+    # Bitcoin configuration.
+    # @return [Merkle::Config]
+    def self.bitcoin
+      Config.new(hash_type: :double_sha256)
+    end
+
+    # Taptree configuration.
+    # @return [Merkle::Config]
+    def self.taptree
+      Config.new(branch_tag: 'TapBranch', sort_hashes: true)
+    end
+
+    # Generate tagged hash.
+    # @param [String] data The data to be hashed.
+    # @param [String] tag Tag string used tagging.
+    # @return [String] Tagged hash value.
+    def tagged_hash(data, tag = branch_tag)
+      raise ArgumentError, "data must be string." unless data.is_a?(String)
+      data = [data].pack('H*') if hex_string?(data)
+
+      unless tag.empty?
+        tag_hash = Digest::SHA256.digest(tag)
+        data = tag_hash + tag_hash + data
+      end
+
+      case hash_type
+      when :sha256
+        Digest::SHA256.digest(data)
+      when :double_sha256
+        Digest::SHA256.digest(Digest::SHA256.digest(data))
+      end
+    end
+  end
+end

data/lib/merkle/proof.rb

@@ -0,0 +1,51 @@
+module Merkle
+  class Proof
+    include Util
+
+    attr_reader :config, :root, :leaf, :siblings, :directions
+
+    # Constructor.
+    # @param [Merkle::Config] config
+    # @param [String] root
+    # @param [String] leaf
+    # @param [Array] siblings
+    # @param [Array] directions Array of positions at each level(0: left, 1: right),
+    # only required if sort_hashes is false in config.
+    def initialize(config:, root:, leaf:, siblings:, directions: [])
+      raise ArgumentError, 'config must be a Merkle::Config' unless config.is_a?(Merkle::Config)
+      raise ArgumentError, 'root must be string' unless root.is_a?(String)
+      raise ArgumentError, 'leaf must be string' unless leaf.is_a?(String)
+      raise ArgumentError, 'directions must be an Array' unless directions.is_a?(Array)
+      raise ArgumentError, 'No directions are required because sorted_hash is enabled' if config.sort_hashes && !directions.empty?
+      @config = config
+      @root = root
+      @leaf = leaf
+      @siblings = siblings
+      @directions = directions
+    end
+
+    # Verify the proof.
+    # @return [Boolean] true if the proof is valid, false otherwise.
+    def valid?
+      current = hex_to_bin(leaf)
+
+      siblings.each_with_index do |sibling, index|
+        sibling_bin = hex_to_bin(sibling)
+        
+        if config.sort_hashes
+          # Sort lexicographically when combining
+          combined = combine_sorted(config, current, sibling_bin)
+        else
+          # Use direction to determine order
+          direction = directions[index]
+          combined = direction == 0 ? sibling_bin + current : current + sibling_bin
+        end
+        
+        current = config.tagged_hash(combined)
+      end
+
+      current.unpack1('H*') == root
+    end
+
+  end
+end

data/lib/merkle/util.rb

@@ -0,0 +1,40 @@
+module Merkle
+  module Util
+
+    # Check whether +data+ is hex string or not.
+    # @return [Boolean]
+    # @raise [ArgumentError]
+    def hex_string?(data)
+      raise ArgumentError, 'data must be string' unless data.is_a?(String)
+      data.match?(/\A[0-9a-fA-F]+\z/)
+    end
+
+    # Convert hex string +data+ to binary.
+    # @return [String]
+    # @raise [ArgumentError]
+    def hex_to_bin(data)
+      raise ArgumentError, 'data must be string' unless data.is_a?(String)
+      hex_string?(data) ? [data].pack('H*') : data
+    end
+
+    # Combine two elements(+left+ and +right+) with sort configuration.
+    # @param [Merkle::Config] config
+    # @param [String] left Left element(binary format).
+    # @param [String] right Right element(binary format).
+    # @return [String] Combined string.
+    # @raise [ArgumentError]
+    def combine_sorted(config, left, right)
+      raise ArgumentError, "config must be Merkle::Config" unless config.is_a?(Merkle::Config)
+      raise ArgumentError, "left must be string" unless left.is_a?(String)
+      raise ArgumentError, "right must be string" unless right.is_a?(String)
+      if config.sort_hashes
+        lh = left.unpack1('H*')
+        rh = right.unpack1('H*')
+        lh < rh ? left + right : right + left
+      else
+        left + right
+      end
+    end
+
+  end
+end

data/lib/merkle/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Merkle
+  VERSION = "0.1.0"
+end

data/lib/merkle.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "merkle/version"
+require_relative 'merkle/util'
+require_relative 'merkle/config'
+require_relative 'merkle/abstract_tree'
+require_relative 'merkle/binary_tree'
+require_relative 'merkle/adaptive_tree'
+require_relative 'merkle/proof'
+
+# Merkle tree module.
+module Merkle
+
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/merkle.rbs

@@ -0,0 +1,4 @@
+module Merkle
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: merkle
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- azuchi
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby library for Merkle trees
+email:
+- azuchi@chaintope.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/merkle.rb
+- lib/merkle/abstract_tree.rb
+- lib/merkle/adaptive_tree.rb
+- lib/merkle/binary_tree.rb
+- lib/merkle/config.rb
+- lib/merkle/proof.rb
+- lib/merkle/util.rb
+- lib/merkle/version.rb
+- sig/merkle.rbs
+homepage: https://github.com/chaintope/merkle
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/chaintope/merkle
+  source_code_uri: https://github.com/chaintope/merkle
+  changelog_uri: https://github.com/chaintope/merkle
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A Ruby library for Merkle trees
+test_files: []