record_on_chain 0.1.0

data/lib/record_on_chain/command_loader.rb

@@ -0,0 +1,20 @@
+require_relative "./cli"
+require_relative "./constants"
+
+module RecordOnChain
+  class CommandLoader
+    def self.load( name, dirpath= COMMANDS_DIRPATH, argv= ARGV, cli= Cli.new )
+      # except abstract sourcefile
+      return nil if name.start_with?("abstract","mod")
+      # expand command file path
+      filepath = File.expand_path( name, dirpath ) << ".rb"
+      # check file existance
+      return nil unless File.file?( filepath )
+      # require command file
+      require( filepath )
+      # generate object
+      class_name = "RecordOnChain::Commands::#{name.capitalize}"
+      return Object.const_get( class_name ).new( argv , cli )
+    end
+  end
+end

data/lib/record_on_chain/commands/abstract_command.rb

@@ -0,0 +1,55 @@
+require "optparse"
+require_relative "../cli"
+
+module RecordOnChain
+
+  module Commands
+    # base of command class
+    class AbstractCommand
+      def initialize( command_name , cli= Cli.new )
+        @command_name = command_name
+        @cli = cli
+      end
+
+      def start
+        raise NotImplementedError.new
+      end
+
+      def squeeze_args_from_argv( val_context= {} , flag_context= {} , argv= ARGV )
+        opts = OptionParser.new
+        args = {}
+        # set to args according to hash_context.
+        val_context.each { |key,val| opts.on("#{key} VAL"){|v| args[val] = v} }
+        # set to args according to flag_context
+        flag_context.each{ |key,val| opts.on("#{key}"){|v| args[val] = true} }
+        # raise erro if user set unknown option
+        # except first because @argv.first is command name
+        opts.parse( argv )
+        return args
+      end
+
+      private
+
+      def roc_exit( code , msg="" )
+        known_codes = [:nomal_end,:halt]
+        raise "Unknown exit code #{code}" unless known_codes.include?(code)
+        # puts exit messages
+        case code
+        when :nomal_end
+          # nomal end
+          out =  "Exit NOMAL : #{@command_name} command execution succeede.\n"
+          out << "#{msg}"
+          @cli.puts_success_msg( out )
+          exit 0
+        when :halt
+          # something happen
+          err =  "Exit ERROR : #{@command_name} command execution failed.\n"
+          err << "[ ERROR MESSAGE ]\n"
+          err << "#{msg}"
+          @cli.puts_error_msg( err )
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/record_on_chain/commands/help.rb

@@ -0,0 +1,50 @@
+require_relative "./abstract_command"
+require_relative "./init"
+require_relative "./record"
+require_relative "./secret"
+require_relative "../utils"
+
+module RecordOnChain
+  module Commands
+    class Help < AbstractCommand
+
+      def self.description
+        return "display usage"
+      end
+
+      def self.usage; end
+
+      def initialize( argv= ARGV , cli= Cli.new )
+        super( argv.first , cli )
+      end
+
+      def start
+        command_names = [ "init", "record", "secret", "help" ]
+        # command_name : description
+        descriptions = {}
+        # command_name : usage
+        examples = {}
+
+        command_names.each do |name|
+          klass = Object.const_get( "RecordOnChain::Commands::#{name.capitalize}" )
+          description = klass.send( :description )
+          descriptions[ name ] = description unless description.nil?
+          examples[ name ] = klass.usage unless klass.usage.nil?
+        end
+
+        @cli.puts_enhance_msg( "== Record on Chain HELP ==" )
+        @cli.blank_line
+        @cli.puts_underline_msg("description")
+        @cli.puts_hash( descriptions , nil , 1 )
+        @cli.blank_line
+
+        @cli.puts_underline_msg("usage")
+        examples.each do | c_name, usage |
+          @cli.out.puts( " [ #{c_name} ]" )
+          @cli.out.puts( "#{usage}" )
+          @cli.blank_line
+        end
+      end
+    end
+  end
+end

data/lib/record_on_chain/commands/init.rb

