// ResultXDR returns the XDR encoded result for this transaction
func (tx *Transaction) ResultXDR() string {
out, err := xdr.MarshalBase64(tx.Result.Result)
if err != nil {
panic(err)
}
return out
}
// EnvelopeXDR returns the XDR encoded envelope for this transaction
func (tx *Transaction) EnvelopeXDR() string {
out, err := xdr.MarshalBase64(tx.Envelope)
if err != nil {
panic(err)
}
return out
}
// ChangesXDR returns the XDR encoded changes for this transaction fee
func (fee *TransactionFee) ChangesXDR() string {
out, err := xdr.MarshalBase64(fee.Changes)
if err != nil {
panic(err)
}
return out
}
func main() {
in = bufio.NewReader(os.Stdin)
// read envelope
env, err := readLine("Enter envelope (base64): ", false)
if err != nil {
log.Fatal(err)
}
// parse the envelope
var txe xdr.TransactionEnvelope
err = xdr.SafeUnmarshalBase64(env, &txe)
if err != nil {
log.Fatal(err)
}
// TODO: print transaction details
// read seed
seed, err := readLine("Enter seed: ", true)
if err != nil {
log.Fatal(err)
}
// parse the seed into a private key
_, priv, err := stellarbase.GenerateKeyFromSeed(seed)
if err != nil {
log.Fatal(err)
}
// sign the transaction
b := &build.TransactionEnvelopeBuilder{E: &txe}
b.Init()
b.MutateTX(build.PublicNetwork)
b.Mutate(build.Sign{&priv})
if b.Err != nil {
log.Fatal(b.Err)
}
newEnv, err := xdr.MarshalBase64(b.E)
if err != nil {
log.Fatal(err)
}
fmt.Print("\n==== Result ====\n\n")
fmt.Println(newEnv)
}
// SignAndSubmitRawTransaction will:
// - update sequence number of the transaction to the current one,
// - sign it,
// - submit it to the network.
func (ts *TransactionSubmitter) SignAndSubmitRawTransaction(seed string, tx *xdr.Transaction) (response horizon.SubmitTransactionResponse, err error) {
account, err := ts.GetAccount(seed)
if err != nil {
return
}
account.Mutex.Lock()
account.SequenceNumber++
tx.SeqNum = xdr.SequenceNumber(account.SequenceNumber)
account.Mutex.Unlock()
hash, err := TransactionHash(tx, ts.Network.Passphrase)
if err != nil {
ts.log.Print("Error calculating transaction hash")
return
}
sig, err := account.Keypair.SignDecorated(hash[:])
if err != nil {
ts.log.Print("Error signing a transaction")
return
}
envelopeXdr := xdr.TransactionEnvelope{
Tx: *tx,
Signatures: []xdr.DecoratedSignature{sig},
}
txeB64, err := xdr.MarshalBase64(envelopeXdr)
if err != nil {
ts.log.Print("Cannot encode transaction envelope")
return
}
transactionHashBytes, err := TransactionHash(tx, ts.Network.Passphrase)
if err != nil {
ts.log.WithFields(logrus.Fields{"err": err}).Warn("Error calculating tx hash")
return
}
sentTransaction := &entities.SentTransaction{
TransactionID: hex.EncodeToString(transactionHashBytes[:]),
Status: entities.SentTransactionStatusSending,
Source: account.Keypair.Address(),
SubmittedAt: ts.now(),
EnvelopeXdr: txeB64,
}
err = ts.EntityManager.Persist(sentTransaction)
if err != nil {
return
}
response, err = ts.Horizon.SubmitTransaction(txeB64)
if err != nil {
ts.log.Error("Error submitting transaction ", err)
return
}
if response.Ledger != nil {
sentTransaction.MarkSucceeded(*response.Ledger)
} else {
var result string
if response.Extras != nil {
result = response.Extras.ResultXdr
} else {
result = "<empty>"
}
sentTransaction.MarkFailed(result)
}
err = ts.EntityManager.Persist(sentTransaction)
if err != nil {
return
}
// Sync sequence number
if response.Extras != nil && response.Extras.ResultXdr == "AAAAAAAAAAD////7AAAAAA==" {
account.Mutex.Lock()
ts.log.Print("Syncing sequence number for ", account.Keypair.Address())
accountResponse, err2 := ts.Horizon.LoadAccount(account.Keypair.Address())
if err2 != nil {
ts.log.Error("Error updating sequence number ", err)
} else {
account.SequenceNumber, _ = strconv.ParseUint(accountResponse.SequenceNumber, 10, 64)
}
account.Mutex.Unlock()
}
return
}