cardano-up 0.1.1 → 0.1.3

data/lib/cardano-up/err.rb

@@ -1,6 +1,41 @@
 # frozen_string_literal: true
 
 module CardanoUp
+  # Thrown when service not exists in session
+  class SessionServiceNotUpError < StandardError
+    def initialize(session_name, env, service)
+      super("Service '#{service}' is not running on '#{env}' in session '#{session_name}'!")
+    end
+  end
+
+  # Thrown when env not exists in session
+  class SessionEnvNotUpError < StandardError
+    def initialize(session_name, env)
+      super("Nothing is running on '#{env}' in session '#{session_name}'!")
+    end
+  end
+
+  # Thrown when session not exists
+  class SessionNotExistsError < StandardError
+    def initialize(session_name)
+      super("Session '#{session_name}' does not exist!")
+    end
+  end
+
+  # Thrown when there is already a node running in the session
+  class SessionHasNodeError < StandardError
+    def initialize(session_name, network)
+      super("Session '#{session_name}' already has node running on '#{network}'!")
+    end
+  end
+
+  # Thrown when there is already a wallet running in the session
+  class SessionHasWalletError < StandardError
+    def initialize(session_name, network)
+      super("Session '#{session_name}' already has wallet running on '#{network}'!")
+    end
+  end
+
   # Thrown when env is not supported
   class EnvNotSupportedError < StandardError
     def initialize(env)
@@ -22,11 +57,25 @@ module CardanoUp
     end
   end
 
+  # Thrown when wallet port is not set
+  class WalletPortUsedError < StandardError
+    def initialize(port)
+      super("The port #{port} is already in use!")
+    end
+  end
+
   # Thrown when version of bundle to download is not supported
   class VersionNotSupportedError < StandardError
     def initialize(ver)
-      super(["Not supported version: #{ver}. Supported are: 'latest', 'master',",
-             "tag (e.g. 'v2022-08-16') or pr number ('3045')"].join(' '))
+      super(["Not supported version: #{ver}. Supported are: 'latest' or",
+             "tag (e.g. 'v2022-08-16')"].join(' '))
+    end
+  end
+
+  # Thrown when there is no screen on the system
+  class NoScreenError < StandardError
+    def initialize
+      super('There is no screen tool on the system!')
     end
   end
 end

