stellar-base 0.0.20 → 0.1.0

data/lib/stellar/currency.rb

@@ -1,39 +0,0 @@
-module Stellar
-  class Currency
-    def self.native
-      new(:currency_type_native)
-    end
-
-    def self.alphanum(code, issuer)
-      raise ArgumentError, "Bad :issuer" unless issuer.is_a?(KeyPair)
-      code = normalize_code(code)
-      an = AlphaNum.new({currency_code:code, issuer:issuer.account_id})
-      new(:currency_type_alphanum, an)
-    end
-
-    def to_s
-      if switch == CurrencyType.currency_type_native
-        "native"
-      else
-        encoder = Stellar::Util::Base58.stellar
-        issuer_address = encoder.check_encode(:account_id,alpha_num.issuer)
-        "#{alpha_num.currency_code}/#{issuer_address}"
-      end
-    end
-
-    def inspect
-      label = switch.to_s
-      "#<Stellar::Currency #{to_s}>"
-    end
-
-    def code
-      self.alpha_num!.currency_code
-    end
-
-    def self.normalize_code(code)
-      raise ArgumentError, "Invalid currency code: #{code}, must be <= 4 bytes" if code.length > 4
-
-      code.ljust(4, "\x00")
-    end
-  end
-end

data/lib/stellar/util/base58.rb

@@ -1,127 +0,0 @@
-module Stellar
-  module Util
-    class Base58
-      STELLAR_ALPHABET = "gsphnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCr65jkm8oFqi1tuvAxyz"
-      BITCOIN_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
-      BASE             = 58
-
-      # TODO: improve the conversion to bitstring, perhaps `Fixnum#to_byte`?
-      VERSION_BYTES = {
-        none:       [1].pack("C").encode("BINARY"),
-        account_id: [0].pack("C").encode("BINARY"),
-        seed:       [33].pack("C").encode("BINARY"),
-      }
-
-      def self.stellar
-        Thread.current[:stellar_base58] ||= new(STELLAR_ALPHABET)
-      end
-
-      def self.bitcoin
-        Thread.current[:bitcoin_base58] ||= new(BITCOIN_ALPHABET)
-      end
-
-      def initialize(alphabet)
-        raise ArgumentError, "Invalid alphabet length" if alphabet.length != BASE
-        @alphabet = alphabet
-      end
-
-      def encode(byte_str)
-        return "" if byte_str.nil? || byte_str.empty?
-
-        leading_zeros = byte_str.each_byte.take_while{|b| b == 0}.length
-        int           = bytes_to_int(byte_str) # step 1
-
-        encode_int(int, leading_zeros)
-      end
-
-      def check_encode(version, byte_str)
-        version_byte = VERSION_BYTES[version]
-        raise ArgumentError, "Invalid version: #{version}" if version_byte.blank?
-
-        payload = version_byte + byte_str.dup.force_encoding("BINARY")
-        check   = checksum(payload)
-        encode(payload + check)
-      end
-
-      def decode(str)
-        leading_zeros = str.each_char.take_while{|c| c == @alphabet[0]}.length
-
-        ("\x00" * leading_zeros) + decode_int(str)
-      end
-
-      def check_decode(expected_version, str)
-        decoded      = decode(str)
-        version_byte = decoded[0]
-        payload      = decoded[1...-4]
-        check        = decoded[-4..-1]
-        version      = VERSION_BYTES.key(version_byte)
-
-        raise ArgumentError, "Unexpected version: #{version.inspect}" if version != expected_version
-        raise ArgumentError, "Invalid checksum" if check != checksum(decoded[0...-4])
-        payload
-      end
-
-      def checksum(bytes)
-        inner = Digest::SHA256.digest(bytes)
-        Digest::SHA256.digest(inner)[0...4]
-      end
-
-      private
-      def encode_int(int, leading_zeros=0)
-        # algorithm:
-        # 1. convert the bytes to a bignum
-        # 2. turn the bignum into a array of digits, least significant first
-        # 3. add any leading zero bytes as leading 0 digits
-        # 4. alphabatize the digits based upon the chosen alphabet
-        # 5. reverse the alphabetized digits (to get most significant digit first)
-
-        digits = []
-
-        # step 2
-        while int > 0
-          int, rem = int.divmod(BASE)
-          digits.push rem
-        end
-
-        # step 3
-        leading_zeros.times{ digits.push 0 }
-
-        digits
-          .map{|d| @alphabet[d]} # step 4
-          .reverse # step 5
-          .join
-      end
-
-      def decode_int(str)
-        int = str.reverse.each_char.with_index.inject(0) do |result, (digit, index)|
-                digit_val = @alphabet.index(digit)
-                raise ArgumentError, "#{digit} is not a valid base58 digit" if digit_val.nil?
-                result + (digit_val * (BASE**index))
-              end
-
-        int_to_bytes(int)
-      end
-
-      def bytes_to_int(bytes)
-        bytes.unpack("C*").inject do |result, byte|
-          result <<= 8
-          result + byte
-        end
-      end
-
-      def int_to_bytes(int)
-        return "\x00" if int == 0
-
-        bytes   = []
-        current = int
-
-        while current > 0
-          bytes.unshift(current & 0xFF)
-          current >>= 8
-        end
-
-        bytes.pack("C*")
-      end
-    end
-  end
-end

