txnbuild

package
v0.0.0-...-fb9541f Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 27, 2020 License: Apache-2.0 Imports: 16 Imported by: 0

README

txnbuild

txnbuild is a Paydex SDK, implemented in Go. It provides a reference implementation of the complete set of operations that compose transactions for the Paydex distributed ledger.

This project is maintained by the Paydex Development Foundation.

  import (
	"log"

	"github.com/paydex-core/paydex-go/clients/horizonclient"
	"github.com/paydex-core/paydex-go/keypair"
	"github.com/paydex-core/paydex-go/network"
	"github.com/paydex-core/paydex-go/txnbuild"
	)

	// Make a keypair for a known account from a secret seed
	kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")

	// Get the current state of the account from the network
	client := horizonclient.DefaultTestNetClient
	ar := horizonclient.AccountRequest{AccountID: kp.Address()}
	sourceAccount, err := client.AccountDetail(ar)
  	if err != nil {
    		log.Println(err)
  	}

	// Build an operation to create and fund a new account
	op := txnbuild.CreateAccount{
		Destination: "GCCOBXW2XQNUSL467IEILE6MMCNRR66SSVL4YQADUNYYNUVREF3FIV2Z",
		Amount:      "10",
	}

	// Construct the transaction that holds the operations to execute on the network
	tx := txnbuild.Transaction{
		SourceAccount: &sourceAccount,
		Operations:    []txnbuild.Operation{&op},
		Timebounds:    txnbuild.NewTimeout(300),
		Network:       network.TestNetworkPassphrase,
	}

	// Serialise, sign and encode the transaction
	txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
  	if err != nil {
    		log.Println(err)
  	}

	// Send the transaction to the network
	resp, err := client.SubmitTransactionXDR(txe)
  	if err != nil {
    		log.Println(err)
  	}

Getting Started

This library is aimed at developers building Go applications on top of the Paydex network. Transactions constructed by this library may be submitted to any Horizon instance for processing onto the ledger, using any Paydex SDK client. The recommended client for Go programmers is horizonclient. Together, these two libraries provide a complete Paydex SDK.

An easy-to-follow demonstration that exercises this SDK on the TestNet with actual accounts is also included! See the Demo section below.

Prerequisites
  • Go 1.12 or greater
  • Modules to manage dependencies
Installing
  • go get github.com/paydex-core/paydex-go/clients/txnbuild

Running the tests

Run the unit tests from the package directory: go test

Demo

To see the SDK in action, build and run the demo:

  • Enter the demo directory: cd $GOPATH/src/github.com/paydex-core/paydex-go/txnbuild/cmd/demo
  • Build the demo: go build
  • Run the demo: ./demo init

Contributing

Please read Code of Conduct to understand this project's communication rules.

To submit improvements and fixes to this library, please see CONTRIBUTING.

License

This project is licensed under the Apache License - see the LICENSE file for details.

Documentation

Overview

