vendi 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b6e8fbf628bc618da176a73c2f7e77d9ff300bb022dc8dfbe672e5fe3e7e1a1
-  data.tar.gz: 4c1d42a3aecf7eace980b4d91c2b5ff8378cc22d5fac64ad7b671cdcabf8490f
+  metadata.gz: a41b9c15bcb8f4c01eaf41358958fd00b4afa10da4a48b86fdd1463a0c7f0605
+  data.tar.gz: c3ab3e68705decb0ea6a9031eddcb77689fdbff85dae62d0436c0ed512e6c95d
 SHA512:
-  metadata.gz: c98f5cec080dfe60b0258963a81bd2bdd17e6545b5f93b8e64819ab6827fe77e2e3d607997199543e48eaedc130b004cdde0941e9818703220e985deb78b7999
-  data.tar.gz: cb5354b00b067303470076e72b9368e2664b5fa2c75cb4ac7ba902b4433c1b6d7d65e7fd5aebd235f393fd11d4d3d6cfd1f95a2b7fed0927deafe617ea69e7d1
+  metadata.gz: 7c37116a06be27482dc5e330bc8bd652b1eeeeb599c338c6ceeb9e11f2f259c15c18dede31fe652c48e6a0345cf55203550a83e584888965f5dc776748aba229
+  data.tar.gz: 8ab473e74a1090701beecb4815a6fa7ac2d2040a585c6ad7529eee89c072ac1bd6da1498b486f694b994ba65e813c56f4a8c565952e98bea96b40d8dd87e5b4d

data/README.md

@@ -1,9 +1,14 @@
 # Vendi
 
+[![Gem Version](https://badge.fury.io/rb/vendi.svg)](https://badge.fury.io/rb/vendi)
+
+## Overview
+
 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). :)
+Check out the 
+  👉 **[Demo](http://185.201.114.10:4321)** 👈 and [how it was prepared](https://github.com/piotr-iohk/vendi/tree/master/demo#how-it-was-prepared).
 
 ## Installation
 

data/bin/vendi

@@ -8,8 +8,8 @@ doc = <<~DOCOPT
   Vendi - CNFT Vending Machine.
 
   Usage:
-    #{File.basename(__FILE__)} fill --collection <name> --price <lovelace> --nft-count <int> [--wallet-port <port>] [--skip-wallet-creation]
-    #{File.basename(__FILE__)} serve --collection <name> [--wallet-port <port>] [--logfile <file>]
+    #{File.basename(__FILE__)} fill --collection <name> --price <lovelace> --nft-count <int> [--wallet-port <port>] [--skip-wallet]
+    #{File.basename(__FILE__)} serve --collection <name> [--vend-max <int>] [--wallet-port <port>] [--logfile <file>]
     #{File.basename(__FILE__)} -v | --version
     #{File.basename(__FILE__)} -h | --help
 
@@ -19,9 +19,11 @@ doc = <<~DOCOPT
     serve                   Start vending machine.
     --collection <name>     Name of the collection.
     --price <lovelace>      Single NFT price in lovelace.
+    --vend-max <int>        Max number of NFTs vended in single transaction [default: 1].
     --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).
+    --skip-wallet           Skip creation of wallet when filling vending machine.
 
     -v --version            Check #{File.basename(__FILE__)} version.
     -h --help               This help.
@@ -47,7 +49,7 @@ begin
     price = o['--price']
     nft_count = o['--nft-count']
     wallet_port = o['--wallet-port']
-    skip_wallet = o['--skip-wallet-creation']
+    skip_wallet = o['--skip-wallet']
     vendi = Vendi.init({ port: wallet_port.to_i })
     begin
       if File.directory?(File.join(vendi.config_dir, collection_name))
@@ -72,13 +74,14 @@ begin
     collection_name = o['--collection']
     wallet_port = o['--wallet-port']
     logfile = o['--logfile']
+    vend_max = o['--vend-max']
     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)
+      vendi.serve(collection_name, vend_max)
     rescue Errno::ECONNREFUSED => e
       # retry if cannot connect to cardano-wallet
       vendi.logger.error e.message

data/lib/vendi/machine.rb

@@ -50,18 +50,34 @@ module Vendi
       File.join(collection_dir(collection_name), 'metadata-sent.json')
     end
 
+    def failed_mints_path(collection_name)
+      File.join(collection_dir(collection_name), 'failed-mints.json')
+    end
+
     def config(collection_name)
       from_json(config_path(collection_name))
     end
 
+    def set_config(collection_name, configuration)
+      to_json(config_path(collection_name), configuration)
+    end
+
     def metadata_vending(collection_name)
       from_json(metadata_vending_path(collection_name))
     end
 
