stellar-base 0.0.1

data/generated/stellar/transaction_result.rb

@@ -0,0 +1,33 @@
+# Automatically generated on 2015-04-07T10:52:07-07:00
+# DO NOT EDIT or your changes may be overwritten
+        
+require 'xdr'
+
+# === xdr source ============================================================
+#
+#   struct TransactionResult
+#   {
+#       int64 feeCharged; // actual fee charged for the transaction
+#   
+#       union switch (TransactionResultCode code)
+#       {
+#       case txSUCCESS:
+#       case txFAILED:
+#           OperationResult results<>;
+#       default:
+#           void;
+#       }
+#       result;
+#   };
+#
+# ===========================================================================
+module Stellar
+  class TransactionResult < XDR::Struct
+    include XDR::Namespace
+
+    autoload :Result
+
+    attribute :fee_charged, Int64
+    attribute :result,      Result
+  end
+end

data/generated/stellar/transaction_result_code.rb

@@ -0,0 +1,46 @@
+# Automatically generated on 2015-04-07T10:52:07-07:00
+# DO NOT EDIT or your changes may be overwritten
+        
+require 'xdr'
+
+# === xdr source ============================================================
+#
+#   enum TransactionResultCode
+#   {
+#       txSUCCESS = 0, // all operations succeeded
+#   
+#       txDUPLICATE = 1, // transaction was already submited
+#   
+#       txFAILED = 2, // one of the operations failed (but none were applied)
+#   
+#       txBAD_LEDGER = 3,        // ledger is not in range [minLeder; maxLedger]
+#       txMISSING_OPERATION = 4, // no operation was specified
+#       txBAD_SEQ = 5,           // sequence number does not match source account
+#   
+#       txBAD_AUTH = 6,             // not enough signatures to perform transaction
+#       txINSUFFICIENT_BALANCE = 7, // fee would bring account below reserve
+#       txNO_ACCOUNT = 8,           // source account not found
+#       txINSUFFICIENT_FEE = 9,     // max fee is too small
+#       txBAD_AUTH_EXTRA = 10,      // too many signatures on transaction
+#       txINTERNAL_ERROR = 0xFFFFFFFF // an unknown error occured
+#   };
+#
+# ===========================================================================
+module Stellar
+  class TransactionResultCode < XDR::Enum
+    member :tx_success,              0
+    member :tx_duplicate,            1
+    member :tx_failed,               2
+    member :tx_bad_ledger,           3
+    member :tx_missing_operation,    4
+    member :tx_bad_seq,              5
+    member :tx_bad_auth,             6
+    member :tx_insufficient_balance, 7
+    member :tx_no_account,           8
+    member :tx_insufficient_fee,     9
+    member :tx_bad_auth_extra,       10
+    member :tx_internal_error,       4294967295
+
+    seal
+  end
+end

data/generated/stellar/transaction_result_pair.rb

@@ -0,0 +1,20 @@
+# Automatically generated on 2015-04-07T10:52:07-07:00
+# DO NOT EDIT or your changes may be overwritten
+        
+require 'xdr'
+
+# === xdr source ============================================================
+#
+#   struct TransactionResultPair
+#   {
+#       Hash transactionHash;
+#       TransactionResult result; // result for the transaction
+#   };
+#
+# ===========================================================================
+module Stellar
+  class TransactionResultPair < XDR::Struct
+    attribute :transaction_hash, Hash
+    attribute :result,           TransactionResult
+  end
+end

data/generated/stellar/transaction_result_set.rb

@@ -0,0 +1,18 @@
+# Automatically generated on 2015-04-07T10:52:07-07:00
+# DO NOT EDIT or your changes may be overwritten
+        
+require 'xdr'
+
+# === xdr source ============================================================
+#
+#   struct TransactionResultSet
+#   {
+#       TransactionResultPair results<5000>;
+#   };
+#
+# ===========================================================================
+module Stellar
+  class TransactionResultSet < XDR::Struct
+    attribute :results, XDR::VarArray[TransactionResultPair, 5000]
+  end
+end

