dcha 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 314de64cafe77939bedb982c40f3ee3e5eab7885
+  data.tar.gz: 55ef4a1efa2a294955a436b76f8d586784312e1f
+SHA512:
+  metadata.gz: 001c015d804aa09c5e5477bf6b080ffaf6952f883b291e51771949d11e16a25246d3a93226afacd696240e26f1e340349d79a344ed53d49180d94b6923479bf7
+  data.tar.gz: 7d271e47ec85bb8896b3cd53a44ce630a38de5d0763263d2df9157fbbcbe32884899f3be271da634711a9606a819b42be29a8756b204a05e6d8a44122cd764ce

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.16.0

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in dcha.gemspec
+gemspec
+
+gem 'pry'

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    dcha (0.1.0)
+      curses
+      oj
+      rlp
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.2)
+    curses (1.2.4)
+    diff-lcs (1.3)
+    method_source (0.9.0)
+    oj (3.3.10)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rake (10.5.0)
+    rlp (0.7.3)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.0)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  dcha!
+  pry
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.16.0

data/README.md

@@ -0,0 +1,35 @@
+# Dcha
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/dcha`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dcha'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dcha
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/dcha.

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'dcha'
+
+# 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/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/dcha.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dcha/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dcha'
+  spec.version       = Dcha::VERSION
+  spec.authors       = ['蒼時弦也']
+  spec.email         = ['elct9620@frost.tw']
+
+  spec.summary       = 'The decenterialize chat powered by blockchain'
+  spec.description   = 'The decenterialize chat powered by blockchain'
+  spec.homepage      = 'https://github.com/elct9620/dcha'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'oj'
+  spec.add_runtime_dependency 'rlp'
+  spec.add_runtime_dependency 'curses'
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/exe/dcha

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'dcha'
+
+Thread.abort_on_exception = true
+
+peer = Dcha::Peer.new
+peer.join
+
+Dcha::UI.new(peer).show

data/lib/dcha.rb

@@ -0,0 +1,24 @@
+require 'oj'
+require 'rlp'
+require 'digest'
+require 'socket'
+require 'ipaddr'
+require 'singleton'
+require 'curses'
+require 'observer'
+require 'pathname'
+
+require 'dcha/version'
+
+# :nodoc:
+module Dcha
+  autoload :Config, 'dcha/config'
+  autoload :MPT, 'dcha/mpt'
+  autoload :UI, 'dcha/ui'
+  autoload :Peer, 'dcha/peer'
+  autoload :Chunk, 'dcha/chunk'
+  autoload :PacketManager, 'dcha/packet_manager'
+  autoload :Block, 'dcha/block'
+  autoload :Chain, 'dcha/chain'
+  autoload :Store, 'dcha/store'
+end

data/lib/dcha/block.rb

@@ -0,0 +1,36 @@
+module Dcha
+  # :nodoc:
+  class Block
+    attr_accessor :index, :hash, :root_hash, :parent_hash, :time, :proof
+
+    def initialize(options = {})
+      @time = Time.now.to_i
+      @proof = ''
+      options.each { |k, v| send("#{k}=", v) }
+    end
+
+    def valid_after?(previous_block)
+      (previous_block.hash == parent_hash) &&
+        (hash == Digest::SHA256.hexdigest(body.join)) &&
+        valid_proof?
+    end
+
+    def body
+      [index, time, root_hash, parent_hash]
+    end
+
+    def valid_proof?
+      Digest::SHA256.hexdigest((body + [proof]).join).start_with?('abc')
+    end
+
+    def make_proof
+      @hash = Digest::SHA256.hexdigest(body.join)
+      letters = ('a'..'z').to_a
+      @proof << letters.sample until valid_proof?
+      self
+    end
+
+    # rubocop:disable Metrics/LineLength
+    GENESIS = Block.new(index: 0, parent_hash: 0, time: 0, root_hash: "\0", proof: 'lvew')
+  end
+end

data/lib/dcha/chain.rb

@@ -0,0 +1,49 @@
+module Dcha
+  # :nodoc:
+  class Chain
+    attr_reader :blocks
+
+    def initialize
+      @blocks = [Block::GENESIS]
+    end
+
+    def add_block(block)
+      blocks << block if block.valid_after?(blocks.last)
+
+      unless valid_chain?
+        @blocks = @blocks[0..-2]
+        return false
+      end
+
+      true
+    end
+
+    def create_and_add_block(root_hash)
+      add_block(Block.new(
+        index: blocks.last.index + 1,
+        parent_hash: blocks.last.hash,
+        root_hash: root_hash
+      ).make_proof)
+    end
+
+    def replace_with(new_blocks)
+      new_blocks = [Block::GENESIS] + new_blocks
+      return unless valid_chain?(new_blocks) &&
+                    new_blocks.length > blocks.length
+      @blocks = new_blocks
+      true
+    end
+
+    def valid_chain?(blocks = @blocks)
+      valid = true
+      blocks.each.with_index(0) do |block, idx|
+        valid &&= if idx.zero?
+                    Oj.dump(block) == Oj.dump(Block::GENESIS)
+                  else
+                    block.valid_after?(blocks[idx - 1])
+                  end
+      end
+      valid
+    end
+  end
+end

data/lib/dcha/chunk.rb

@@ -0,0 +1,43 @@
+module Dcha
+  # :nodoc:
+  class Chunk < Array
+    SIZE = 128
+    TAG_SIZE = 40 # SHA1
+
+    class << self
+      def create(data)
+        split(data).map { |bytes| new bytes }
+      end
+
+      def split(data)
+        buffer = Oj.dump(data)
+        tag = Digest::SHA1.hexdigest(buffer).unpack('C*')
+        slices = buffer.unpack('C*').each_slice(SIZE)
+        size = slices.size
+        slices.map.with_index do |bytes, index|
+          [tag, index, size, bytes].flatten
+        end
+      end
+    end
+
+    include Comparable
+
+    attr_reader :tag, :index, :total
+
+    def initialize(bytes)
+      super
+      @tag = bytes.shift(TAG_SIZE).pack('C*')
+      @index = bytes.shift
+      @total = bytes.shift
+      @buffer = bytes.pack('C*')
+    end
+
+    def <=>(other)
+      index <=> other.index
+    end
+
+    def to_s
+      @buffer
+    end
+  end
+end

data/lib/dcha/config.rb

@@ -0,0 +1,24 @@
+module Dcha
+  # :nodoc:
+  class Config
+    class << self
+      def respond_to_missing?(name)
+        instance.respond_to_missing?(name)
+      end
+
+      def method_missing(name, *args, &block)
+        return instance.send(name, *args, &block) if instance.respond_to?(name)
+        super
+      end
+    end
+
+    include Singleton
+
+    attr_accessor :digest, :store
+
+    def initialize
+      @digest = Digest::SHA256
+      @store = Store::Memory.new
+    end
+  end
+end

data/lib/dcha/mpt.rb

@@ -0,0 +1,8 @@
+module Dcha
+  # Merkle Particia Tree
+  module MPT
+    autoload :Trie, 'dcha/mpt/trie'
+    autoload :Node, 'dcha/mpt/node'
+    autoload :NibbleKey, 'dcha/mpt/nibble_key'
+  end
+end

data/lib/dcha/mpt/nibble_key.rb

@@ -0,0 +1,110 @@
+module Dcha
+  module MPT
+    # :nodoc:
+    class NibbleKey < Array
+      TERM_FLAG  = 0b0010
+      ODD_FLAG   = 0b0001
+      TERMINATOR = 16
+
+      HEX_VALUES = Hash[(0..15).map { |i| [i.to_s(16), i] }]
+
+      class << self
+        def encode(nibbles)
+          flags = 0
+
+          if nibbles.last == TERMINATOR
+            flags |= TERM_FLAG
+            nibbles = nibbles[0...-1]
+          end
+
+          odd = nibbles.size % 2
+          flags |= odd
+          return pack [flags] + nibbles if odd == 1
+          pack [flags, 0b0000] + nibbles
+        end
+
+        def decode(bytes)
+          o = from_string bytes
+          flags = o[0]
+
+          o.push TERMINATOR if flags & TERM_FLAG > 0
+          fill = flags & ODD_FLAG > 0 ? 1 : 2
+          new o[fill..-1]
+        end
+
+        def from_string(s)
+          nibbles = s.unpack('H*')
+                     .first
+                     .each_char
+                     .map { |c| HEX_VALUES[c] }
+          new nibbles
+        end
+
+        def to_string(nibbles)
+          # TODO: Add error message
+          raise ArgumentError unless nibbles.any? { |x| x.between?(0, 15) }
+          raise ArgumentError if nibbles.size.odd?
+
+          pack nibbles
+        end
+
+        def terminator
+          new [TERMINATOR]
+        end
+
+        private
+
+        def pack(nibbles)
+          size = nibbles.size / 2
+          (0...size).map do |i|
+            base = i * 2
+            (16 * nibbles[base] + nibbles[base + 1]).chr
+          end.join
+        end
+      end
+
+      def terminate?
+        last == TERMINATOR
+      end
+
+      def terminate(flag)
+        dup.tap do |copy|
+          if flag
+            copy.push TERMINATOR unless copy.terminate?
+          elsif copy.terminate?
+            copy.pop
+          end
+        end
+      end
+
+      def prefix?(another_key)
+        return false if another_key.size < size
+        another_key.take(size) == self
+      end
+
+      def common_prefix(another_key)
+        prefix = []
+
+        [size, another_key.size].min.times do |i|
+          break if self[i] != another_key[i]
+          prefix.push self[i]
+        end
+
+        self.class.new prefix
+      end
+
+      def encode
+        self.class.encode self
+      end
+
+      def to_s
+        self.class.to_string self
+      end
+      alias to_string to_s
+
+      def +(other)
+        self.class.new super(other)
+      end
+    end
+  end
+end