open-core 0.3.0

data/lib/stellar/base.rb

@@ -0,0 +1 @@
+require "stellar-base"

data/lib/stellar/base/version.rb

@@ -0,0 +1,5 @@
+module Stellar
+  module Base
+    VERSION = "0.3.0"
+  end
+end

data/lib/stellar/convert.rb

@@ -0,0 +1,32 @@
+module Stellar
+  #
+  # Generic format conversion module
+  #
+  module Convert
+    require 'base64'
+
+    def to_hex(string)
+      string.unpack("H*").first
+    end
+
+    def from_hex(hex_string)
+      [hex_string].pack("H*")
+    end
+
+    def to_base64(string)
+      Base64.strict_encode64(string)
+    end
+
+    def from_base64(base64_string)
+      Base64.strict_decode64(base64_string)
+    end
+
+    ## Converts a Stellar::PublicKey instance (or any typedef of it such as
+    # Stellar::AccountID) to an address
+    def pk_to_address(pk)
+      Stellar::Util::StrKey.check_encode(:account_id, pk.ed25519!)
+    end
+
+    extend self
+  end
+end

data/lib/stellar/key_pair.rb

@@ -0,0 +1,112 @@
+module Stellar
+  class KeyPair
+    def self.from_seed(seed)
+      seed_bytes = Util::StrKey.check_decode(:seed, seed)
+      from_raw_seed seed_bytes
+    end
+
+    def self.from_raw_seed(seed_bytes)
+      secret_key = RbNaCl::SigningKey.new(seed_bytes)
+      public_key = secret_key.verify_key
+      new(public_key, secret_key)
+    end
+
+    def self.from_public_key(pk_bytes)
+      public_key = RbNaCl::VerifyKey.new(pk_bytes)
+      new(public_key)
+    end
+
+    def self.from_address(address)
+      pk_bytes = Util::StrKey.check_decode(:account_id, address)
+      from_public_key(pk_bytes)
+    end
+
+    def self.random
+      secret_key = RbNaCl::SigningKey.generate
+      public_key = secret_key.verify_key
+      new(public_key, secret_key)
+    end
+
+    def self.from_network_passphrase(passphrase)
+      network_id = Digest::SHA256.digest(passphrase)
+      from_raw_seed network_id
+    end
+
+    def self.master
+      from_raw_seed(Stellar.current_network_id)
+    end
+
+    def initialize(public_key, secret_key=nil)
+      @public_key = public_key
+      @secret_key = secret_key
+    end
+
+    def account_id
+      Stellar::AccountID.new :key_type_ed25519, raw_public_key
+    end
+
+    def public_key
+      Stellar::PublicKey.new :key_type_ed25519, raw_public_key
+    end
+
+    def raw_public_key
+      @public_key.to_bytes
+    end
+
+    def signature_hint
+      # take last 4 bytes
+      account_id.to_xdr.slice(-4, 4)
+    end
+
+    def raw_seed
+      @secret_key.to_bytes
+    end
+
+    def rbnacl_signing_key
+      @secret_key
+    end
+
+    def rbnacl_verify_key
+      @public_key
+    end
+
+    def address
+      pk_bytes = raw_public_key
+      Util::StrKey.check_encode(:account_id, pk_bytes)
+    end
+
+    def seed
+      raise "no private key" if @secret_key.nil?
+      #TODO: improve the error class above
+      seed_bytes = raw_seed
+      encoder = Util::StrKey.check_encode(:seed, seed_bytes)
+    end
+
+    def sign?
+      !@secret_key.nil?
+    end
+
+    def sign(message)
+      raise "no private key" if @secret_key.nil?
+      #TODO: improve the error class above
+      @secret_key.sign(message)
+    end
+
+    def sign_decorated(message)
+      raw_signature = sign(message)
+      Stellar::DecoratedSignature.new({
+        hint:      signature_hint,
+        signature: raw_signature
+      })
+    end
+
+    def verify(signature, message)
+      @public_key.verify(signature, message)
+    rescue RbNaCl::LengthError
+      false
+    rescue RbNaCl::BadSignatureError
+      false
+    end
+
+  end
+end

