calimero 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 70d04b0fe2325e620f6ec464863c5ad0d631c4ab3fac3c64e0833588de23adf1
+  data.tar.gz: 5771da472ba8150018bda106145e13e60707962a7b20d0a3c6be3c601f92dbdd
+SHA512:
+  metadata.gz: be4b26a632b5d9c73647d15e08622d64195ff9b665d979b7f3656a2c9f79ad9ffe48b2c04f8828587e9940746a84404aa0f2a9ae72866fd5fccc0e5ec125fb78
+  data.tar.gz: f1824a22ed7201565be9f76f2c8e1ff218755874ee1ff185c562180a2b47ba262629eafcb109014ad849c4bb485bfcaa2e6c34c40cb5e9291c8b85dc05c086a1

data/AUTHORS

@@ -0,0 +1 @@
+* Kirill Abramov <septengineering@pm.me>

data/CHANGES.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 0.2.0 - 2025-03-18
+
+* Implement `Config` to manage config of Calimero nodes.
+* Implement `Ed25519Keypair` to support identity keypairs and other keys used in Calimero.
+* Implement authentication using Calimero identity key for interaction with the JSONRPC dev endpoint.
+* Add tests for `Config` and `Ed25519Keypair` classes.
+* Improve smoke tests.
+* Update README with more examples.
+
+## 0.1.0 - 2025-03-11
+
+## 0.0.0 - 2025-03-08
+

data/README.md

