vendi 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 19f37dec74417ace8e5980584edc2e5c9b02fb03e5480abf35f2d929126df521
+  data.tar.gz: bc8ac9b3addadc2c10230468ed18a2081a86c42681ec2beccdd798ba6b1b311f
+SHA512:
+  metadata.gz: f7b93150c1274e0f5bf81687ba4e42ba5bd291f747397c900ad2d73aa986ac1a926cad2c5bf579aea7b78012b0b02a99ad838df4cbfdc1f152675e84566aceb2
+  data.tar.gz: 79644c8d01cd86d11803ec04c9cc2f692537009a20bdeb2753ef679a9301317df078b913a532383d8612fc65eba85cd3ba9a597627d92d35deac88c13fd66cd4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Piotr Stachyra
+
+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,38 @@
+# Vendi
+
+Vendi is simple CNFT vending machine based on [`cardano-wallet`](https://github.com/input-output-hk/cardano-wallet).
+You need to have `cardano-wallet` started and synced.
+
+It... seems to work, check out the [Demo](https://github.com/piotr-iohk/vendi/tree/master/demo). :)
+
+## Installation
+
+**Rubygem:**
+
+    $ gem install vendi
+
+## Usage
+
+Fill vending machine with exemplary NFT collection:
+
+    $ vendi fill --collection TestBudz --price 10000000 --nft-count 100
+
+Now check out `$HOME/.vendi-nft-machine/TestBudz`, refine configs as you prefer.
+When ready start vending machine:
+
+    $ vendi serve --collection TestBudz
+
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/piotr-iohk/vendi. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/piotr-iohk/vendi/blob/master/CODE_OF_CONDUCT.md).
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Vendi project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/piotr-iohk/vendi/blob/master/CODE_OF_CONDUCT.md).

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'vendi'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/rebuild

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+gem build *.gemspec -o vendi.gem
+gem install vendi.gem

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/vendi

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'vendi'
+require 'docopt'
+
+doc = <<~DOCOPT
+  Vendi - CNFT Vending Machine.
+
+  Usage:
+    #{File.basename(__FILE__)} fill --collection <name> --price <lovelace> --nft-count <int> [--wallet-port <port>]
+    #{File.basename(__FILE__)} serve --collection <name> [--wallet-port <port>] [--logfile <file>]
+    #{File.basename(__FILE__)} -v | --version
+    #{File.basename(__FILE__)} -h | --help
+
+  Options:
+    fill                    Setup vending machine by filling it with exemplary set of NFT CIP-25 metadata
+                            and creating a source wallet for minting.
+    serve                   Start vending machine.
+    --collection <name>     Name of the collection.
+    --price <lovelace>      Single NFT price in lovelace.
+    --nft-count <int>       How many NFTs would you like to generate.
+    --wallet-port <port>    Cardano-wallet port [default: 8090].
+    --logfile <file>        Logfile (will be rotated daily).
+
+    -v --version            Check #{File.basename(__FILE__)} version.
+    -h --help               This help.
+
+  Example:
+    Fill vending machine with exemplary NFT collection:
+
+      $ vendi fill --collection TestBudz --price 10000000 --nft-count 100
+
+    Now check out $HOME/.vendi-nft-machine/TestBudz, refine configs as you prefer.
+    When ready start vending machine:
+
+      $ vendi serve --collection TestBudz
+
+DOCOPT
+
+begin
+  o = Docopt.docopt(doc)
+
+  warn Vendi::VERSION if o['--version']
+
+  if o['fill']
+    collection_name = o['--collection']
+    price = o['--price']
+    nft_count = o['--nft-count']
+    wallet_port = o['--wallet-port']
+    vendi = Vendi.init({ port: wallet_port.to_i })
+    begin
+      if File.directory?(File.join(vendi.config_dir, collection_name))
+        $stdout.print "Collection '#{collection_name}' already exists do you want to overwrite? (y/n): "
+        yn = $stdin.gets.chomp
+        raise Interrupt unless %w[y Y].include?(yn)
+      end
+      vendi.fill(collection_name, price, nft_count)
+    rescue StandardError => e
+      vendi.logger.error e.message
+    rescue Interrupt
+      warn ''
+      vendi.logger.info 'Vending machine filling stopped.'
+    end
+  end
+
+  if o['serve']
+    collection_name = o['--collection']
+    wallet_port = o['--wallet-port']
+    logfile = o['--logfile']
+    vendi = if logfile
+              Vendi.init({ port: wallet_port.to_i }, :info, logfile)
+            else
+              Vendi.init({ port: wallet_port.to_i })
+            end
+    begin
+      vendi.serve(collection_name)
+    rescue Errno::ECONNREFUSED => e
+      # retry if cannot connect to cardano-wallet
+      vendi.logger.error e.message
+      sleep 5
+      retry
+    rescue StandardError => e
+      vendi.logger.error e.message
+    rescue Interrupt
+      vendi.logger.info 'Vending machine stopped.'
+    end
+  end
+rescue Docopt::Exit => e
+  puts e.message
+end