data/lib/cardano-up/launcher.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+module CardanoUp
+  ##
+  # Start/stop cardano-node and cardano-wallet on your system.
+  #
+  # For Linux and MacOS it will attempt to start separate screen sessions for
+  # wallet and node respectively, therefore 'screen' tool is required on your system.
+  # @see https://www.gnu.org/software/screen/
+  # If screen is not present you can install it using your package manager for instance:
+  #  # MacOS:
+  #  brew install screen
+  #  # Linux:
+  #  sudo apt-get install screen
+  #
+  # For Windows it will attepmt to install cardano-node and cardano-wallet as Windows services
+  # using 'nssm' tool.
+  # @see https://nssm.cc/
+  # Nssm can be installed via choco package manager:
+  #  choco install nssm
+  module Launcher
+    # Create common set of variables for getting node and wallet up
+    # @param env [Hash] provide env and wallet_port,
+    #  e.g. { env: 'mainnet', wallet_port: '8090', session_name: '0' }
+    # @raise CardanoUp::EnvNotSupportedError
+    # @raise CardanoUp::WalletPortError
+    def self.setup(opt = { env: 'mainnet', wallet_port: '8090', session_name: '0' })
+      env = opt[:env]
+      raise CardanoUp::EnvNotSupportedError, env unless CardanoUp::ENVS.include? env
+
+      wallet_port = opt[:wallet_port]
+      raise CardanoUp::WalletPortError if wallet_port.nil? || wallet_port.empty?
+
+      session_name = opt[:session_name] || '0'
+
+      token_metadata_server = env == 'mainnet' ? CardanoUp::MAINNET_TOKEN_SERVER : CardanoUp::TESTNET_TOKEN_SERVER
+
+      CardanoUp.configure_default unless CardanoUp.configured?
+      configs = CardanoUp.config
+      bin_dir = configs[:bin_dir]
+      config_dir = File.join(configs[:config_dir], env)
+      log_dir = File.join(configs[:log_dir], session_name, env)
+      state_dir = File.join(configs[:state_dir], session_name, env)
+      wallet_db_dir = File.join(state_dir, 'wallet-db')
+      node_db_dir = File.join(state_dir, 'node-db')
+      [bin_dir, config_dir, log_dir, state_dir, wallet_db_dir, node_db_dir].each do |dir|
+        FileUtils.mkdir_p(dir)
+      end
+
+      node_socket = if CardanoUp::Utils.win?
+                      "\\\\.\\pipe\\cardano-node-#{env}-#{session_name}"
+                    else
+                      File.join(state_dir, 'node.socket')
+                    end
+      network = env == 'mainnet' ? '--mainnet' : "--testnet #{File.join(config_dir, 'byron-genesis.json')}"
+
+      {
+        env: env,
+        wallet_port: wallet_port,
+        token_metadata_server: token_metadata_server,
+        bin_dir: bin_dir,
+        config_dir: config_dir,
+        log_dir: log_dir,
+        state_dir: state_dir,
+        wallet_db_dir: wallet_db_dir,
+        node_db_dir: node_db_dir,
+        node_socket: node_socket,
+        network: network,
+        session_name: session_name
+      }
+    end
+
+    # @param configuration [Hash] output of setup
+    # @raise CardanoUp::SessionHasNodeError
+    # @raise CardanoUp::SessionHasWalletError
+    # @raise CardanoUp::NoScreenError
+    def self.node_up(configuration)
+      env = configuration[:env]
+      bin_dir = configuration[:bin_dir]
+      config_dir = configuration[:config_dir]
+      log_dir = configuration[:log_dir]
+      node_db_dir = configuration[:node_db_dir]
+      node_socket = configuration[:node_socket]
+      session_name = configuration[:session_name]
+
+      raise CardanoUp::NoScreenError if !CardanoUp::Utils.win? && !CardanoUp::Utils.screen?
+
+      exe = CardanoUp::Utils.win? ? '.exe' : ''
+      cardano_node = "#{File.join(bin_dir, 'cardano-node')}#{exe}"
+      version = CardanoUp::Utils.cmd "#{cardano_node} version"
+      node_cmd = ["#{cardano_node} run",
+                  "--config #{File.join(config_dir, 'config.json')}",
+                  "--topology #{File.join(config_dir, 'topology.json')}",
+                  "--database-path #{node_db_dir}",
+                  "--socket-path #{node_socket}"].join(' ')
+      node_service = if CardanoUp::Utils.win?
+                       "cardano-node-#{env}-#{session_name}"
+                     else
+                       "NODE_#{env}_#{session_name}"
+                     end
+      logfile = File.join(log_dir, 'node.log')
+      service_details = {
+        network: env,
+        node: {
+          service: node_service,
+          version: version,
+          log: logfile,
+          db_dir: node_db_dir,
+          socket_path: node_socket,
+          protocol_magic: get_protocol_magic(config_dir),
+          bin: node_cmd.split.first,
+          cmd: node_cmd
+        }
+      }
+      CardanoUp::Session.create_or_update(session_name, service_details)
+      if CardanoUp::Utils.win?
+        # Turn off p2p for Windows
+        # TODO: remove after https://github.com/input-output-hk/ouroboros-network/issues/3968 released
+        config_win = CardanoUp::Utils.from_json("#{config_dir}/config.json")
+        config_win[:EnableP2P] = false
+        CardanoUp::Utils.to_json("#{config_dir}/config.json", config_win)
+        topology = {
+          Producers: [
+            {
+              addr: "#{env}-node.world.dev.cardano.org",
+              port: 30_002,
+              valency: 2
+            }
+          ]
+        }
+        CardanoUp::Utils.to_json("#{config_dir}/topology.json", topology)
+
+        # create cardano-node.bat file
+        File.write("#{bin_dir}/cardano-node.bat", node_cmd)
+        install_node = "nssm install #{node_service} #{bin_dir}/cardano-node.bat"
+        log_stdout_node = "nssm set #{node_service} AppStdout #{logfile}"
+        log_stderr_node = "nssm set #{node_service} AppStderr #{logfile}"
+        start_node = "nssm start #{node_service}"
+
+        CardanoUp::Utils.cmd install_node
+        CardanoUp::Utils.cmd log_stdout_node
+        CardanoUp::Utils.cmd log_stderr_node
+        CardanoUp::Utils.cmd start_node
+      else
+        screen_cmd = "screen -dmS #{node_service} -L -Logfile #{logfile} #{node_cmd}"
+        CardanoUp::Utils.cmd screen_cmd
+      end
+      service_details
+    end
+
+    # @param configuration [Hash] output of setup
+    # @raise CardanoUp::NoScreenError
+    # @raise CardanoUp::WalletPortUsedError
+    def self.wallet_up(configuration)
+      if CardanoUp::Utils.port_used?(configuration[:wallet_port].to_i)
+        raise CardanoUp::WalletPortUsedError, configuration[:wallet_port]
+      end
+
+      raise CardanoUp::NoScreenError if !CardanoUp::Utils.win? && !CardanoUp::Utils.screen?
+
+      env = configuration[:env]
+      wallet_port = configuration[:wallet_port]
+      token_metadata_server = configuration[:token_metadata_server]
+      bin_dir = configuration[:bin_dir]
+      log_dir = configuration[:log_dir]
+      wallet_db_dir = configuration[:wallet_db_dir]
+      node_socket = configuration[:node_socket]
+      network = configuration[:network]
+      session_name = configuration[:session_name]
+
+      exe = CardanoUp::Utils.win? ? '.exe' : ''
+      cardano_wallet = "#{File.join(bin_dir, 'cardano-wallet')}#{exe}"
+      wallet_cmd = ["#{cardano_wallet} serve",
+                    "--port #{wallet_port}",
+                    "--node-socket #{node_socket}",
+                    network.to_s,
+                    "--database #{wallet_db_dir}",
+                    "--token-metadata-server #{token_metadata_server}"].join(' ')
+      version = CardanoUp::Utils.cmd "#{bin_dir}/cardano-wallet#{exe} version"
+      wallet_service = if CardanoUp::Utils.win?
+                         "cardano-wallet-#{env}-#{session_name}"
+                       else
+                         "WALLET_#{env}_#{session_name}"
+                       end
+      logfile = File.join(log_dir, 'wallet.log')
+      service_details = {
+        network: env,
+        wallet: {
+          service: wallet_service,
+          version: version,
+          log: logfile,
+          db_dir: wallet_db_dir,
+          port: wallet_port.to_i,
+          url: "http://localhost:#{wallet_port}/v2",
+          bin: wallet_cmd.split.first,
+          cmd: wallet_cmd
+        }
+      }
+
+      CardanoUp::Session.create_or_update(session_name, service_details)
+      if CardanoUp::Utils.win?
+        # create cardano-wallet.bat file
+        File.write("#{bin_dir}/cardano-wallet.bat", wallet_cmd)
+        install_wallet = "nssm install #{wallet_service} #{bin_dir}/cardano-wallet.bat"
+        log_stdout_wallet = "nssm set #{wallet_service} AppStdout #{logfile}"
+        log_stderr_wallet = "nssm set #{wallet_service} AppStderr #{logfile}"
+        start_wallet = "nssm start #{wallet_service}"
+
+        CardanoUp::Utils.cmd install_wallet
+        CardanoUp::Utils.cmd log_stdout_wallet
+        CardanoUp::Utils.cmd log_stderr_wallet
+        CardanoUp::Utils.cmd start_wallet
+      else
+        CardanoUp::Utils.cmd "screen -dmS #{wallet_service} -L -Logfile #{logfile} #{wallet_cmd}"
+      end
+
+      service_details
+    end
+
+    # @raise CardanoUp::EnvNotSupportedError
+    # @raise CardanoUp::NoScreenError
+    def self.node_down(env, session_name = '0')
+      raise CardanoUp::EnvNotSupportedError, env unless CardanoUp::ENVS.include? env
+
+      raise CardanoUp::NoScreenError if !CardanoUp::Utils.win? && !CardanoUp::Utils.screen?
+
+      if CardanoUp::Utils.win?
+        CardanoUp::Utils.cmd "nssm stop cardano-node-#{env}-#{session_name}"
+        CardanoUp::Utils.cmd "nssm remove cardano-node-#{env}-#{session_name} confirm"
+      else
+        CardanoUp::Utils.cmd "screen -S NODE_#{env}_#{session_name} -X at '0' stuff '^C'"
+        CardanoUp::Utils.cmd "screen -XS NODE_#{env}_#{session_name} quit"
+      end
+      CardanoUp::Session.remove(session_name, { network: env, service: 'node' })
+    end
+
+    # @raise CardanoUp::EnvNotSupportedError
+    # @raise CardanoUp::NoScreenError
+    def self.wallet_down(env, session_name = '0')
+      raise CardanoUp::EnvNotSupportedError, env unless CardanoUp::ENVS.include? env
+
+      raise CardanoUp::NoScreenError if !CardanoUp::Utils.win? && !CardanoUp::Utils.screen?
+
+      if CardanoUp::Utils.win?
+        CardanoUp::Utils.cmd "nssm stop cardano-wallet-#{env}-#{session_name}"
+        CardanoUp::Utils.cmd "nssm remove cardano-wallet-#{env}-#{session_name} confirm"
+      else
+        CardanoUp::Utils.cmd "screen -S WALLET_#{env}_#{session_name} -X at '0' stuff '^C'"
+        CardanoUp::Utils.cmd "screen -XS WALLET_#{env}_#{session_name} quit"
+      end
+      CardanoUp::Session.remove(session_name, { network: env, service: 'wallet' })
+    end
+
+    ##
+    # Get protocol magic from config's byron-genesis.json
+    def get_protocol_magic(config)
+      byron_genesis = CardanoUp::Utils.from_json(File.join(config, 'byron-genesis.json'))
+      byron_genesis[:protocolConsts][:protocolMagic].to_i
+    end
+    module_function :get_protocol_magic
+    private_class_method :get_protocol_magic
+  end
+end

