stellar-base 0.20.0 → 0.21.0

data/generated/stellar/{path_payment_op.rb → path_payment_strict_receive_op.rb}

@@ -5,7 +5,7 @@ require 'xdr'
 
 # === xdr source ============================================================
 #
-#   struct PathPaymentOp
+#   struct PathPaymentStrictReceiveOp
 #   {
 #       Asset sendAsset; // asset we pay with
 #       int64 sendMax;   // the maximum amount of sendAsset to
@@ -21,7 +21,7 @@ require 'xdr'
 #
 # ===========================================================================
 module Stellar
-  class PathPaymentOp < XDR::Struct
+  class PathPaymentStrictReceiveOp < XDR::Struct
     attribute :send_asset,  Asset
     attribute :send_max,    Int64
     attribute :destination, AccountID

data/generated/stellar/path_payment_strict_receive_result.rb

@@ -0,0 +1,38 @@
+# This code was automatically generated using xdrgen
+# DO NOT EDIT or your changes may be overwritten
+
+require 'xdr'
+
+# === xdr source ============================================================
+#
+#   union PathPaymentStrictReceiveResult switch (PathPaymentStrictReceiveResultCode code)
+#   {
+#   case PATH_PAYMENT_STRICT_RECEIVE_SUCCESS:
+#       struct
+#       {
+#           ClaimOfferAtom offers<>;
+#           SimplePaymentResult last;
+#       } success;
+#   case PATH_PAYMENT_STRICT_RECEIVE_NO_ISSUER:
+#       Asset noIssuer; // the asset that caused the error
+#   default:
+#       void;
+#   };
+#
+# ===========================================================================
+module Stellar
+  class PathPaymentStrictReceiveResult < XDR::Union
+    include XDR::Namespace
+
+    autoload :Success
+
+    switch_on PathPaymentStrictReceiveResultCode, :code
+
+    switch :path_payment_strict_receive_success,   :success
+    switch :path_payment_strict_receive_no_issuer, :no_issuer
+    switch :default
+
+    attribute :success,   Success
+    attribute :no_issuer, Asset
+  end
+end

data/generated/stellar/path_payment_strict_receive_result/success.rb

@@ -0,0 +1,22 @@
+# This code was automatically generated using xdrgen
+# DO NOT EDIT or your changes may be overwritten
+
+require 'xdr'
+
+# === xdr source ============================================================
+#
+#   struct
+#       {
+#           ClaimOfferAtom offers<>;
+#           SimplePaymentResult last;
+#       }
+#
+# ===========================================================================
+module Stellar
+  class PathPaymentStrictReceiveResult
+    class Success < XDR::Struct
+      attribute :offers, XDR::VarArray[ClaimOfferAtom]
+      attribute :last,   SimplePaymentResult
+    end
+  end
+end

data/generated/stellar/path_payment_strict_receive_result_code.rb

@@ -0,0 +1,47 @@
+# This code was automatically generated using xdrgen
+# DO NOT EDIT or your changes may be overwritten
+
+require 'xdr'
+
+# === xdr source ============================================================
+#
+#   enum PathPaymentStrictReceiveResultCode
+#   {
+#       // codes considered as "success" for the operation
+#       PATH_PAYMENT_STRICT_RECEIVE_SUCCESS = 0, // success
+#   
+#       // codes considered as "failure" for the operation
+#       PATH_PAYMENT_STRICT_RECEIVE_MALFORMED = -1,          // bad input
+#       PATH_PAYMENT_STRICT_RECEIVE_UNDERFUNDED = -2,        // not enough funds in source account
+#       PATH_PAYMENT_STRICT_RECEIVE_SRC_NO_TRUST = -3,       // no trust line on source account
+#       PATH_PAYMENT_STRICT_RECEIVE_SRC_NOT_AUTHORIZED = -4, // source not authorized to transfer
+#       PATH_PAYMENT_STRICT_RECEIVE_NO_DESTINATION = -5,     // destination account does not exist
+#       PATH_PAYMENT_STRICT_RECEIVE_NO_TRUST = -6,           // dest missing a trust line for asset
+#       PATH_PAYMENT_STRICT_RECEIVE_NOT_AUTHORIZED = -7,     // dest not authorized to hold asset
+#       PATH_PAYMENT_STRICT_RECEIVE_LINE_FULL = -8,          // dest would go above their limit
+#       PATH_PAYMENT_STRICT_RECEIVE_NO_ISSUER = -9,          // missing issuer on one asset
+#       PATH_PAYMENT_STRICT_RECEIVE_TOO_FEW_OFFERS = -10,    // not enough offers to satisfy path
+#       PATH_PAYMENT_STRICT_RECEIVE_OFFER_CROSS_SELF = -11,  // would cross one of its own offers
+#       PATH_PAYMENT_STRICT_RECEIVE_OVER_SENDMAX = -12       // could not satisfy sendmax
+#   };
+#
+# ===========================================================================
+module Stellar
+  class PathPaymentStrictReceiveResultCode < XDR::Enum
+    member :path_payment_strict_receive_success,            0
+    member :path_payment_strict_receive_malformed,          -1
+    member :path_payment_strict_receive_underfunded,        -2
+    member :path_payment_strict_receive_src_no_trust,       -3
+    member :path_payment_strict_receive_src_not_authorized, -4
+    member :path_payment_strict_receive_no_destination,     -5
+    member :path_payment_strict_receive_no_trust,           -6
+    member :path_payment_strict_receive_not_authorized,     -7
+    member :path_payment_strict_receive_line_full,          -8
+    member :path_payment_strict_receive_no_issuer,          -9
+    member :path_payment_strict_receive_too_few_offers,     -10
+    member :path_payment_strict_receive_offer_cross_self,   -11
+    member :path_payment_strict_receive_over_sendmax,       -12
+
+    seal
+  end
+end