data/lib/vendi/machine.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module Vendi
+  # Vending Machine: fill it with NFTs and serve to the hungry and in need!
+  class Machine
+    include Vendi::Utils
+    include Vendi::Monitor
+    include Vendi::Minter
+
+    attr_reader :logger, :cw
+    attr_accessor :config_dir
+
+    def initialize(wallet_opts = {}, log_level = :info, log_file = nil)
+      @cw = CardanoWallet.new(wallet_opts)
+      progname = 'vendi'
+      datetime_format = '%Y-%m-%d %H:%M:%S'
+      @logger = if log_file
+                  Logger.new(log_file,
+                             'daily',
+                             # shift_size = 10,
+                             progname: progname,
+                             level: log_level,
+                             datetime_format: datetime_format)
+                else
+                  Logger.new($stdout,
+                             progname: progname,
+                             level: log_level,
+                             datetime_format: datetime_format)
+                end
+      @config_dir = File.join(Dir.home, '.vendi-nft-machine')
+    end
+
+    def collection_dir(collection_name)
+      File.join(@config_dir, collection_name)
+    end
+
+    def config_path(collection_name)
+      File.join(collection_dir(collection_name), 'config.json')
+    end
+
+    def metadata_path(collection_name)
+      File.join(collection_dir(collection_name), 'metadata.json')
+    end
+
+    def metadata_vending_path(collection_name)
+      File.join(collection_dir(collection_name), 'metadata-vending.json')
+    end
+
+    def metadata_sent_path(collection_name)
+      File.join(collection_dir(collection_name), 'metadata-sent.json')
+    end
+
+    def config(collection_name)
+      from_json(config_path(collection_name))
+    end
+
+    def metadata_vending(collection_name)
+      from_json(metadata_vending_path(collection_name))
+    end
+
+    def metadata_sent(collection_name)
+      from_json(metadata_sent_path(collection_name))
+    end
+
+    def metadata(collection_name)
+      from_json(metadata_path(collection_name))
+    end
+
+    def set_metadata(collection_name, metadata)
+      to_json(metadata_path(collection_name), metadata)
+    end
+
+    def set_metadata_sent(collection_name, metadata)
+      to_json(metadata_sent_path(collection_name), metadata)
+    end
+
+    def set_metadata_vending(collection_name, metadata)
+      to_json(metadata_vending_path(collection_name), metadata)
+    end
+
+    def set_config(collection_name, configuration)
+      to_json(config_path(collection_name), configuration)
+    end
+
+    # Fill vending machine with exemplary set of CIP-25 metadata for minting,
+    # set up basic config and create wallet for minting
+    def fill(collection_name, price, nft_count, skip_wallet: false)
+      FileUtils.mkdir_p(collection_dir(collection_name))
+      if skip_wallet
+        @logger.info('Skipping wallet generation for your collection.')
+        wallet_details = { wallet_id: '',
+                           wallet_name: '',
+                           wallet_pass: '',
+                           wallet_address: '',
+                           wallet_policy_id: '',
+                           wallet_mnemonics: '' }
+      else
+        @logger.info('Generating wallet for your collection.')
+        wallet_details = create_wallet("Vendi wallet - #{collection_name}")
+      end
+
+      @logger.info("Generating your NFT collection config into #{config_path(collection_name)}.")
+      @logger.info("NFT price: #{as_ada(price.to_i)}.")
+      config = { price: price.to_i }
+      mnemonics = wallet_details[:wallet_mnemonics]
+      wallet_details.delete(:wallet_mnemonics)
+      config.merge!(wallet_details)
+      set_config(collection_name, config)
+
+      @logger.info("Generating exemplary CIP-25 metadata set into #{metadata_path(collection_name)}.")
+      metadatas = generate_metadata(collection_name, nft_count.to_i)
+      set_metadata(collection_name, metadatas)
+
+      @logger.info('IMPORTANT NOTES! 👇')
+      @logger.info('----------------')
+      @logger.info("Check contents of #{collection_dir(collection_name)} and edit files as needed.")
+      @logger.info('Before starting vending machine make sure your wallet is synced and has enough funds.')
+      @logger.info("To fund your wallet send ADA to: #{wallet_details[:wallet_address]}")
+      @logger.info("❗ Write down your wallet mnemonics: #{mnemonics}.")
+    end
+
+    # Turn on vending machine and make it serve NFTs for anyone who dares to
+    # pay the 'price' to the 'address', that is specified in the config_file
+    def serve(collection_name)
+      set_metadata_sent(collection_name, {}) unless File.exist?(metadata_sent_path(collection_name))
+
+      c = config(collection_name)
+      wid = c[:wallet_id]
+      pass = c[:wallet_pass]
+      address = c[:wallet_address]
+      policy_id = c[:wallet_policy_id]
+      price = c[:price]
+      wallet = @cw.shelley.wallets.get(wid)
+
+      raise "Wallet #{wid} does not exist!" if wallet.code == 404
+      raise "Wallet #{wid} is not synced (#{wallet['state']})!" if wallet['state']['status'] != 'ready'
+      raise "Wallet #{wid} has no funds!" if (wallet['balance']['available']['quantity']).zero?
+
+      @logger.info 'Vending machine started.'
+      @logger.info "Wallet id: #{wid}"
+      @logger.info "Address: #{address}"
+      @logger.info "NFT price: #{as_ada(price)}"
+      @logger.info "Original NFT stock: #{metadata(collection_name).size}"
+      @logger.info '----------------'
+      unless File.exist?(metadata_vending_path(collection_name))
+        @logger.info "Making copy of #{metadata_path(collection_name)} to #{metadata_vending_path(collection_name)}."
+        FileUtils.cp(metadata_path(collection_name), metadata_vending_path(collection_name))
+      end
+
+      txs = get_incoming_txs(wid)
+      until metadata_vending(collection_name).empty?
+        nfts = metadata_vending(collection_name)
+        nfts_sent = metadata_sent(collection_name)
+        wallet_balance = @cw.shelley.wallets.get(wid)['balance']['available']['quantity']
+        @logger.info "Vending machine [In stock: #{nfts.size}, Sent: #{nfts_sent.size}, NFT price: #{as_ada(price)}, Balance: #{as_ada(wallet_balance)}]"
+
+        txs_new = get_incoming_txs(wid)
+        if txs.size < txs_new.size
+          txs_to_check = get_transactions_to_process(tx_delta, txs)
+          @logger.info "New txs arrived: #{txs_to_check.size}"
+          @logger.info (txs_to_check.map { |t| t['id'] }).to_s
+
+          txs_to_check.each do |t|
+            @logger.info "Checking #{t['id']}"
+            if incoming_tx_ok?(t, address, price)
+              @logger.info 'OK! VENDING!'
+              @logger.info '----------------'
+              dest_addr = get_dest_addr(t, address)
+
+              # prepare metadata and mint payload
+              key = nfts.keys.sample
+              metadata = prepare_metadata(nfts, key, policy_id)
+              mint = mint_payload(asset_name(key.to_s), dest_addr)
+              @logger.debug JSON.pretty_generate(metadata)
+              @logger.debug JSON.pretty_generate(mint)
+
+              # mint
+              @logger.info "Minting NFT: #{key} to #{dest_addr}"
+              tx_res = construct_sign_submit(wid, pass, metadata, mint)
+              if outgoing_tx_ok?(tx_res)
+                mint_tx_id = tx_res.last['id']
+                wait_for_tx_in_ledger(wid, mint_tx_id)
+                # update metadata files
+                update_metadata_files(nfts, key, metadata_vending_path(collection_name), metadata_sent_path(collection_name))
+              else
+                @logger.error 'Minting tx failed!'
+                @logger.error "Construct tx: #{JSON.pretty_generate(tx_res[0])}"
+                @logger.error "Sign tx: #{JSON.pretty_generate(tx_res[1])}"
+                @logger.error "Submit tx: #{JSON.pretty_generate(tx_res[2])}"
+              end
+              @logger.info '----------------'
+
+            else
+              @logger.warn "NO GOOD! NOT VENDING! Tx: #{t['id']}"
+            end
+          end
+
+          txs = txs_new
+        end
+
+        sleep 5
+      end
+      @logger.info 'Turning off! Vending machine empty!'
+    end
+
+    private
+
+    def create_wallet(wallet_name = nil, wallet_pass = nil, wallet_mnemonics = nil)
+      wallet_name ||= 'Vendi wallet'
+      wallet_mnemonics ||= @cw.utils.mnemonic_sentence
+      wallet_pass ||= 'Secure Passphrase'
+      wallet = @cw.shelley.wallets.create({ name: wallet_name,
+                                            mnemonic_sentence: wallet_mnemonics,
+                                            passphrase: wallet_pass })
+
+      @logger.debug('!!!!! Write down wallet mnemonics !!!!')
+      @logger.debug(wallet_mnemonics.to_s)
+      wid = wallet['id']
+      wallet_address = @cw.shelley.addresses.list(wid).first['id']
+      wallet_policy_id = @cw.shelley.keys.create_policy_id(wid, Vendi::POLICY_SCRIPT_TEMPLATE)['policy_id']
+      { wallet_id: wallet['id'],
+        wallet_name: wallet_name,
+        wallet_pass: wallet_pass,
+        wallet_address: wallet_address,
+        wallet_policy_id: wallet_policy_id,
+        wallet_mnemonics: wallet_mnemonics }
+    end
+
+    def generate_metadata(nft_name_prefix, nft_count)
+      metadata = {}
+      1.upto nft_count do |i|
+        nft_metadata = {
+          "#{nft_name_prefix}_#{i}" => {
+            'name' => "#{nft_name_prefix.upcase} No #{i}",
+            'image' => 'ipfs://QmRhTTbUrPYEw3mJGGhQqQST9k86v1DPBiTTWJGKDJsVFw',
+            'Copyright' => "Vendi #{Time.now.year}",
+            'Collection' => "#{nft_name_prefix} #{Time.now.year}"
+          }
+        }
+        metadata.merge!(nft_metadata)
+      end
+      metadata
+    end
+  end
+end