@@ -0,0 +1,150 @@
+require "nem"
+require "pathname"
+require_relative "./abstract_command"
+require_relative "../utils"
+require_relative "../keyfile"
+require_relative "../config"
+require_relative "../constants"
+require_relative "../nem_controller"
+require_relative "../crypto/default_cryptor"
+
+module RecordOnChain
+  module Commands
+    class Init < AbstractCommand
+
+      def self.description
+        return "initialize RecordOnChain"
+      end
+
+      def self.usage
+        output = <<-EOS
+ -p <value> => base path         ( default : $HOME              )
+ -s <value> => 32byte hex secret ( default : random hex         )
+ -k <value> => keyfile name      ( default : default_key.yml    )
+ -c <value> => configfile name   ( defailt : default_config.yml )
+ -t         => network type      ( defailt : false -> mainnet   )
+
+ (e.g.) secret:XXX , keyfile_name:mykey.yml , network_type:testnet
+ => $ rochain init -k mykey.yml -s XXX -t
+        EOS
+        return output
+      end
+
+      def initialize( argv= ARGV , cli= Cli.new )
+        super( argv.first , cli )
+        val_context  = { "-p" => :path,
+                         "-s" => :secret,
+                         "-k" => :keyfile_name,
+                         "-c" => :configfile_name }
+        flag_context = { "-t" => :testnet }
+
+        args = squeeze_args_from_argv( val_context , flag_context , argv )
+
+        @secret          = args[:secret]
+        @network_type    = args[:testnet] ? "testnet" : "mainnet"
+        @maindir_path    = get_maindir_path( args[:path] ) # Pathname obj
+        @keyfile_path    = get_datafile_path( "keyfile"    , args[:keyfile_name]    ) # Pathname obj
+        @configfile_path = get_datafile_path( "configfile" , args[:configfile_name] ) # Pathname obj
+      rescue => e
+        roc_exit( :halt , "#{e.message}" )
+      end
+
+      # you can specify maindir path with argument.
+      def start
+        @cli.puts_enhance_msg( "[ Start gnerate keyfile ]" )
+        generate_keyfile
+
+        @cli.puts_enhance_msg( "[ Start gnerate configfile ]" )
+        generate_config
+
+        @cli.blank_line
+
+        # nomal_end
+        roc_exit( :nomal_end )
+      rescue => e
+        roc_exit( :halt , "#{e.message}" )
+      end
+
+      private
+
+      def get_maindir_path( base_path )
+        # default = homedir
+        base_path = base_path ? to_absolute_path( base_path ) : Dir.home
+        # dir not found
+        raise "#{base_path} directory not found." unless Dir.exist?( base_path )
+        # generate maindir
+        maindir_path = Pathname.new( base_path ) + MAINDIR_NAME
+        # mkdir if not exist
+        maindir_path.mkdir unless maindir_path.directory?
+        return maindir_path
+      end
+
+      def to_absolute_path( path )
+        if Pathname.new(path).absolute? then
+          return path # no change
+        else
+          return File.expand_path( path , Dir.pwd )
+        end
+      end
+
+      def get_datafile_path( type , name )
+        datafile_name = name ? name : D_DATAFILE_NAME
+        # add suffix to prevent conflicts
+        datafile_name += RecordOnChain.const_get( "D_#{type.upcase}_SUFFIX" )
+        # to path
+        return @maindir_path + datafile_name
+      end
+
+      def generate_keyfile
+        # skip if already exist
+        if @keyfile_path.exist? then
+          @cli.out.puts( "#{@keyfile_path.to_s} already exists. skip generate keyfile." )
+          return
+        end
+
+        # check hex_str
+        validate_secret_form
+
+        # decide password
+        password = decide_password
+
+        # cretae cryptor
+        cryptor  = Crypto::DefaultCryptor.generate
+
+        # create status
+        salt       = cryptor.generate_salt
+        secret     = @secret ? @secret : cryptor.generate_secret
+        public_key = NemController.public_from_secret( secret )
+        address    = NemController.address_from_public( public_key, @network_type )
+        encrypted_secret = cryptor.encrypt( password, salt, secret )
+        # generate
+        Keyfile.generate( @keyfile_path.to_s, @network_type, salt, encrypted_secret, public_key, address )
+        # display address
+        @cli.puts_attention_msg( "New keyfile address is #{address}" )
+      end
+
+      def validate_secret_form
+        raise "Illegal secret. Secret should be 32byte-hex_string (64chars)." unless @secret.nil? || Utils.hex_str?( @secret , 32 )
+      end
+
+      def decide_password
+        pass = @cli.decide_password
+        raise "5 incorrect password attempts." if pass.nil?
+        return pass
+      end
+
+      def generate_config
+        # skip if already exist
+        if @configfile_path.exist? then
+          @cli.out.puts( "#{@configfile_path.to_s} already exists. skip generate config file." )
+          return
+        end
+
+        # create default_values from loaded keyfile
+        keyfile = Keyfile.load( @keyfile_path )
+        # generate
+        Config.generate( @configfile_path.to_s, @keyfile_path.to_s, keyfile.address, [] )
+      end
+    end
+  end
+end