Package txnbuild implements transactions and operations on the Paydex network. This library provides an interface to the Paydex transaction model. It supports the building of Go applications on top of the Paydex network (https://www.paydex.org/). Transactions constructed by this library may be submitted to any Horizon instance for processing onto the ledger, using any Paydex SDK client. The recommended client for Go programmers is horizonclient (https://github.com/paydex-core/paydex-go/tree/master/clients/horizonclient). Together, these two libraries provide a complete Paydex SDK. For more information and further examples, see https://www.paydex.org/developers/go/reference/index.html.

Index

Examples

Constants

View Source 
const AuthImmutable = AccountFlag(xdr.AccountFlagsAuthImmutableFlag)

AuthImmutable is a flag that if set prevents any authorization flags from being set, and prevents the account from ever being merged (deleted).

View Source 
const AuthRequired = AccountFlag(xdr.AccountFlagsAuthRequiredFlag)

AuthRequired is a flag that requires the issuing account to give other accounts permission before they can hold the issuing account's credit.

View Source 
const AuthRevocable = AccountFlag(xdr.AccountFlagsAuthRevocableFlag)

AuthRevocable is a flag that allows the issuing account to revoke its credit held by other accounts.

View Source 
const MemoTextMaxLength = 28

MemoTextMaxLength is the maximum number of bytes allowed for a text memo.

View Source 
const TimeoutInfinite = int64(0)

TimeoutInfinite allows an indefinite upper bound to be set for Transaction.MaxTime. This is usually not what you want.

Variables

View Source 
var MaxTrustlineLimit = amount.StringFromInt64(math.MaxInt64)

MaxTrustlineLimit represents the maximum value that can be set as a trustline limit.

Functions

func BuildChallengeTx 

func BuildChallengeTx(serverSignerSecret, clientAccountID, anchorName, network string, timebound time.Duration) (string, error)

BuildChallengeTx is a factory method that creates a valid SEP 10 challenge, for use in web authentication. "timebound" is the time duration the transaction should be valid for, and must be greater than 1s (300s is recommended). More details on SEP 10: https://github.com/paydex-core/paydex-protocol/blob/master/ecosystem/sep-0010.md

Example 
// Generate random nonce
serverSignerSeed := "SBZVMB74Z76QZ3ZOY7UTDFYKMEGKW5XFJEB6PFKBF4UYSSWHG4EDH7PY"
clientAccountID := "GDQNY3PBOJOKYZSRMK2S7LHHGWZIUISD4QORETLMXEWXBI7KFZZMKTL3"
anchorName := "SDF"
timebound := time.Duration(5 * time.Minute)

tx, err := BuildChallengeTx(serverSignerSeed, clientAccountID, anchorName, network.TestNetworkPassphrase, timebound)
_, err = checkChallengeTx(tx, anchorName)

check(err)

Output:

func NewHomeDomain 

func NewHomeDomain(hd string) *string

NewHomeDomain is syntactic sugar that makes instantiating SetOptions more convenient.

func NewInflationDestination 

func NewInflationDestination(ai string) *string

NewInflationDestination is syntactic sugar that makes instantiating SetOptions more convenient.

func SetOpSourceAccount 

func SetOpSourceAccount(op *xdr.Operation, sourceAccount Account)

SetOpSourceAccount sets the source account ID on an Operation.

func VerifyChallengeTx 

func VerifyChallengeTx(challengeTx, serverAccountID, network string) (bool, error)

VerifyChallengeTx is a factory method that verifies a SEP 10 challenge transaction, for use in web authentication. It can be used by a server to verify that the challenge has been signed by the client. More details on SEP 10: https://github.com/paydex-core/paydex-protocol/blob/master/ecosystem/sep-0010.md

Types

type Account 

type Account interface {
	GetAccountID() string
	IncrementSequenceNumber() (xdr.SequenceNumber, error)
}

Account represents the aspects of a Paydex account necessary to construct transactions. See https://www.paydex.org/developers/guides/concepts/accounts.html

type AccountFlag 

type AccountFlag uint32

AccountFlag represents the bitmask flags used to set and clear account authorization options.

type AccountMerge 

type AccountMerge struct {
	Destination   string
	SourceAccount Account
}

AccountMerge represents the Paydex merge account operation. See https://www.paydex.org/developers/guides/concepts/list-of-operations.html

Example 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

op := AccountMerge{
	Destination: "GCCOBXW2XQNUSL467IEILE6MMCNRR66SSVL4YQADUNYYNUVREF3FIV2Z",
}

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAIAAAAAITg3tq8G0kvnvoIhZPMYJsY+9KVV8xAA6NxhtKxIXZUAAAAAAAAAAHqLnLFAAAAQC87HdYfOZpOx/isr7JEOy9ef3GH51ToKSkC6b4UJdDktlCqHFCD0cSttJ/F5MUx2ScSkwpeAlEVR8B62X6N/g4=

func (*AccountMerge) BuildXDR 

func (am *AccountMerge) BuildXDR() (xdr.Operation, error)

BuildXDR for AccountMerge returns a fully configured XDR Operation.

func (*AccountMerge) FromXDR 

func (am *AccountMerge) FromXDR(xdrOp xdr.Operation) error

FromXDR for AccountMerge initialises the txnbuild struct from the corresponding xdr Operation.

func (*AccountMerge) GetSourceAccount 

func (am *AccountMerge) GetSourceAccount() Account

GetSourceAccount returns the source account of the operation, or nil if not set.

func (*AccountMerge) Validate 

func (am *AccountMerge) Validate() error

Validate for AccountMerge validates the required struct fields. It returns an error if any of the fields are invalid. Otherwise, it returns nil.

type AllowTrust 

type AllowTrust struct {
	Trustor       string
	Type          Asset
	Authorize     bool
	SourceAccount Account
}

AllowTrust represents the Paydex allow trust operation. See https://www.paydex.org/developers/guides/concepts/list-of-operations.html

Example 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

op := AllowTrust{
	Trustor:   "GCCOBXW2XQNUSL467IEILE6MMCNRR66SSVL4YQADUNYYNUVREF3FIV2Z",
	Type:      CreditAsset{"ABCD", "GCCOBXW2XQNUSL467IEILE6MMCNRR66SSVL4YQADUNYYNUVREF3FIV2Z"},
	Authorize: true,
}

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAHAAAAAITg3tq8G0kvnvoIhZPMYJsY+9KVV8xAA6NxhtKxIXZUAAAAAUFCQ0QAAAABAAAAAAAAAAHqLnLFAAAAQBjcydaIxwvXxLFEhNK4jm1lJeYSjRDfxRmDSOIkZTZTqRKewI1NMmIYAIZCUis98Axi32ShqutfXXDscsGixA0=

func (*AllowTrust) BuildXDR 

func (at *AllowTrust) BuildXDR() (xdr.Operation, error)

BuildXDR for AllowTrust returns a fully configured XDR Operation.

func (*AllowTrust) FromXDR 

func (at *AllowTrust) FromXDR(xdrOp xdr.Operation) error

FromXDR for AllowTrust initialises the txnbuild struct from the corresponding xdr Operation.

func (*AllowTrust) GetSourceAccount 

func (at *AllowTrust) GetSourceAccount() Account

GetSourceAccount returns the source account of the operation, or nil if not set.

func (*AllowTrust) Validate 

func (at *AllowTrust) Validate() error

Validate for AllowTrust validates the required struct fields. It returns an error if any of the fields are invalid. Otherwise, it returns nil.

type Asset 

type Asset interface {
	GetType() (AssetType, error)
	IsNative() bool
	GetCode() string
	GetIssuer() string
	ToXDR() (xdr.Asset, error)
}

Asset represents a Paydex asset.

type AssetType 

type AssetType xdr.AssetType

AssetType represents the type of a Paydex asset. 

const (
	AssetTypeNative           AssetType = AssetType(xdr.AssetTypeAssetTypeNative)
	AssetTypeCreditAlphanum4  AssetType = AssetType(xdr.AssetTypeAssetTypeCreditAlphanum4)
	AssetTypeCreditAlphanum12 AssetType = AssetType(xdr.AssetTypeAssetTypeCreditAlphanum12)
)

AssetTypeNative, AssetTypeCreditAlphanum4, AssetTypeCreditAlphanum12 enumerate the different types of asset on the Paydex network.

type BumpSequence 

type BumpSequence struct {
	BumpTo        int64
	SourceAccount Account
}

BumpSequence represents the Paydex bump sequence operation. See https://www.paydex.org/developers/guides/concepts/list-of-operations.html

Example 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

op := BumpSequence{
	BumpTo: 9606132444168300,
}

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAALACIgugAAAGwAAAAAAAAAAeoucsUAAABAQi/I4d0+fzZyQpchIYXqxHhhTmjHvfmK8qsL/BLjrXmPUADja9tdIupKEkDn/v8NfnpRS/4u3u+Vy70zuOxHDg==

func (*BumpSequence) BuildXDR 

func (bs *BumpSequence) BuildXDR() (xdr.Operation, error)

BuildXDR for BumpSequence returns a fully configured XDR Operation.

func (*BumpSequence) FromXDR 

func (bs *BumpSequence) FromXDR(xdrOp xdr.Operation) error

FromXDR for BumpSequence initialises the txnbuild struct from the corresponding xdr Operation.

func (*BumpSequence) GetSourceAccount 

func (bs *BumpSequence) GetSourceAccount() Account

GetSourceAccount returns the source account of the operation, or nil if not set.

func (*BumpSequence) Validate 

func (bs *BumpSequence) Validate() error

Validate for BumpSequence validates the required struct fields. It returns an error if any of the fields are invalid. Otherwise, it returns nil.

type ChangeTrust 

type ChangeTrust struct {
	Line          Asset
	Limit         string
	SourceAccount Account
}

ChangeTrust represents the Paydex change trust operation. See https://www.paydex.org/developers/guides/concepts/list-of-operations.html. If Limit is omitted, it defaults to txnbuild.MaxTrustlineLimit.

Example 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

op := ChangeTrust{
	Line:  CreditAsset{"ABCD", "GCCOBXW2XQNUSL467IEILE6MMCNRR66SSVL4YQADUNYYNUVREF3FIV2Z"},
	Limit: "10",
}

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAGAAAAAUFCQ0QAAAAAhODe2rwbSS+e+giFk8xgmxj70pVXzEADo3GG0rEhdlQAAAAABfXhAAAAAAAAAAAB6i5yxQAAAECqpS4iUUyuUSVicZIseVoj8DjWgYDet21zUQeHNr1teTflnCUS+awFQ5lNqxl+AHPB34JzN6RYoEISoEIfNpIH
Example (RemoveTrustline) 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

op := RemoveTrustlineOp(CreditAsset{"ABCD", "GCCOBXW2XQNUSL467IEILE6MMCNRR66SSVL4YQADUNYYNUVREF3FIV2Z"})

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAGAAAAAUFCQ0QAAAAAhODe2rwbSS+e+giFk8xgmxj70pVXzEADo3GG0rEhdlQAAAAAAAAAAAAAAAAAAAAB6i5yxQAAAEAouZRZwuPF5j68byMRcw2mtToS6nFsxGJcZjO4oGm2dWVsVS1MGqFhr+JvIJlMRUKKdPxtZAoO9kjSbpUspUcC

func RemoveTrustlineOp 

func RemoveTrustlineOp(issuedAsset Asset) ChangeTrust

RemoveTrustlineOp returns a ChangeTrust operation to remove the trustline of the described asset, by setting the limit to "0".

func (*ChangeTrust) BuildXDR 

func (ct *ChangeTrust) BuildXDR() (xdr.Operation, error)

BuildXDR for ChangeTrust returns a fully configured XDR Operation.

func (*ChangeTrust) FromXDR 

func (ct *ChangeTrust) FromXDR(xdrOp xdr.Operation) error

FromXDR for ChangeTrust initialises the txnbuild struct from the corresponding xdr Operation.

func (*ChangeTrust) GetSourceAccount 

func (ct *ChangeTrust) GetSourceAccount() Account

GetSourceAccount returns the source account of the operation, or nil if not set.

func (*ChangeTrust) Validate 

func (ct *ChangeTrust) Validate() error

Validate for ChangeTrust validates the required struct fields. It returns an error if any of the fields are invalid. Otherwise, it returns nil.

type CreateAccount 

type CreateAccount struct {
	Destination   string
	Amount        string
	SourceAccount Account
}

CreateAccount represents the Paydex create account operation. See https://www.paydex.org/developers/guides/concepts/list-of-operations.html

Example 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

op := CreateAccount{
	Destination: "GCCOBXW2XQNUSL467IEILE6MMCNRR66SSVL4YQADUNYYNUVREF3FIV2Z",
	Amount:      "10",
}

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAITg3tq8G0kvnvoIhZPMYJsY+9KVV8xAA6NxhtKxIXZUAAAAAAX14QAAAAAAAAAAAeoucsUAAABAqyuXG3pGL9a4MZwrX5OTWF1gd094rsowh2zXSZzDPDoGlAVljE/yjo7p6MkUY7TpMAa3Y+iXC5ael6JVD0pyDQ==

func (*CreateAccount) BuildXDR 

func (ca *CreateAccount) BuildXDR() (xdr.Operation, error)

BuildXDR for CreateAccount returns a fully configured XDR Operation.

func (*CreateAccount) FromXDR 

func (ca *CreateAccount) FromXDR(xdrOp xdr.Operation) error

FromXDR for CreateAccount initialises the txnbuild struct from the corresponding xdr Operation.

func (*CreateAccount) GetSourceAccount 

func (ca *CreateAccount) GetSourceAccount() Account

GetSourceAccount returns the source account of the operation, or nil if not set.

func (*CreateAccount) Validate 

func (ca *CreateAccount) Validate() error

Validate for CreateAccount validates the required struct fields. It returns an error if any of the fields are invalid. Otherwise, it returns nil.

type CreatePassiveSellOffer 

type CreatePassiveSellOffer struct {
	Selling       Asset
	Buying        Asset
	Amount        string
	Price         string
	SourceAccount Account
}

CreatePassiveSellOffer represents the Paydex create passive offer operation. See https://www.paydex.org/developers/guides/concepts/list-of-operations.html

Example 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

op := CreatePassiveSellOffer{
	Selling: NativeAsset{},
	Buying:  CreditAsset{"ABCD", "GAS4V4O2B7DW5T7IQRPEEVCRXMDZESKISR7DVIGKZQYYV3OSQ5SH5LVP"},
	Amount:  "10",
	Price:   "1.0",
}

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAEAAAAAAAAAAFBQkNEAAAAACXK8doPx27P6IReQlRRuweSSUiUfjqgyswxiu3Sh2R+AAAAAAX14QAAAAABAAAAAQAAAAAAAAAB6i5yxQAAAEAThdst0NXPUzAL0GzzieSoryHIeF5VtjOc1KIA/SGI/xq69woAydjPccm/MzwfSr8rkw++AFp6Edn+1C1o9IYG

func (*CreatePassiveSellOffer) BuildXDR 

func (cpo *CreatePassiveSellOffer) BuildXDR() (xdr.Operation, error)

BuildXDR for CreatePassiveSellOffer returns a fully configured XDR Operation.

func (*CreatePassiveSellOffer) FromXDR 

func (cpo *CreatePassiveSellOffer) FromXDR(xdrOp xdr.Operation) error

FromXDR for CreatePassiveSellOffer initialises the txnbuild struct from the corresponding xdr Operation.

func (*CreatePassiveSellOffer) GetSourceAccount 

func (cpo *CreatePassiveSellOffer) GetSourceAccount() Account

GetSourceAccount returns the source account of the operation, or nil if not set.

func (*CreatePassiveSellOffer) Validate 

func (cpo *CreatePassiveSellOffer) Validate() error

Validate for CreatePassiveSellOffer validates the required struct fields. It returns an error if any of the fields are invalid. Otherwise, it returns nil.

type CreditAsset 

type CreditAsset struct {
	Code   string
	Issuer string
}

CreditAsset represents non-XLM assets on the Paydex network.

func (CreditAsset) GetCode 

func (ca CreditAsset) GetCode() string

GetCode for CreditAsset returns the asset code.

func (CreditAsset) GetIssuer 

func (ca CreditAsset) GetIssuer() string

GetIssuer for CreditAsset returns the address of the issuing account.

func (CreditAsset) GetType 

func (ca CreditAsset) GetType() (AssetType, error)

GetType for CreditAsset returns the enum type of the asset, based on its code length.

func (CreditAsset) IsNative 

func (ca CreditAsset) IsNative() bool

IsNative for CreditAsset returns false (this is not an XLM asset).

func (CreditAsset) ToXDR 

func (ca CreditAsset) ToXDR() (xdr.Asset, error)

ToXDR for CreditAsset produces a corresponding XDR asset.

type Inflation 

type Inflation struct {
	SourceAccount Account
}

Inflation represents the Paydex inflation operation. See https://www.paydex.org/developers/guides/concepts/list-of-operations.html

Example 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

op := Inflation{}

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAJAAAAAAAAAAHqLnLFAAAAQP3NHWXvzKIHB3+jjhHITdc/tBPntWYj3SoTjpON+dxjKqU5ohFamSHeqi5ONXkhE9Uajr5sVZXjQfUcTTzsWAA=

func (*Inflation) BuildXDR 

func (inf *Inflation) BuildXDR() (xdr.Operation, error)

BuildXDR for Inflation returns a fully configured XDR Operation.

func (*Inflation) FromXDR 

func (inf *Inflation) FromXDR(xdrOp xdr.Operation) error

FromXDR for Inflation initialises the txnbuild struct from the corresponding xdr Operation.

func (*Inflation) GetSourceAccount 

func (inf *Inflation) GetSourceAccount() Account

GetSourceAccount returns the source account of the operation, or nil if not set.

func (*Inflation) Validate 

func (inf *Inflation) Validate() error

Validate for Inflation is just a method that implements the Operation interface. No logic is actually performed because the inflation operation does not have any required field. Nil is always returned.

type ManageBuyOffer 

type ManageBuyOffer struct {
	Selling       Asset
	Buying        Asset
	Amount        string
	Price         string
	OfferID       int64
	SourceAccount Account
}

ManageBuyOffer represents the Paydex manage buy offer operation. See https://www.paydex.org/developers/guides/concepts/list-of-operations.html

Example 
kp, _ := keypair.Parse("SBZVMB74Z76QZ3ZOY7UTDFYKMEGKW5XFJEB6PFKBF4UYSSWHG4EDH7PY")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

buyOffer := ManageBuyOffer{
	Selling: NativeAsset{},
	Buying:  CreditAsset{"ABCD", "GDQNY3PBOJOKYZSRMK2S7LHHGWZIUISD4QORETLMXEWXBI7KFZZMKTL3"},
	Amount:  "100",
	Price:   "0.01",
	OfferID: 0,
}

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&buyOffer},
	Timebounds:    NewInfiniteTimeout(),
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAH4RyzTWNfXhqwLUoCw91aWkZtgIzY8SAVkIPc0uFVmYAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAMAAAAAAAAAAFBQkNEAAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAADuaygAAAAABAAAAZAAAAAAAAAAAAAAAAAAAAAEuFVmYAAAAQPh8h1TrzDpcgzB/VE8V0X2pFGV8/JyuYrx0I5bRfBJuLJr0l8yL1isP1wZjvMdX7fNiktwSLuUuj749nWA6wAo=