data/lib/stellar/networks.rb

@@ -0,0 +1,45 @@
+module Stellar
+  # Provides a container for well-known network passphrases, such as the main network and SDF test network
+  module Networks
+
+    PUBLIC  = "Public Global Stellar Network ; September 2015"
+    TESTNET = "Test SDF Network ; September 2015"
+
+  end
+
+  # Configures the default stellar network passphrase for the current process.  Unless otherwise
+  # specified in a method that needs the passphrase, this value will be used.
+  #
+  # NOTE:  This method is not thread-safe.  It's best to just call this at startup once and use the other
+  #        methods of specifying a network if you need two threads in the same process to communicate with
+  #        different networks
+  #
+  # @see Stellar.default_network
+  # @see Stellar.on_network
+  def self.default_network=(passphrase)
+    @default_network = passphrase
+  end
+
+  # Returns the passphrase for the currently-configured network, as set by Stellar.default_network
+  # or Stellar.on_network
+  def self.current_network
+    Thread.current["stellar_network_passphrase"] || 
+    @default_network || 
+    Stellar::Networks::PUBLIC
+  end
+
+  # Returns the id for the currently configured network, suitable for use in generating
+  # a signature base string or making the root account's keypair.
+  def self.current_network_id
+    Digest::SHA256.digest(self.current_network) 
+  end
+
+  # Executes the provided block in the context of the provided network.
+  def self.on_network(passphrase, &block)
+    old = Thread.current["stellar_network_passphrase"]
+    Thread.current["stellar_network_passphrase"] = passphrase
+    block.call
+  ensure
+    Thread.current["stellar_network_passphrase"] = old
+  end
+end

data/lib/stellar/operation.rb