data/lib/record_on_chain/commands/mod_command.rb

@@ -0,0 +1,38 @@
+require_relative "../keyfile"
+require_relative "../crypto/default_cryptor"
+
+# module set for command
+module RecordOnChain
+  module Commands
+
+    module M_LoadDatafile
+      # base method of load_config & load_keyfile
+      def load_datafile( datafile_path , class_name )
+        # try to load
+        full_class_name = "RecordOnChain::#{class_name.capitalize}"
+        # get klass => klass.send( :load , path ) => klass.load( path )
+        klass = Object.const_get( full_class_name )
+        datafile = klass.send( :load , datafile_path )
+        # if fail to load becaseu any field is illegal
+        raise "Fail to load #{class_name}.Please check the fields of #{class_name}." if datafile.nil?
+        # success
+        return datafile
+      end
+    end
+
+    module M_GetSecret
+      # recover secret from keyfile and user password
+      def get_secret( cli , keyfile )
+        answer  = ""
+        cryptor = RecordOnChain::Crypto::DefaultCryptor.generate
+        decrypt_func = ->( attempt ){ cryptor.decrypt( attempt,  keyfile.salt, keyfile.encrypted_secret ) }
+        secret = cli.encrypt_with_password( decrypt_func )
+        # too many inccorect
+        raise "3 incorrect password attempts." if secret.nil?
+        # if not nil, success to decrypt
+        return secret
+      end
+    end
+
+  end
+end

data/lib/record_on_chain/commands/record.rb

