canoser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 605cb23e469f4b87cd405b7c68232bbf4370efb17a3f9ee08f5835ede36b2e2d
+  data.tar.gz: dc1d93b906f7d3d56346038c671e756d0e10e7887b6ca8c6f688659d11fa0e84
+SHA512:
+  metadata.gz: c9d5d29d35b7682ac3932f3320c176b2230a427ec154a1107826820daf994d77c241bdac1e82786540b9f8e470e6c52276e727b273e2bffcafdc147afd4dac61
+  data.tar.gz: fd1d4aa6c2bc971dc2502b1bf264cc7065f1c703e637696c0865e494aa91f84edfee21d12daf72c9aad4c0d281024a259ce087b899df56ec3fcf658dd17940dc

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.byebug_history
+

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 2.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in canoser.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    canoser (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (11.0.0)
+    minitest (5.11.3)
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  byebug (~> 11.0)
+  canoser!
+  minitest (~> 5.0)
+  rake (~> 10.0)
+
+BUNDLED WITH
+   2.0.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 yuan xinyu
+
+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-CN.md

@@ -0,0 +1,147 @@
+# Canoser
+
+
+Canoser是facebook推出的Libra网络中使用的规范序列化(canonical serialization)协议的第三方ruby实现框架。
+
+规范序列化可确保内存里的数据结构在序列化的时候保证字节一致性。它适用于双方想要有效比较他们独立维护的数据结构。在共识协议中，独立验证者需要就他们独立计算的状态达成一致。共识双方比较的是序列化数据的加密散列。要实现这一点，在计算时，相同数据结构的序列化必须相同。而独立验证器可能由不同的语言编写，有不同的实现代码，但是都遵循同一个规范。
+
+
+## 安装
+
+添加下列行到你的项目的Gemfile文件:
+
+```ruby
+gem 'canoser'
+```
+
+然后执行:
+
+    $ bundle
+
+或者直接通过命令行安装:
+
+    $ gem install canoser
+
+## 使用
+
+首先用Canoser定义一个数据结构，也就是写一个类继承自"Canoser::Struct"，然后通过"define_field"方法来定义该结构所拥有的字段。该结构自然就拥有了序列化和反序列化的能力。例如下面的AccountResource定义了一个Libra代码中的同名数据结构：
+```ruby
+  #ruby代码，利用canoser定义数据结构
+  class AccountResource < Canoser::Struct
+  	define_field :authentication_key, [Canoser::Uint8]
+  	define_field :balance, Canoser::Uint64
+  	define_field :delegated_withdrawal_capability, Canoser::Bool
+  	define_field :received_events_count, Canoser::Uint64
+  	define_field :sent_events_count, Canoser::Uint64
+  	define_field :sequence_number, Canoser::Uint64
+  end
+```
+
+下面是Libra中定义该数据结构以及序列化的代码：
+```rust
+// Libra中的rust语言代码
+// 定义数据结构
+pub struct AccountResource {
+    balance: u64,
+    sequence_number: u64,
+    authentication_key: ByteArray,
+    sent_events_count: u64,
+    received_events_count: u64,
+    delegated_withdrawal_capability: bool,
+}
+// 实现序列化
+impl CanonicalSerialize for AccountResource {
+    fn serialize(&self, serializer: &mut impl CanonicalSerializer) -> Result<()> {
+        serializer
+            .encode_struct(&self.authentication_key)?
+            .encode_u64(self.balance)?
+            .encode_bool(self.delegated_withdrawal_capability)?
+            .encode_u64(self.received_events_count)?
+            .encode_u64(self.sent_events_count)?
+            .encode_u64(self.sequence_number)?;
+        Ok(())
+    }
+}
+```
+在Libra使用的rust语言中，需要手动写代码实现数据结构的序列化/反序列化，而且数据结构中的字段顺序和序列化时的顺序不一定一致。
+在Canoser中，定义好数据结构后，不需要写序列化和反序列化的代码。注意，Canoser中的数据结构顺序要按照Libra中序列化的顺序来定义。
+
+### 支持的数据类型
+
+字段支持的类型有：
+
+| 字段类型 | 可选子类型 | 说明 |
+| ------ | ------ | ------ |
+| Canoser::Uint8 |  | 无符号8位整数 |
+| Canoser::Uint16 |  | 无符号16位整数 |
+| Canoser::Uint32 |  | 无符号32位整数 |
+| Canoser::Uint64 |  | 无符号64位整数 |
+| Canoser::Bool |  | 布尔类型 |
+| Canoser::Str |  | 字符串 |
+| [] | 支持 | 数组类型 |
+| {} | 支持 |  Map类型 |
+| A Canoser::Struct Name |  | 嵌套的另外一个结构（不能循环引用） |
+
+### 关于数组类型
+数组里的数据，如果没有定义类型，那么缺省是Uint8。下面的两个定义等价：
+```ruby
+  class Arr1 < Canoser::Struct
+    define_field :addr, []
+  end
+  class Arr2 < Canoser::Struct
+    define_field :addr, [Canoser::Uint8]
+  end  
+```  
+数组还可以定义长度，表示定长数据。比如Libra中的地址是256位，也就是32个字节，所以可以如下定义：
+```ruby
+  class Address < Canoser::Struct
+    define_field :addr, [Canoser::Uint8], 32
+  end  
+```  
+定长数据在序列化的时候，不写入长度信息。
+
+### 关于Map类型
+Map里的数据，如果没有定义类型，那么缺省是字节数组。下面的两个定义等价：
+```ruby
+  class Map1 < Canoser::Struct
+    define_field :addr, {}
+  end
+  class Map2 < Canoser::Struct
+    define_field :addr, {[Canoser::Uint8], [Canoser::Uint8]}
+  end  
+```  
+
+### 结构嵌套
+下面是一个复杂的例子，包含三个数据结构：
+```ruby
+  class Addr < Canoser::Struct
+    define_field :addr, [Canoser::Uint8], 32
+  end
+
+  class Bar < Canoser::Struct
+    define_field :a, Canoser::Uint64
+    define_field :b, [Canoser::Uint8]
+    define_field :c, Addr
+    define_field :d, Canoser::Uint32
+  end
+
+  class Foo < Canoser::Struct
+    define_field :a, Canoser::Uint64
+    define_field :b, [Canoser::Uint8]
+    define_field :c, Bar
+    define_field :d, Canoser::Bool
+    define_field :e, {}
+  end
+```
+这个例子参考自libra中canonical serialization的测试代码。
+
+### 序列化和反序列化
+在定义好Canoser::Struct后，不需要自己实现序列化和反序列化代码，直接调用基类的默认实现即可。以AccountResource结构为例：
+```ruby
+#序列化
+obj = AccountResource.new(authentication_key:[...],...)
+bytes = obj.serialize
+#反序列化
+obj = AccountResource.deserialize(bytes)
+```
+

data/README.md

@@ -0,0 +1,170 @@
+# Canoser
+
+[中文文档 Chinese document](/README-CN.md)
+
+A ruby implementation of the canonical serialization for the Libra network.
+
+Canonical serialization guarantees byte consistency when serializing an in-memory
+data structure. It is useful for situations where two parties want to efficiently compare
+data structures they independently maintain. It happens in consensus where
+independent validators need to agree on the state they independently compute. A cryptographic
+hash of the serialized data structure is what ultimately gets compared. In order for
+this to work, the serialization of the same data structures must be identical when computed
+by independent validators potentially running different implementations
+of the same spec in different languages.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'canoser'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install canoser
+
+## Usage
+
+First define a data structure with Canoser, that is, write a class that inherits from "Canoser::Struct", and then define the fields owned by the structure through the "define_field" method. This structure naturally has the ability to canonical serialize and deserialize types. For example, the following AccountResource defines a data structure of the same name in the Libra code：
+```ruby
+  #ruby code，define canoser data structure
+  class AccountResource < Canoser::Struct
+  	define_field :authentication_key, [Canoser::Uint8]
+  	define_field :balance, Canoser::Uint64
+  	define_field :delegated_withdrawal_capability, Canoser::Bool
+  	define_field :received_events_count, Canoser::Uint64
+  	define_field :sent_events_count, Canoser::Uint64
+  	define_field :sequence_number, Canoser::Uint64
+  end
+```
+
+Here is the code that defines this data structure and serialization in Libra code:
+```rust
+// rust code in Libra
+// define the data structure
+pub struct AccountResource {
+    balance: u64,
+    sequence_number: u64,
+    authentication_key: ByteArray,
+    sent_events_count: u64,
+    received_events_count: u64,
+    delegated_withdrawal_capability: bool,
+}
+// serialization
+impl CanonicalSerialize for AccountResource {
+    fn serialize(&self, serializer: &mut impl CanonicalSerializer) -> Result<()> {
+        serializer
+            .encode_struct(&self.authentication_key)?
+            .encode_u64(self.balance)?
+            .encode_bool(self.delegated_withdrawal_capability)?
+            .encode_u64(self.received_events_count)?
+            .encode_u64(self.sent_events_count)?
+            .encode_u64(self.sequence_number)?;
+        Ok(())
+    }
+}
+```
+In the rust language used by Libra, it is necessary to manually write code to serialize/deserialize the data structure, and the order of the fields in the data structure and the order of serialization are not necessarily the same.
+
+In Canoser, after defining the data structure, you don't need to write code to implement serialization and deserialization. Note that the order of the data structures in Canoser is defined in the order in which they are serialized in Libra.
+
+### Supported field types
+
+| field type | optionl sub type | description |
+| ------ | ------ | ------ |
+| Canoser::Uint8 |  | Unsigned 8-bit integer |
+| Canoser::Uint16 |  | Unsigned 16-bit integer|
+| Canoser::Uint32 |  | Unsigned 32-bit integer |
+| Canoser::Uint64 |  | Unsigned 64-bit integer |
+| Canoser::Bool |  | Boolean |
+| Canoser::Str |  | String |
+| [] | supported | Array Type |
+| {} | supported |  Map Type |
+| A Canoser::Struct Name|  | Another structure nested (cannot be recycled) |
+
+### About Array Type
+The default data type (if not defined) in the array is Uint8. The following two definitions are equivalent:
+```ruby
+  class Arr1 < Canoser::Struct
+    define_field :addr, []
+  end
+  class Arr2 < Canoser::Struct
+    define_field :addr, [Canoser::Uint8]
+  end  
+```  
+Arrays can also define lengths to represent fixed length data. For example, the address in Libra is 256 bits, which is 32 bytes, so it can be defined as follows:
+```ruby
+  class Address < Canoser::Struct
+    define_field :addr, [Canoser::Uint8], 32
+  end  
+```  
+When the fixed length data is serialized, the length information is not written to the output.
+
+
+### About map type
+The default data type (if not defined) in the map is an array of Uint8. The following two definitions are equivalent:
+```ruby
+  class Map1 < Canoser::Struct
+    define_field :addr, {}
+  end
+  class Map2 < Canoser::Struct
+    define_field :addr, {[Canoser::Uint8], [Canoser::Uint8]}
+  end  
+```  
+
+### Nested data structure
+The following is a complex example with three data structures:
+```ruby
+  class Addr < Canoser::Struct
+    define_field :addr, [Canoser::Uint8], 32
+  end
+
+  class Bar < Canoser::Struct
+    define_field :a, Canoser::Uint64
+    define_field :b, [Canoser::Uint8]
+    define_field :c, Addr
+    define_field :d, Canoser::Uint32
+  end
+
+  class Foo < Canoser::Struct
+    define_field :a, Canoser::Uint64
+    define_field :b, [Canoser::Uint8]
+    define_field :c, Bar
+    define_field :d, Canoser::Bool
+    define_field :e, {}
+  end
+```
+This example refers to the test code from canonical serialization in libra.
+
+### Serialization and deserialization
+After defining Canoser::Struct, you don't need to implement serialization and deserialization code yourself, you can directly call the default implementation of the base class. Take the AccountResource structure as an example:
+
+```ruby
+#序列化
+obj = AccountResource.new(authentication_key:[...],...)
+bytes = obj.serialize
+#反序列化
+obj = AccountResource.deserialize(bytes)
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` 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/yuanxinyu/canoser. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

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

@@ -0,0 +1,44 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "canoser/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "canoser"
+  spec.version       = Canoser::VERSION
+  spec.authors       = ["yuan xinyu"]
+  spec.email         = ["yuanxinyu.hangzhou@gmail.com"]
+
+  spec.summary       = %q{A ruby implementation of the canonical serialization for the Libra network.}
+  spec.description   = %q{A ruby implementation of the canonical serialization for the Libra network.}
+  spec.homepage      = "https://github.com/yuanxinyu/canoser.git"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/yuanxinyu/canoser.git"
+    spec.metadata["changelog_uri"] = "https://github.com/yuanxinyu/canoser.git"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |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_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "byebug", "~> 11.0"
+
+end

data/lib/canoser.rb

@@ -0,0 +1,46 @@
+# What is canonical serialization?
+#
+# Canonical serialization guarantees byte consistency when serializing an in-memory
+# data structure. It is useful for situations where two parties want to efficiently compare
+# data structures they independently maintain. It happens in consensus where
+# independent validators need to agree on the state they independently compute. A cryptographic
+# hash of the serialized data structure is what ultimately gets compared. In order for
+# this to work, the serialization of the same data structures must be identical when computed
+# by independent validators potentially running different implementations
+# of the same spec in different languages.
+#
+# One design
+# goal of this serialization format is to optimize for simplicity. It is not designed to be
+# another full-fledged network serialization as Protobuf or Thrift. It is designed
+# for doing only one thing right, which is to deterministically generate consistent bytes
+# from a data structure.
+#
+# An extremely simple implementation of CanonicalSerializer is also provided, the encoding
+# rules are:
+# (All unsigned integers are encoded in little-endian representation unless specified otherwise)
+#
+# 1. The encoding of an unsigned 64-bit integer is defined as its little-endian representation
+#    in 8 bytes
+#
+# 2. The encoding of an item (byte array) is defined as:
+#    [length in bytes, represented as 4-byte integer] || [item in bytes]
+#
+#
+# 3. The encoding of a list of items is defined as: (This is not implemented yet because
+#    there is no known struct that needs it yet, but can be added later easily)
+#    [No. of items in the list, represented as 4-byte integer] || encoding(item_0) || ....
+#
+# 4. The encoding of an ordered map where the keys are ordered by lexicographic order.
+#    Currently, we only support key and value of type Vec<u8>. The encoding is defined as:
+#    [No. of key value pairs in the map, represented as 4-byte integer] || encode(key1) ||
+#    encode(value1) || encode(key2) || encode(value2)...
+#    where the pairs are appended following the lexicographic order of the key
+#
+require "canoser/version"
+require "canoser/cursor"
+require "canoser/field"
+require "canoser/struct"
+
+module Canoser
+	class ParseError < StandardError; end
+end

data/lib/canoser/cursor.rb

@@ -0,0 +1,24 @@
+module Canoser
+  class Cursor
+  	def initialize(bytes, offset=0)
+  		@bytes = bytes
+  		@offset = offset
+  	end
+
+  	def read_bytes(size)
+  		raise ParseError.new("#{@offset+size} exceed bytes size:#{@bytes.size}") if @offset+size > @bytes.size
+  		ret = @bytes[@offset, size]
+  		@offset += size
+  		ret
+  	end
+
+    def peek_bytes(size)
+      raise ParseError.new("#{@offset+size} exceed bytes size:#{@bytes.size}") if @offset+size > @bytes.size
+      @bytes[@offset, size]
+    end    
+
+  	def finished?
+  		@offset == @bytes.size
+  	end
+  end
+end

data/lib/canoser/field.rb

@@ -0,0 +1,167 @@
+
+module Canoser
+  class IntField
+    @@pack_map = {8 => "C", 16 => "S", 32 => "L", 64 => "Q"}
+
+    def initialize(int_bits)
+      @int_bits = int_bits
+    end
+
+    def inspect
+      "Uint#{@int_bits}"
+    end
+
+    def to_s
+      inspect
+    end
+
+    def pack_str
+      @@pack_map[@int_bits]
+    end
+
+    def encode(value)
+      [value].pack(pack_str)
+    end
+
+    def decode_bytes(bytes)
+      bytes.unpack(pack_str)[0]
+    end
+
+    def decode(cursor)
+      bytes = cursor.read_bytes(@int_bits/8)
+      decode_bytes(bytes)
+    end
+
+    def max_value
+      2**@int_bits - 1
+    end
+  end
+
+  Uint8 = IntField.new(8)
+  Uint16 = IntField.new(16)
+  Uint32 = IntField.new(32)
+  Uint64 = IntField.new(64)
+
+  class Bool
+    def self.encode(value)
+      if value
+        "\1"
+      else
+        "\0"
+      end
+    end
+
+    def self.decode_bytes(bytes)
+      return true if bytes == "\1"
+      return false if bytes == "\0"
+      raise ParseError.new("bool should be 0 or 1.")
+    end
+
+    def self.decode(cursor)
+      bytes = cursor.read_bytes(1)
+      decode_bytes(bytes)
+    end
+  end
+
+
+  class Str
+    def self.encode(value)
+      output = ""
+      bytes = value.bytes
+      output << Uint32.encode(bytes.size)
+      bytes.each{|x| output << Canoser::Uint8.encode(x)}
+      output
+    end
+
+    def self.decode(cursor)
+      str = ""
+      len = Uint32.decode(cursor)
+      len.times do
+        str << Uint8.decode(cursor)
+      end
+      str 
+    end
+  end
+
+
+  class ArrayT
+    attr_accessor :type, :fixed_len
+
+    def initialize(type=Uint8, fixed_len=nil)
+      @type = type
+      @fixed_len = fixed_len
+    end
+
+    def encode(arr)
+      output = ""
+      output << Uint32.encode(arr.size) unless @fixed_len
+      arr.each{|x| output << @type.encode(x)}
+      output
+    end
+
+    def decode(cursor)
+      arr = []
+      len = @fixed_len
+      len = Uint32.decode(cursor) unless @fixed_len
+      len.times do
+        arr << @type.decode(cursor)
+      end
+      arr 
+    end
+
+    def ==(other)
+      return self.type == other.type && self.fixed_len == other.fixed_len
+    end
+
+  end
+
+  DEFAULT_KV = ArrayT.new(Uint8)
+
+  class HashT
+    attr_accessor :ktype, :vtype
+
+    def initialize(ktype=DEFAULT_KV, vtype=DEFAULT_KV)
+      @ktype = ktype || DEFAULT_KV
+      @vtype = vtype || DEFAULT_KV
+    end
+
+    def encode(hash)
+      output = ""
+      output << Uint32.encode(hash.size)
+      sorted_map = {}
+      hash.each do |k, v|
+        sorted_map[ktype.encode(k)] = vtype.encode(v)
+      end
+      sorted_map.keys.sort.each do |k|
+        output << k
+        output << sorted_map[k]
+      end
+      output
+    end
+
+    def decode(cursor)
+      hash = {}
+      len = Uint32.decode(cursor)
+      len.times do
+        k = ktype.decode(cursor)
+        v = vtype.decode(cursor)
+        hash[k] = v
+      end
+      hash
+    end
+
+    def ==(other)
+      return self.ktype == other.ktype && self.vtype == other.vtype
+    end
+
+  end
+
+
+  class Optional
+  	def initialize(bool, value)
+  	end
+
+  end
+
+
+end

data/lib/canoser/struct.rb

@@ -0,0 +1,90 @@
+
+module Canoser
+
+  class Struct
+  	def self.define_field(name, type, arr_len=nil)
+      name = ":"+name.to_sym.to_s
+      if type.class == Array
+        type =  ArrayT.new(type[0], arr_len)
+      elsif type.class == Hash
+        type = HashT.new(type.keys[0], type.values[0])
+      else
+        raise "type #{type} doen't support arr_len param" if arr_len
+      end
+      str = %Q{
+        @@names ||= []
+        @@names << #{name}
+        @@types ||= []
+        @@types << type
+      }
+      class_eval str
+  	end
+
+  	def initialize(hash={})
+      @values = {}
+  		hash.each do |k,v|
+  			idx =  self.class.class_variable_get("@@names").find_index{|x| x==k}
+  			raise "#{k} is not a field of #{self}" unless idx
+  			type = self.class.class_variable_get("@@types")[idx]
+        if type.class == ArrayT
+          len = type.fixed_len
+          raise "fix-length array #{k}: #{len} != #{v.size}" if len && v.size != len
+        end
+        @values[k] = v
+  		end
+  	end
+
+    def [](name)
+      @values[name.to_sym]
+    end
+
+    def []=(name, value)
+      @values[name.to_sym] = value
+    end
+
+    def ==(other)
+      return true if self.equal?(other)
+      self.class.class_variable_get("@@names").each_with_index do |name, idx|
+        unless @values[name] == other[name]
+          return false
+        end
+      end
+      true
+    end
+
+    def self.encode(value)
+      value.serialize
+    end
+
+  	def serialize
+      output = ""
+  		self.class.class_variable_get("@@names").each_with_index do |name, idx|
+  			type = self.class.class_variable_get("@@types")[idx]
+        value = @values[name]
+        output << type.encode(value)
+  		end
+      output
+  	end
+
+  	def self.deserialize(bytes)
+      cursor = Canoser::Cursor.new(bytes)
+      ret = decode(cursor)
+      raise ParseError.new("bytes not all consumed.") unless cursor.finished?
+      ret
+  	end
+
+    def self.decode(cursor)
+      self.new({}).decode(cursor)
+    end
+
+    def decode(cursor)
+      self.class.class_variable_get("@@names").each_with_index do |name, idx|
+        type = self.class.class_variable_get("@@types")[idx]
+        @values[name] = type.decode(cursor)
+      end
+      self
+    end
+
+  end
+
+end

data/lib/canoser/version.rb

@@ -0,0 +1,3 @@
+module Canoser
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: canoser
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- yuan xinyu
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-08-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+description: A ruby implementation of the canonical serialization for the Libra network.
+email:
+- yuanxinyu.hangzhou@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README-CN.md
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- canoser.gemspec
+- lib/canoser.rb
+- lib/canoser/cursor.rb
+- lib/canoser/field.rb
+- lib/canoser/struct.rb
+- lib/canoser/version.rb
+homepage: https://github.com/yuanxinyu/canoser.git
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/yuanxinyu/canoser.git
+  source_code_uri: https://github.com/yuanxinyu/canoser.git
+  changelog_uri: https://github.com/yuanxinyu/canoser.git
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: A ruby implementation of the canonical serialization for the Libra network.
+test_files: []