@@ -0,0 +1,168 @@
+# Calimero Network for Ruby
+
+[![License](https://img.shields.io/badge/license-Public%20Domain-blue.svg)](https://unlicense.org)
+[![Compatibility](https://img.shields.io/badge/ruby-3.0%2B-blue)](https://rubygems.org/gems/calimero)
+[![Package](https://img.shields.io/gem/v/calimero)](https://rubygems.org/gems/calimero)
+[![Documentation](https://img.shields.io/badge/rubydoc-latest-blue)](https://rubydoc.info/gems/calimero)
+
+**Calimero.rb** is a [Ruby] client library for the [Calimero Network].
+
+> [!TIP]
+> 🚧 _We are building in public. This is presently under heavy construction._
+
+## ✨ Features
+
+- Implemented natively in Ruby with minimal dependencies, ensuring low overhead and efficient performance.
+- Implements a `JsonRpcClient` for sending queries and updates to the applications in Calimero nodes.
+- Handles write and read calls to Calimero network applications.
+- Handles config management of Calimero nodes.
+- Manages authentication workflow using Ed25519-keypair.
+- 🚧 Manages authentication workflow using token acquisitions and refresh.
+- 🚧Implements a `WsSubscriptionsClient` for subscribing to real-time updates from the Calimero nodes.
+- 🚧 Supports interaction with Calimero Admin and Calimero Node APIs.
+- Adheres to the Ruby API Guidelines in its [naming conventions].
+- 100% free and unencumbered public domain software.
+
+## 🛠️ Prerequisites
+
+- [Ruby] 3.0+
+
+## ⬇️ Installation
+
+### Installation via RubyGems
+
+```bash
+gem install calimero
+```
+
+## 👉 Examples
+
+### Importing the library
+
+```ruby
+require 'calimero'
+```
+
+### Loading the Calimero config
+
+You can load a Calimero config file the following way:
+
+```ruby
+require 'calimero'
+
+config_path = "/path/to/your/calimero/config.toml"
+config = Calimero::load_config(config_path)
+```
+
+If you would like to utilize the default Calimero config folder:
+```ruby
+require 'calimero'
+
+config_path = "#{Calimero::default_config_folder}/node1/config.toml"
+config = Calimero::load_config(config_path)
+```
+
+### Importing `Ed25519Keypair` from the config and signing an arbitrary message with it
+
+```ruby
+require 'calimero'
+
+config_path = "#{Calimero::default_config_folder}/node1/config.toml"
+config = Calimero::load_config(config_path)
+
+message = "Hello, Calimero"
+signature = config.keypair.sign(message)
+```
+
+### Importing `Ed25519Keypair` from base58-encoded protobuf message and signing an arbitrary message with it
+
+```ruby
+require 'calimero'
+
+# The keypair should be base58-encoded protobuf message (using `libp2p_identity::Keypair`)
+keypair_base58_protobuf = "<YOUR_BASE58_ENCODED_ED25519_KEYPAIR>"
+keypair = Ed25519Keypair.new(keypair_base58_protobuf)
+message = "Hello, Calimero"
+signature = keypair.sign(message)
+```
+
+### Executing arbitrary method in Calimero Application with authentication using dev JSONRPC endpoint
+
+```ruby
+require 'calimero'
+require 'base58'
+
+client = JsonRpcClient.new('http://localhost:2428', '/jsonrpc/dev')
+params = RpcQueryParams.new('your_application_context_id', 'some_method', { 'some': 'args' }, 'executor_public_key')
+
+config_path = "#{Calimero::default_config_folder}/node1/config.toml"
+config = Calimero::load_config(config_path)
+
+timestamp = Time.now.utc.to_i.to_s
+signature = config.keypair.sign(timestamp)
+signature_b58 = Base58.binary_to_base58(signature, :bitcoin)
+
+headers = {
+  'Content-Type' => 'application/json',
+  'X-Signature' => signature_b58,
+  'X-Timestamp' => timestamp
+}
+request_config = RequestConfig.new(timeout: 1000, headers: headers)
+result = client.execute(query_params, request_config)
+if result.error
+  puts "Error: #{result.error}"
+else
+  puts "Result: #{result.result}"
+end
+```
+
+### Executing arbitrary method in Calimero Application
+
+```ruby
+require 'calimero'
+
+client = JsonRpcClient.new('http://localhost:2428', '/jsonrpc')
+params = RpcQueryParams.new('your_application_context_id', 'some_method', { 'some': 'args' }, 'executor_public_key')
+bearer_auth_token = "some bearer auth token"
+headers = {
+  'Content-Type' => 'application/json',
+  'Authorization' => "Bearer #{bearer_auth_token}"
+}
+request_config = RequestConfig.new(timeout: 1000, headers: headers)
+result = client.execute(params, request_config)
+if result.error
+  puts "Error: #{result.error}"
+else
+  puts "Result: #{result.result}"
+end
+```
+
+### Fetching all posts from OnlyPeers application
+
+You can query all the posts in the given [OnlyPeers] demo application, by using the following example:
+```sh
+CONTEXT_ID=<ONLYPEERS_CONTEXT_ID> EXECUTOR_PUBLIC_KEY=<YOUR_EXECUTOR_PUBLIC_KEY> ruby examples/onlypeers_get_all_posts.rb
+```
+
+That example also contains an example on how to use the `Config` and `Ed25519Keypair` to authenticate your requests to the Calimero node.
+
+## 📚 Reference
+
+https://rubydoc.info/gems/calimero
+
+## 👨‍💻 Development
+
+```bash
+git clone https://github.com/dryruby/calimero.rb.git
+```
+
+- - -
+
+[![Share on Twitter](https://img.shields.io/badge/share%20on-twitter-03A9F4?logo=twitter)](https://x.com/share?url=https://github.com/dryruby/calimero.rb&text=calimero.rb)
+[![Share on Reddit](https://img.shields.io/badge/share%20on-reddit-red?logo=reddit)](https://reddit.com/submit?url=https://github.com/dryruby/calimero.rb&title=calimero.rb)
+[![Share on Hacker News](https://img.shields.io/badge/share%20on-hacker%20news-orange?logo=ycombinator)](https://news.ycombinator.com/submitlink?u=https://github.com/dryruby/calimero.rb&t=calimero.rb)
+[![Share on Facebook](https://img.shields.io/badge/share%20on-facebook-1976D2?logo=facebook)](https://www.facebook.com/sharer/sharer.php?u=https://github.com/dryruby/calimero.rb)
+
+[Calimero Network]: https://calimero.network/
+[Ruby]: https://ruby-lang.org
+[OnlyPeers]: https://calimero-network.github.io/tutorials/awesome-projects/only-peers/

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <https://unlicense.org/>

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/calimero/config/config.rb

@@ -0,0 +1,48 @@
+# This is free and unencumbered software released into the public domain.
+
+require 'toml-rb'
+require_relative '../types/keypair'
+
+class ConfigError < StandardError; end
+
+# Configuration class that holds a Keypair and is extensible for future for other fields
+class Config
+  attr_reader :keypair
+
+  # Initialize with a TOML file path
+  def initialize(file_path)
+    @config_data = load_toml(file_path)
+    keypair_value = @config_data.dig('identity', 'keypair')
+    raise ConfigError, "'keypair' not found in [identity] section" unless keypair_value
+    @keypair = Ed25519Keypair.new(keypair_value)
+  end
+
+  # Allow dynamic access to raw config data
+  def [](key)
+    @config_data[key]
+  end
+
+  # Extend config with additional fields in the future
+  def method_missing(method_name, *args, &block)
+    if @config_data.key?(method_name.to_s)
+      @config_data[method_name.to_s]
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    @config_data.key?(method_name.to_s) || super
+  end
+
+  def load_toml(file_path)
+    TomlRB.load_file(file_path)
+  rescue Errno::ENOENT
+    raise ConfigError, "Config file '#{file_path}' not found"
+  rescue TomlRB::ParseError => e
+    raise ConfigError, "Failed to parse TOML file: #{e.message}"
+  end
+
+  private :load_toml
+end
+

data/lib/calimero/config.rb

@@ -0,0 +1,3 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'config/config'

data/lib/calimero/jsonrpc.rb

@@ -0,0 +1,154 @@
+require 'net/http'
+require 'uri'
+require 'json'
+
+require_relative 'types/rpc'
+
+module HTTPStatusCodes
+  HTTPOK = 200
+  HTTPBadRequest = 400
+  HTTPInternalServerError = 500
+end
+
+class JsonRpcClient < RpcClient
+  attr_reader :path, :base_url, :default_timeout
+
+  def initialize(base_url, path, default_timeout = 1000)
+    @base_url = base_url
+    @path = path
+    @default_timeout = default_timeout
+  end
+
+  def execute(params, config = RequestConfig.new(timeout: default_timeout))
+    request('execute', params, config)
+  end
+
+  def request(method, params, config = RequestConfig.new(timeout: default_timeout))
+    request_id = get_random_request_id
+    data = {
+      jsonrpc: '2.0',
+      id: request_id,
+      method: method,
+      params: params.instance_variables.each_with_object({}) { |var, hash| hash[var.to_s.delete('@')] = params.instance_variable_get(var) }
+    }
+
+    uri = URI.parse("#{@base_url}#{@path}")
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = uri.scheme == 'https'
+    http.open_timeout = config.timeout || @default_timeout
+    http.read_timeout = config.timeout || @default_timeout
+    headers = {'Content-Type' => 'application/json'}.merge(config.headers ? config.headers : {})
+
+    begin
+      response = http.post(uri.path, data.to_json, headers)
+      parsed_response = JSON.parse(response.body)
+
+      if response.is_a?(Net::HTTPOK)
+        if parsed_response['id'] != request_id
+          return RpcResult.new(result: nil, error: {
+            code: HTTPStatusCodes::HTTPBadRequest,
+            id: parsed_response['id'],
+            jsonrpc: parsed_response['jsonrpc'],
+            error: {
+              name: 'MissmatchedRequestIdError',
+              cause: {
+                name: 'MissmatchedRequestIdError',
+                info: {
+                  message: "Missmatched RequestId expected #{request_id}, got #{parsed_response['id']}"
+                }
+              }
+            }
+          })
+        end
+
+        error_data = parsed_response['error']
+        #TODO figure out if there are still weird use cases where error_data['data']['data'] might not be a Hash, but a String
+        if error_data
+          error_cause_name = if error_data['data'].is_a?(Hash)
+                               error_data.dig('data', 'type')
+                             else
+                               error_data['type']
+                             end
+          error_message = if error_data['data'].is_a?(Hash) && error_data['data']['data'].is_a?(Hash)
+                            error_data.dig('data', 'data', 'type')
+                          else
+                            error_data['data']
+                          end
+          return RpcResult.new(result: nil, error: {
+            code: HTTPStatusCodes::HTTPBadRequest,
+            id: parsed_response['id'],
+            jsonrpc: parsed_response['jsonrpc'],
+            error: {
+              name: error_data['type'],
+              cause: {
+                name: error_cause_name,
+                info: {
+                  message: error_message
+                }
+              }
+            }
+          })
+        end
+
+        return RpcResult.new(result: parsed_response['result'], error: nil)
+      else
+        error_data = parsed_response['error']
+        error_message = if error_data['data'].is_a?(Hash) && error_data['data']['data'].is_a?(Hash)
+                          error_data.dig('data', 'data', 'type')
+                        else
+                          error_data['data']
+                        end
+        return RpcResult.new(result: nil, error: {
+          id: parsed_response['id'],
+          jsonrpc: parsed_response['jsonrpc'],
+          code: response.code.to_i,
+          error: {
+            name: 'InvalidRequestError',
+            cause: {
+              name: 'InvalidRequestError',
+              info: {
+                message: error_message
+              }
+            }
+          }
+        })
+      end
+    rescue JSON::ParserError
+      return RpcResult.new(result: nil, error: {
+        id: request_id,
+        jsonrpc: '2.0',
+        code: HTTPStatusCodes::HTTPInternalServerError,
+        error: {
+          name: 'InvalidJsonResponseError',
+          cause: {
+            name: 'InvalidJsonResponseError',
+            info: {
+              message: "Invalid JSON response from server."
+            }
+          }
+        }
+      })
+    rescue StandardError => e
+      return RpcResult.new(result: nil, error: {
+        id: request_id,
+        jsonrpc: '2.0',
+        code: HTTPStatusCodes::HTTPInternalServerError,
+        error: {
+          name: 'UnknownServerError',
+          cause: {
+            name: 'UnknownServerError',
+            info: {
+              message: e.message
+            }
+          }
+        }
+      })
+    end
+  end
+
+  def get_random_request_id
+    rand(2**32)
+  end
+
+  private :request, :get_random_request_id
+end

data/lib/calimero/types/context.rb

@@ -0,0 +1,4 @@
+# This is free and unencumbered software released into the public domain.
+
+# ContextId is a string.
+ContextId = String

data/lib/calimero/types/keypair.rb

@@ -0,0 +1,74 @@
+# This is free and unencumbered software released into the public domain.
+
+require 'base58'
+require 'ed25519'
+
+class KeypairError < StandardError; end
+
+class Ed25519Keypair
+  attr_reader :private_key, :public_key, :stored_public_key
+
+  # Expected protobuf prefix for Ed25519 keypair (type: 1, data length: 64)
+  # The implementation is used for compatibility with Ed25519 keypair from
+  # [libp2p_identity/keypair](https://github.com/libp2p/rust-libp2p/blob/88f7875ad1a3e240aa2d9b9fb6f6c5354f1a62eb/identity/src/keypair.rs#L262)
+  PROTOBUF_PREFIX = "\x08\x01\x12\x40".freeze
+
+  # Initialize with a Base58-encoded keypair string
+  def initialize(base58_keypair)
+    raise KeypairError, "Base58 keypair cannot be nil" if base58_keypair.nil?
+    @key_bytes = decode_base58(base58_keypair)
+    validate_keypair_length
+    validate_protobuf_prefix
+    extract_keys
+    initialize_signing_key
+  end
+
+  # Sign a message (as raw bytes)
+  def sign(message)
+    @signing_key.sign(message)
+  end
+
+  # Verify a signature against a message
+  def verify(signature, message)
+    @verify_key.verify(signature, message)
+    true
+  rescue Ed25519::VerifyError
+    false
+  end
+
+  def decode_base58(base58_keypair)
+    Base58.base58_to_binary(base58_keypair, :bitcoin)
+  rescue StandardError => e
+    raise KeypairError, "Failed to decode Base58 keypair: #{e.message}"
+  end
+
+  def validate_keypair_length
+    return if @key_bytes.length == 68
+    raise KeypairError, "Unexpected keypair length: #{@key_bytes.length} bytes (expected 68)"
+  end
+
+  def validate_protobuf_prefix
+    prefix = @key_bytes[0..3]
+    unless prefix == PROTOBUF_PREFIX
+      raise KeypairError, "Invalid protobuf prefix: #{prefix.unpack1('H*')} (expected #{PROTOBUF_PREFIX.unpack1('H*')})"
+    end
+  end
+
+  def extract_keys
+    @private_key = @key_bytes[4..35]  # 32-byte private key
+    @stored_public_key = @key_bytes[36..67]  # 32-byte stored public key
+    unless @private_key.length == 32 && @stored_public_key.length == 32
+      raise KeypairError, "Invalid key lengths: private #{@private_key.length}, stored public #{@stored_public_key.length} (expected 32 each)"
+    end
+  end
+
+  def initialize_signing_key
+    @signing_key = Ed25519::SigningKey.new(@private_key)
+    @verify_key = @signing_key.verify_key
+    @public_key = @verify_key.to_bytes
+  rescue ArgumentError => e
+    raise KeypairError, "Invalid Ed25519 private key: #{e.message}"
+  end
+
+  private :decode_base58, :validate_keypair_length, :extract_keys, :initialize_signing_key
+end

data/lib/calimero/types/rpc.rb

@@ -0,0 +1,102 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'context'
+require_relative 'rpc_request'
+
+class RpcError < StandardError
+  attr_reader :id, :jsonrpc, :code, :error_info
+
+  def initialize(id, jsonrpc, code, error_info)
+    @id = id
+    @jsonrpc = jsonrpc
+    @code = code
+    @error_info = error_info
+    super(error_info[:message])
+  end
+end
+
+class RpcErrorInfo < StandardError
+  attr_reader :name, :cause
+
+  def initialize(name, cause)
+    @name = name
+    @cause = cause
+    super(cause[:message])
+  end
+end
+
+class RpcCauseInfo < StandardError
+  attr_reader :name, :info
+
+  def initialize(name, info)
+    @name = name
+    @info = info
+    super(info[:message])
+  end
+end
+
+class RpcClient
+  def execute(params, config = {})
+    raise NotImplementedError, "Subclasses must implement execute"
+  end
+end
+
+class RequestConfig
+  attr_accessor :timeout, :headers
+
+  def initialize(timeout: nil, headers: nil)
+    @timeout = timeout
+    @headers = headers
+  end
+
+  def to_h
+    {
+      timeout: @timeout,
+      headers: @headers
+    }
+  end
+end
+
+class RpcResult
+  attr_accessor :result, :error
+
+  def initialize(result: nil, error: nil)
+    @result = result
+    @error = error
+  end
+
+  def to_h
+    {
+      result: @result,
+      error: @error,
+    }
+  end
+end
+
+class RpcQueryParams
+  attr_accessor :contextId, :method, :argsJson, :executorPublicKey
+
+  def initialize(contextId, method, argsJson, executorPublicKey)
+    @contextId = contextId
+    @method = method
+    @argsJson = argsJson
+    @executorPublicKey = executorPublicKey
+  end
+
+  def to_h
+    {
+      contextId: @contextId,
+      method: @method,
+      argsJson: @argsJson,
+      executorPublicKey: @executorPublicKey
+    }
+  end
+end
+
+class RpcQueryResponse
+  attr_accessor :output
+
+  def initialize(output: nil)
+    @output = output
+  end
+end

data/lib/calimero/types/rpc_request.rb

@@ -0,0 +1,7 @@
+# This is free and unencumbered software released into the public domain.
+
+module RpcRequestId
+  def self.valid?(value)
+    value.is_a?(String) || value.is_a?(Numeric)
+  end
+end

data/lib/calimero/types.rb

@@ -0,0 +1,4 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'types/rpc'
+require_relative 'types/keypair'

data/lib/calimero/version.rb

@@ -0,0 +1 @@
+# This is free and unencumbered software released into the public domain.

data/lib/calimero.rb

@@ -0,0 +1,30 @@
+# This is free and unencumbered software released into the public domain.
+
+module Calimero; end
+
+require_relative 'calimero/config'
+require_relative 'calimero/jsonrpc'
+require_relative 'calimero/types'
+require_relative 'calimero/version'
+
+module Calimero
+  ##
+  # @return [Calimero::default_rpc_url]
+  def self.default_rpc_url
+    @rpc_url ||= "http://127.0.0.1:2428"
+  end
+
+  ##
+  # @return [Calimero::default_config_path]
+  def self.default_config_folder
+    @config_path ||= "#{Dir.home}/.calimero"
+  end
+
+  ##
+  # @return [Calimero::load_config]
+  # Utility method to load config from TOML file
+  def self.load_config(file_path)
+    Config.new(file_path)
+  end
+end
+

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: calimero
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Kirill Abramov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2025-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: tempfile
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: net-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+- !ruby/object:Gem::Dependency
+  name: uri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.10'
+- !ruby/object:Gem::Dependency
+  name: toml-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+- !ruby/object:Gem::Dependency
+  name: ed25519
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: base58
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+description: A Ruby client library for the Calimero Network.
+email: septengineering@pm.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- AUTHORS
+- CHANGES.md
+- README.md
+- UNLICENSE
+- VERSION
+- lib/calimero.rb
+- lib/calimero/config.rb
+- lib/calimero/config/config.rb
+- lib/calimero/jsonrpc.rb
+- lib/calimero/types.rb
+- lib/calimero/types/context.rb
+- lib/calimero/types/keypair.rb
+- lib/calimero/types/rpc.rb
+- lib/calimero/types/rpc_request.rb
+- lib/calimero/version.rb
+homepage: https://github.com/dryruby/calimero.rb
+licenses:
+- Unlicense
+metadata:
+  bug_tracker_uri: https://github.com/dryruby/calimero.rb/issues
+  changelog_uri: https://github.com/dryruby/calimero.rb/blob/master/CHANGES.md
+  documentation_uri: https://rubydoc.info/gems/calimero
+  homepage_uri: https://github.com/dryruby/calimero.rb
+  source_code_uri: https://github.com/dryruby/calimero.rb
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: 'Calimero.rb: Calimero Network for Ruby'
+test_files: []