data/generated/stellar/transaction_set.rb

@@ -0,0 +1,20 @@
+# Automatically generated on 2015-04-07T10:52:07-07:00
+# DO NOT EDIT or your changes may be overwritten
+        
+require 'xdr'
+
+# === xdr source ============================================================
+#
+#   struct TransactionSet
+#   {
+#       Hash previousLedgerHash;
+#       TransactionEnvelope txs<5000>;
+#   };
+#
+# ===========================================================================
+module Stellar
+  class TransactionSet < XDR::Struct
+    attribute :previous_ledger_hash, Hash
+    attribute :txs,                  XDR::VarArray[TransactionEnvelope, 5000]
+  end
+end

data/generated/stellar/trust_line_entry.rb

@@ -0,0 +1,28 @@
+# Automatically generated on 2015-04-07T10:52:07-07:00
+# DO NOT EDIT or your changes may be overwritten
+        
+require 'xdr'
+
+# === xdr source ============================================================
+#
+#   struct TrustLineEntry
+#   {
+#       AccountID accountID; // account this trustline belongs to
+#       Currency currency;   // currency (with issuer)
+#       int64 balance;       // how much of this currency the user has.
+#                            // Currency defines the unit for this;
+#   
+#       int64 limit;     // balance cannot be above this
+#       bool authorized; // issuer has authorized account to hold its credit
+#   };
+#
+# ===========================================================================
+module Stellar
+  class TrustLineEntry < XDR::Struct
+    attribute :account_id, AccountID
+    attribute :currency,   Currency
+    attribute :balance,    Int64
+    attribute :limit,      Int64
+    attribute :authorized, XDR::Bool
+  end
+end

data/generated/stellar-base-generated.rb

@@ -0,0 +1,160 @@
+# Automatically generated on 2015-04-07T11:38:37-07:00
+# DO NOT EDIT or your changes may be overwritten
+        
+require 'xdr'
+
+module Stellar
+  include XDR::Namespace
+
+  Signature = XDR::Opaque[64]
+  Hash = XDR::Opaque[32]
+  Uint256 = XDR::Opaque[32]
+  Uint32 = XDR::UnsignedInt
+  Uint64 = XDR::UnsignedHyper
+  Value = XDR::VarOpaque[]
+  Evidence = XDR::VarOpaque[]
+
+  autoload :SCPBallot
+
+  autoload :SCPStatementType
+
+  autoload :SCPStatement
+  autoload :SCPEnvelope
+  autoload :SCPQuorumSet
+end
+module Stellar
+  include XDR::Namespace
+
+  autoload :LedgerEntryType
+
+  autoload :Signer
+
+  autoload :AccountFlags
+
+  autoload :AccountEntry
+  autoload :TrustLineEntry
+  autoload :OfferEntry
+
+  autoload :LedgerEntry
+end
+module Stellar
+  include XDR::Namespace
+
+  autoload :LedgerHeader
+
+  autoload :LedgerKey
+
+  autoload :BucketEntryType
+
+  autoload :BucketEntry
+
+  autoload :TransactionSet
+  autoload :TransactionResultPair
+  autoload :TransactionResultSet
+  autoload :TransactionMeta
+  autoload :TransactionHistoryEntry
+  autoload :TransactionHistoryResultEntry
+  autoload :LedgerHeaderHistoryEntry
+end
+module Stellar
+  include XDR::Namespace
+
+  autoload :StellarBallotValue
+  autoload :StellarBallot
+  autoload :Error
+  autoload :Hello
+  autoload :PeerAddress
+
+  autoload :MessageType
+
+  autoload :DontHave
+
+  autoload :StellarMessage
+end
+module Stellar
+  include XDR::Namespace
+
+  autoload :DecoratedSignature
+
+  autoload :OperationType
+
+  autoload :PaymentOp
+  autoload :CreateOfferOp
+  autoload :SetOptionsOp
+  autoload :ChangeTrustOp
+  autoload :AllowTrustOp
+  autoload :Operation
+  autoload :Transaction
+  autoload :TransactionEnvelope
+  autoload :ClaimOfferAtom
+
+  autoload :PaymentResultCode
+
+  autoload :SimplePaymentResult
+  autoload :PaymentSuccessMultiResult
+
+  autoload :PaymentResult
+
+  autoload :CreateOfferResultCode
+  autoload :CreateOfferEffect
+
+  autoload :CreateOfferSuccessResult
+
+  autoload :CreateOfferResult
+
+  autoload :SetOptionsResultCode
+
+  autoload :SetOptionsResult
+
+  autoload :ChangeTrustResultCode
+
+  autoload :ChangeTrustResult
+
+  autoload :AllowTrustResultCode
+
+  autoload :AllowTrustResult
+
+  autoload :AccountMergeResultCode
+
+  autoload :AccountMergeResult
+
+  autoload :InflationResultCode
+
+  autoload :InflationPayout
+
+  autoload :InflationResult
+
+  autoload :OperationResultCode
+
+  autoload :OperationResult
+
+  autoload :TransactionResultCode
+
+  autoload :TransactionResult
+end
+module Stellar
+  include XDR::Namespace
+
+  Uint512 = XDR::Opaque[64]
+  Uint256 = XDR::Opaque[32]
+  Uint64 = XDR::UnsignedHyper
+  Int64 = XDR::Hyper
+  Uint32 = XDR::UnsignedInt
+  Int32 = XDR::Int
+  AccountID = XDR::Opaque[32]
+  Signature = XDR::Opaque[64]
+  Hash = XDR::Opaque[32]
+  Thresholds = XDR::Opaque[4]
+  SequenceNumber = Uint64
+
+  autoload :CurrencyType
+
+  autoload :ISOCurrencyIssuer
+
+  autoload :Currency
+
+  autoload :Price
+end
+module Stellar
+  include XDR::Namespace
+end