data/generated/stellar/path_payment_strict_send_op.rb

@@ -0,0 +1,32 @@
+# This code was automatically generated using xdrgen
+# DO NOT EDIT or your changes may be overwritten
+
+require 'xdr'
+
+# === xdr source ============================================================
+#
+#   struct PathPaymentStrictSendOp
+#   {
+#       Asset sendAsset;  // asset we pay with
+#       int64 sendAmount; // amount of sendAsset to send (excluding fees)
+#   
+#       AccountID destination; // recipient of the payment
+#       Asset destAsset;       // what they end up with
+#       int64 destMin;         // the minimum amount of dest asset to
+#                              // be received
+#                              // The operation will fail if it can't be met
+#   
+#       Asset path<5>; // additional hops it must go through to get there
+#   };
+#
+# ===========================================================================
+module Stellar
+  class PathPaymentStrictSendOp < XDR::Struct
+    attribute :send_asset,  Asset
+    attribute :send_amount, Int64
+    attribute :destination, AccountID
+    attribute :dest_asset,  Asset
+    attribute :dest_min,    Int64
+    attribute :path,        XDR::VarArray[Asset, 5]
+  end
+end

data/generated/stellar/{path_payment_result.rb → path_payment_strict_send_result.rb}

@@ -5,15 +5,15 @@ require 'xdr'
 
 # === xdr source ============================================================
 #
-#   union PathPaymentResult switch (PathPaymentResultCode code)
+#   union PathPaymentStrictSendResult switch (PathPaymentStrictSendResultCode code)
 #   {
-#   case PATH_PAYMENT_SUCCESS:
+#   case PATH_PAYMENT_STRICT_SEND_SUCCESS:
 #       struct
 #       {
 #           ClaimOfferAtom offers<>;
 #           SimplePaymentResult last;
 #       } success;
-#   case PATH_PAYMENT_NO_ISSUER:
+#   case PATH_PAYMENT_STRICT_SEND_NO_ISSUER:
 #       Asset noIssuer; // the asset that caused the error
 #   default:
 #       void;
@@ -21,15 +21,15 @@ require 'xdr'
 #
 # ===========================================================================
 module Stellar
-  class PathPaymentResult < XDR::Union
+  class PathPaymentStrictSendResult < XDR::Union
     include XDR::Namespace
 
     autoload :Success
 
-    switch_on PathPaymentResultCode, :code
+    switch_on PathPaymentStrictSendResultCode, :code
 
-    switch :path_payment_success,   :success
-    switch :path_payment_no_issuer, :no_issuer
+    switch :path_payment_strict_send_success,   :success
+    switch :path_payment_strict_send_no_issuer, :no_issuer
     switch :default
 
     attribute :success,   Success

data/generated/stellar/{path_payment_result → path_payment_strict_send_result}/success.rb

@@ -13,7 +13,7 @@ require 'xdr'
 #
 # ===========================================================================
 module Stellar
-  class PathPaymentResult
+  class PathPaymentStrictSendResult
     class Success < XDR::Struct
       attribute :offers, XDR::VarArray[ClaimOfferAtom]
       attribute :last,   SimplePaymentResult

data/generated/stellar/path_payment_strict_send_result_code.rb