data/lib/cardano-up/ping.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module CardanoUp
+  # Check status (ping) of running node and wallet services
+  module Ping
+    # @param session_name [String]
+    # @param env [String]
+    # @raise CardanoUp::EnvNotSupportedError
+    # @raise CardanoUp::SessionNotExistsError
+    # @raise CardanoUp::SessionServiceNotUpError
+    # @raise CardanoUp::SessionEnvNotUpError
+    def self.wallet(session_name, env)
+      CardanoUp::Configs.exist?(env)
+      CardanoUp::Session.network_or_raise?(session_name, env.to_sym)
+      CardanoUp::Session.wallet_or_raise?(session_name, env.to_sym)
+      session = CardanoUp::Session.get(session_name)
+
+      url = session[env.to_sym][:wallet][:url]
+      r = HTTParty.get("#{url}/network/information")
+      [r.parsed_response, r.code]
+    end
+
+    # @param session_name [String]
+    # @param env [String]
+    # @raise CardanoUp::EnvNotSupportedError
+    # @raise CardanoUp::SessionNotExistsError
+    # @raise CardanoUp::SessionServiceNotUpError
+    # @raise CardanoUp::SessionEnvNotUpError
+    def self.node(session_name, env)
+      CardanoUp::Configs.exist?(env)
+      CardanoUp::Session.network_or_raise?(session_name, env.to_sym)
+      CardanoUp::Session.node_or_raise?(session_name, env.to_sym)
+      session = CardanoUp::Session.get(session_name)
+      bin_dir = CardanoUp.config[:bin_dir]
+
+      ENV['CARDANO_NODE_SOCKET_PATH'] = session[env.to_sym][:node][:socket_path]
+      protocol_magic = session[env.to_sym][:node][:protocol_magic]
+      network_arg = env == 'mainnet' ? '--mainnet' : "--testnet-magic #{protocol_magic}"
+      exe = CardanoUp::Utils.win? ? '.exe' : ''
+      cmd = "#{File.join(bin_dir, 'cardano-cli')}#{exe} query tip #{network_arg}"
+      res = CardanoUp::Utils.cmd cmd
+      begin
+        r = JSON.parse(res)
+        c = 200
+      rescue JSON::ParserError
+        r = 'Not responding.'
+        c = 404
+      end
+      [r, c]
+    end
+  end
+end

