func (this *StellarAccountMerge) GetSigned(seed string) string {
tx := build.TransactionBuilder{}
tx.TX = &xdr.Transaction{}
opt := xdr.Operation{}
srcAccID, _ := stellarbase.AddressToAccountId(this.SrcInfo.ID)
destAccID, _ := stellarbase.AddressToAccountId(this.DestPublicAddr)
opt.SourceAccount = &srcAccID
opt.Body, _ = xdr.NewOperationBody(xdr.OperationTypeAccountMerge,
destAccID)
tx.TX.Operations = append(tx.TX.Operations, opt)
tx.Mutate(build.Sequence{xdr.SequenceNumber(this.SrcInfo.NextSequence())})
if STELLAR_DEFAULT_NETWORK == STELLAR_TEST_NETWORK {
tx.Mutate(build.TestNetwork)
} else {
tx.Mutate(build.PublicNetwork)
}
tx.Mutate(build.SourceAccount{this.SrcInfo.ID})
tx.TX.Fee = BASEMENT_FEE
result := tx.Sign(seed)
var err error
this.signBase64, err = result.Base64()
// fmt.Printf("tx base64: %s\r\n", this.signBase64)
if err == nil {
return this.signBase64
}
fmt.Println(err)
return ""
}
// ExampleLowLevelTransaction creates and signs a simple transaction, and then
// encodes it into a hex string capable of being submitted to stellar-core.
//
// It uses the low-level xdr facilities to create the transaction.
func ExampleLowLevelTransaction() {
spub, spriv, err := GenerateKeyFromSeed("s3Fy8h5LEcYVE8aofthKWHeJpygbntw5HgcekFw93K6XqTW4gEx")
if err != nil {
log.Fatal(err)
}
dpub, _, err := GenerateKeyFromSeed("sfkPCKA6XgaeHZH3NE57i3QrjVcw61c1noWQCgnHa6KJP2BrbXD")
if err != nil {
log.Fatal(err)
}
op := xdr.PaymentOp{
Destination: dpub.KeyData(),
Currency: xdr.NewCurrencyCurrencyTypeNative(),
Amount: 50 * 10000000,
}
tx := xdr.Transaction{
SourceAccount: spub.KeyData(),
Fee: 10,
SeqNum: xdr.SequenceNumber(1),
Memo: xdr.NewMemoMemoNone(),
Operations: []xdr.Operation{
{Body: xdr.NewOperationBodyPayment(op)},
},
}
var txBytes bytes.Buffer
_, err = xdr.Marshal(&txBytes, tx)
if err != nil {
log.Fatal(err)
}
txHash := Hash(txBytes.Bytes())
signature := spriv.Sign(txHash[:])
ds := xdr.DecoratedSignature{
Hint: spriv.Hint(),
Signature: xdr.Uint512(signature),
}
txe := xdr.TransactionEnvelope{
Tx: tx,
Signatures: []xdr.DecoratedSignature{ds},
}
var txeBytes bytes.Buffer
_, err = xdr.Marshal(&txeBytes, txe)
if err != nil {
log.Fatal(err)
}
txeHex := hex.EncodeToString(txeBytes.Bytes())
fmt.Printf("tx hex: %s", txeHex)
// Output: tx hex: 3658fe7598d20c7a6de3297f84bc52bd2a1ec8c0f1f6c5b41cc1c7571b4331f00000000a000000000000000100000000000000000000000100000000000000012d24692ed08bbf679ba199448870d2191e876fecd92fdd9f6d274da4e6de134100000000000000001dcd650000000001dd302d0c0cee527cf02f6a0aec6916966298712914c63e3c57de74a6e27c29ea234a555fcc36533417afe4e1147815a42529fbca3429bc7caf0a06dc6b383ca6e9d4d80f
}
// SequenceForAccount implements build.SequenceProvider
func (c *Client) SequenceForAccount(
accountID string,
) (xdr.SequenceNumber, error) {
a, err := c.LoadAccount(accountID)
if err != nil {
return 0, err
}
seq, err := strconv.ParseUint(a.Sequence, 10, 64)
if err != nil {
return 0, err
}
return xdr.SequenceNumber(seq), nil
}
func (bot *Bot) makeTx(address string) (string, error) {
bot.lock.Lock()
bot.lock.Unlock()
tx := Transaction(
SourceAccount{bot.Secret},
Sequence{xdr.SequenceNumber(bot.sequence + 1)},
CreateAccount(
Destination{address},
NativeAmount{"10000.00"},
Network{bot.Network},
),
)
bot.sequence++
txe := tx.Sign(bot.Secret)
return txe.Base64()
}
func (this *StellarAccountCreateInfo) GetSigned(seed string) string {
// _, spriv, _ := stellarbase.GenerateKeyFromSeed(seed)
// kp,_ := keypair.Parse(seed)
tx := build.TransactionBuilder{}
ca := build.CreateAccountBuilder{}
ca.Mutate(build.Destination{this.Destinaton})
ca.Mutate(build.SourceAccount{this.SrcInfo.ID})
ca.Mutate(build.NativeAmount{fmt.Sprintf("%f", this.Amount)})
tx.Mutate(build.Sequence{xdr.SequenceNumber(this.SrcInfo.NextSequence())})
if STELLAR_DEFAULT_NETWORK == STELLAR_TEST_NETWORK {
tx.Mutate(build.TestNetwork)
} else {
tx.Mutate(build.PublicNetwork)
}
tx.Mutate(ca)
tx.Mutate(build.SourceAccount{this.SrcInfo.ID})
tx.TX.Fee = BASEMENT_FEE
// result := tx.Sign(&spriv)
result := tx.Sign(seed)
var err error
this.signBase64, err = result.Base64()
// fmt.Printf("tx base64: %s\r\n", this.signBase64)
if err == nil {
return this.signBase64
}
fmt.Println(err)
return ""
}
// MutateTransaction for Sequence sets the SeqNum on the transaction.
func (m Sequence) MutateTransaction(o *TransactionBuilder) error {
o.TX.SeqNum = xdr.SequenceNumber(m.Sequence)
return nil
}
// 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
}
// MutateTransaction for Sequence sets the SeqNum on the transaction.
func (m Sequence) MutateTransaction(o *xdr.Transaction) error {
o.SeqNum = xdr.SequenceNumber(m.Sequence)
return nil
}
// ExampleLowLevelTransaction creates and signs a simple transaction, and then
// encodes it into a hex string capable of being submitted to stellar-core.
//
// It uses the low-level xdr facilities to create the transaction.
func ExampleLowLevelTransaction() {
spub, spriv, err := GenerateKeyFromSeed("SA26PHIKZM6CXDGR472SSGUQQRYXM6S437ZNHZGRM6QA4FOPLLLFRGDX")
if err != nil {
panic(err)
}
dpub, _, err := GenerateKeyFromSeed("SBQHO2IMYKXAYJFCWGXC7YKLJD2EGDPSK3IUDHVJ6OOTTKLSCK6Z6POM")
if err != nil {
panic(err)
}
asset, err := xdr.NewAsset(xdr.AssetTypeAssetTypeNative, nil)
if err != nil {
panic(err)
}
destination, err := AddressToAccountId(dpub.Address())
if err != nil {
panic(err)
}
op := xdr.PaymentOp{
Destination: destination,
Asset: asset,
Amount: 50 * 10000000,
}
memo, err := xdr.NewMemo(xdr.MemoTypeMemoNone, nil)
source, err := AddressToAccountId(spub.Address())
if err != nil {
panic(err)
}
body, err := xdr.NewOperationBody(xdr.OperationTypePayment, op)
if err != nil {
panic(err)
}
tx := xdr.Transaction{
SourceAccount: source,
Fee: 10,
SeqNum: xdr.SequenceNumber(1),
Memo: memo,
Operations: []xdr.Operation{
{Body: body},
},
}
var txBytes bytes.Buffer
_, err = xdr.Marshal(&txBytes, tx)
if err != nil {
panic(err)
}
txHash := Hash(txBytes.Bytes())
signature := spriv.Sign(txHash[:])
ds := xdr.DecoratedSignature{
Hint: spriv.Hint(),
Signature: xdr.Signature(signature[:]),
}
txe := xdr.TransactionEnvelope{
Tx: tx,
Signatures: []xdr.DecoratedSignature{ds},
}
var txeBytes bytes.Buffer
_, err = xdr.Marshal(&txeBytes, txe)
if err != nil {
panic(err)
}
txeB64 := base64.StdEncoding.EncodeToString(txeBytes.Bytes())
fmt.Printf("tx base64: %s", txeB64)
// Output: tx base64: AAAAAAU08yUQ8sHqhY8j9mXWwERfHC/3cKFSe/spAr0rGtO2AAAACgAAAAAAAAABAAAAAAAAAAAAAAABAAAAAAAAAAEAAAAA+fnTe7/v4whpBUx96oj92jfZPz7S00l3O2xeyeqWIA0AAAAAAAAAAB3NZQAAAAAAAAAAATXnnQoAAABAieruUIGcQH6RlQ+prYflPFU3nED2NvWhtaC+tgnKsqgiKURK4xo/W7EgH0+I6aQok52awbE+ksOxEQ5MLJ9eAw==
}