@@ -0,0 +1,47 @@
+# This code was automatically generated using xdrgen
+# DO NOT EDIT or your changes may be overwritten
+
+require 'xdr'
+
+# === xdr source ============================================================
+#
+#   enum PathPaymentStrictSendResultCode
+#   {
+#       // codes considered as "success" for the operation
+#       PATH_PAYMENT_STRICT_SEND_SUCCESS = 0, // success
+#   
+#       // codes considered as "failure" for the operation
+#       PATH_PAYMENT_STRICT_SEND_MALFORMED = -1,          // bad input
+#       PATH_PAYMENT_STRICT_SEND_UNDERFUNDED = -2,        // not enough funds in source account
+#       PATH_PAYMENT_STRICT_SEND_SRC_NO_TRUST = -3,       // no trust line on source account
+#       PATH_PAYMENT_STRICT_SEND_SRC_NOT_AUTHORIZED = -4, // source not authorized to transfer
+#       PATH_PAYMENT_STRICT_SEND_NO_DESTINATION = -5,     // destination account does not exist
+#       PATH_PAYMENT_STRICT_SEND_NO_TRUST = -6,           // dest missing a trust line for asset
+#       PATH_PAYMENT_STRICT_SEND_NOT_AUTHORIZED = -7,     // dest not authorized to hold asset
+#       PATH_PAYMENT_STRICT_SEND_LINE_FULL = -8,          // dest would go above their limit
+#       PATH_PAYMENT_STRICT_SEND_NO_ISSUER = -9,          // missing issuer on one asset
+#       PATH_PAYMENT_STRICT_SEND_TOO_FEW_OFFERS = -10,    // not enough offers to satisfy path
+#       PATH_PAYMENT_STRICT_SEND_OFFER_CROSS_SELF = -11,  // would cross one of its own offers
+#       PATH_PAYMENT_STRICT_SEND_UNDER_DESTMIN = -12      // could not satisfy destMin
+#   };
+#
+# ===========================================================================
+module Stellar
+  class PathPaymentStrictSendResultCode < XDR::Enum
+    member :path_payment_strict_send_success,            0
+    member :path_payment_strict_send_malformed,          -1
+    member :path_payment_strict_send_underfunded,        -2
+    member :path_payment_strict_send_src_no_trust,       -3
+    member :path_payment_strict_send_src_not_authorized, -4
+    member :path_payment_strict_send_no_destination,     -5
+    member :path_payment_strict_send_no_trust,           -6
+    member :path_payment_strict_send_not_authorized,     -7
+    member :path_payment_strict_send_line_full,          -8
+    member :path_payment_strict_send_no_issuer,          -9
+    member :path_payment_strict_send_too_few_offers,     -10
+    member :path_payment_strict_send_offer_cross_self,   -11
+    member :path_payment_strict_send_under_destmin,      -12
+
+    seal
+  end
+end

data/lib/stellar-base.rb

@@ -20,7 +20,7 @@ require_relative './stellar/account_flags'
 require_relative './stellar/asset'
 require_relative './stellar/key_pair'
 require_relative './stellar/operation'
-require_relative './stellar/path_payment_result'
+require_relative './stellar/path_payment_strict_receive_result'
 require_relative './stellar/price'
 require_relative './stellar/signer_key'
 require_relative './stellar/thresholds'

data/lib/stellar/base/version.rb

@@ -1,5 +1,5 @@
 module Stellar
   module Base
-    VERSION = "0.20.0"
+    VERSION = "0.21.0"
   end
 end

data/lib/stellar/operation.rb

@@ -59,21 +59,42 @@ module Stellar
     end
 
     #
-    # Helper method to create a valid PathPaymentOp, wrapped
+    # Helper method to create a valid PathPaymentStrictReceiveOp, wrapped
     # in the necessary XDR structs to be included within a
     # transactions `operations` array.
+    # 
+    # @deprecated Please use Operation.path_payment_strict_receive
     #
     # @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] :amount the destination asset and 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
+    # @return [Stellar::Operation] the built operation, containing a Stellar::PaymentOp body
+    #                              
     def self.path_payment(attributes={})
+      path_payment_strict_receive(attributes)
+    end
+
+    #
+    # Helper method to create a valid PathPaymentStrictReceiveOp, 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 destination asset and 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_strict_receive(attributes={})
       destination             = attributes[:destination]
       asset, amount           = extract_amount(attributes[:amount])
       send_asset, send_max    = extract_amount(attributes[:with])
@@ -81,7 +102,7 @@ module Stellar
 
       raise ArgumentError unless destination.is_a?(KeyPair)
 
-      op               = PathPaymentOp.new
+      op               = PathPaymentStrictReceiveOp.new
       op.send_asset    = send_asset
       op.send_max      = send_max
       op.destination   = destination.account_id
