leighmcculloch
commented
2 years ago Here is the code that triggers the situation. The transaction being built is really irrelevant to the situation, and I know it is odd, but don't get too hung up on that. This shouldn't happen with any transaction submitted Horizon.
This situation was noticed in Starlight integration test suite, when the test suite accidentally submitted a transaction to Horizon Testnet. The transaction that was submitted shouldn't succeed on testnet.
module testgo
go 1.18
require github.com/stellar/go v0.0.0-20220419042134-9f968df09eda
require (
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/go-chi/chi v4.0.3+incompatible // indirect
github.com/go-errors/errors v0.0.0-20150906023321-a41850380601 // indirect
github.com/gorilla/schema v1.1.0 // indirect
github.com/konsorten/go-windows-terminal-sequences v1.0.1 // indirect
github.com/manucorporat/sse v0.0.0-20160126180136-ee05b128a739 // indirect
github.com/pkg/errors v0.9.1 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/segmentio/go-loggly v0.5.1-0.20171222203950-eb91657e62b2 // indirect
github.com/sirupsen/logrus v1.4.1 // indirect
github.com/stellar/go-xdr v0.0.0-20211103144802-8017fc4bdfee // indirect
github.com/stretchr/objx v0.3.0 // indirect
github.com/stretchr/testify v1.7.0 // indirect
golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c // indirect
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect
)package main
import (
"bytes"
"fmt"
"io"
"io/ioutil"
"net/http"
"net/url"
"time"
"github.com/davecgh/go-spew/spew"
"github.com/stellar/go/amount"
"github.com/stellar/go/clients/horizonclient"
"github.com/stellar/go/keypair"
"github.com/stellar/go/txnbuild"
)
type HTTPLogger struct {
horizonclient.HTTP
}
func logRequest(req *http.Request) error {
if req.Body == nil {
fmt.Println("-->", req.URL.String())
return nil
}
reqBody, err := ioutil.ReadAll(req.Body)
if err != nil {
fmt.Println("-->", req.URL.String(), "err reading request body:", err)
return err
}
fmt.Println("-->", req.URL.String(), string(reqBody))
req.Body = io.NopCloser(bytes.NewBuffer(reqBody))
return nil
}
func logResponse(resp *http.Response) error {
respBody, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("<-- err reading response body:", err)
return err
}
fmt.Println("<--", string(respBody))
resp.Body = io.NopCloser(bytes.NewBuffer(respBody))
return nil
}
func (h *HTTPLogger) Do(req *http.Request) (resp *http.Response, err error) {
fmt.Printf("%#v\n", req)
err = logRequest(req)
if err != nil {
return nil, err
}
resp, err = h.HTTP.Do(req)
if err != nil {
return nil, err
}
err = logResponse(resp)
if err != nil {
return nil, err
}
return resp, err
}
func (h *HTTPLogger) Get(url string) (resp *http.Response, err error) {
resp, err = h.HTTP.Get(url)
if err != nil {
return nil, err
}
err = logResponse(resp)
if err != nil {
return nil, err
}
return resp, err
}
func (h *HTTPLogger) PostForm(url string, data url.Values) (resp *http.Response, err error) {
resp, err = h.HTTP.PostForm(url, data)
if err != nil {
return nil, err
}
err = logResponse(resp)
if err != nil {
return nil, err
}
return resp, err
}
func main() {
client := &horizonclient.Client{
HorizonURL: "http://horizon-testnet.stellar.org",
HTTP: &http.Client{Timeout: 20 * time.Second},
}
account := keypair.MustRandom()
startingBalance := int64(1_000_0000000)
rootResp, err := client.Root()
if err != nil {
panic(err)
}
root := keypair.Master(rootResp.NetworkPassphrase).(*keypair.Full)
sourceAccount, err := client.AccountDetail(horizonclient.AccountRequest{AccountID: root.Address()})
if err != nil {
panic(err)
}
tx, err := txnbuild.NewTransaction(
txnbuild.TransactionParams{
SourceAccount: &sourceAccount,
IncrementSequenceNum: true,
BaseFee: txnbuild.MinBaseFee,
Preconditions: txnbuild.Preconditions{TimeBounds: txnbuild.NewTimeout(300)},
Operations: []txnbuild.Operation{
&txnbuild.CreateAccount{
Destination: account.Address(),
Amount: amount.StringFromInt64(startingBalance),
},
},
},
)
if err != nil {
panic(err)
}
tx, err = tx.Sign(rootResp.NetworkPassphrase, root)
if err != nil {
panic(err)
}
fmt.Print("HashHex: ")
fmt.Println(tx.HashHex(rootResp.NetworkPassphrase))
fmt.Print("Base64: ")
fmt.Println(tx.Base64())
client.HTTP = &HTTPLogger{HTTP: client.HTTP}
resp, err := client.SubmitTransaction(tx)
if err != nil {
panic(err)
}
fmt.Print("Tx: ")
spew.Dump(resp)
}
bartekn
It appears that horizonclient or horizon is behaving oddly under some conditions in testnet. I'm submitting a transaction that I expect to fail with bad auth, however Horizon is redirecting the request to the /transactions endpoint, which causes the client to think it got a successful response, but then the client is unable to parse the response, but the client doesn't error. So from the developer perspective it appears like the transaction was accepted onto the network, but as a failed transaction. In reality the transaction was not accepted.