data/spec/lib/stellar/util/base58_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe Stellar::Util::Base58 do
-  subject{ Stellar::Util::Base58.new(Stellar::Util::Base58::BITCOIN_ALPHABET) }
-
-  describe "#decode" do
-    it "properly encodes" do
-      expect(decode "z").to eq_bytes("\x39")
-      expect(decode "111z").to eq_bytes("\x00\x00\x00\x39")
-      expect(decode "2UzHL").to eq_bytes("\xFF\xFF\xFF")
-    end
-
-    it "raises an ArgumentError when the string cantains an invalid character" do
-      expect{ decode "OOO" }.to raise_error(ArgumentError)
-      expect{ decode "\xFF" }.to raise_error(ArgumentError)
-      expect{ decode "\x00" }.to raise_error(ArgumentError)
-    end
-
-    def decode(bytes)
-      subject.decode(bytes)
-    end
-  end
-
-  describe "#check_decode" do
-    it "properly decodes" do
-      expect(decode :none, "cKyAv51").to eq_bytes("\x39")
-      expect(decode :seed, "RN3BaguaZ6Mi").to eq_bytes("\x00\x00\x00\x39")
-      expect(decode :account_id, "1Ahg1iQXoss").to eq_bytes("\xFF\xFF\xFF")
-    end
-
-    it "raises an ArgumentError if the decoded version byte does not match the expected value" do
-      expect{ decode :none, "1Ahg1iQXoss" }.to raise_error(ArgumentError)
-      expect{ decode :seed, "cKyAv51" }.to raise_error(ArgumentError)
-      expect{ decode :account_id, "RN3BaguaZ6Mi" }.to raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError if the decoded value cannot be validated by the checksum" do
-      expect{decode :seed, "RN3BaguaZ6MM"}.to raise_error(ArgumentError)
-    end
-
-    def decode(version, bytes)
-      subject.check_decode(version, bytes)
-    end
-  end
-
-  describe"#encode" do
-    it "properly encodes" do
-      expect(encode "\x39").to eq("z")
-      expect(encode "\x00\x00\x00\x39").to eq("111z")
-      expect(encode "\xFF\xFF\xFF").to eq("2UzHL")
-    end
-
-    def encode(bytes)
-      subject.encode(bytes)
-    end
-  end
-
-  describe"#check_encode" do
-    it "properly encodes" do
-      expect(encode :none, "\x39").to eq("cKyAv51")
-      expect(encode :seed, "\x00\x00\x00\x39").to eq("RN3BaguaZ6Mi")
-      expect(encode :account_id, "\xFF\xFF\xFF").to eq("1Ahg1iQXoss")
-    end
-
-    it "raises an ArgumentError when an invalid version is provided" do
-      expect{ encode :floob, "\x39" }.to raise_error(ArgumentError)
-    end
-
-    def encode(version, bytes)
-      subject.check_encode(version, bytes)
-    end
-  end
-
-end

data/spec/support/matchers/be_base58_check.rb

@@ -1,9 +0,0 @@
-RSpec::Matchers.define :be_base58_check do |version_byte|
-  match do |actual|
-    begin
-      Stellar::Util::Base58.stellar.check_decode(version_byte, actual)
-    rescue ArgumentError
-      false
-    end
-  end
-end

data/xdr/StellarXDR.x

@@ -1,11 +0,0 @@
-%#include "generated/Stellar-SCP.h"
-%#include "generated/Stellar-types.h"
-%#include "generated/Stellar-ledger-entries.h"
-%#include "generated/Stellar-transaction.h"
-%#include "generated/Stellar-ledger.h"
-%#include "generated/Stellar-overlay.h"
-
-namespace stellar
-{
-}
-