data/lib/stellar/base/version.rb

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

data/lib/stellar/base.rb

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

data/lib/stellar/change_trust_op.rb

@@ -0,0 +1,10 @@
+module Stellar
+  ChangeTrustOp.class_eval do
+
+    def to_operation(source_account=nil)
+      body = Operation::Body.new(:change_trust, self)
+      Operation.new(source_account: source_account, body:body)
+    end
+    
+  end
+end

data/lib/stellar/currency.rb

@@ -0,0 +1,28 @@
+module Stellar
+  Currency.class_eval do
+    def self.native
+      new(:native)
+    end
+
+    def self.iso4217(code, issuer)
+      raise ArgumentError, "Bad :issuer" unless issuer.is_a?(KeyPair)
+      ici = ISOCurrencyIssuer.new({currency_code:code, issuer:issuer.public_key})
+      new(:iso4217, ici)
+    end
+
+    def to_s
+      if switch == CurrencyType.native
+        "native"
+      else
+        encoder = Stellar::Util::Base58.stellar
+        issuer_address = encoder.check_encode(:account_id,iso_ci.issuer)
+        "#{iso_ci.currency_code}/#{issuer_address}"
+      end
+    end
+
+    def inspect
+      label = switch.to_s
+      "#<Stellar::Currency #{to_s}>"
+    end
+  end
+end

data/lib/stellar/key_pair.rb