data/lib/cardano-up/session.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module CardanoUp
+  # Basic sessions management
+  module Session
+    # Check session file exists
+    def self.exists?(session_name)
+      CardanoUp.configure_default unless CardanoUp.configured?
+      File.exist?(session_file_path(session_name))
+    end
+
+    # get session contents
+    def self.get(session_name)
+      raise CardanoUp::SessionNotExistsError, session_name unless exists?(session_name)
+
+      CardanoUp.configure_default unless CardanoUp.configured?
+      session = session_file_path(session_name)
+      CardanoUp::Utils.from_json(session)
+    end
+
+    def self.destroy!(session_name)
+      path = session_file_path(session_name)
+      FileUtils.rm_f(path)
+    end
+
+    def self.destroy_all!
+      list_all.each do |path|
+        FileUtils.rm_f(path)
+      end
+    end
+
+    def self.list_all
+      Dir[File.join(CardanoUp.base_dir, '.session*')]
+    end
+
+    # create or update session with details of launched service
+    # @param session_name [String] session name
+    # @param service_details [Hash] service details
+    # @raise ArgumentError
+    # @raise CardanoUp::SessionHasNodeError
+    # @raise CardanoUp::SessionHasWalletError
+    def self.create_or_update(session_name, service_details)
+      raise ArgumentError, 'service_details should be Hash' unless service_details.is_a?(Hash)
+      raise ArgumentError, 'service_details shoud have :network' if service_details[:network].nil?
+
+      service_network = service_details[:network].to_sym || :unknown
+
+      if !exists?(session_name) || empty?(session_name)
+        # if session is not set then just create new with just service_details
+        content = { service_network => service_details }
+        put_content(session_name, content)
+      elsif !network?(session_name, service_network)
+        # if session exists but has no network, add new network
+        existing_services = get(session_name)
+        new_service = { service_network => service_details }
+        put_content(session_name, existing_services.merge(new_service))
+      else
+        # if session has network and node already, you can add only wallet
+        if service_details.key?(:node) && node?(session_name, service_network)
+          raise CardanoUp::SessionHasNodeError.new(session_name, service_network)
+        end
+
+        # if session has network and wallet already, you can add only node
+        if service_details.key?(:wallet) && wallet?(session_name, service_network)
+          raise CardanoUp::SessionHasWalletError.new(session_name,
+                                                     service_network)
+        end
+
+        existing_services = get(session_name)
+        updated_network = existing_services[service_network].merge(service_details)
+        existing_services[service_network] = updated_network
+        put_content(session_name, existing_services)
+      end
+    end
+
+    def self.node_or_raise?(session_name, env)
+      raise CardanoUp::SessionServiceNotUpError.new(session_name, env, :node) unless node?(session_name, env)
+
+      true
+    end
+
+    def self.wallet_or_raise?(session_name, env)
+      raise CardanoUp::SessionServiceNotUpError.new(session_name, env, :wallet) unless wallet?(session_name, env)
+
+      true
+    end
+
+    def self.network_or_raise?(session_name, env)
+      raise CardanoUp::SessionEnvNotUpError.new(session_name, env) unless network?(session_name, env)
+
+      true
+    end
+
+    # remove entry from session
+    # @param session_name [String] session name
+    # @param service_details [Hash] service details ({ network: 'preprod', service: 'wallet' })
+    def self.remove(session_name, service_details)
+      existing_services = get(session_name)
+      service = service_details[:service].to_sym
+      network = service_details[:network].to_sym
+      if existing_services && existing_services[network]
+        existing_services[network].delete(service)
+
+        unless existing_services[network].key?(:node) || existing_services[network].key?(:wallet)
+          existing_services.delete(network)
+        end
+        put_content(session_name, existing_services)
+      end
+
+      destroy!(session_name) if empty?(session_name)
+    end
+
+    def session_file_path(session_name)
+      File.join(CardanoUp.base_dir, ".session-#{session_name}.json")
+    end
+    module_function :session_file_path
+    private_class_method :session_file_path
+
+    def put_content(session_name, contents)
+      raise ArgumentError, 'contents should be Hash' unless contents.is_a?(Hash)
+
+      path = session_file_path(session_name)
+      File.write(path, JSON.pretty_generate(contents))
+      path
+    end
+    module_function :put_content
+    private_class_method :put_content
+
+    def empty?(session_name)
+      get(session_name) == {}
+    end
+    module_function :empty?
+    private_class_method :empty?
+
+    def network?(session_name, env)
+      get(session_name).key?(env.to_sym)
+    end
+    module_function :network?
+    private_class_method :network?
+
+    def node?(session_name, env)
+      get(session_name)[env.to_sym].key?(:node)
+    end
+    module_function :node?
+    private_class_method :node?
+
+    def wallet?(session_name, env)
+      get(session_name)[env.to_sym].key?(:wallet)
+    end
+    module_function :wallet?
+    private_class_method :wallet?
+  end
+end