data/lib/vendi/minter.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Vendi
+  # helper methods for minting NFT
+  module Minter
+    def prepare_metadata(nfts, key, policy_id)
+      {
+        '721' => {
+          policy_id => {
+            key => nfts[key]
+          }
+        }
+      }
+    end
+
+    def update_metadata_files(nfts, key, metadata_vending_file, metadata_sent_file)
+      # metadata sent
+      m = { key => nfts[key] }
+      if File.exist? metadata_sent_file
+        sent = from_json(metadata_sent_file)
+        sent.merge!(m)
+        to_json(metadata_sent_file, sent)
+      else
+        to_json(metadata_sent_file, m)
+      end
+      # metadata available
+      nfts.delete(key)
+      to_json(metadata_vending_file, nfts)
+    end
+
+    # Build mint payload for construct tx
+    def mint_payload(asset_name, address, quantity = 1)
+      mint = { 'operation' => { 'mint' => { 'quantity' => quantity,
+                                            'receiving_address' => address } },
+               'policy_script_template' => Vendi::POLICY_SCRIPT_TEMPLATE }
+      mint['asset_name'] = asset_name unless asset_name.nil?
+      [mint]
+    end
+
+    # Construct -> Sign -> Submit
+    def construct_sign_submit(wid, pass, metadata, mint_payload)
+      tx_constructed = @cw.shelley.transactions.construct(wid,
+                                                          nil,
+                                                          nil,
+                                                          metadata,
+                                                          nil,
+                                                          mint_payload,
+                                                          nil)
+      # puts tx_constructed.request.options[:body]
+      tx_signed = @cw.shelley.transactions.sign(wid, pass, tx_constructed['transaction'])
+      # puts tx_signed
+      tx_submitted = @cw.shelley.transactions.submit(wid, tx_signed['transaction'])
+      # puts tx_submitted
+
+      [tx_constructed, tx_signed, tx_submitted]
+    end
+
+    def outgoing_tx_ok?(tx_res)
+      tx_constructed, tx_signed, tx_submitted = tx_res
+      tx_constructed.code == 202 && tx_signed.code == 202 && tx_submitted.code == 202
+    end
+
+    def wait_for_tx_in_ledger(wid, tx_id)
+      eventually "Tx #{tx_id} is in ledger" do
+        @logger.info "Waiting for #{tx_id} to get in_ledger"
+        tx = @cw.shelley.transactions.get(wid, tx_id)
+        tx.code == 200 && tx['status'] == 'in_ledger'
+      end
+    end
+  end
+end