func (*ManageBuyOffer) BuildXDR 

func (mo *ManageBuyOffer) BuildXDR() (xdr.Operation, error)

BuildXDR for ManageBuyOffer returns a fully configured XDR Operation.

func (*ManageBuyOffer) FromXDR 

func (mo *ManageBuyOffer) FromXDR(xdrOp xdr.Operation) error

FromXDR for ManageBuyOffer initialises the txnbuild struct from the corresponding xdr Operation.

func (*ManageBuyOffer) GetSourceAccount 

func (mo *ManageBuyOffer) GetSourceAccount() Account

GetSourceAccount returns the source account of the operation, or nil if not set.

func (*ManageBuyOffer) Validate 

func (mo *ManageBuyOffer) Validate() error

Validate for ManageBuyOffer validates the required struct fields. It returns an error if any of the fields are invalid. Otherwise, it returns nil.

type ManageData 

type ManageData struct {
	Name          string
	Value         []byte
	SourceAccount Account
}

ManageData represents the Paydex manage data operation. See https://www.paydex.org/developers/guides/concepts/list-of-operations.html

Example 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

op := ManageData{
	Name:  "Fruit preference",
	Value: []byte("Apple"),
}

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAKAAAAEEZydWl0IHByZWZlcmVuY2UAAAABAAAABUFwcGxlAAAAAAAAAAAAAAHqLnLFAAAAQO1ELJBEoqBDyIsS7uSJwe1LOimV/E+09MyF1G/+yrxSggFVPEjD5LXcm/6POze3IsMuIYJU1et5Q2Vt9f73zQo=
Example (RemoveDataEntry) 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

