Path payments

Author: bartekn

README.md

@@ -82,11 +82,11 @@ name |  | description
 --- | --- | ---
 `source` | optional | Secret seed of transaction source account. If ommitted it will use the `base_seed` specified in the config file.
 `destination` | required | Account ID or Stellar address (ex. `bob*stellar.org`) of payment destination account
-`amount` | required | Amount to send
+`amount` | required | Amount that destination will receive
 `memo_type` | optional | Memo type, one of: `id`, `text`, `hash`, `extra`
-`memo` | optional | Memo value, when `memo_type` is `extra` you can include any info here and it will be included in the pre-image of the transaction's memo hash. See the [Stellar Memo Convention](). `id` it must be uint64, when `hash` it must be 32 bytes hex value.  
-`asset_code` | optional | Asset code (XLM when empty)
-`asset_issuer` | optional | Account ID of asset issuer (XLM when empty)
+`memo` | optional | Memo value, when `memo_type` is `extra` you can include any info here and it will be included in the pre-image of the transaction's memo hash. See the [Stellar Memo Convention](https://github.com/stellar/stellar-protocol/issues/28). `id` it must be uint64, when `hash` it must be 32 bytes hex value.  
+`asset_code` | optional | Asset code (XLM when empty) destination will receive
+`asset_issuer` | optional | Account ID of asset issuer (XLM when empty) destination will receive
 `send_max` | optional | [path_payment] Maximum amount of send_asset to send
 `send_asset_code` | optional | [path_payment] Sending asset code (XLM when empty)
 `send_asset_issuer` | optional | [path_payment] Account ID of sending asset issuer (XLM when empty)