+    def set_metadata_vending(collection_name, metadata)
+      to_json(metadata_vending_path(collection_name), metadata)
+    end
+
     def metadata_sent(collection_name)
       from_json(metadata_sent_path(collection_name))
     end
 
+    def set_metadata_sent(collection_name, metadata)
+      to_json(metadata_sent_path(collection_name), metadata)
+    end
+
     def metadata(collection_name)
       from_json(metadata_path(collection_name))
     end
@@ -70,16 +86,12 @@ module Vendi
       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)
+    def failed_mints(collection_name)
+      from_json(failed_mints_path(collection_name))
     end
 
-    def set_config(collection_name, configuration)
-      to_json(config_path(collection_name), configuration)
+    def set_failed_mints(collection_name, failed_mints)
+      to_json(failed_mints_path(collection_name), failed_mints)
     end
 
     # Fill vending machine with exemplary set of CIP-25 metadata for minting,
@@ -88,12 +100,18 @@ module Vendi
       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: '' }
+        wallet_details = if File.exist?(config_path(collection_name))
+                           c = config(collection_name)
+                           c.delete(:price)
+                           c
+                         else
+                           { wallet_id: '',
+                             wallet_name: '',
+                             wallet_pass: '',
+                             wallet_address: '',
+                             wallet_policy_id: '',
+                             wallet_mnemonics: '' }
+                         end
       else
         @logger.info('Generating wallet for your collection.')
         wallet_details = create_wallet("Vendi wallet - #{collection_name}")
@@ -110,6 +128,9 @@ module Vendi
       @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)
+      set_metadata_vending(collection_name, metadatas)
+      set_metadata_sent(collection_name, {})
+      set_failed_mints(collection_name, {})
 
       @logger.info('IMPORTANT NOTES! 👇')
       @logger.info('----------------')
@@ -121,12 +142,11 @@ module Vendi
 
     # 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)
+    def serve(collection_name, vend_max = 1)
       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]
@@ -138,8 +158,10 @@ module Vendi
 
       @logger.info 'Vending machine started.'
       @logger.info "Wallet id: #{wid}"
+      @logger.info "Policy id: #{policy_id}"
       @logger.info "Address: #{address}"
       @logger.info "NFT price: #{as_ada(price)}"
+      @logger.info "Vend max NFTs: #{vend_max}"
       @logger.info "Original NFT stock: #{metadata(collection_name).size}"
       @logger.info '----------------'
       unless File.exist?(metadata_vending_path(collection_name))
@@ -152,7 +174,12 @@ module Vendi
         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)}]"
+        @logger.info "[In stock: #{nfts.size}, Sent: #{nfts_sent.size}, NFT price: #{as_ada(price)}, Vend max: #{vend_max}, Balance: #{as_ada(wallet_balance)}]"
+        n = @cw.misc.network.information
+        unless n['sync_progress']['status'] == 'ready'
+          @logger.error "Network is not synced (#{n['sync_progress']['status']} #{n['sync_progress']['progress']['quantity']}%), waiting..."
+          sleep 5
+        end
 
         txs_new = get_incoming_txs(wid)
         if txs.size < txs_new.size
@@ -166,32 +193,34 @@ module Vendi
               @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)
+              minted = mint_nft(collection_name, t['amount']['quantity'], vend_max, dest_addr)
+              tx_res = minted[:tx_res]
+              keys = minted[:keys]
               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))
+                update_metadata_files(keys, 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])}"
+                @logger.warn "Updating #{failed_mints_path(collection_name)} file."
+                update_failed_mints(collection_name, t['id'], tx_res, keys)
               end
               @logger.info '----------------'
 
             else
-              @logger.warn "NO GOOD! NOT VENDING! Tx: #{t['id']}"
+              amt = t['amount']['quantity']
+              @logger.warn "NOT VENDING! Amt: #{as_ada(amt)}, Tx: #{t['id']}"
+              @logger.warn "Updating #{failed_mints_path(collection_name)} file."
+              reason = if amt.to_i < price.to_i
+                         "wrong_amount = #{as_ada(amt)}"
+                       else
+                         "wrong_address = #{address} was not in incoming tx outputs"
+                       end
+              update_failed_mints(collection_name, t['id'], reason, keys)
             end
           end
 

data/lib/vendi/minter.rb

@@ -3,19 +3,46 @@
 module Vendi
   # helper methods for minting NFT
   module Minter
