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== }