@@ -118,7 +118,7 @@ http://localhost:8001/payment
 Can be used to authorize other accounts to hold your assets.
 It will build and submits a transaction with a [`allow_trust`](https://www.stellar.org/developers/learn/concepts/list-of-operations.html#allow-trust) operation. 
 The source of this transaction will be the account specified by `accounts.authorizing_seed` config parameter. 
-You should make sure that this account is a low weight signer on the issuing account. See [Multi-sig]() for more information. 
+You should make sure that this account is a low weight signer on the issuing account. See [Multi-sig](https://www.stellar.org/developers/learn/concepts/multi-sig.html) for more information. 
 
 #### Request Parameters
 

src/github.com/stellar/gateway/bridge/app.go

@@ -5,6 +5,7 @@ import (
 	"flag"
 	"fmt"
 	log "github.com/Sirupsen/logrus"
+	"net/http"
 	"os"
 	"time"
 
@@ -137,16 +138,23 @@ func NewApp(config config.Config, migrateFlag bool) (app *App, err error) {
 
 	err = g.Provide(
 		&inject.Object{Value: &requestHandler},
+		&inject.Object{Value: &config},
 		&inject.Object{Value: &stellartoml.Resolver{}},
 		&inject.Object{Value: &federation.Resolver{}},
 		&inject.Object{Value: &h},
+		&inject.Object{Value: &ts},
 		&inject.Object{Value: &paymentListener},
+		&inject.Object{Value: &http.Client{}},
 	)
 
 	if err != nil {
 		log.Fatal("Injector: ", err)
 	}
 
+	if err := g.Populate(); err != nil {
+		log.Fatal("Injector: ", err)
+	}
+
 	app = &App{
 		config:         config,
 		requestHandler: requestHandler,

src/github.com/stellar/gateway/bridge/handlers/main.go

@@ -8,13 +8,15 @@ import (
 
 	"github.com/stellar/gateway/bridge/config"
 	"github.com/stellar/gateway/horizon"
+	"github.com/stellar/gateway/net"
 	"github.com/stellar/gateway/protocols/federation"
 	"github.com/stellar/gateway/protocols/stellartoml"
 	"github.com/stellar/gateway/submitter"
 )
 
 type RequestHandler struct {
 	Config               *config.Config                          `inject:""`
+	Client               net.HttpClientInterface                 `inject:""`
 	Horizon              horizon.HorizonInterface                `inject:""`
 	StellarTomlResolver  stellartoml.ResolverInterface           `inject:""`
 	FederationResolver   federation.ResolverInterface            `inject:""`

src/github.com/stellar/gateway/bridge/handlers/request_handler_payment.go

@@ -3,6 +3,7 @@ package handlers
 import (
 	"encoding/hex"
 	"encoding/json"
+	"fmt"
 	log "github.com/Sirupsen/logrus"
 	"io/ioutil"
 	"net/http"
@@ -34,6 +35,9 @@ func (rh *RequestHandler) Payment(w http.ResponseWriter, r *http.Request) {
 	assetIssuer := r.PostFormValue("asset_issuer")
 	memoType := r.PostFormValue("memo_type")
 	memo := r.PostFormValue("memo")
+	sendMax := r.PostFormValue("send_max")
+	sendAssetCode := r.PostFormValue("send_asset_code")
+	sendAssetIssuer := r.PostFormValue("send_asset_issuer")
 	extraMemo := r.PostFormValue("extra_memo")
 
 	if extraMemo != "" && rh.Config.Compliance != nil {
@@ -48,7 +52,7 @@ func (rh *RequestHandler) Payment(w http.ResponseWriter, r *http.Request) {
 			ExtraMemo:   extraMemo,
 		}
 
-		resp, err := http.PostForm(
+		resp, err := rh.Client.PostForm(
 			*rh.Config.Compliance+"/send",
 			request.ToValues(),
 		)
@@ -115,6 +119,45 @@ func (rh *RequestHandler) Payment(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 
+		var payWithMutator *b.PayWithPath
+
+		if sendMax != "" {
+			// Path payment
+			var sendAsset b.Asset
+			if sendAssetCode != "" && sendAssetIssuer != "" {
+				sendAsset = b.CreditAsset(sendAssetCode, sendAssetIssuer)
+			} else if sendAssetCode == "" && sendAssetIssuer == "" {
+				sendAsset = b.NativeAsset()
+			} else {
+				log.Print("Missing send asset param.")
+				server.Write(w, h.NewErrorResponse(h.PaymentMissingParamAsset))
+				return
+			}
+
+			payWith := b.PayWith(sendAsset, sendMax)
+
+			for i := 0; ; i++ {
+				codeFieldName := fmt.Sprintf("path[%d][asset_code]", i)
+				issuerFieldName := fmt.Sprintf("path[%d][asset_issuer]", i)
+
+				// If the element does not exist in PostForm break the loop
+				if _, exists := r.PostForm[codeFieldName]; !exists {
+					break
+				}
+
+				code := r.PostFormValue(codeFieldName)
+				issuer := r.PostFormValue(issuerFieldName)
+
+				if code == "" && issuer == "" {
+					payWith = payWith.Through(b.NativeAsset())
+				} else {
+					payWith = payWith.Through(b.CreditAsset(code, issuer))
+				}
+			}
+
+			payWithMutator = &payWith
+		}
+
 		var operationBuilder interface{}
 
 		if assetCode != "" && assetIssuer != "" {
@@ -125,16 +168,26 @@ func (rh *RequestHandler) Payment(w http.ResponseWriter, r *http.Request) {
 				return
 			}
 
-			operationBuilder = b.Payment(
+			mutators := []interface{}{
 				b.Destination{destinationObject.AccountId},
 				b.CreditAmount{assetCode, issuerKeypair.Address(), amount},
-			)
+			}
+
+			if payWithMutator != nil {
+				mutators = append(mutators, *payWithMutator)
+			}
+
+			operationBuilder = b.Payment(mutators...)
 		} else if assetCode == "" && assetIssuer == "" {
 			mutators := []interface{}{
 				b.Destination{destinationObject.AccountId},
 				b.NativeAmount{amount},
 			}
 
+			if payWithMutator != nil {
+				mutators = append(mutators, *payWithMutator)
+			}
+
 			// Check if destination account exist
 			_, err = rh.Horizon.LoadAccount(destinationObject.AccountId)
 			if err != nil {