@@ -0,0 +1,94 @@
+module Stellar
+  class KeyPair
+    def self.from_seed(seed)
+      seed_bytes = Util::Base58.stellar.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::Base58.stellar.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 initialize(public_key, secret_key=nil)
+      @public_key = public_key
+      @secret_key = secret_key
+    end
+
+    def public_key
+      @public_key.to_bytes
+    end
+
+    def public_key_hint
+      public_key.slice(0, 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 = public_key
+      Util::Base58.stellar.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::Base58.stellar.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:      public_key_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/payment_op.rb

@@ -0,0 +1,38 @@
+module Stellar
+  PaymentOp.class_eval do
+
+    def self.native(amount)
+      currency = Stellar::Currency.new(:native)
+      with_currency(currency).tap do |result|
+        result.amount   = amount
+        result.send_max = amount
+      end
+    end
+
+    def self.iso4217(code, issuer, amount)
+      currency = Stellar::Currency.iso4217(code, issuer)
+      with_currency(currency).tap do |result|
+        result.amount   = amount
+        result.send_max = amount
+      end
+    end
+
+    def self.with_currency(currency)
+      new.tap do |result|
+        result.currency = currency
+        result.path     = []
+      end
+    end
+
+    def apply_defaults
+      self.source_memo ||= ""
+      self.memo ||= ""
+    end
+
+    def to_operation(source_account=nil)
+      body = Operation::Body.new(:payment, self)
+      Operation.new(source_account: source_account, body:body)
+    end
+
+  end
+end

data/lib/stellar/transaction.rb

@@ -0,0 +1,72 @@
+module Stellar
+  Transaction.class_eval do
+
+    def self.payment(attributes={})
+      destination = attributes[:destination]
+      amount      = attributes[:amount]
+
+      raise ArgumentError unless destination.is_a?(KeyPair)
+
+      for_account(attributes).tap do |result|
+        payment = PaymentOp.send(*amount)
+        payment.destination = destination.public_key
+        payment.apply_defaults
+
+        result.operations = [payment.to_operation]
+      end
+    end
+
+    def self.change_trust(attributes={})
+      line  = Currency.send(*attributes[:line])
+      limit = attributes[:limit]
+
+      raise ArgumentError, "Bad :limit #{limit}" unless limit.is_a?(Integer)
+
+      for_account(attributes).tap do |result|
+        details = ChangeTrustOp.new(line: line, limit: limit)
+        result.operations = [details.to_operation]
+      end
+    end
+
+    def self.for_account(attributes={})
+      account       = attributes[:account]
+      sequence      = attributes[:sequence]
+      
+      raise ArgumentError, "Bad :account" unless account.is_a?(KeyPair) && account.sign?
+      raise ArgumentError, "Bad :sequence #{sequence}" unless sequence.is_a?(Integer)
+
+      new.tap do |result|
+        result.seq_num  = sequence
+        result.source_account  = account.public_key
+        result.apply_defaults
+      end
+    end
+
+    def sign(key_pair)
+      key_pair.sign(hash)
+    end
+
+    def sign_decorated(key_pair)
+      key_pair.sign_decorated(hash)
+    end
+
+    def hash
+      Digest::SHA256.digest(to_xdr)
+    end
+
+    def to_envelope(*key_pairs)
+      signatures = key_pairs.map(&method(:sign_decorated))
+      
+      TransactionEnvelope.new({
+        :signatures => signatures,
+        :tx => self
+      })
+    end
+
+    def apply_defaults
+      self.max_fee    ||= 10
+      self.min_ledger ||= 0
+      self.max_ledger ||= 2**32 - 1
+    end
+  end
+end

data/lib/stellar/transaction_envelope.rb

@@ -0,0 +1,32 @@
+module Stellar
+  TransactionEnvelope.class_eval do
+
+    # 
+    # Checks to ensure that every signature for the envelope is
+    # a valid signature of one of the provided `key_pairs`
+    # 
+    # NOTE: this does not do any authorization checks, which requires access to
+    # the current ledger state.
+    # 
+    # @param *key_pairs [Array<Stellar::KeyPair>] The key pairs to check the envelopes signatures against
+    # 
+    # @return [Boolean] true if all signatures are from the provided key_pairs and validly sign the tx's hash
+    def signed_correctly?(*key_pairs)
+      hash = tx.hash
+      return false if signatures.empty?
+
+      key_index = key_pairs.index_by(&:public_key_hint)
+      
+      signatures.all? do |sig| 
+        key_pair = key_index[sig.hint]
+        break false if key_pair.nil?
+
+        key_pair.verify(sig.signature, hash)
+      end
+    end
+
+    def hash
+      Digest::SHA256.digest(to_xdr)
+    end
+  end
+end