data/lib/cardano-up/utils.rb

@@ -8,7 +8,12 @@ module CardanoUp
       res = `#{cmd}`
       puts cmd if display_result
       puts res if display_result
-      res.gsub("\n", '')
+      res.gsub("\n", ' ').strip
+    end
+
+    # Check if screen command is available
+    def self.screen?
+      cmd('which screen').chomp.length.positive?
     end
 
     def self.wget(url, file = nil)
@@ -17,6 +22,31 @@ module CardanoUp
       File.binwrite(file, resp.body)
     end
 
+    # Check if port is already used
+    def self.port_used?(port)
+      begin
+        Timeout.timeout(1) do
+          s = TCPSocket.new('localhost', port)
+          s.close
+          return true
+        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+          return false
+        end
+      rescue Timeout::Error
+        # do nothing
+      end
+
+      false
+    end
+
+    def self.from_json(file)
+      JSON.parse(File.read(file), { symbolize_names: true })
+    end
+
+    def self.to_json(file, hash)
+      File.write(file, JSON.pretty_generate(hash))
+    end
+
     def self.win?
       RUBY_PLATFORM =~ /cygwin|mswin|mingw|bccwin|wince|emx/
     end
@@ -36,40 +66,21 @@ module CardanoUp
 
     ##
     # Latest binary url for latest release or particular tag, from master or pr num.