data/lib/vendi/monitor.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Vendi
+  # helper methods for monitoring incoming transactions
+  module Monitor
+    def get_incoming_txs(wid)
+      @cw.shelley.transactions.list(wid).select { |t| t['direction'] == 'incoming' }
+    end
+
+    def get_transactions_to_process(txs_new, txs)
+      txs_new[0..(txs_new.size - txs.size - 1)]
+    end
+
+    # incoming tx is correct when the address is on any of the outputs (means that someone was sending to it)
+    # and tx amount is >= price set in the config
+    def incoming_tx_ok?(tx, address, price)
+      (tx['outputs'].any? { |o| (o['address'] == address) }) && (tx['amount']['quantity'] >= price)
+    end
+
+    # trying to naively get address to send back NFT, take first address from the output that isn't our address
+    # assuming that it is a change address
+    def get_dest_addr(tx, address)
+      output_dest_addr = tx['outputs'].map { |o| o['address'] }.reject { |a| a == address }.first
+
+      # if no address in outputs try to get one from inputs
+      output_dest_addr || tx['inputs'].map { |o| o['address'] }.reject { |a| a == address }.first
+    end
+  end
+end

data/lib/vendi/utils.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Vendi
+  # general utility methods
+  module Utils
+    def from_json(file)
+      JSON.parse(File.read(file), { symbolize_names: true })
+    end
+
+    def to_json(file, hash)
+      File.write(file, JSON.pretty_generate(hash))
+    end
+
+    def as_ada(quantity)
+      res = quantity.to_f / 1_000_000
+      str_res = format('%.7f', res)
+      last = str_res[-1]
+      final = ''
+      until last == '.'
+        str_res.chop!
+        if last == '0'
+          final = str_res
+          break unless final[-1] == '0'
+        end
+        last = str_res[-1]
+      end
+      final.chop! if final[-1] == '.'
+      "#{final} ₳"
+    end
+
+    ##
+    # wait until action passed as &block returns true or TIMEOUT is reached
+    def eventually(label, &block)
+      current_time = Time.now
+      timeout_treshold = current_time + Vendi::TIMEOUT
+      while (block.call == false) && (current_time <= timeout_treshold)
+        sleep 5
+        current_time = Time.now
+      end
+      if current_time > timeout_treshold
+        @logger.error "Action '#{label}' did not resolve within timeout: #{Vendi::TIMEOUT}s"
+        false
+      else
+        true
+      end
+    end
+
+    ##
+    # encode string asset_name to hex representation
+    def asset_name(asset_name)
+      asset_name.unpack1('H*')
+    end
+  end
+end