op := ManageData{
	Name: "Fruit preference",
}

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAKAAAAEEZydWl0IHByZWZlcmVuY2UAAAAAAAAAAAAAAAHqLnLFAAAAQMWkjW+mHMbwOfLhpUMDu3I6U/nv132RY7RT++arqlZOs2hx3r7FOJTvndbnSSwSxwDp/VY3BSxB/4MLCZl+ogA=

func (*ManageData) BuildXDR 

func (md *ManageData) BuildXDR() (xdr.Operation, error)

BuildXDR for ManageData returns a fully configured XDR Operation.

func (*ManageData) FromXDR 

func (md *ManageData) FromXDR(xdrOp xdr.Operation) error

FromXDR for ManageData initialises the txnbuild struct from the corresponding xdr Operation.

func (*ManageData) GetSourceAccount 

func (md *ManageData) GetSourceAccount() Account

GetSourceAccount returns the source account of the operation, or nil if not set.

func (*ManageData) Validate 

func (md *ManageData) Validate() error

Validate for ManageData validates the required struct fields. It returns an error if any of the fields are invalid. Otherwise, it returns nil.

type ManageSellOffer 

type ManageSellOffer struct {
	Selling       Asset
	Buying        Asset
	Amount        string
	Price         string
	OfferID       int64
	SourceAccount Account
}

ManageSellOffer represents the Paydex manage offer operation. See https://www.paydex.org/developers/guides/concepts/list-of-operations.html

Example 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

selling := NativeAsset{}
buying := CreditAsset{"ABCD", "GAS4V4O2B7DW5T7IQRPEEVCRXMDZESKISR7DVIGKZQYYV3OSQ5SH5LVP"}
sellAmount := "100"
price := "0.01"
op, err := CreateOfferOp(selling, buying, sellAmount, price)
check(err)

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAFBQkNEAAAAACXK8doPx27P6IReQlRRuweSSUiUfjqgyswxiu3Sh2R+AAAAADuaygAAAAABAAAAZAAAAAAAAAAAAAAAAAAAAAHqLnLFAAAAQG1+s35VQTuILAGTT6uaDT9RrgMi0xYTLqdoZbGgMGLiSwIglJk/OS/v1DrmshoXIhwL/O7Ilychy/vcA/4dAQo=
Example (DeleteOffer) 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