@@ -0,0 +1,304 @@
+require 'bigdecimal'
+
+module Stellar
+  class Operation
+
+
+    #
+    # Construct a new Stellar::Operation from the provided
+    # source account and body
+    #
+    # @param [Hash] attributes the attributes to create the operation with
+    # @option attributes [Stellar::KeyPair] :source_account
+    # @option attributes [Stellar::Operation::Body] :body
+    #
+    # @return [Stellar::Operation] the built operation
+    def self.make(attributes={})
+      source_account = attributes[:source_account]
+      body           = Stellar::Operation::Body.new(*attributes[:body])
+
+      op = Stellar::Operation.new(body:body)
+
+      if source_account
+        raise ArgumentError, "Bad :source_account" unless source_account.is_a?(Stellar::KeyPair)
+        op.source_account = source_account.account_id
+      end
+
+      return op
+    end
+
+
+    #
+    # Helper method to create a valid PaymentOp, wrapped
+    # in the necessary XDR structs to be included within a
+    # transactions `operations` array.
+    #
+    # @see Stellar::Asset
+    #
+    # @param [Hash] attributes the attributes to create the operation with
+    # @option attributes [Stellar::KeyPair] :destination the receiver of the payment
+    # @option attributes [Array] :amount the amount to pay
+    # @return [Stellar::Operation] the built operation, containing a
+    #                              Stellar::PaymentOp body
+    def self.payment(attributes={})
+      destination = attributes[:destination]
+      asset, amount = extract_amount(attributes[:amount])
+
+      raise ArgumentError unless destination.is_a?(KeyPair)
+
+
+      op             = PaymentOp.new
+      op.asset       = asset
+      op.amount      = amount
+      op.destination = destination.account_id
+
+      return make(attributes.merge({
+        body:[:payment, op]
+      }))
+    end
+
+    #
+    # Helper method to create a valid PathPaymentOp, wrapped
+    # in the necessary XDR structs to be included within a
+    # transactions `operations` array.
+    #
+    # @see Stellar::Asset
+    #
+    # @param [Hash] attributes the attributes to create the operation with
+    # @option attributes [Stellar::KeyPair] :destination the receiver of the payment
+    # @option attributes [Array] :amount the amount to pay
+    # @option attributes [Array] :with the source asset and maximum allowed source amount to pay with
+    # @option attributes [Array<Stellar::Asset>] :path the payment path to use
+    #
+    # @return [Stellar::Operation] the built operation, containing a
+    #                              Stellar::PaymentOp body
+    def self.path_payment(attributes={})
+      destination             = attributes[:destination]
+      asset, amount           = extract_amount(attributes[:amount])
+      send_asset, send_max    = extract_amount(attributes[:with])
+      path                    = (attributes[:path] || []).map{|p| Stellar::Asset.send(*p)}
+
+      raise ArgumentError unless destination.is_a?(KeyPair)
+
+      op               = PathPaymentOp.new
+      op.send_asset    = send_asset
+      op.send_max      = send_max
+      op.destination   = destination.account_id
+      op.dest_asset    = asset
+      op.dest_amount   = amount
+      op.path          = path
+
+      return make(attributes.merge({
+        body:[:path_payment, op]
+      }))
+    end
+
+    def self.create_account(attributes={})
+      destination      = attributes[:destination]
+      starting_balance = attributes[:starting_balance]
+
+      raise ArgumentError unless destination.is_a?(KeyPair)
+
+      op = CreateAccountOp.new()
+      op.destination = destination.account_id
+      op.starting_balance = starting_balance
+
+      return make(attributes.merge({
+        body:[:create_account, op]
+      }))
+    end
+
+    #
+    # Helper method to create a valid ChangeTrustOp, wrapped
+    # in the necessary XDR structs to be included within a
+    # transactions `operations` array.
+    #
+    # @param [Hash] attributes the attributes to create the operation with
+    # @option attributes [Stellar::Currrency] :line the asset to trust
+    # @option attributes [Fixnum] :limit the maximum amount to trust
+    #
+    # @return [Stellar::Operation] the built operation, containing a
+    #                              Stellar::ChangeTrustOp body
+    def self.change_trust(attributes={})
+      line  = Asset.send(*attributes[:line])
+      limit = attributes[:limit]
+
+      raise ArgumentError, "Bad :limit #{limit}" unless limit.is_a?(Integer)
+
+      op = ChangeTrustOp.new(line: line, limit: limit)
+
+      return make(attributes.merge({
+        body:[:change_trust, op]
+      }))
+    end
+
+    def self.manage_offer(attributes={})
+      buying     = Asset.send(*attributes[:buying])
+      selling    = Asset.send(*attributes[:selling])
+      amount     = attributes[:amount]
+      offer_id   = attributes[:offer_id] || 0
+      price      = interpret_price(attributes[:price])
+
+      op = ManageOfferOp.new({
+        buying:     buying,
+        selling:    selling,
+        amount:     amount,
+        price:      price,
+        offer_id:   offer_id
+      })
+
+      return make(attributes.merge({
+        body:[:manage_offer, op]
+      }))
+    end
+
+    def self.create_passive_offer(attributes={})
+      buying     = Asset.send(*attributes[:buying])
+      selling    = Asset.send(*attributes[:selling])
+      amount     = attributes[:amount]
+      price      = interpret_price(attributes[:price])
+
+      op = CreatePassiveOfferOp.new({
+        buying:     buying,
+        selling:    selling,
+        amount:     amount,
+        price:      price,
+      })
+
+      return make(attributes.merge({
+        body:[:create_passive_offer, op]
+      }))
+    end
+
+    #
+    # Helper method to create a valid SetOptionsOp, wrapped
+    # in the necessary XDR structs to be included within a
+    # transactions `operations` array.
+    #
+    # @param [Hash] attributes the attributes to create the operation with
+    # @option attributes [Stellar::KeyPair] :inflation_dest
+    # @option attributes [Array<Stellar::AccountFlags>] :set flags to set
+    # @option attributes [Array<Stellar::AccountFlags>] :clear flags to clear
+    # @option attributes [String] :thresholds
+    # @option attributes [Stellar::Signer] :signer
+    #
+    # @return [Stellar::Operation] the built operation, containing a
+    #                              Stellar::SetOptionsOp body
+    def self.set_options(attributes={})
+      op                = SetOptionsOp.new()
+      op.set_flags      = Stellar::AccountFlags.make_mask attributes[:set]
+      op.clear_flags    = Stellar::AccountFlags.make_mask attributes[:clear]
+      op.master_weight  = attributes[:master_weight]
+      op.low_threshold  = attributes[:low_threshold]
+      op.med_threshold  = attributes[:med_threshold]
+      op.high_threshold = attributes[:high_threshold]
+
+      op.signer      = attributes[:signer]
+      op.home_domain = attributes[:home_domain]
+
+
+      inflation_dest = attributes[:inflation_dest]
+      if inflation_dest
+        raise ArgumentError, "Bad :inflation_dest" unless inflation_dest.is_a?(Stellar::KeyPair)
+        op.inflation_dest = inflation_dest.account_id
+      end
+
+
+      return make(attributes.merge({
+        body:[:set_options, op]
+      }))
+    end
+
+    #
+    # Helper method to create a valid AllowTrustOp, wrapped
+    # in the necessary XDR structs to be included within a
+    # transactions `operations` array.
+    #
+    # @param [Hash] attributes the attributes to create the operation with
+    # @option attributes [Stellar::KeyPair]  :trustor
+    # @option attributes [Stellar::Asset] :asset
+    #
+    # @return [Stellar::Operation] the built operation, containing a
+    #                              Stellar::AllowTrustOp body
+    def self.allow_trust(attributes={})
+      op = AllowTrustOp.new()
+
+      trustor   = attributes[:trustor]
+      authorize = attributes[:authorize]
+      asset     = Asset.send(*attributes[:asset])
+
+      raise ArgumentError, "Bad :trustor" unless trustor.is_a?(Stellar::KeyPair)
+      raise ArgumentError, "Bad :authorize" unless authorize == !!authorize # check boolean
+      raise ArgumentError, "Bad :asset" unless asset.type == Stellar::AssetType.asset_type_credit_alphanum4
+
+      atc = AllowTrustOp::Asset.new(:asset_type_credit_alphanum4, asset.code)
+
+      op.trustor   = trustor.account_id
+      op.authorize = authorize
+      op.asset     = atc
+
+      return make(attributes.merge({
+        body:[:allow_trust, op]
+      }))
+    end
+
+    #
+    # Helper method to create an account merge operation
+    #
+    # @param [Hash] attributes the attributes to create the operation with
+    # @option attributes [Stellar::KeyPair]  :destination
+    #
+    # @return [Stellar::Operation] the built operation
+    def self.account_merge(attributes={})
+      destination = attributes[:destination]
+
+      raise ArgumentError, "Bad :destination" unless destination.is_a?(KeyPair)
+
+      # TODO: add source_account support
+      return make(attributes.merge({
+        body:[:account_merge, destination.account_id]
+      }))
+    end
+
+    #
+    # Helper method to create an inflation operation
+    #
+    # @param [Hash] attributes the attributes to create the operation with
+    # @option attributes [Integer]  :sequence
+    #
+    # @return [Stellar::Operation] the built operation
+    def self.inflation(attributes={})
+      sequence = attributes[:sequence]
+
+      raise ArgumentError, "Bad :sequence #{sequence}" unless sequence.is_a?(Integer)
+
+      # TODO: add source_account support
+      return make(attributes.merge({
+        body:[:inflation]
+      }))
+    end
+
+    private
+    def self.extract_amount(a)
+      amount   = a.last
+      asset    = Stellar::Asset.send(*a[0...-1])
+
+      return asset, amount
+    end
+
+
+    def self.interpret_price(price)
+      case price
+      when String
+        bd = BigDecimal.new(price)
+        Price.from_f(bd)
+      when Numeric
+        Price.from_f(price)
+      when Stellar::Price
+        price
+      else
+        raise ArgumentError, "Invalid price type: #{price.class}. Must be String, Numeric, or Stellar::Price"
+      end
+    end
+  end
+end