-    # @param release [String] - 'latest' | /^v20.{2}-.{2}-.{2}/ | 'master' | '3341'
+    # @param release [String] - 'latest' | /^v20.{2}-.{2}-.{2}/
     # @raise CardanoUp::VersionNotSupportedError
     def self.get_binary_url(release = 'latest')
-      unless release == 'master' || release == 'latest' || release =~ /^v20.{2}-.{2}-.{2}/ || release =~ /^\d+$/
-        raise CardanoUp::VersionNotSupportedError, release
-      end
+      raise CardanoUp::VersionNotSupportedError, release unless release == 'latest' || release =~ /^v20.{2}-.{2}-.{2}/
 
-      url = ''
-      if release == 'latest' || release =~ /^v20.{2}-.{2}-.{2}/
-        tag = release == 'latest' ? latest_tag : release
-        if linux?
-          file = "cardano-wallet-#{tag}-linux64.tar.gz"
-        elsif mac?
-          file = "cardano-wallet-#{tag}-macos-intel.tar.gz"
-        elsif win?
-          file = "cardano-wallet-#{tag}-win64.zip"
-        end
-        url = "#{CardanoUp::BINS_BASE_URL}/releases/download/#{tag}/#{file}"
-      else
-        if linux?
-          os = 'linux.musl.cardano-wallet-linux64'
-        elsif mac?
-          os = 'macos.intel.cardano-wallet-macos-intel'
-        elsif win?
-          os = 'linux.windows.cardano-wallet-win64'
-        end
-
-        url = if release == 'master'
-                "#{CardanoUp::HYDRA_BASE_URL}/#{os}/latest/download-by-type/file/binary-dist"
-              else
-                "#{CardanoUp::HYDRA_BASE_URL}-pr-#{release}/#{os}/latest/download-by-type/file/binary-dist"
-              end
+      tag = release == 'latest' ? latest_tag : release
+      if linux?
+        file = "cardano-wallet-#{tag}-linux64.tar.gz"
+      elsif mac?
+        file = "cardano-wallet-#{tag}-macos-intel.tar.gz"
+      elsif win?
+        file = "cardano-wallet-#{tag}-win64.zip"
       end
-      url
+
+      "#{CardanoUp::BINS_BASE_URL}/releases/download/#{tag}/#{file}"
     end
 
     ##

data/lib/cardano-up/version.rb

@@ -2,5 +2,5 @@
 
 # Version
 module CardanoUp
-  VERSION ||= '0.1.1'
+  VERSION ||= '0.1.3'
 end