offerID := int64(2921622)
op, err := DeleteOfferOp(offerID)
check(err)

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAFGQUtFAAAAAEEHgGTElYZi82AkGiJdSja2OBaU2aEcwwp3AY3tFJ2xAAAAAAAAAAAAAAABAAAAAQAAAAAALJSWAAAAAAAAAAHqLnLFAAAAQGcT6ggtq6q3qbx+PsMgE1b9cGYonfhIu8d3E/Ti9vbpojyr2L/an3+kkydY946gjDR/qOt5HfTqo8kWGMy2XgY=
Example (UpdateOffer) 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

selling := NativeAsset{}
buying := CreditAsset{"ABCD", "GAS4V4O2B7DW5T7IQRPEEVCRXMDZESKISR7DVIGKZQYYV3OSQ5SH5LVP"}
sellAmount := "50"
price := "0.02"
offerID := int64(2497628)
op, err := UpdateOfferOp(selling, buying, sellAmount, price, offerID)
check(err)

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAADAAAAAAAAAAFBQkNEAAAAACXK8doPx27P6IReQlRRuweSSUiUfjqgyswxiu3Sh2R+AAAAAB3NZQAAAAABAAAAMgAAAAAAJhxcAAAAAAAAAAHqLnLFAAAAQKY77jK6QC4tG1HghFY9W2jJnYsl5qKk+55z78zUkYOhMU9QsOXeSC6A/BXeavSO8w0CsF1HxLc1TDfWC1PlNw4=

func CreateOfferOp 

func CreateOfferOp(selling, buying Asset, amount, price string, sourceAccount ...Account) (ManageSellOffer, error)

CreateOfferOp returns a ManageSellOffer operation to create a new offer, by setting the OfferID to "0". The sourceAccount is optional, and if not provided, will be that of the surrounding transaction.

func DeleteOfferOp 

func DeleteOfferOp(offerID int64, sourceAccount ...Account) (ManageSellOffer, error)

DeleteOfferOp returns a ManageSellOffer operation to delete an offer, by setting the Amount to "0". The sourceAccount is optional, and if not provided, will be that of the surrounding transaction.

func UpdateOfferOp 

func UpdateOfferOp(selling, buying Asset, amount, price string, offerID int64, sourceAccount ...Account) (ManageSellOffer, error)

UpdateOfferOp returns a ManageSellOffer operation to update an offer. The sourceAccount is optional, and if not provided, will be that of the surrounding transaction.

func (*ManageSellOffer) BuildXDR 

func (mo *ManageSellOffer) BuildXDR() (xdr.Operation, error)

BuildXDR for ManageSellOffer returns a fully configured XDR Operation.

func (*ManageSellOffer) FromXDR 

func (mo *ManageSellOffer) FromXDR(xdrOp xdr.Operation) error

FromXDR for ManageSellOffer initialises the txnbuild struct from the corresponding xdr Operation.

func (*ManageSellOffer) GetSourceAccount 

func (mo *ManageSellOffer) GetSourceAccount() Account

GetSourceAccount returns the source account of the operation, or nil if not set.

func (*ManageSellOffer) Validate 

func (mo *ManageSellOffer) Validate() error

Validate for ManageSellOffer validates the required struct fields. It returns an error if any of the fields are invalid. Otherwise, it returns nil.

type Memo 

type Memo interface {
	ToXDR() (xdr.Memo, error)
}

Memo represents the superset of all memo types.

type MemoHash 

type MemoHash [32]byte

MemoHash is a hash representing a reference to another transaction.

func (MemoHash) ToXDR 

func (mh MemoHash) ToXDR() (xdr.Memo, error)

ToXDR for MemoHash returns an XDR object representation of a Memo of the same type.

type MemoID 

type MemoID uint64

MemoID is an identifier representing the transaction originator.

func (MemoID) ToXDR 

func (mid MemoID) ToXDR() (xdr.Memo, error)

ToXDR for MemoID returns an XDR object representation of a Memo of the same type.

type MemoReturn 

type MemoReturn [32]byte

MemoReturn is a hash representing the hash of the transaction the sender is refunding.

func (MemoReturn) ToXDR 

func (mr MemoReturn) ToXDR() (xdr.Memo, error)

ToXDR for MemoReturn returns an XDR object representation of a Memo of the same type.

type MemoText 

type MemoText string

MemoText is used to send human messages of up to 28 bytes of ASCII/UTF-8.

func (MemoText) ToXDR 

func (mt MemoText) ToXDR() (xdr.Memo, error)

ToXDR for MemoText returns an XDR object representation of a Memo of the same type.

type NativeAsset 

type NativeAsset struct{}

NativeAsset represents the native XLM asset.

func (NativeAsset) GetCode 

func (na NativeAsset) GetCode() string