@@ -0,0 +1,163 @@
+require "pathname"
+require_relative "./abstract_command"
+require_relative "./mod_command"
+require_relative "../keyfile"
+require_relative "../config"
+require_relative "../nem_controller"
+require_relative "../constants"
+require_relative "../crypto/default_cryptor"
+
+module RecordOnChain
+  module Commands
+    class Record < AbstractCommand
+
+      def self.description
+        return "record message on nem(ver-1) chain"
+      end
+
+      def self.usage
+        output = <<-EOS
+ -p <value> => base path       ( default : $HOME              )
+ -c <value> => configfile name ( defailt : default_config.yml )
+ -m <value> => message you want to record ( *mandatory fields )
+
+ (e.g.) configfile_name:my_config.yml , message:good_luck!
+ => $ rochain record -c my_config.yml -m good_luck!
+        EOS
+        return output
+      end
+
+      def initialize( argv = ARGV , cli = Cli.new )
+        super( argv.first , cli )
+        val_context = { "-p" => :path,
+                        "-c" => :config,
+                        "-m" => :msg }
+        flag_context = {}
+
+        args = squeeze_args_from_argv( val_context , flag_context , argv )
+
+        @maindir_path = get_dirpath( args[:path] ) # String
+        @config       = load_config( args[:config] )
+        @keyfile      = load_keyfile
+        @msg          = args[:msg]
+        @nem          = create_nem_controller
+      rescue => e
+        roc_exit( :halt , "#{e.message}" )
+      end
+
+      def start
+        # send
+        result = send_tx
+        # exit
+        result[:success?] ? roc_exit( :nomal_end, "tx_hash [ #{result[:tx_hash]} ]" ) :
+                            roc_exit( :halt     , "Fail to send tx. #{result[:message]}" )
+      rescue => e
+        roc_exit( :halt , e.message )
+      end
+
+      private
+
+      # region get_dirpath
+
+      def get_dirpath( dir_path )
+        # default = homedir
+        dir_path = dir_path ? dir_path : Dir.home
+        pn = Pathname.new( dir_path )
+        # dir not found
+        raise "#{dir_path} directory not found." unless pn.directory?
+        return ( pn + MAINDIR_NAME ).to_s
+      end
+
+      # region load_config & load_keyfile
+      include M_LoadDatafile
+
+      def load_config( name )
+        configfile_name = name ? name : D_CONFIGFILE_NAME
+        configfile_path = "#{@maindir_path}/#{configfile_name}"
+        return load_datafile( configfile_path , "config" )
+      end
+
+      def load_keyfile
+        return load_datafile( @config.keyfile_path , "keyfile" )
+      end
+
+      # region create_nem_controller
+
+      def create_nem_controller
+        node_urls = get_node_urls
+        return NemController.new( node_urls , @keyfile.network_type )
+      end
+
+      def get_node_urls
+        # testnet? mainnet?
+        network_type = @keyfile.network_type.to_s
+        preset_filepath = RESOURCES_DIRPATH + "/preset_#{network_type}_nodes"
+        # load preset node set
+        preset_node_urls = []
+        File.foreach( preset_filepath ){ |url| preset_node_urls.push( url.chomp ) }
+        # select nodes
+        node_count = 10
+        nodes = preset_node_urls.sample( node_count )
+        # add nodes thas is specified by user
+        # These nodes have priority
+        add_node = @config.add_node
+        # add in fornt
+        nodes = add_node + nodes
+        return delete_invalid_nodes( nodes )
+      end
+
+      # delete invalid form
+      def delete_invalid_nodes( urls )
+        # delete empty and including unsafe char
+        urls.delete_if{ |u| u.empty? || u.match?( URI::UNSAFE ) }
+        # modify
+        return urls.map do |u|
+          # if not start_with http:// or https://. add prefix
+          u.start_with?( "http://" , "https://" ) ? u : "http://" << u
+        end
+      end
+
+      # region send_tx
+      include M_GetSecret
+
+      def send_tx
+        raise "Massage not found. Nothing to record." if @msg.nil? || @msg.empty?
+        # get secret from keyfile and password.
+        secret = get_secret( @cli, @keyfile )
+        # get address from the secret to use for confirm.
+        sender_address = NemController.address_from_secret( secret , @keyfile.network_type )
+        # for confirm
+        recipient = @config.recipient
+        # prepare transfer tx
+        @nem.prepare_tx( recipient , @msg )
+        # confirm
+        confirm_before_send_tx( sender_address , recipient )
+        # broadcast tx and return result
+        return @nem.send_transfer_tx( secret )
+      end
+
+      def confirm_before_send_tx( sender_address , recipient )
+        fee = @nem.calc_fee/1000000.to_f
+        address_info = @nem.get_address_status( sender_address )
+
+        # caoutino if address has too many xem
+        balance = address_info[:balance]
+        too_many_xem = 1000 * 1000000
+        @cli.puts_caution_msg( "Caution! There are too many xems in this address!　This warning is displayed when it is more than #{too_many_xem/1000000}xem." ) if balance > too_many_xem
+
+        # multisig not supported
+        raise "Error : Sorry, multisig is not supported." if address_info[:multisig]
+
+        # confirmation info
+        @cli.puts_attention_msg( "!! confirm !!" )
+        status = { :sender    => sender_address,
+                   :recipient => recipient,
+                   :data      => @msg,
+                   :fee       => "#{fee} xem"}
+        @cli.puts_hash( status , :enhance )
+        # if not agree, stop recording
+        raise "Stop recording." unless @cli.agree( "record" )
+      end
+    end
+  end
+end