@@ -90,7 +111,43 @@ module Stellar
       op.path          = path
 
       return make(attributes.merge({
-        body:[:path_payment, op]
+        body:[:path_payment_strict_receive, op]
+      }))
+    end
+
+    #
+    # Helper method to create a valid PathPaymentStrictSendOp, 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 destination asset and the minimum amount of destination asset to be received
+    # @option attributes [Array] :with the source asset and 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_strict_send(attributes={})
+      destination             = attributes[:destination]
+      asset, dest_min         = extract_amount(attributes[:amount])
+      send_asset, send_amount = extract_amount(attributes[:with])
+      path                    = (attributes[:path] || []).map{|p| Stellar::Asset.send(*p)}
+
+      raise ArgumentError unless destination.is_a?(KeyPair)
+
+      op               = PathPaymentStrictSendOp.new
+      op.send_asset    = send_asset
+      op.send_amount   = send_amount
+      op.destination   = destination.account_id
+      op.dest_asset    = asset
+      op.dest_min      = dest_min
+      op.path          = path
+
+      return make(attributes.merge({
+        body:[:path_payment_strict_send, op]
       }))
     end
 

data/lib/stellar/{path_payment_result.rb → path_payment_strict_receive_result.rb}

@@ -1,5 +1,5 @@
 module Stellar
-  class PathPaymentResult
+  class PathPaymentStrictReceiveResult
     # send_amount returns the actual amount paid for the corresponding
     # PathPaymentOp to this result.
     #

data/lib/stellar/transaction.rb

@@ -13,6 +13,18 @@ module Stellar
       make :path_payment, attributes
     end
 
+    #
+    # @see  Stellar::Operation.path_payment_strict_receive
+    def self.path_payment_strict_receive(attributes={})
+      make :path_payment_strict_receive, attributes
+    end
+
+    #
+    # @see  Stellar::Operation.path_payment_strict_send
+    def self.path_payment_strict_send(attributes={})
+      make :path_payment_strict_send, attributes
+    end
+
     #
     # @see  Stellar::Operation.create_account
     def self.create_account(attributes={})

data/spec/lib/stellar/operation_spec.rb

@@ -12,6 +12,69 @@ describe Stellar::Operation, ".payment" do
 
 end
 
+def pk_to_address(pk)
+  Stellar::Convert.pk_to_address(pk)
+end
+
+describe "path payment operations" do
+  let(:destination){ Stellar::KeyPair.random }
+  let(:send_asset_issuer){ Stellar::KeyPair.master }
+  let(:send_asset){ Stellar::Asset.alphanum4("USD", send_asset_issuer) }
+  let(:dest_asset_issuer){ Stellar::KeyPair.master }
+  let(:dest_asset){ Stellar::Asset.alphanum4("EUR", dest_asset_issuer) }
+  let(:amount){ [:alphanum4, dest_asset.code, dest_asset_issuer, 9.2] }
+  let(:with){ [:alphanum4, send_asset.code, send_asset_issuer, 10] }
+  
+  describe Stellar::Operation, ".path_payment" do
+    it "works" do
+      destination = Stellar::KeyPair.random
+      amount = [:alphanum4, "USD", Stellar::KeyPair.master, 10]    
+      with = [:alphanum4, "EUR", Stellar::KeyPair.master, 9.2]
+
+      op = Stellar::Operation.path_payment(
+        destination: destination,
+        amount: amount,
+        with: with
+      )
+
+      expect(op.body.arm).to eql(:path_payment_strict_receive_op)
+    end
+  end
+
+  describe Stellar::Operation, ".path_payment_strict_receive" do
+    it "works" do
+      op = Stellar::Operation.path_payment_strict_receive(
+        destination: destination,
+        amount: amount,
+        with: with
+      )
+
+      expect(op.body.arm).to eql(:path_payment_strict_receive_op)
+      expect(op.body.value.destination).to eql(destination.public_key)
+      expect(op.body.value.send_asset).to eql(send_asset)
+      expect(op.body.value.dest_asset).to eql(dest_asset)
+      expect(op.body.value.send_max).to eq(100000000)
+      expect(op.body.value.dest_amount).to eq(92000000)
+    end
+  end
+
+  describe Stellar::Operation, ".path_payment_strict_send" do
+    it "works" do
+      op = Stellar::Operation.path_payment_strict_send(
+        destination: destination,
+        amount: amount,
+        with: with
+      )
+
+      expect(op.body.arm).to eql(:path_payment_strict_send_op)
+      expect(op.body.value.destination).to eql(destination.public_key)
+      expect(op.body.value.send_asset).to eql(send_asset)
+      expect(op.body.value.dest_asset).to eql(dest_asset)
+      expect(op.body.value.send_amount).to eq(100000000)
+      expect(op.body.value.dest_min).to eq(92000000)
+    end
+  end
+end
 
 describe Stellar::Operation, ".manage_data" do
 
@@ -67,5 +130,4 @@ describe Stellar::Operation, ".change_trust" do
       Stellar::Operation.change_trust(line: [:alphanum4, "USD", issuer], limit: true)
     }.to raise_error(ArgumentError)
   end
-
 end