data/lib/vendi/version.rb

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

data/lib/vendi.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'fileutils'
+require 'cardano_wallet'
+require 'vendi/version'
+require 'vendi/utils'
+require 'vendi/monitor'
+require 'vendi/minter'
+require 'vendi/machine'
+
+# Vendi CNFT Vending machine
+module Vendi
+  # Timeout for tx to get into ledger
+  TIMEOUT = 300
+
+  POLICY_SCRIPT_TEMPLATE = 'cosigner#0'
+
+  def self.init(wallet_opts = {}, log_level = :info, logfile = nil)
+    Vendi::Machine.new(wallet_opts, log_level, logfile)
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: vendi
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Piotr Stachyra
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cardano_wallet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.28
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.28
+- !ruby/object:Gem::Dependency
+  name: docopt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.11.0
+description: CNFT Vending Machine - cardano-wallet based
+email:
+- piotr.stachyra@gmail.com
+executables:
+- vendi
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- bin/console
+- bin/rebuild
+- bin/setup
+- bin/vendi
+- lib/vendi.rb
+- lib/vendi/machine.rb
+- lib/vendi/minter.rb
+- lib/vendi/monitor.rb
+- lib/vendi/utils.rb
+- lib/vendi/version.rb
+homepage: https://github.com/piotr-iohk/vendi
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org/
+  homepage_uri: https://github.com/piotr-iohk/vendi
+  source_code_uri: https://github.com/piotr-iohk/vendi
+  changelog_uri: https://github.com/piotr-iohk/vendi
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- bin
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: CNFT Vending Machine - cardano-wallet based
+test_files: []