-    def prepare_metadata(nfts, key, policy_id)
+    ##
+    # encode string asset_name to hex representation
+    def asset_name(asset_name)
+      asset_name.unpack1('H*')
+    end
+
+    ##
+    # get list of keys of metadata to be minted
+    def keys_to_mint(tx_amt, price, vend_max, collection_name)
+      nfts = metadata_vending(collection_name)
+      to_mint = (tx_amt / price) > vend_max.to_i ? vend_max.to_i : (tx_amt / price)
+      nfts.keys.sample(to_mint)
+    end
+
+    ##
+    # get metadata for keys to be minted
+    def metadatas(keys, collection_name)
+      nfts = metadata_vending(collection_name)
+      keys.to_h do |key|
+        [key, nfts[key]]
+      end
+    end
+
+    ##
+    # prepare metadata for minting
+    def prepare_metadata(keys, collection_name, policy_id)
       {
         '721' => {
-          policy_id => {
-            key => nfts[key]
-          }
+          policy_id => metadatas(keys, collection_name)
         }
       }
     end
 
-    def update_metadata_files(nfts, key, metadata_vending_file, metadata_sent_file)
+    ##
+    # update metadata files after minting
+    def update_metadata_files(keys, collection_name)
+      metadata_vending_file = metadata_vending_path(collection_name)
+      metadata_sent_file = metadata_sent_path(collection_name)
       # metadata sent
-      m = { key => nfts[key] }
+      m = metadatas(keys, collection_name)
       if File.exist? metadata_sent_file
         sent = from_json(metadata_sent_file)
         sent.merge!(m)
@@ -24,20 +51,37 @@ module Vendi
         to_json(metadata_sent_file, m)
       end
       # metadata available
-      nfts.delete(key)
+      nfts = metadata_vending(collection_name)
+      keys.each do |key|
+        nfts.delete(key)
+      end
       to_json(metadata_vending_file, nfts)
     end
 
+    ##
+    # update failed mints
+    def update_failed_mints(collection_name, tx_id, reason, keys)
+      failed_mints_file = failed_mints_path(collection_name)
+      if File.exist? failed_mints_file
+        failed_mints = from_json(failed_mints_file)
+        failed_mints[tx_id] = [reason, keys]
+        to_json(failed_mints_file, failed_mints)
+      else
+        to_json(failed_mints_file, tx_id => [reason, keys])
+      end
+    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]
+    def mint_payload(keys, address, quantity = 1)
+      keys.map do |key|
+        { 'operation' => { 'mint' => { 'quantity' => quantity,
+                                       'receiving_address' => address } },
+          'policy_script_template' => Vendi::POLICY_SCRIPT_TEMPLATE,
+          'asset_name' => asset_name(key.to_s) }
+      end
     end
 
-    # Construct -> Sign -> Submit
+    # Construct -> Sign -> Submit transaction
     def construct_sign_submit(wid, pass, metadata, mint_payload)
       tx_constructed = @cw.shelley.transactions.construct(wid,
                                                           nil,
@@ -55,11 +99,30 @@ module Vendi
       [tx_constructed, tx_signed, tx_submitted]
     end
 
+    # Mint NFT
+    def mint_nft(collection_name, tx_amt, vend_max, dest_address)
+      c = config(collection_name)
+      wid = c[:wallet_id]
+      pass = c[:wallet_pass]
+      policy_id = c[:wallet_policy_id]
+      price = c[:price]
+      keys = keys_to_mint(tx_amt, price, vend_max, collection_name)
+      @logger.info "Minting #{keys.size} NFT(s): #{keys} to #{dest_address}"
+      metadata = prepare_metadata(keys, collection_name, policy_id)
+      mint_payload = mint_payload(keys, dest_address, 1)
+      tx_res = construct_sign_submit(wid, pass, metadata, mint_payload)
+      { keys: keys, tx_res: tx_res }
+    end
+
+    ##
+    # check if NFT mint transaction is successful
     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
 
+    ##
+    # wait for NFT to be minted
     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"

data/lib/vendi/monitor.rb

@@ -14,7 +14,9 @@ module Vendi
     # 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)
+      (tx['outputs'].any? { |o| (o['address'] == address) }) &&
+        (tx['amount']['quantity'] >= price) &&
+        (tx['direction'] == 'incoming')
     end
 
     # trying to naively get address to send back NFT, take first address from the output that isn't our address

data/lib/vendi/utils.rb

@@ -44,11 +44,5 @@ module Vendi
         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

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vendi
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Piotr Stachyra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-10-28 00:00:00.000000000 Z
+date: 2022-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cardano_wallet
@@ -111,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: CNFT Vending Machine - cardano-wallet based