GetCode for NativeAsset returns an empty string (XLM doesn't have a code).

func (NativeAsset) GetIssuer 

func (na NativeAsset) GetIssuer() string

GetIssuer for NativeAsset returns an empty string (XLM doesn't have an issuer).

func (NativeAsset) GetType 

func (na NativeAsset) GetType() (AssetType, error)

GetType for NativeAsset returns the enum type of the asset.

func (NativeAsset) IsNative 

func (na NativeAsset) IsNative() bool

IsNative for NativeAsset returns true (this is an XLM asset).

func (NativeAsset) ToXDR 

func (na NativeAsset) ToXDR() (xdr.Asset, error)

ToXDR for NativeAsset produces a corresponding XDR asset.

type Operation 

type Operation interface {
	BuildXDR() (xdr.Operation, error)
	FromXDR(xdrOp xdr.Operation) error
	Validate() error
	GetSourceAccount() Account
}

Operation represents the operation types of the Paydex network.

type PathPayment 

type PathPayment = PathPaymentStrictReceive

PathPayment represents the Paydex path_payment operation. This operation was removed in Paydex Protocol 12 and replaced by PathPaymentStrictReceive. Deprecated: This operation was renamed to PathPaymentStrictReceive, which functions identically.

Example 
kp, _ := keypair.Parse("SBZVMB74Z76QZ3ZOY7UTDFYKMEGKW5XFJEB6PFKBF4UYSSWHG4EDH7PY")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

abcdAsset := CreditAsset{"ABCD", "GDQNY3PBOJOKYZSRMK2S7LHHGWZIUISD4QORETLMXEWXBI7KFZZMKTL3"}
op := PathPayment{
	SendAsset:   NativeAsset{},
	SendMax:     "10",
	Destination: kp.Address(),
	DestAsset:   NativeAsset{},
	DestAmount:  "1",
	Path:        []Asset{abcdAsset},
}

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAH4RyzTWNfXhqwLUoCw91aWkZtgIzY8SAVkIPc0uFVmYAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAF9eEAAAAAAH4RyzTWNfXhqwLUoCw91aWkZtgIzY8SAVkIPc0uFVmYAAAAAAAAAAAAmJaAAAAAAQAAAAFBQkNEAAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAAAAAAAEuFVmYAAAAQOGE+w2bvIp8JQIPIFXWk5kO77cNUOlPZwlItA5V68/qmZTbJWq8wqdZtjELkZtNcQQX4x8EToShbn5nitG3RA4=

type PathPaymentStrictReceive 

type PathPaymentStrictReceive struct {
	SendAsset     Asset
	SendMax       string
	Destination   string
	DestAsset     Asset
	DestAmount    string
	Path          []Asset
	SourceAccount Account
}

PathPaymentStrictReceive represents the Paydex path_payment_strict_receive operation. See https://www.paydex.org/developers/guides/concepts/list-of-operations.html

Example 
kp, _ := keypair.Parse("SBZVMB74Z76QZ3ZOY7UTDFYKMEGKW5XFJEB6PFKBF4UYSSWHG4EDH7PY")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

abcdAsset := CreditAsset{"ABCD", "GDQNY3PBOJOKYZSRMK2S7LHHGWZIUISD4QORETLMXEWXBI7KFZZMKTL3"}
op := PathPaymentStrictReceive{
	SendAsset:   NativeAsset{},
	SendMax:     "10",
	Destination: kp.Address(),
	DestAsset:   NativeAsset{},
	DestAmount:  "1",
	Path:        []Asset{abcdAsset},
}

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAH4RyzTWNfXhqwLUoCw91aWkZtgIzY8SAVkIPc0uFVmYAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAACAAAAAAAAAAAF9eEAAAAAAH4RyzTWNfXhqwLUoCw91aWkZtgIzY8SAVkIPc0uFVmYAAAAAAAAAAAAmJaAAAAAAQAAAAFBQkNEAAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAAAAAAAEuFVmYAAAAQOGE+w2bvIp8JQIPIFXWk5kO77cNUOlPZwlItA5V68/qmZTbJWq8wqdZtjELkZtNcQQX4x8EToShbn5nitG3RA4=

func (*PathPaymentStrictReceive) BuildXDR 

func (pp *PathPaymentStrictReceive) BuildXDR() (xdr.Operation, error)

BuildXDR for PathPaymentStrictReceive returns a fully configured XDR Operation.

func (*PathPaymentStrictReceive) FromXDR 

func (pp *PathPaymentStrictReceive) FromXDR(xdrOp xdr.Operation) error

FromXDR for PathPaymentStrictReceive initialises the txnbuild struct from the corresponding xdr Operation.

func (*PathPaymentStrictReceive) GetSourceAccount 

func (pp *PathPaymentStrictReceive) GetSourceAccount() Account

GetSourceAccount returns the source account of the operation, or nil if not set.

func (*PathPaymentStrictReceive) Validate 

func (pp *PathPaymentStrictReceive) Validate() error

Validate for PathPaymentStrictReceive validates the required struct fields. It returns an error if any of the fields are invalid. Otherwise, it returns nil.

type PathPaymentStrictSend 

type PathPaymentStrictSend struct {
	SendAsset     Asset
	SendAmount    string
	Destination   string
	DestAsset     Asset
	DestMin       string
	Path          []Asset
	SourceAccount Account
}

PathPaymentStrictSend represents the Paydex path_payment_strict_send operation. See https://www.paydex.org/developers/guides/concepts/list-of-operations.html

Example 
kp, _ := keypair.Parse("SBZVMB74Z76QZ3ZOY7UTDFYKMEGKW5XFJEB6PFKBF4UYSSWHG4EDH7PY")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

abcdAsset := CreditAsset{"ABCD", "GDQNY3PBOJOKYZSRMK2S7LHHGWZIUISD4QORETLMXEWXBI7KFZZMKTL3"}
op := PathPaymentStrictSend{
	SendAsset:   NativeAsset{},
	SendAmount:  "1",
	Destination: kp.Address(),
	DestAsset:   NativeAsset{},
	DestMin:     "10",
	Path:        []Asset{abcdAsset},
}

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAH4RyzTWNfXhqwLUoCw91aWkZtgIzY8SAVkIPc0uFVmYAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAANAAAAAAAAAAAAmJaAAAAAAH4RyzTWNfXhqwLUoCw91aWkZtgIzY8SAVkIPc0uFVmYAAAAAAAAAAAF9eEAAAAAAQAAAAFBQkNEAAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAAAAAAAEuFVmYAAAAQNXoKZHgBO+2baoHMcT1SqpL3lmcggeCm5TuFNk7fwMeF/6h5lDTYMa+y3i9gwwAg8aQwCwuV8A38AWKfPvgMAM=

func (*PathPaymentStrictSend) BuildXDR 

func (pp *PathPaymentStrictSend) BuildXDR() (xdr.Operation, error)

BuildXDR for Payment returns a fully configured XDR Operation.

func (*PathPaymentStrictSend) FromXDR 

func (pp *PathPaymentStrictSend) FromXDR(xdrOp xdr.Operation) error

FromXDR for PathPaymentStrictSend initialises the txnbuild struct from the corresponding xdr Operation.

func (*PathPaymentStrictSend) GetSourceAccount 

func (pp *PathPaymentStrictSend) GetSourceAccount() Account

GetSourceAccount returns the source account of the operation, or nil if not set.

func (*PathPaymentStrictSend) Validate 

func (pp *PathPaymentStrictSend) Validate() error

Validate for PathPaymentStrictSend validates the required struct fields. It returns an error if any of the fields are invalid. Otherwise, it returns nil.

type Payment 

type Payment struct {
	Destination   string
	Amount        string
	Asset         Asset
	SourceAccount Account
}

Payment represents the Paydex payment operation. See https://www.paydex.org/developers/guides/concepts/list-of-operations.html

Example 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

op := Payment{
	Destination: "GCCOBXW2XQNUSL467IEILE6MMCNRR66SSVL4YQADUNYYNUVREF3FIV2Z",
	Amount:      "10",
	Asset:       NativeAsset{},
}

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAITg3tq8G0kvnvoIhZPMYJsY+9KVV8xAA6NxhtKxIXZUAAAAAAAAAAAF9eEAAAAAAAAAAAHqLnLFAAAAQHb8LTro4QVpzcGzOToW28p340o54KX5/xxodABM+izweQlbVKb9bISRUOu+sNfi50weXeAeGVL+oTQS5YR4lgI=
Example (SetBaseFee) 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

op1 := Payment{
	Destination: "GCCOBXW2XQNUSL467IEILE6MMCNRR66SSVL4YQADUNYYNUVREF3FIV2Z",
	Amount:      "10",
	Asset:       NativeAsset{},
}

op2 := Payment{
	Destination: "GCCOBXW2XQNUSL467IEILE6MMCNRR66SSVL4YQADUNYYNUVREF3FIV2Z",
	Amount:      "100",
	Asset:       NativeAsset{},
}

// get fees from network
feeStats, err := client.FeeStats()
check(err)

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op1, &op2},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
	BaseFee:       uint32(feeStats.P50AcceptedFee),
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAEsAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAABAAAAAITg3tq8G0kvnvoIhZPMYJsY+9KVV8xAA6NxhtKxIXZUAAAAAAAAAAAF9eEAAAAAAAAAAAEAAAAAhODe2rwbSS+e+giFk8xgmxj70pVXzEADo3GG0rEhdlQAAAAAAAAAADuaygAAAAAAAAAAAeoucsUAAABAyY5c/6T3cQ1i27t681O7aHrdSQ2tCcXpyLj06HVe59DeuHNLgN3X7oBeqBZrgVty+VNVGPEK6uR+UjhGi/bGBA==

func (*Payment) BuildXDR 

func (p *Payment) BuildXDR() (xdr.Operation, error)

BuildXDR for Payment returns a fully configured XDR Operation.

func (*Payment) FromXDR 

func (p *Payment) FromXDR(xdrOp xdr.Operation) error

FromXDR for Payment initialises the txnbuild struct from the corresponding xdr Operation.

func (*Payment) GetSourceAccount 

func (p *Payment) GetSourceAccount() Account

GetSourceAccount returns the source account of the operation, or nil if not set.

func (*Payment) Validate 

func (p *Payment) Validate() error

Validate for Payment validates the required struct fields. It returns an error if any of the fields are invalid. Otherwise, it returns nil.

type SetOptions 

type SetOptions struct {
	InflationDestination *string
	SetFlags             []AccountFlag
	ClearFlags           []AccountFlag
	MasterWeight         *Threshold
	LowThreshold         *Threshold
	MediumThreshold      *Threshold
	HighThreshold        *Threshold
	HomeDomain           *string
	Signer               *Signer

	SourceAccount Account
	// contains filtered or unexported fields
}

SetOptions represents the Paydex set options operation. See https://www.paydex.org/developers/guides/concepts/list-of-operations.html

Example 
kp, _ := keypair.Parse("SBPQUZ6G4FZNWFHKUWC5BEYWF6R52E3SEP7R3GWYSM2XTKGF5LNTWW4R")
client := horizonclient.DefaultTestNetClient
ar := horizonclient.AccountRequest{AccountID: kp.Address()}
sourceAccount, err := client.AccountDetail(ar)
check(err)

op := SetOptions{
	InflationDestination: NewInflationDestination("GCCOBXW2XQNUSL467IEILE6MMCNRR66SSVL4YQADUNYYNUVREF3FIV2Z"),
	ClearFlags:           []AccountFlag{AuthRevocable},
	SetFlags:             []AccountFlag{AuthRequired, AuthImmutable},
	MasterWeight:         NewThreshold(10),
	LowThreshold:         NewThreshold(1),
	MediumThreshold:      NewThreshold(2),
	HighThreshold:        NewThreshold(2),
	HomeDomain:           NewHomeDomain("LovelyLumensLookLuminous.com"),
	Signer:               &Signer{Address: "GCCOBXW2XQNUSL467IEILE6MMCNRR66SSVL4YQADUNYYNUVREF3FIV2Z", Weight: Threshold(4)},
}

tx := Transaction{
	SourceAccount: &sourceAccount,
	Operations:    []Operation{&op},
	Timebounds:    NewInfiniteTimeout(), // Use a real timeout in production!
	Network:       network.TestNetworkPassphrase,
}

txe, err := tx.BuildSignEncode(kp.(*keypair.Full))
check(err)
fmt.Println(txe)

Output:

AAAAAODcbeFyXKxmUWK1L6znNbKKIkPkHRJNbLktcKPqLnLFAAAAZAAMoj8AAAAEAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAFAAAAAQAAAACE4N7avBtJL576CIWTzGCbGPvSlVfMQAOjcYbSsSF2VAAAAAEAAAACAAAAAQAAAAUAAAABAAAACgAAAAEAAAABAAAAAQAAAAIAAAABAAAAAgAAAAEAAAAcTG92ZWx5THVtZW5zTG9va0x1bWlub3VzLmNvbQAAAAEAAAAAhODe2rwbSS+e+giFk8xgmxj70pVXzEADo3GG0rEhdlQAAAAEAAAAAAAAAAHqLnLFAAAAQHGdxG4uiB41Dywb1OiNQwHpCYoNZiaEXTRbPjdRf3SkBCdI1wkBDG6vREDsWfouMks5urKNx0hzg/YMLTa7TwY=

func (*SetOptions) BuildXDR 

func (so *SetOptions) BuildXDR() (xdr.Operation, error)

BuildXDR for SetOptions returns a fully configured XDR Operation.

func (*SetOptions) FromXDR 

func (so *SetOptions) FromXDR(xdrOp xdr.Operation) error

FromXDR for SetOptions initialises the txnbuild struct from the corresponding xdr Operation.

func (*SetOptions) GetSourceAccount 

func (so *SetOptions) GetSourceAccount() Account

GetSourceAccount returns the source account of the operation, or nil if not set.

func (*SetOptions) Validate 

func (so *SetOptions) Validate() error

Validate for SetOptions validates the required struct fields. It returns an error if any of the fields are invalid. Otherwise, it returns nil.

type Signer 

type Signer struct {
	Address string
	Weight  Threshold
}

Signer represents the Signer in a SetOptions operation. If the signer already exists, it is updated. If the weight is 0, the signer is deleted.

type SimpleAccount 

type SimpleAccount struct {
	AccountID string
	Sequence  int64
}

SimpleAccount is a minimal implementation of an Account.

func NewSimpleAccount 

func NewSimpleAccount(accountID string, sequence int64) SimpleAccount

NewSimpleAccount is a factory method that creates a SimpleAccount from "accountID" and "sequence".

func (*SimpleAccount) GetAccountID 

func (sa *SimpleAccount) GetAccountID() string

GetAccountID returns the Account ID.

func (*SimpleAccount) GetSequenceNumber 

func (sa *SimpleAccount) GetSequenceNumber() (xdr.SequenceNumber, error)

GetSequenceNumber returns the sequence number of the account.

func (*SimpleAccount) IncrementSequenceNumber 

func (sa *SimpleAccount) IncrementSequenceNumber() (xdr.SequenceNumber, error)

IncrementSequenceNumber increments the internal record of the account's sequence number by 1.

type Threshold 

type Threshold uint8

Threshold is the datatype for MasterWeight, Signer.Weight, and Thresholds. Each is a number between 0-255 inclusive.

func NewThreshold 

func NewThreshold(t Threshold) *Threshold

NewThreshold is syntactic sugar that makes instantiating SetOptions more convenient.

type Timebounds 

type Timebounds struct {
	MinTime int64
	MaxTime int64
	// contains filtered or unexported fields
}

Timebounds represents the time window during which a Paydex transaction is considered valid.

MinTime and MaxTime represent Paydex timebounds - a window of time over which the Transaction will be considered valid. In general, almost all Transactions benefit from setting an upper timebound, because once submitted, the status of a pending Transaction may remain unresolved for a long time if the network is congested. With an upper timebound, the submitter has a guaranteed time at which the Transaction is known to have either succeeded or failed, and can then take appropriate action (e.g. to resubmit or mark as resolved).

Create a Timebounds struct using one of NewTimebounds(), NewTimeout(), or NewInfiniteTimeout().

func NewInfiniteTimeout 

func NewInfiniteTimeout() Timebounds

NewInfiniteTimeout is a factory method that sets the MaxTime to a value representing an indefinite upper time bound. This is rarely needed, but is helpful for certain smart contracts, and for deterministic testing. A Transaction cannot be built unless a Timebounds object is provided through a factory method.

func NewTimebounds 

func NewTimebounds(minTime, maxTime int64) Timebounds

NewTimebounds is a factory method that constructs a Timebounds object from a min and max time. A Transaction cannot be built unless a Timebounds object is provided through a factory method.

func NewTimeout 

func NewTimeout(timeout int64) Timebounds

NewTimeout is a factory method that sets the MaxTime to be the duration in seconds in the future specified by 'timeout'. A Transaction cannot be built unless a Timebounds object is provided through a factory method. This method uses the provided system time - make sure it is accurate.

func (*Timebounds) Validate 

func (tb *Timebounds) Validate() error

Validate for Timebounds sanity-checks the configured Timebound limits, and confirms the object was built using a factory method. This is done to ensure that default Timebound structs (which have no limits) are not valid - you must explicitly specifiy the Timebound you require.

type Transaction 

type Transaction struct {
	SourceAccount Account
	Operations    []Operation
	BaseFee       uint32
	Memo          Memo
	Timebounds    Timebounds
	Network       string
	// contains filtered or unexported fields
}

Transaction represents a Paydex transaction. See https://www.paydex.org/developers/guides/concepts/transactions.html

func TransactionFromXDR 

func TransactionFromXDR(txeB64 string) (Transaction, error)

TransactionFromXDR parses the supplied transaction envelope in base64 XDR and returns a Transaction object.

func (*Transaction) Base64 

func (tx *Transaction) Base64() (string, error)

Base64 returns the base 64 XDR representation of the transaction envelope.

func (*Transaction) Build 

func (tx *Transaction) Build() error

Build for Transaction completely configures the Transaction. After calling Build, the Transaction is ready to be serialised or signed.

func (*Transaction) BuildSignEncode 

func (tx *Transaction) BuildSignEncode(keypairs ...*keypair.Full) (string, error)

BuildSignEncode performs all the steps to produce a final transaction suitable for submitting to the network.

func (*Transaction) Hash 

func (tx *Transaction) Hash() ([32]byte, error)

Hash provides a signable object representing the Transaction on the specified network.

func (*Transaction) HashHex 

func (tx *Transaction) HashHex() (string, error)

HashHex returns the hex-encoded hash of the transaction.

func (*Transaction) MarshalBinary 

func (tx *Transaction) MarshalBinary() ([]byte, error)

MarshalBinary returns the binary XDR representation of the transaction envelope.

func (*Transaction) SetDefaultFee 

func (tx *Transaction) SetDefaultFee()

SetDefaultFee sets a sensible minimum default for the Transaction fee, if one has not already been set. It is a linear function of the number of Operations in the Transaction. Deprecated: This will be removed in v2.0.0 and setting `Transaction.BaseFee` will be mandatory. Action needed in release: horizonclient-v2.0.0

func (*Transaction) Sign 

func (tx *Transaction) Sign(kps ...*keypair.Full) error

Sign for Transaction signs a previously built transaction. A signed transaction may be submitted to the network.

func (*Transaction) SignHashX 

func (tx *Transaction) SignHashX(preimage []byte) error

SignHashX signs a transaction with HashX signature type. See description here: https://www.paydex.org/developers/guides/concepts/multi-sig.html#hashx.

func (*Transaction) SignWithKeyString 

func (tx *Transaction) SignWithKeyString(keys ...string) error

SignWithKeyString for Transaction signs a previously built transaction with the secret key as a string. This can be used when you don't have access to a Paydex keypair. A signed transaction may be submitted to the network.

func (*Transaction) TransactionFee 

func (tx *Transaction) TransactionFee() int

TransactionFee returns the fee to be paid for a transaction.

func (*Transaction) TxEnvelope 

func (tx *Transaction) TxEnvelope() *xdr.TransactionEnvelope

TxEnvelope returns the TransactionEnvelope XDR struct.

type ValidationError 

type ValidationError struct {
	Field   string // Field is the struct field on which the validation error occured.
	Message string // Message is the validation error message.
}

ValidationError is a custom error struct that holds validation errors of txnbuild's operation structs.

func NewValidationError 

func NewValidationError(field, message string) *ValidationError

NewValidationError creates a ValidationError struct with the provided field and message values.

func (*ValidationError) Error 

func (opError *ValidationError) Error() string

Error for ValidationError struct implements the error interface.

Source Files

View all Source files

Directories

Path Synopsis
cmd
demo
Demo is an interactive demonstration of the Go SDK using the Paydex TestNet.
 Demo is an interactive demonstration of the Go SDK using the Paydex TestNet.
demo/cmd
demo/operations
Package demo is an interactive demonstration of the Go SDK using the Paydex TestNet.
 Package demo is an interactive demonstration of the Go SDK using the Paydex TestNet.
Package examplehorizonclient provides a dummy client for use with the GoDoc examples.
 Package examplehorizonclient provides a dummy client for use with the GoDoc examples.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.