Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

xdr

package

Go to main page

Versions in this module

v0

v0.1.2

Nov 14, 2024

v0.1.1

Jan 25, 2024

Changes in this version

+ const LiquidityPoolFeeV18

+ const MaskAccountFlags

+ const MaskAccountFlagsV17

+ const MaskClaimableBalanceFlags

+ const MaskLedgerHeaderFlags

+ const MaskOfferentryFlags

+ const MaskTrustlineFlags

+ const MaskTrustlineFlagsV13

+ const MaskTrustlineFlagsV17

+ const MaxOpsPerTx

+ const MaxSigners

+ var AssetTypeToString = map[AssetType]string

+ var LiquidityPoolTypeToString = map[LiquidityPoolType]string

+ var OperationTypeToStringMap = operationTypeMap

+ var StringToAssetType = map[string]AssetType

+ var ValidAssetCode = regexp.MustCompile("^[[:alnum:]]{1,12}$")

+ func Marshal(w io.Writer, v interface{}) (int, error)

+ func MarshalBase64(v interface{}) (string, error)

+ func MarshalFramed(w io.Writer, v interface{}) error

+ func MarshalHex(v interface{}) (string, error)

+ func ReadFrameLength(d *xdr.Decoder) (uint32, error)

+ func SafeUnmarshal(data []byte, dest interface{}) error

+ func SafeUnmarshalBase64(data string, dest interface{}) error

+ func SafeUnmarshalHex(data string, dest interface{}) error

+ func Unmarshal(r io.Reader, v interface{}) (int, error)

+ type AccountEntry struct

+ AccountId AccountId

+ Balance Int64

+ Ext AccountEntryExt

+ Flags Uint32

+ HomeDomain String32

+ InflationDest *AccountId

+ NumSubEntries Uint32

+ SeqNum SequenceNumber

+ Signers []Signer

+ Thresholds Thresholds

+ func (account *AccountEntry) Liabilities() Liabilities

+ func (account *AccountEntry) MasterKeyWeight() byte

+ func (account *AccountEntry) NumSponsored() Uint32

+ func (account *AccountEntry) NumSponsoring() Uint32

+ func (account *AccountEntry) SignerSponsoringIDs() []SponsorshipDescriptor

+ func (account *AccountEntry) SignerSummary() map[string]int32

+ func (account *AccountEntry) SponsorPerSigner() map[string]AccountId

+ func (account *AccountEntry) ThresholdHigh() byte

+ func (account *AccountEntry) ThresholdLow() byte

+ func (account *AccountEntry) ThresholdMedium() byte

+ func (s *AccountEntry) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *AccountEntry) EncodeTo(e *xdr.Encoder) error

+ func (s *AccountEntry) UnmarshalBinary(inp []byte) error

+ func (s AccountEntry) MarshalBinary() ([]byte, error)

+ type AccountEntryExt struct

+ V int32

+ V1 *AccountEntryExtensionV1

+ func NewAccountEntryExt(v int32, value interface{}) (result AccountEntryExt, err error)

+ func (s *AccountEntryExt) UnmarshalBinary(inp []byte) error

+ func (s AccountEntryExt) MarshalBinary() ([]byte, error)

+ func (u *AccountEntryExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u AccountEntryExt) ArmForSwitch(sw int32) (string, bool)

+ func (u AccountEntryExt) EncodeTo(e *xdr.Encoder) error

+ func (u AccountEntryExt) GetV1() (result AccountEntryExtensionV1, ok bool)

+ func (u AccountEntryExt) MustV1() AccountEntryExtensionV1

+ func (u AccountEntryExt) SwitchFieldName() string

+ type AccountEntryExtensionV1 struct

+ Ext AccountEntryExtensionV1Ext

+ Liabilities Liabilities

+ func (s *AccountEntryExtensionV1) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *AccountEntryExtensionV1) EncodeTo(e *xdr.Encoder) error

+ func (s *AccountEntryExtensionV1) UnmarshalBinary(inp []byte) error

+ func (s AccountEntryExtensionV1) MarshalBinary() ([]byte, error)

+ type AccountEntryExtensionV1Ext struct

+ V int32

+ V2 *AccountEntryExtensionV2

+ func NewAccountEntryExtensionV1Ext(v int32, value interface{}) (result AccountEntryExtensionV1Ext, err error)

+ func (s *AccountEntryExtensionV1Ext) UnmarshalBinary(inp []byte) error

+ func (s AccountEntryExtensionV1Ext) MarshalBinary() ([]byte, error)

+ func (u *AccountEntryExtensionV1Ext) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u AccountEntryExtensionV1Ext) ArmForSwitch(sw int32) (string, bool)

+ func (u AccountEntryExtensionV1Ext) EncodeTo(e *xdr.Encoder) error

+ func (u AccountEntryExtensionV1Ext) GetV2() (result AccountEntryExtensionV2, ok bool)

+ func (u AccountEntryExtensionV1Ext) MustV2() AccountEntryExtensionV2

+ func (u AccountEntryExtensionV1Ext) SwitchFieldName() string

+ type AccountEntryExtensionV2 struct

+ Ext AccountEntryExtensionV2Ext

+ NumSponsored Uint32

+ NumSponsoring Uint32

+ SignerSponsoringIDs []SponsorshipDescriptor

+ func (s *AccountEntryExtensionV2) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *AccountEntryExtensionV2) EncodeTo(e *xdr.Encoder) error

+ func (s *AccountEntryExtensionV2) UnmarshalBinary(inp []byte) error

+ func (s AccountEntryExtensionV2) MarshalBinary() ([]byte, error)

+ type AccountEntryExtensionV2Ext struct

+ V int32

+ func NewAccountEntryExtensionV2Ext(v int32, value interface{}) (result AccountEntryExtensionV2Ext, err error)

+ func (s *AccountEntryExtensionV2Ext) UnmarshalBinary(inp []byte) error

+ func (s AccountEntryExtensionV2Ext) MarshalBinary() ([]byte, error)

+ func (u *AccountEntryExtensionV2Ext) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u AccountEntryExtensionV2Ext) ArmForSwitch(sw int32) (string, bool)

+ func (u AccountEntryExtensionV2Ext) EncodeTo(e *xdr.Encoder) error

+ func (u AccountEntryExtensionV2Ext) SwitchFieldName() string

+ type AccountFlags int32

+ const AccountFlagsAuthClawbackEnabledFlag

+ const AccountFlagsAuthImmutableFlag

+ const AccountFlagsAuthRequiredFlag

+ const AccountFlagsAuthRevocableFlag

+ func (accountFlags AccountFlags) IsAuthClawbackEnabled() bool

+ func (accountFlags AccountFlags) IsAuthImmutable() bool

+ func (accountFlags AccountFlags) IsAuthRequired() bool

+ func (accountFlags AccountFlags) IsAuthRevocable() bool

+ func (e *AccountFlags) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e AccountFlags) EncodeTo(enc *xdr.Encoder) error

+ func (e AccountFlags) String() string

+ func (e AccountFlags) ValidEnum(v int32) bool

+ func (s *AccountFlags) UnmarshalBinary(inp []byte) error

+ func (s AccountFlags) MarshalBinary() ([]byte, error)

+ func (t *AccountFlags) Scan(src interface{}) error

+ type AccountId PublicKey

+ func AddressToAccountId(address string) (AccountId, error)

+ func MustAddress(address string) AccountId

+ func MustAddressPtr(address string) *AccountId

+ func NewAccountId(aType PublicKeyType, value interface{}) (result AccountId, err error)

+ func (a AccountId) GoString() string

+ func (aid *AccountId) Equals(other AccountId) bool

+ func (aid *AccountId) GetAddress() (string, error)

+ func (aid *AccountId) LedgerKey() (ret LedgerKey)

+ func (aid *AccountId) SetAddress(address string) error

+ func (aid *AccountId) ToMuxedAccount() MuxedAccount

+ func (aid AccountId) Address() string

+ func (s *AccountId) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *AccountId) UnmarshalBinary(inp []byte) error

+ func (s AccountId) EncodeTo(e *xdr.Encoder) error

+ func (s AccountId) MarshalBinary() ([]byte, error)

+ func (u AccountId) ArmForSwitch(sw int32) (string, bool)

+ func (u AccountId) GetEd25519() (result Uint256, ok bool)

+ func (u AccountId) MustEd25519() Uint256

+ func (u AccountId) SwitchFieldName() string

+ type AccountMergeResult struct

+ Code AccountMergeResultCode

+ SourceAccountBalance *Int64

+ func NewAccountMergeResult(code AccountMergeResultCode, value interface{}) (result AccountMergeResult, err error)

+ func (s *AccountMergeResult) UnmarshalBinary(inp []byte) error

+ func (s AccountMergeResult) MarshalBinary() ([]byte, error)

+ func (u *AccountMergeResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u AccountMergeResult) ArmForSwitch(sw int32) (string, bool)

+ func (u AccountMergeResult) EncodeTo(e *xdr.Encoder) error

+ func (u AccountMergeResult) GetSourceAccountBalance() (result Int64, ok bool)

+ func (u AccountMergeResult) MustSourceAccountBalance() Int64

+ func (u AccountMergeResult) SwitchFieldName() string

+ type AccountMergeResultCode int32

+ const AccountMergeResultCodeAccountMergeDestFull

+ const AccountMergeResultCodeAccountMergeHasSubEntries

+ const AccountMergeResultCodeAccountMergeImmutableSet

+ const AccountMergeResultCodeAccountMergeIsSponsor

+ const AccountMergeResultCodeAccountMergeMalformed

+ const AccountMergeResultCodeAccountMergeNoAccount

+ const AccountMergeResultCodeAccountMergeSeqnumTooFar

+ const AccountMergeResultCodeAccountMergeSuccess

+ func (e *AccountMergeResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e AccountMergeResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e AccountMergeResultCode) String() string

+ func (e AccountMergeResultCode) ValidEnum(v int32) bool

+ func (s *AccountMergeResultCode) UnmarshalBinary(inp []byte) error

+ func (s AccountMergeResultCode) MarshalBinary() ([]byte, error)

+ type AllowTrustOp struct

+ Asset AssetCode

+ Authorize Uint32

+ Trustor AccountId

+ func (s *AllowTrustOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *AllowTrustOp) EncodeTo(e *xdr.Encoder) error

+ func (s *AllowTrustOp) UnmarshalBinary(inp []byte) error

+ func (s AllowTrustOp) MarshalBinary() ([]byte, error)

+ type AllowTrustResult struct

+ Code AllowTrustResultCode

+ func NewAllowTrustResult(code AllowTrustResultCode, value interface{}) (result AllowTrustResult, err error)

+ func (s *AllowTrustResult) UnmarshalBinary(inp []byte) error

+ func (s AllowTrustResult) MarshalBinary() ([]byte, error)

+ func (u *AllowTrustResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u AllowTrustResult) ArmForSwitch(sw int32) (string, bool)

+ func (u AllowTrustResult) EncodeTo(e *xdr.Encoder) error

+ func (u AllowTrustResult) SwitchFieldName() string

+ type AllowTrustResultCode int32

+ const AllowTrustResultCodeAllowTrustCantRevoke

+ const AllowTrustResultCodeAllowTrustLowReserve

+ const AllowTrustResultCodeAllowTrustMalformed

+ const AllowTrustResultCodeAllowTrustNoTrustLine

+ const AllowTrustResultCodeAllowTrustSelfNotAllowed

+ const AllowTrustResultCodeAllowTrustSuccess

+ const AllowTrustResultCodeAllowTrustTrustNotRequired

+ func (e *AllowTrustResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e AllowTrustResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e AllowTrustResultCode) String() string

+ func (e AllowTrustResultCode) ValidEnum(v int32) bool

+ func (s *AllowTrustResultCode) UnmarshalBinary(inp []byte) error

+ func (s AllowTrustResultCode) MarshalBinary() ([]byte, error)

+ type AlphaNum12 struct

+ AssetCode AssetCode12

+ Issuer AccountId

+ func (s *AlphaNum12) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *AlphaNum12) EncodeTo(e *xdr.Encoder) error

+ func (s *AlphaNum12) UnmarshalBinary(inp []byte) error

+ func (s AlphaNum12) MarshalBinary() ([]byte, error)

+ type AlphaNum4 struct

+ AssetCode AssetCode4

+ Issuer AccountId

+ func (s *AlphaNum4) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *AlphaNum4) EncodeTo(e *xdr.Encoder) error

+ func (s *AlphaNum4) UnmarshalBinary(inp []byte) error

+ func (s AlphaNum4) MarshalBinary() ([]byte, error)

+ type Asset struct

+ AlphaNum12 *AlphaNum12

+ AlphaNum4 *AlphaNum4

+ Type AssetType

+ func BuildAsset(assetType, issuer, code string) (Asset, error)

+ func BuildAssets(s string) ([]Asset, error)

+ func MustNewCreditAsset(code string, issuer string) Asset

+ func MustNewNativeAsset() Asset

+ func NewAsset(aType AssetType, value interface{}) (result Asset, err error)

+ func NewCreditAsset(code string, issuer string) (Asset, error)

+ func (a *Asset) GetCode() string

+ func (a *Asset) GetIssuer() string

+ func (a *Asset) LessThan(b Asset) bool

+ func (a *Asset) SetCredit(code string, issuer AccountId) error

+ func (a *Asset) SetNative() error

+ func (a *Asset) ToAssetCode(code string) (AssetCode, error)

+ func (a Asset) Equals(other Asset) bool

+ func (a Asset) Extract(typ interface{}, code interface{}, issuer interface{}) error

+ func (a Asset) GoString() string

+ func (a Asset) MustExtract(typ interface{}, code interface{}, issuer interface{})

+ func (a Asset) String() string

+ func (a Asset) StringCanonical() string

+ func (a Asset) ToChangeTrustAsset() ChangeTrustAsset

+ func (a Asset) ToTrustLineAsset() TrustLineAsset

+ func (s *Asset) UnmarshalBinary(inp []byte) error

+ func (s Asset) MarshalBinary() ([]byte, error)

+ func (t *Asset) Scan(src interface{}) error

+ func (t Asset) Value() (driver.Value, error)

+ func (u *Asset) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u Asset) ArmForSwitch(sw int32) (string, bool)

+ func (u Asset) EncodeTo(e *xdr.Encoder) error

+ func (u Asset) GetAlphaNum12() (result AlphaNum12, ok bool)

+ func (u Asset) GetAlphaNum4() (result AlphaNum4, ok bool)

+ func (u Asset) MustAlphaNum12() AlphaNum12

+ func (u Asset) MustAlphaNum4() AlphaNum4

+ func (u Asset) SwitchFieldName() string

+ type AssetCode struct

+ AssetCode12 *AssetCode12

+ AssetCode4 *AssetCode4

+ Type AssetType

+ func MustNewAssetCodeFromString(code string) AssetCode

+ func NewAssetCode(aType AssetType, value interface{}) (result AssetCode, err error)

+ func NewAssetCodeFromString(code string) (AssetCode, error)

+ func (a AssetCode) ToAsset(issuer AccountId) (asset Asset)

+ func (s *AssetCode) UnmarshalBinary(inp []byte) error

+ func (s AssetCode) GoString() string

+ func (s AssetCode) MarshalBinary() ([]byte, error)

+ func (u *AssetCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u AssetCode) ArmForSwitch(sw int32) (string, bool)

+ func (u AssetCode) EncodeTo(e *xdr.Encoder) error

+ func (u AssetCode) GetAssetCode12() (result AssetCode12, ok bool)

+ func (u AssetCode) GetAssetCode4() (result AssetCode4, ok bool)

+ func (u AssetCode) MustAssetCode12() AssetCode12

+ func (u AssetCode) MustAssetCode4() AssetCode4

+ func (u AssetCode) SwitchFieldName() string

+ type AssetCode12 [12]byte

+ func (e AssetCode12) XDRMaxSize() int

+ func (s *AssetCode12) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *AssetCode12) EncodeTo(e *xdr.Encoder) error

+ func (s *AssetCode12) UnmarshalBinary(inp []byte) error

+ func (s AssetCode12) MarshalBinary() ([]byte, error)

+ type AssetCode4 [4]byte

+ func (e AssetCode4) XDRMaxSize() int

+ func (s *AssetCode4) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *AssetCode4) EncodeTo(e *xdr.Encoder) error

+ func (s *AssetCode4) UnmarshalBinary(inp []byte) error

+ func (s AssetCode4) MarshalBinary() ([]byte, error)

+ type AssetType int32

+ const AssetTypeAssetTypeCreditAlphanum12

+ const AssetTypeAssetTypeCreditAlphanum4

+ const AssetTypeAssetTypeNative

+ const AssetTypeAssetTypePoolShare

+ func (e *AssetType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e AssetType) EncodeTo(enc *xdr.Encoder) error

+ func (e AssetType) String() string

+ func (e AssetType) ValidEnum(v int32) bool

+ func (s *AssetType) UnmarshalBinary(inp []byte) error

+ func (s AssetType) MarshalBinary() ([]byte, error)

+ func (t *AssetType) Scan(src interface{}) error

+ type Auth struct

+ Unused int32

+ func (s *Auth) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Auth) EncodeTo(e *xdr.Encoder) error

+ func (s *Auth) UnmarshalBinary(inp []byte) error

+ func (s Auth) MarshalBinary() ([]byte, error)

+ type AuthCert struct

+ Expiration Uint64

+ Pubkey Curve25519Public

+ Sig Signature

+ func (s *AuthCert) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *AuthCert) EncodeTo(e *xdr.Encoder) error

+ func (s *AuthCert) UnmarshalBinary(inp []byte) error

+ func (s AuthCert) MarshalBinary() ([]byte, error)

+ type AuthenticatedMessage struct

+ V Uint32

+ V0 *AuthenticatedMessageV0

+ func NewAuthenticatedMessage(v Uint32, value interface{}) (result AuthenticatedMessage, err error)

+ func (s *AuthenticatedMessage) UnmarshalBinary(inp []byte) error

+ func (s AuthenticatedMessage) MarshalBinary() ([]byte, error)

+ func (u *AuthenticatedMessage) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u AuthenticatedMessage) ArmForSwitch(sw int32) (string, bool)

+ func (u AuthenticatedMessage) EncodeTo(e *xdr.Encoder) error

+ func (u AuthenticatedMessage) GetV0() (result AuthenticatedMessageV0, ok bool)

+ func (u AuthenticatedMessage) MustV0() AuthenticatedMessageV0

+ func (u AuthenticatedMessage) SwitchFieldName() string

+ type AuthenticatedMessageV0 struct

+ Mac HmacSha256Mac

+ Message DiamcircleMessage

+ Sequence Uint64

+ func (s *AuthenticatedMessageV0) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *AuthenticatedMessageV0) EncodeTo(e *xdr.Encoder) error

+ func (s *AuthenticatedMessageV0) UnmarshalBinary(inp []byte) error

+ func (s AuthenticatedMessageV0) MarshalBinary() ([]byte, error)

+ type BeginSponsoringFutureReservesOp struct

+ SponsoredId AccountId

+ func (s *BeginSponsoringFutureReservesOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *BeginSponsoringFutureReservesOp) EncodeTo(e *xdr.Encoder) error

+ func (s *BeginSponsoringFutureReservesOp) UnmarshalBinary(inp []byte) error

+ func (s BeginSponsoringFutureReservesOp) MarshalBinary() ([]byte, error)

+ type BeginSponsoringFutureReservesResult struct

+ Code BeginSponsoringFutureReservesResultCode

+ func NewBeginSponsoringFutureReservesResult(code BeginSponsoringFutureReservesResultCode, value interface{}) (result BeginSponsoringFutureReservesResult, err error)

+ func (s *BeginSponsoringFutureReservesResult) UnmarshalBinary(inp []byte) error

+ func (s BeginSponsoringFutureReservesResult) MarshalBinary() ([]byte, error)

+ func (u *BeginSponsoringFutureReservesResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u BeginSponsoringFutureReservesResult) ArmForSwitch(sw int32) (string, bool)

+ func (u BeginSponsoringFutureReservesResult) EncodeTo(e *xdr.Encoder) error

+ func (u BeginSponsoringFutureReservesResult) SwitchFieldName() string

+ type BeginSponsoringFutureReservesResultCode int32

+ const BeginSponsoringFutureReservesResultCodeBeginSponsoringFutureReservesAlreadySponsored

+ const BeginSponsoringFutureReservesResultCodeBeginSponsoringFutureReservesMalformed

+ const BeginSponsoringFutureReservesResultCodeBeginSponsoringFutureReservesRecursive

+ const BeginSponsoringFutureReservesResultCodeBeginSponsoringFutureReservesSuccess

+ func (e *BeginSponsoringFutureReservesResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e BeginSponsoringFutureReservesResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e BeginSponsoringFutureReservesResultCode) String() string

+ func (e BeginSponsoringFutureReservesResultCode) ValidEnum(v int32) bool

+ func (s *BeginSponsoringFutureReservesResultCode) UnmarshalBinary(inp []byte) error

+ func (s BeginSponsoringFutureReservesResultCode) MarshalBinary() ([]byte, error)

+ type BucketEntry struct

+ DeadEntry *LedgerKey

+ LiveEntry *LedgerEntry

+ MetaEntry *BucketMetadata

+ Type BucketEntryType

+ func NewBucketEntry(aType BucketEntryType, value interface{}) (result BucketEntry, err error)

+ func (s *BucketEntry) UnmarshalBinary(inp []byte) error

+ func (s BucketEntry) MarshalBinary() ([]byte, error)

+ func (u *BucketEntry) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u BucketEntry) ArmForSwitch(sw int32) (string, bool)

+ func (u BucketEntry) EncodeTo(e *xdr.Encoder) error

+ func (u BucketEntry) GetDeadEntry() (result LedgerKey, ok bool)

+ func (u BucketEntry) GetLiveEntry() (result LedgerEntry, ok bool)

+ func (u BucketEntry) GetMetaEntry() (result BucketMetadata, ok bool)

+ func (u BucketEntry) MustDeadEntry() LedgerKey

+ func (u BucketEntry) MustLiveEntry() LedgerEntry

+ func (u BucketEntry) MustMetaEntry() BucketMetadata

+ func (u BucketEntry) SwitchFieldName() string

+ type BucketEntryType int32

+ const BucketEntryTypeDeadentry

+ const BucketEntryTypeInitentry

+ const BucketEntryTypeLiveentry

+ const BucketEntryTypeMetaentry

+ func (e *BucketEntryType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e BucketEntryType) EncodeTo(enc *xdr.Encoder) error

+ func (e BucketEntryType) String() string

+ func (e BucketEntryType) ValidEnum(v int32) bool

+ func (s *BucketEntryType) UnmarshalBinary(inp []byte) error

+ func (s BucketEntryType) MarshalBinary() ([]byte, error)

+ type BucketMetadata struct

+ Ext BucketMetadataExt

+ LedgerVersion Uint32

+ func (s *BucketMetadata) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *BucketMetadata) EncodeTo(e *xdr.Encoder) error

+ func (s *BucketMetadata) UnmarshalBinary(inp []byte) error

+ func (s BucketMetadata) MarshalBinary() ([]byte, error)

+ type BucketMetadataExt struct

+ V int32

+ func NewBucketMetadataExt(v int32, value interface{}) (result BucketMetadataExt, err error)

+ func (s *BucketMetadataExt) UnmarshalBinary(inp []byte) error

+ func (s BucketMetadataExt) MarshalBinary() ([]byte, error)

+ func (u *BucketMetadataExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u BucketMetadataExt) ArmForSwitch(sw int32) (string, bool)

+ func (u BucketMetadataExt) EncodeTo(e *xdr.Encoder) error

+ func (u BucketMetadataExt) SwitchFieldName() string

+ type BumpSequenceOp struct

+ BumpTo SequenceNumber

+ func (s *BumpSequenceOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *BumpSequenceOp) EncodeTo(e *xdr.Encoder) error

+ func (s *BumpSequenceOp) UnmarshalBinary(inp []byte) error

+ func (s BumpSequenceOp) MarshalBinary() ([]byte, error)

+ type BumpSequenceResult struct

+ Code BumpSequenceResultCode

+ func NewBumpSequenceResult(code BumpSequenceResultCode, value interface{}) (result BumpSequenceResult, err error)

+ func (s *BumpSequenceResult) UnmarshalBinary(inp []byte) error

+ func (s BumpSequenceResult) MarshalBinary() ([]byte, error)

+ func (u *BumpSequenceResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u BumpSequenceResult) ArmForSwitch(sw int32) (string, bool)

+ func (u BumpSequenceResult) EncodeTo(e *xdr.Encoder) error

+ func (u BumpSequenceResult) SwitchFieldName() string

+ type BumpSequenceResultCode int32

+ const BumpSequenceResultCodeBumpSequenceBadSeq

+ const BumpSequenceResultCodeBumpSequenceSuccess

+ func (e *BumpSequenceResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e BumpSequenceResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e BumpSequenceResultCode) String() string

+ func (e BumpSequenceResultCode) ValidEnum(v int32) bool

+ func (s *BumpSequenceResultCode) UnmarshalBinary(inp []byte) error

+ func (s BumpSequenceResultCode) MarshalBinary() ([]byte, error)

+ type BytesDecoder struct

+ func NewBytesDecoder() *BytesDecoder

+ func (d *BytesDecoder) DecodeBytes(v DecoderFrom, b []byte) (int, error)

+ type ChangeTrustAsset struct

+ AlphaNum12 *AlphaNum12

+ AlphaNum4 *AlphaNum4

+ LiquidityPool *LiquidityPoolParameters

+ Type AssetType

+ func NewChangeTrustAsset(aType AssetType, value interface{}) (result ChangeTrustAsset, err error)

+ func (s *ChangeTrustAsset) UnmarshalBinary(inp []byte) error

+ func (s ChangeTrustAsset) MarshalBinary() ([]byte, error)

+ func (tla ChangeTrustAsset) ToAsset() Asset

+ func (u *ChangeTrustAsset) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ChangeTrustAsset) ArmForSwitch(sw int32) (string, bool)

+ func (u ChangeTrustAsset) EncodeTo(e *xdr.Encoder) error

+ func (u ChangeTrustAsset) GetAlphaNum12() (result AlphaNum12, ok bool)

+ func (u ChangeTrustAsset) GetAlphaNum4() (result AlphaNum4, ok bool)

+ func (u ChangeTrustAsset) GetLiquidityPool() (result LiquidityPoolParameters, ok bool)

+ func (u ChangeTrustAsset) MustAlphaNum12() AlphaNum12

+ func (u ChangeTrustAsset) MustAlphaNum4() AlphaNum4

+ func (u ChangeTrustAsset) MustLiquidityPool() LiquidityPoolParameters

+ func (u ChangeTrustAsset) SwitchFieldName() string

+ type ChangeTrustOp struct

+ Limit Int64

+ Line ChangeTrustAsset

+ func (s *ChangeTrustOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ChangeTrustOp) EncodeTo(e *xdr.Encoder) error

+ func (s *ChangeTrustOp) UnmarshalBinary(inp []byte) error

+ func (s ChangeTrustOp) MarshalBinary() ([]byte, error)

+ type ChangeTrustResult struct

+ Code ChangeTrustResultCode

+ func NewChangeTrustResult(code ChangeTrustResultCode, value interface{}) (result ChangeTrustResult, err error)

+ func (s *ChangeTrustResult) UnmarshalBinary(inp []byte) error

+ func (s ChangeTrustResult) MarshalBinary() ([]byte, error)

+ func (u *ChangeTrustResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ChangeTrustResult) ArmForSwitch(sw int32) (string, bool)

+ func (u ChangeTrustResult) EncodeTo(e *xdr.Encoder) error

+ func (u ChangeTrustResult) SwitchFieldName() string

+ type ChangeTrustResultCode int32

+ const ChangeTrustResultCodeChangeTrustCannotDelete

+ const ChangeTrustResultCodeChangeTrustInvalidLimit

+ const ChangeTrustResultCodeChangeTrustLowReserve

+ const ChangeTrustResultCodeChangeTrustMalformed

+ const ChangeTrustResultCodeChangeTrustNoIssuer

+ const ChangeTrustResultCodeChangeTrustNotAuthMaintainLiabilities

+ const ChangeTrustResultCodeChangeTrustSelfNotAllowed

+ const ChangeTrustResultCodeChangeTrustSuccess

+ const ChangeTrustResultCodeChangeTrustTrustLineMissing

+ func (e *ChangeTrustResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ChangeTrustResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e ChangeTrustResultCode) String() string

+ func (e ChangeTrustResultCode) ValidEnum(v int32) bool

+ func (s *ChangeTrustResultCode) UnmarshalBinary(inp []byte) error

+ func (s ChangeTrustResultCode) MarshalBinary() ([]byte, error)

+ type ClaimAtom struct

+ LiquidityPool *ClaimLiquidityAtom

+ OrderBook *ClaimOfferAtom

+ Type ClaimAtomType

+ V0 *ClaimOfferAtomV0

+ func NewClaimAtom(aType ClaimAtomType, value interface{}) (result ClaimAtom, err error)

+ func (a ClaimAtom) AmountBought() Int64

+ func (a ClaimAtom) AmountSold() Int64

+ func (a ClaimAtom) AssetBought() Asset

+ func (a ClaimAtom) AssetSold() Asset

+ func (a ClaimAtom) OfferId() Int64

+ func (a ClaimAtom) SellerId() AccountId

+ func (s *ClaimAtom) UnmarshalBinary(inp []byte) error

+ func (s ClaimAtom) MarshalBinary() ([]byte, error)

+ func (u *ClaimAtom) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ClaimAtom) ArmForSwitch(sw int32) (string, bool)

+ func (u ClaimAtom) EncodeTo(e *xdr.Encoder) error

+ func (u ClaimAtom) GetLiquidityPool() (result ClaimLiquidityAtom, ok bool)

+ func (u ClaimAtom) GetOrderBook() (result ClaimOfferAtom, ok bool)

+ func (u ClaimAtom) GetV0() (result ClaimOfferAtomV0, ok bool)

+ func (u ClaimAtom) MustLiquidityPool() ClaimLiquidityAtom

+ func (u ClaimAtom) MustOrderBook() ClaimOfferAtom

+ func (u ClaimAtom) MustV0() ClaimOfferAtomV0

+ func (u ClaimAtom) SwitchFieldName() string

+ type ClaimAtomType int32

+ const ClaimAtomTypeClaimAtomTypeLiquidityPool

+ const ClaimAtomTypeClaimAtomTypeOrderBook

+ const ClaimAtomTypeClaimAtomTypeV0

+ func (e *ClaimAtomType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ClaimAtomType) EncodeTo(enc *xdr.Encoder) error

+ func (e ClaimAtomType) String() string

+ func (e ClaimAtomType) ValidEnum(v int32) bool

+ func (s *ClaimAtomType) UnmarshalBinary(inp []byte) error

+ func (s ClaimAtomType) MarshalBinary() ([]byte, error)

+ type ClaimClaimableBalanceOp struct

+ BalanceId ClaimableBalanceId

+ func (s *ClaimClaimableBalanceOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ClaimClaimableBalanceOp) EncodeTo(e *xdr.Encoder) error

+ func (s *ClaimClaimableBalanceOp) UnmarshalBinary(inp []byte) error

+ func (s ClaimClaimableBalanceOp) MarshalBinary() ([]byte, error)

+ type ClaimClaimableBalanceResult struct

+ Code ClaimClaimableBalanceResultCode

+ func NewClaimClaimableBalanceResult(code ClaimClaimableBalanceResultCode, value interface{}) (result ClaimClaimableBalanceResult, err error)

+ func (s *ClaimClaimableBalanceResult) UnmarshalBinary(inp []byte) error

+ func (s ClaimClaimableBalanceResult) MarshalBinary() ([]byte, error)

+ func (u *ClaimClaimableBalanceResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ClaimClaimableBalanceResult) ArmForSwitch(sw int32) (string, bool)

+ func (u ClaimClaimableBalanceResult) EncodeTo(e *xdr.Encoder) error

+ func (u ClaimClaimableBalanceResult) SwitchFieldName() string

+ type ClaimClaimableBalanceResultCode int32

+ const ClaimClaimableBalanceResultCodeClaimClaimableBalanceCannotClaim

+ const ClaimClaimableBalanceResultCodeClaimClaimableBalanceDoesNotExist

+ const ClaimClaimableBalanceResultCodeClaimClaimableBalanceLineFull

+ const ClaimClaimableBalanceResultCodeClaimClaimableBalanceNoTrust

+ const ClaimClaimableBalanceResultCodeClaimClaimableBalanceNotAuthorized

+ const ClaimClaimableBalanceResultCodeClaimClaimableBalanceSuccess

+ func (e *ClaimClaimableBalanceResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ClaimClaimableBalanceResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e ClaimClaimableBalanceResultCode) String() string

+ func (e ClaimClaimableBalanceResultCode) ValidEnum(v int32) bool

+ func (s *ClaimClaimableBalanceResultCode) UnmarshalBinary(inp []byte) error

+ func (s ClaimClaimableBalanceResultCode) MarshalBinary() ([]byte, error)

+ type ClaimLiquidityAtom struct

+ AmountBought Int64

+ AmountSold Int64

+ AssetBought Asset

+ AssetSold Asset

+ LiquidityPoolId PoolId

+ func (s *ClaimLiquidityAtom) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ClaimLiquidityAtom) EncodeTo(e *xdr.Encoder) error

+ func (s *ClaimLiquidityAtom) UnmarshalBinary(inp []byte) error

+ func (s ClaimLiquidityAtom) MarshalBinary() ([]byte, error)

+ type ClaimOfferAtom struct

+ AmountBought Int64

+ AmountSold Int64

+ AssetBought Asset

+ AssetSold Asset

+ OfferId Int64

+ SellerId AccountId

+ func (s *ClaimOfferAtom) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ClaimOfferAtom) EncodeTo(e *xdr.Encoder) error

+ func (s *ClaimOfferAtom) UnmarshalBinary(inp []byte) error

+ func (s ClaimOfferAtom) MarshalBinary() ([]byte, error)

+ type ClaimOfferAtomV0 struct

+ AmountBought Int64

+ AmountSold Int64

+ AssetBought Asset

+ AssetSold Asset

+ OfferId Int64

+ SellerEd25519 Uint256

+ func (s *ClaimOfferAtomV0) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ClaimOfferAtomV0) EncodeTo(e *xdr.Encoder) error

+ func (s *ClaimOfferAtomV0) UnmarshalBinary(inp []byte) error

+ func (s ClaimOfferAtomV0) MarshalBinary() ([]byte, error)

+ type ClaimPredicate struct

+ AbsBefore *Int64

+ AndPredicates *[]ClaimPredicate

+ NotPredicate **ClaimPredicate

+ OrPredicates *[]ClaimPredicate

+ RelBefore *Int64

+ Type ClaimPredicateType

+ func NewClaimPredicate(aType ClaimPredicateType, value interface{}) (result ClaimPredicate, err error)

+ func (c *ClaimPredicate) Scan(src interface{}) error

+ func (c *ClaimPredicate) UnmarshalJSON(b []byte) error

+ func (c ClaimPredicate) MarshalJSON() ([]byte, error)

+ func (c ClaimPredicate) Value() (driver.Value, error)

+ func (s *ClaimPredicate) UnmarshalBinary(inp []byte) error

+ func (s ClaimPredicate) MarshalBinary() ([]byte, error)

+ func (u *ClaimPredicate) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ClaimPredicate) ArmForSwitch(sw int32) (string, bool)

+ func (u ClaimPredicate) EncodeTo(e *xdr.Encoder) error

+ func (u ClaimPredicate) GetAbsBefore() (result Int64, ok bool)

+ func (u ClaimPredicate) GetAndPredicates() (result []ClaimPredicate, ok bool)

+ func (u ClaimPredicate) GetNotPredicate() (result *ClaimPredicate, ok bool)

+ func (u ClaimPredicate) GetOrPredicates() (result []ClaimPredicate, ok bool)

+ func (u ClaimPredicate) GetRelBefore() (result Int64, ok bool)

+ func (u ClaimPredicate) MustAbsBefore() Int64

+ func (u ClaimPredicate) MustAndPredicates() []ClaimPredicate

+ func (u ClaimPredicate) MustNotPredicate() *ClaimPredicate

+ func (u ClaimPredicate) MustOrPredicates() []ClaimPredicate

+ func (u ClaimPredicate) MustRelBefore() Int64

+ func (u ClaimPredicate) SwitchFieldName() string

+ type ClaimPredicateType int32

+ const ClaimPredicateTypeClaimPredicateAnd

+ const ClaimPredicateTypeClaimPredicateBeforeAbsoluteTime

+ const ClaimPredicateTypeClaimPredicateBeforeRelativeTime

+ const ClaimPredicateTypeClaimPredicateNot

+ const ClaimPredicateTypeClaimPredicateOr

+ const ClaimPredicateTypeClaimPredicateUnconditional

+ func (e *ClaimPredicateType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ClaimPredicateType) EncodeTo(enc *xdr.Encoder) error

+ func (e ClaimPredicateType) String() string

+ func (e ClaimPredicateType) ValidEnum(v int32) bool

+ func (s *ClaimPredicateType) UnmarshalBinary(inp []byte) error

+ func (s ClaimPredicateType) MarshalBinary() ([]byte, error)

+ type ClaimableBalanceEntry struct

+ Amount Int64

+ Asset Asset

+ BalanceId ClaimableBalanceId

+ Claimants []Claimant

+ Ext ClaimableBalanceEntryExt

+ func (entry *ClaimableBalanceEntry) Flags() ClaimableBalanceFlags

+ func (s *ClaimableBalanceEntry) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ClaimableBalanceEntry) EncodeTo(e *xdr.Encoder) error

+ func (s *ClaimableBalanceEntry) UnmarshalBinary(inp []byte) error

+ func (s ClaimableBalanceEntry) MarshalBinary() ([]byte, error)

+ type ClaimableBalanceEntryExt struct

+ V int32

+ V1 *ClaimableBalanceEntryExtensionV1

+ func NewClaimableBalanceEntryExt(v int32, value interface{}) (result ClaimableBalanceEntryExt, err error)

+ func (s *ClaimableBalanceEntryExt) UnmarshalBinary(inp []byte) error

+ func (s ClaimableBalanceEntryExt) MarshalBinary() ([]byte, error)

+ func (u *ClaimableBalanceEntryExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ClaimableBalanceEntryExt) ArmForSwitch(sw int32) (string, bool)

+ func (u ClaimableBalanceEntryExt) EncodeTo(e *xdr.Encoder) error

+ func (u ClaimableBalanceEntryExt) GetV1() (result ClaimableBalanceEntryExtensionV1, ok bool)

+ func (u ClaimableBalanceEntryExt) MustV1() ClaimableBalanceEntryExtensionV1

+ func (u ClaimableBalanceEntryExt) SwitchFieldName() string

+ type ClaimableBalanceEntryExtensionV1 struct

+ Ext ClaimableBalanceEntryExtensionV1Ext

+ Flags Uint32

+ func (s *ClaimableBalanceEntryExtensionV1) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ClaimableBalanceEntryExtensionV1) EncodeTo(e *xdr.Encoder) error

+ func (s *ClaimableBalanceEntryExtensionV1) UnmarshalBinary(inp []byte) error

+ func (s ClaimableBalanceEntryExtensionV1) MarshalBinary() ([]byte, error)

+ type ClaimableBalanceEntryExtensionV1Ext struct

+ V int32

+ func NewClaimableBalanceEntryExtensionV1Ext(v int32, value interface{}) (result ClaimableBalanceEntryExtensionV1Ext, err error)

+ func (s *ClaimableBalanceEntryExtensionV1Ext) UnmarshalBinary(inp []byte) error

+ func (s ClaimableBalanceEntryExtensionV1Ext) MarshalBinary() ([]byte, error)

+ func (u *ClaimableBalanceEntryExtensionV1Ext) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ClaimableBalanceEntryExtensionV1Ext) ArmForSwitch(sw int32) (string, bool)

+ func (u ClaimableBalanceEntryExtensionV1Ext) EncodeTo(e *xdr.Encoder) error

+ func (u ClaimableBalanceEntryExtensionV1Ext) SwitchFieldName() string

+ type ClaimableBalanceFlags int32

+ const ClaimableBalanceFlagsClaimableBalanceClawbackEnabledFlag

+ func (cbFlags ClaimableBalanceFlags) IsClawbackEnabled() bool

+ func (e *ClaimableBalanceFlags) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ClaimableBalanceFlags) EncodeTo(enc *xdr.Encoder) error

+ func (e ClaimableBalanceFlags) String() string

+ func (e ClaimableBalanceFlags) ValidEnum(v int32) bool

+ func (s *ClaimableBalanceFlags) UnmarshalBinary(inp []byte) error

+ func (s ClaimableBalanceFlags) MarshalBinary() ([]byte, error)

+ type ClaimableBalanceId struct

+ Type ClaimableBalanceIdType

+ V0 *Hash

+ func NewClaimableBalanceId(aType ClaimableBalanceIdType, value interface{}) (result ClaimableBalanceId, err error)

+ func (s *ClaimableBalanceId) UnmarshalBinary(inp []byte) error

+ func (s ClaimableBalanceId) MarshalBinary() ([]byte, error)

+ func (u *ClaimableBalanceId) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ClaimableBalanceId) ArmForSwitch(sw int32) (string, bool)

+ func (u ClaimableBalanceId) EncodeTo(e *xdr.Encoder) error

+ func (u ClaimableBalanceId) GetV0() (result Hash, ok bool)

+ func (u ClaimableBalanceId) MustV0() Hash

+ func (u ClaimableBalanceId) SwitchFieldName() string

+ type ClaimableBalanceIdType int32

+ const ClaimableBalanceIdTypeClaimableBalanceIdTypeV0

+ func (e *ClaimableBalanceIdType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ClaimableBalanceIdType) EncodeTo(enc *xdr.Encoder) error

+ func (e ClaimableBalanceIdType) String() string

+ func (e ClaimableBalanceIdType) ValidEnum(v int32) bool

+ func (s *ClaimableBalanceIdType) UnmarshalBinary(inp []byte) error

+ func (s ClaimableBalanceIdType) MarshalBinary() ([]byte, error)

+ type Claimant struct

+ Type ClaimantType

+ V0 *ClaimantV0

+ func NewClaimant(aType ClaimantType, value interface{}) (result Claimant, err error)

+ func SortClaimantsByDestination(claimants []Claimant) []Claimant

+ func (s *Claimant) UnmarshalBinary(inp []byte) error

+ func (s Claimant) MarshalBinary() ([]byte, error)

+ func (u *Claimant) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u Claimant) ArmForSwitch(sw int32) (string, bool)

+ func (u Claimant) EncodeTo(e *xdr.Encoder) error

+ func (u Claimant) GetV0() (result ClaimantV0, ok bool)

+ func (u Claimant) MustV0() ClaimantV0

+ func (u Claimant) SwitchFieldName() string

+ type ClaimantType int32

+ const ClaimantTypeClaimantTypeV0

+ func (e *ClaimantType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ClaimantType) EncodeTo(enc *xdr.Encoder) error

+ func (e ClaimantType) String() string

+ func (e ClaimantType) ValidEnum(v int32) bool

+ func (s *ClaimantType) UnmarshalBinary(inp []byte) error

+ func (s ClaimantType) MarshalBinary() ([]byte, error)

+ type ClaimantV0 struct

+ Destination AccountId

+ Predicate ClaimPredicate

+ func (s *ClaimantV0) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ClaimantV0) EncodeTo(e *xdr.Encoder) error

+ func (s *ClaimantV0) UnmarshalBinary(inp []byte) error

+ func (s ClaimantV0) MarshalBinary() ([]byte, error)

+ type ClawbackClaimableBalanceOp struct

+ BalanceId ClaimableBalanceId

+ func (s *ClawbackClaimableBalanceOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ClawbackClaimableBalanceOp) EncodeTo(e *xdr.Encoder) error

+ func (s *ClawbackClaimableBalanceOp) UnmarshalBinary(inp []byte) error

+ func (s ClawbackClaimableBalanceOp) MarshalBinary() ([]byte, error)

+ type ClawbackClaimableBalanceResult struct

+ Code ClawbackClaimableBalanceResultCode

+ func NewClawbackClaimableBalanceResult(code ClawbackClaimableBalanceResultCode, value interface{}) (result ClawbackClaimableBalanceResult, err error)

+ func (s *ClawbackClaimableBalanceResult) UnmarshalBinary(inp []byte) error

+ func (s ClawbackClaimableBalanceResult) MarshalBinary() ([]byte, error)

+ func (u *ClawbackClaimableBalanceResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ClawbackClaimableBalanceResult) ArmForSwitch(sw int32) (string, bool)

+ func (u ClawbackClaimableBalanceResult) EncodeTo(e *xdr.Encoder) error

+ func (u ClawbackClaimableBalanceResult) SwitchFieldName() string

+ type ClawbackClaimableBalanceResultCode int32

+ const ClawbackClaimableBalanceResultCodeClawbackClaimableBalanceDoesNotExist

+ const ClawbackClaimableBalanceResultCodeClawbackClaimableBalanceNotClawbackEnabled

+ const ClawbackClaimableBalanceResultCodeClawbackClaimableBalanceNotIssuer

+ const ClawbackClaimableBalanceResultCodeClawbackClaimableBalanceSuccess

+ func (e *ClawbackClaimableBalanceResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ClawbackClaimableBalanceResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e ClawbackClaimableBalanceResultCode) String() string

+ func (e ClawbackClaimableBalanceResultCode) ValidEnum(v int32) bool

+ func (s *ClawbackClaimableBalanceResultCode) UnmarshalBinary(inp []byte) error

+ func (s ClawbackClaimableBalanceResultCode) MarshalBinary() ([]byte, error)

+ type ClawbackOp struct

+ Amount Int64

+ Asset Asset

+ From MuxedAccount

+ func (s *ClawbackOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ClawbackOp) EncodeTo(e *xdr.Encoder) error

+ func (s *ClawbackOp) UnmarshalBinary(inp []byte) error

+ func (s ClawbackOp) MarshalBinary() ([]byte, error)

+ type ClawbackResult struct

+ Code ClawbackResultCode

+ func NewClawbackResult(code ClawbackResultCode, value interface{}) (result ClawbackResult, err error)

+ func (s *ClawbackResult) UnmarshalBinary(inp []byte) error

+ func (s ClawbackResult) MarshalBinary() ([]byte, error)

+ func (u *ClawbackResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ClawbackResult) ArmForSwitch(sw int32) (string, bool)

+ func (u ClawbackResult) EncodeTo(e *xdr.Encoder) error

+ func (u ClawbackResult) SwitchFieldName() string

+ type ClawbackResultCode int32

+ const ClawbackResultCodeClawbackMalformed

+ const ClawbackResultCodeClawbackNoTrust

+ const ClawbackResultCodeClawbackNotClawbackEnabled

+ const ClawbackResultCodeClawbackSuccess

+ const ClawbackResultCodeClawbackUnderfunded

+ func (e *ClawbackResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ClawbackResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e ClawbackResultCode) String() string

+ func (e ClawbackResultCode) ValidEnum(v int32) bool

+ func (s *ClawbackResultCode) UnmarshalBinary(inp []byte) error

+ func (s ClawbackResultCode) MarshalBinary() ([]byte, error)

+ type CreateAccountOp struct

+ Destination AccountId

+ StartingBalance Int64

+ func (s *CreateAccountOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *CreateAccountOp) EncodeTo(e *xdr.Encoder) error

+ func (s *CreateAccountOp) UnmarshalBinary(inp []byte) error

+ func (s CreateAccountOp) MarshalBinary() ([]byte, error)

+ type CreateAccountResult struct

+ Code CreateAccountResultCode

+ func NewCreateAccountResult(code CreateAccountResultCode, value interface{}) (result CreateAccountResult, err error)

+ func (s *CreateAccountResult) UnmarshalBinary(inp []byte) error

+ func (s CreateAccountResult) MarshalBinary() ([]byte, error)

+ func (u *CreateAccountResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u CreateAccountResult) ArmForSwitch(sw int32) (string, bool)

+ func (u CreateAccountResult) EncodeTo(e *xdr.Encoder) error

+ func (u CreateAccountResult) SwitchFieldName() string

+ type CreateAccountResultCode int32

+ const CreateAccountResultCodeCreateAccountAlreadyExist

+ const CreateAccountResultCodeCreateAccountLowReserve

+ const CreateAccountResultCodeCreateAccountMalformed

+ const CreateAccountResultCodeCreateAccountSuccess

+ const CreateAccountResultCodeCreateAccountUnderfunded

+ func (e *CreateAccountResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e CreateAccountResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e CreateAccountResultCode) String() string

+ func (e CreateAccountResultCode) ValidEnum(v int32) bool

+ func (s *CreateAccountResultCode) UnmarshalBinary(inp []byte) error

+ func (s CreateAccountResultCode) MarshalBinary() ([]byte, error)

+ type CreateClaimableBalanceOp struct

+ Amount Int64

+ Asset Asset

+ Claimants []Claimant

+ func (s *CreateClaimableBalanceOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *CreateClaimableBalanceOp) EncodeTo(e *xdr.Encoder) error

+ func (s *CreateClaimableBalanceOp) UnmarshalBinary(inp []byte) error

+ func (s CreateClaimableBalanceOp) MarshalBinary() ([]byte, error)

+ type CreateClaimableBalanceResult struct

+ BalanceId *ClaimableBalanceId

+ Code CreateClaimableBalanceResultCode

+ func NewCreateClaimableBalanceResult(code CreateClaimableBalanceResultCode, value interface{}) (result CreateClaimableBalanceResult, err error)

+ func (s *CreateClaimableBalanceResult) UnmarshalBinary(inp []byte) error

+ func (s CreateClaimableBalanceResult) MarshalBinary() ([]byte, error)

+ func (u *CreateClaimableBalanceResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u CreateClaimableBalanceResult) ArmForSwitch(sw int32) (string, bool)

+ func (u CreateClaimableBalanceResult) EncodeTo(e *xdr.Encoder) error

+ func (u CreateClaimableBalanceResult) GetBalanceId() (result ClaimableBalanceId, ok bool)

+ func (u CreateClaimableBalanceResult) MustBalanceId() ClaimableBalanceId

+ func (u CreateClaimableBalanceResult) SwitchFieldName() string

+ type CreateClaimableBalanceResultCode int32

+ const CreateClaimableBalanceResultCodeCreateClaimableBalanceLowReserve

+ const CreateClaimableBalanceResultCodeCreateClaimableBalanceMalformed

+ const CreateClaimableBalanceResultCodeCreateClaimableBalanceNoTrust

+ const CreateClaimableBalanceResultCodeCreateClaimableBalanceNotAuthorized

+ const CreateClaimableBalanceResultCodeCreateClaimableBalanceSuccess

+ const CreateClaimableBalanceResultCodeCreateClaimableBalanceUnderfunded

+ func (e *CreateClaimableBalanceResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e CreateClaimableBalanceResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e CreateClaimableBalanceResultCode) String() string

+ func (e CreateClaimableBalanceResultCode) ValidEnum(v int32) bool

+ func (s *CreateClaimableBalanceResultCode) UnmarshalBinary(inp []byte) error

+ func (s CreateClaimableBalanceResultCode) MarshalBinary() ([]byte, error)

+ type CreatePassiveSellOfferOp struct

+ Amount Int64

+ Buying Asset

+ Price Price

+ Selling Asset

+ func (s *CreatePassiveSellOfferOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *CreatePassiveSellOfferOp) EncodeTo(e *xdr.Encoder) error

+ func (s *CreatePassiveSellOfferOp) UnmarshalBinary(inp []byte) error

+ func (s CreatePassiveSellOfferOp) MarshalBinary() ([]byte, error)

+ type CryptoKeyType int32

+ const CryptoKeyTypeKeyTypeEd25519

+ const CryptoKeyTypeKeyTypeHashX

+ const CryptoKeyTypeKeyTypeMuxedEd25519

+ const CryptoKeyTypeKeyTypePreAuthTx

+ func (e *CryptoKeyType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e CryptoKeyType) EncodeTo(enc *xdr.Encoder) error

+ func (e CryptoKeyType) String() string

+ func (e CryptoKeyType) ValidEnum(v int32) bool

+ func (s *CryptoKeyType) UnmarshalBinary(inp []byte) error

+ func (s CryptoKeyType) MarshalBinary() ([]byte, error)

+ type Curve25519Public struct

+ Key [32]byte

+ func (s *Curve25519Public) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Curve25519Public) EncodeTo(e *xdr.Encoder) error

+ func (s *Curve25519Public) UnmarshalBinary(inp []byte) error

+ func (s Curve25519Public) MarshalBinary() ([]byte, error)

+ type Curve25519Secret struct

+ Key [32]byte

+ func (s *Curve25519Secret) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Curve25519Secret) EncodeTo(e *xdr.Encoder) error

+ func (s *Curve25519Secret) UnmarshalBinary(inp []byte) error

+ func (s Curve25519Secret) MarshalBinary() ([]byte, error)

+ type DataEntry struct

+ AccountId AccountId

+ DataName String64

+ DataValue DataValue

+ Ext DataEntryExt

+ func (s *DataEntry) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *DataEntry) EncodeTo(e *xdr.Encoder) error

+ func (s *DataEntry) UnmarshalBinary(inp []byte) error

+ func (s DataEntry) MarshalBinary() ([]byte, error)

+ type DataEntryExt struct

+ V int32

+ func NewDataEntryExt(v int32, value interface{}) (result DataEntryExt, err error)

+ func (s *DataEntryExt) UnmarshalBinary(inp []byte) error

+ func (s DataEntryExt) MarshalBinary() ([]byte, error)

+ func (u *DataEntryExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u DataEntryExt) ArmForSwitch(sw int32) (string, bool)

+ func (u DataEntryExt) EncodeTo(e *xdr.Encoder) error

+ func (u DataEntryExt) SwitchFieldName() string

+ type DataValue []byte

+ func (e DataValue) XDRMaxSize() int

+ func (s *DataValue) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *DataValue) UnmarshalBinary(inp []byte) error

+ func (s DataValue) EncodeTo(e *xdr.Encoder) error

+ func (s DataValue) MarshalBinary() ([]byte, error)

+ type DecoderFrom interface

+ type DecoratedSignature struct

+ Hint SignatureHint

+ Signature Signature

+ func (s *DecoratedSignature) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *DecoratedSignature) EncodeTo(e *xdr.Encoder) error

+ func (s *DecoratedSignature) UnmarshalBinary(inp []byte) error

+ func (s DecoratedSignature) MarshalBinary() ([]byte, error)

+ type DiamcircleMessage struct

+ Auth *Auth

+ DontHave *DontHave

+ Envelope *ScpEnvelope

+ Error *Error

+ GetScpLedgerSeq *Uint32

+ Hello *Hello

+ Peers *[]PeerAddress

+ QSet *ScpQuorumSet

+ QSetHash *Uint256

+ SignedSurveyRequestMessage *SignedSurveyRequestMessage

+ SignedSurveyResponseMessage *SignedSurveyResponseMessage

+ Transaction *TransactionEnvelope

+ TxSet *TransactionSet

+ TxSetHash *Uint256

+ Type MessageType

+ func NewDiamcircleMessage(aType MessageType, value interface{}) (result DiamcircleMessage, err error)

+ func (s *DiamcircleMessage) UnmarshalBinary(inp []byte) error

+ func (s DiamcircleMessage) MarshalBinary() ([]byte, error)

+ func (u *DiamcircleMessage) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u DiamcircleMessage) ArmForSwitch(sw int32) (string, bool)

+ func (u DiamcircleMessage) EncodeTo(e *xdr.Encoder) error

+ func (u DiamcircleMessage) GetAuth() (result Auth, ok bool)

+ func (u DiamcircleMessage) GetDontHave() (result DontHave, ok bool)

+ func (u DiamcircleMessage) GetEnvelope() (result ScpEnvelope, ok bool)

+ func (u DiamcircleMessage) GetError() (result Error, ok bool)

+ func (u DiamcircleMessage) GetGetScpLedgerSeq() (result Uint32, ok bool)

+ func (u DiamcircleMessage) GetHello() (result Hello, ok bool)

+ func (u DiamcircleMessage) GetPeers() (result []PeerAddress, ok bool)

+ func (u DiamcircleMessage) GetQSet() (result ScpQuorumSet, ok bool)

+ func (u DiamcircleMessage) GetQSetHash() (result Uint256, ok bool)

+ func (u DiamcircleMessage) GetSignedSurveyRequestMessage() (result SignedSurveyRequestMessage, ok bool)

+ func (u DiamcircleMessage) GetSignedSurveyResponseMessage() (result SignedSurveyResponseMessage, ok bool)

+ func (u DiamcircleMessage) GetTransaction() (result TransactionEnvelope, ok bool)

+ func (u DiamcircleMessage) GetTxSet() (result TransactionSet, ok bool)

+ func (u DiamcircleMessage) GetTxSetHash() (result Uint256, ok bool)

+ func (u DiamcircleMessage) MustAuth() Auth

+ func (u DiamcircleMessage) MustDontHave() DontHave

+ func (u DiamcircleMessage) MustEnvelope() ScpEnvelope

+ func (u DiamcircleMessage) MustError() Error

+ func (u DiamcircleMessage) MustGetScpLedgerSeq() Uint32

+ func (u DiamcircleMessage) MustHello() Hello

+ func (u DiamcircleMessage) MustPeers() []PeerAddress

+ func (u DiamcircleMessage) MustQSet() ScpQuorumSet

+ func (u DiamcircleMessage) MustQSetHash() Uint256

+ func (u DiamcircleMessage) MustSignedSurveyRequestMessage() SignedSurveyRequestMessage

+ func (u DiamcircleMessage) MustSignedSurveyResponseMessage() SignedSurveyResponseMessage

+ func (u DiamcircleMessage) MustTransaction() TransactionEnvelope

+ func (u DiamcircleMessage) MustTxSet() TransactionSet

+ func (u DiamcircleMessage) MustTxSetHash() Uint256

+ func (u DiamcircleMessage) SwitchFieldName() string

+ type DiamcircleValue struct

+ CloseTime TimePoint

+ Ext DiamcircleValueExt

+ TxSetHash Hash

+ Upgrades []UpgradeType

+ func (s *DiamcircleValue) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *DiamcircleValue) EncodeTo(e *xdr.Encoder) error

+ func (s *DiamcircleValue) UnmarshalBinary(inp []byte) error

+ func (s DiamcircleValue) MarshalBinary() ([]byte, error)

+ type DiamcircleValueExt struct

+ LcValueSignature *LedgerCloseValueSignature

+ V DiamcircleValueType

+ func NewDiamcircleValueExt(v DiamcircleValueType, value interface{}) (result DiamcircleValueExt, err error)

+ func (s *DiamcircleValueExt) UnmarshalBinary(inp []byte) error

+ func (s DiamcircleValueExt) MarshalBinary() ([]byte, error)

+ func (u *DiamcircleValueExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u DiamcircleValueExt) ArmForSwitch(sw int32) (string, bool)

+ func (u DiamcircleValueExt) EncodeTo(e *xdr.Encoder) error

+ func (u DiamcircleValueExt) GetLcValueSignature() (result LedgerCloseValueSignature, ok bool)

+ func (u DiamcircleValueExt) MustLcValueSignature() LedgerCloseValueSignature

+ func (u DiamcircleValueExt) SwitchFieldName() string

+ type DiamcircleValueType int32

+ const DiamcircleValueTypeDiamcircleValueBasic

+ const DiamcircleValueTypeDiamcircleValueSigned

+ func (e *DiamcircleValueType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e DiamcircleValueType) EncodeTo(enc *xdr.Encoder) error

+ func (e DiamcircleValueType) String() string

+ func (e DiamcircleValueType) ValidEnum(v int32) bool

+ func (s *DiamcircleValueType) UnmarshalBinary(inp []byte) error

+ func (s DiamcircleValueType) MarshalBinary() ([]byte, error)

+ type DontHave struct

+ ReqHash Uint256

+ Type MessageType

+ func (s *DontHave) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *DontHave) EncodeTo(e *xdr.Encoder) error

+ func (s *DontHave) UnmarshalBinary(inp []byte) error

+ func (s DontHave) MarshalBinary() ([]byte, error)

+ type EncoderTo interface

+ EncodeTo func(e *xdr.Encoder) error

+ type EncodingBuffer struct

+ func NewEncodingBuffer() *EncodingBuffer

+ func (e *EncodingBuffer) LedgerKeyUnsafeMarshalBinaryCompress(key LedgerKey) ([]byte, error)

+ func (e *EncodingBuffer) MarshalBase64(encodable EncoderTo) (string, error)

+ func (e *EncodingBuffer) MarshalBinary(encodable EncoderTo) ([]byte, error)

+ func (e *EncodingBuffer) MarshalHex(encodable EncoderTo) (string, error)

+ func (e *EncodingBuffer) UnsafeMarshalBase64(encodable EncoderTo) ([]byte, error)

+ func (e *EncodingBuffer) UnsafeMarshalBinary(encodable EncoderTo) ([]byte, error)

+ func (e *EncodingBuffer) UnsafeMarshalHex(encodable EncoderTo) ([]byte, error)

+ type EncryptedBody []byte

+ func (e EncryptedBody) XDRMaxSize() int

+ func (s *EncryptedBody) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *EncryptedBody) UnmarshalBinary(inp []byte) error

+ func (s EncryptedBody) EncodeTo(e *xdr.Encoder) error

+ func (s EncryptedBody) MarshalBinary() ([]byte, error)

+ type EndSponsoringFutureReservesResult struct

+ Code EndSponsoringFutureReservesResultCode

+ func NewEndSponsoringFutureReservesResult(code EndSponsoringFutureReservesResultCode, value interface{}) (result EndSponsoringFutureReservesResult, err error)

+ func (s *EndSponsoringFutureReservesResult) UnmarshalBinary(inp []byte) error

+ func (s EndSponsoringFutureReservesResult) MarshalBinary() ([]byte, error)

+ func (u *EndSponsoringFutureReservesResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u EndSponsoringFutureReservesResult) ArmForSwitch(sw int32) (string, bool)

+ func (u EndSponsoringFutureReservesResult) EncodeTo(e *xdr.Encoder) error

+ func (u EndSponsoringFutureReservesResult) SwitchFieldName() string

+ type EndSponsoringFutureReservesResultCode int32

+ const EndSponsoringFutureReservesResultCodeEndSponsoringFutureReservesNotSponsored

+ const EndSponsoringFutureReservesResultCodeEndSponsoringFutureReservesSuccess

+ func (e *EndSponsoringFutureReservesResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e EndSponsoringFutureReservesResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e EndSponsoringFutureReservesResultCode) String() string

+ func (e EndSponsoringFutureReservesResultCode) ValidEnum(v int32) bool

+ func (s *EndSponsoringFutureReservesResultCode) UnmarshalBinary(inp []byte) error

+ func (s EndSponsoringFutureReservesResultCode) MarshalBinary() ([]byte, error)

+ type EnvelopeType int32

+ const EnvelopeTypeEnvelopeTypeAuth

+ const EnvelopeTypeEnvelopeTypeOpId

+ const EnvelopeTypeEnvelopeTypePoolRevokeOpId

+ const EnvelopeTypeEnvelopeTypeScp

+ const EnvelopeTypeEnvelopeTypeScpvalue

+ const EnvelopeTypeEnvelopeTypeTx

+ const EnvelopeTypeEnvelopeTypeTxFeeBump

+ const EnvelopeTypeEnvelopeTypeTxV0

+ func (e *EnvelopeType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e EnvelopeType) EncodeTo(enc *xdr.Encoder) error

+ func (e EnvelopeType) String() string

+ func (e EnvelopeType) ValidEnum(v int32) bool

+ func (s *EnvelopeType) UnmarshalBinary(inp []byte) error

+ func (s EnvelopeType) MarshalBinary() ([]byte, error)

+ type Error struct

+ Code ErrorCode

+ Msg string

+ func (s *Error) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Error) EncodeTo(e *xdr.Encoder) error

+ func (s *Error) UnmarshalBinary(inp []byte) error

+ func (s Error) MarshalBinary() ([]byte, error)

+ type ErrorCode int32

+ const ErrorCodeErrAuth

+ const ErrorCodeErrConf

+ const ErrorCodeErrData

+ const ErrorCodeErrLoad

+ const ErrorCodeErrMisc

+ func (e *ErrorCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ErrorCode) EncodeTo(enc *xdr.Encoder) error

+ func (e ErrorCode) String() string

+ func (e ErrorCode) ValidEnum(v int32) bool

+ func (s *ErrorCode) UnmarshalBinary(inp []byte) error

+ func (s ErrorCode) MarshalBinary() ([]byte, error)

+ type FeeBumpTransaction struct

+ Ext FeeBumpTransactionExt

+ Fee Int64

+ FeeSource MuxedAccount

+ InnerTx FeeBumpTransactionInnerTx

+ func (s *FeeBumpTransaction) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *FeeBumpTransaction) EncodeTo(e *xdr.Encoder) error

+ func (s *FeeBumpTransaction) UnmarshalBinary(inp []byte) error

+ func (s FeeBumpTransaction) MarshalBinary() ([]byte, error)

+ type FeeBumpTransactionEnvelope struct

+ Signatures []DecoratedSignature

+ Tx FeeBumpTransaction

+ func (s *FeeBumpTransactionEnvelope) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *FeeBumpTransactionEnvelope) EncodeTo(e *xdr.Encoder) error

+ func (s *FeeBumpTransactionEnvelope) UnmarshalBinary(inp []byte) error

+ func (s FeeBumpTransactionEnvelope) MarshalBinary() ([]byte, error)

+ type FeeBumpTransactionExt struct

+ V int32

+ func NewFeeBumpTransactionExt(v int32, value interface{}) (result FeeBumpTransactionExt, err error)

+ func (s *FeeBumpTransactionExt) UnmarshalBinary(inp []byte) error

+ func (s FeeBumpTransactionExt) MarshalBinary() ([]byte, error)

+ func (u *FeeBumpTransactionExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u FeeBumpTransactionExt) ArmForSwitch(sw int32) (string, bool)

+ func (u FeeBumpTransactionExt) EncodeTo(e *xdr.Encoder) error

+ func (u FeeBumpTransactionExt) SwitchFieldName() string

+ type FeeBumpTransactionInnerTx struct

+ Type EnvelopeType

+ V1 *TransactionV1Envelope

+ func NewFeeBumpTransactionInnerTx(aType EnvelopeType, value interface{}) (result FeeBumpTransactionInnerTx, err error)

+ func (e FeeBumpTransactionInnerTx) GoString() string

+ func (s *FeeBumpTransactionInnerTx) UnmarshalBinary(inp []byte) error

+ func (s FeeBumpTransactionInnerTx) MarshalBinary() ([]byte, error)

+ func (u *FeeBumpTransactionInnerTx) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u FeeBumpTransactionInnerTx) ArmForSwitch(sw int32) (string, bool)

+ func (u FeeBumpTransactionInnerTx) EncodeTo(e *xdr.Encoder) error

+ func (u FeeBumpTransactionInnerTx) GetV1() (result TransactionV1Envelope, ok bool)

+ func (u FeeBumpTransactionInnerTx) MustV1() TransactionV1Envelope

+ func (u FeeBumpTransactionInnerTx) SwitchFieldName() string

+ type Hash [32]byte

+ func (e Hash) XDRMaxSize() int

+ func (h Hash) HexString() string

+ func (s *Hash) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Hash) EncodeTo(e *xdr.Encoder) error

+ func (s *Hash) UnmarshalBinary(inp []byte) error

+ func (s Hash) MarshalBinary() ([]byte, error)

+ func (t *Hash) Scan(src interface{}) error

+ type HashIdPreimage struct

+ OperationId *HashIdPreimageOperationId

+ RevokeId *HashIdPreimageRevokeId

+ Type EnvelopeType

+ func NewHashIdPreimage(aType EnvelopeType, value interface{}) (result HashIdPreimage, err error)

+ func (s *HashIdPreimage) UnmarshalBinary(inp []byte) error

+ func (s HashIdPreimage) MarshalBinary() ([]byte, error)

+ func (u *HashIdPreimage) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u HashIdPreimage) ArmForSwitch(sw int32) (string, bool)

+ func (u HashIdPreimage) EncodeTo(e *xdr.Encoder) error

+ func (u HashIdPreimage) GetOperationId() (result HashIdPreimageOperationId, ok bool)

+ func (u HashIdPreimage) GetRevokeId() (result HashIdPreimageRevokeId, ok bool)

+ func (u HashIdPreimage) MustOperationId() HashIdPreimageOperationId

+ func (u HashIdPreimage) MustRevokeId() HashIdPreimageRevokeId

+ func (u HashIdPreimage) SwitchFieldName() string

+ type HashIdPreimageOperationId struct

+ OpNum Uint32

+ SeqNum SequenceNumber

+ SourceAccount AccountId

+ func (s *HashIdPreimageOperationId) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *HashIdPreimageOperationId) EncodeTo(e *xdr.Encoder) error

+ func (s *HashIdPreimageOperationId) UnmarshalBinary(inp []byte) error

+ func (s HashIdPreimageOperationId) MarshalBinary() ([]byte, error)

+ type HashIdPreimageRevokeId struct

+ Asset Asset

+ LiquidityPoolId PoolId

+ OpNum Uint32

+ SeqNum SequenceNumber

+ SourceAccount AccountId

+ func (s *HashIdPreimageRevokeId) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *HashIdPreimageRevokeId) EncodeTo(e *xdr.Encoder) error

+ func (s *HashIdPreimageRevokeId) UnmarshalBinary(inp []byte) error

+ func (s HashIdPreimageRevokeId) MarshalBinary() ([]byte, error)

+ type Hello struct

+ Cert AuthCert

+ LedgerVersion Uint32

+ ListeningPort int32

+ NetworkId Hash

+ Nonce Uint256

+ OverlayMinVersion Uint32

+ OverlayVersion Uint32

+ PeerId NodeId

+ VersionStr string

+ func (s *Hello) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Hello) EncodeTo(e *xdr.Encoder) error

+ func (s *Hello) UnmarshalBinary(inp []byte) error

+ func (s Hello) MarshalBinary() ([]byte, error)

+ type HmacSha256Key struct

+ Key [32]byte

+ func (s *HmacSha256Key) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *HmacSha256Key) EncodeTo(e *xdr.Encoder) error

+ func (s *HmacSha256Key) UnmarshalBinary(inp []byte) error

+ func (s HmacSha256Key) MarshalBinary() ([]byte, error)

+ type HmacSha256Mac struct

+ Mac [32]byte

+ func (s *HmacSha256Mac) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *HmacSha256Mac) EncodeTo(e *xdr.Encoder) error

+ func (s *HmacSha256Mac) UnmarshalBinary(inp []byte) error

+ func (s HmacSha256Mac) MarshalBinary() ([]byte, error)

+ type InflationPayout struct

+ Amount Int64

+ Destination AccountId

+ func (s *InflationPayout) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *InflationPayout) EncodeTo(e *xdr.Encoder) error

+ func (s *InflationPayout) UnmarshalBinary(inp []byte) error

+ func (s InflationPayout) MarshalBinary() ([]byte, error)

+ type InflationResult struct

+ Code InflationResultCode

+ Payouts *[]InflationPayout

+ func NewInflationResult(code InflationResultCode, value interface{}) (result InflationResult, err error)

+ func (s *InflationResult) UnmarshalBinary(inp []byte) error

+ func (s InflationResult) MarshalBinary() ([]byte, error)

+ func (u *InflationResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u InflationResult) ArmForSwitch(sw int32) (string, bool)

+ func (u InflationResult) EncodeTo(e *xdr.Encoder) error

+ func (u InflationResult) GetPayouts() (result []InflationPayout, ok bool)

+ func (u InflationResult) MustPayouts() []InflationPayout

+ func (u InflationResult) SwitchFieldName() string

+ type InflationResultCode int32

+ const InflationResultCodeInflationNotTime

+ const InflationResultCodeInflationSuccess

+ func (e *InflationResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e InflationResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e InflationResultCode) String() string

+ func (e InflationResultCode) ValidEnum(v int32) bool

+ func (s *InflationResultCode) UnmarshalBinary(inp []byte) error

+ func (s InflationResultCode) MarshalBinary() ([]byte, error)

+ type InnerTransactionResult struct

+ Ext InnerTransactionResultExt

+ FeeCharged Int64

+ Result InnerTransactionResultResult

+ func (s *InnerTransactionResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *InnerTransactionResult) EncodeTo(e *xdr.Encoder) error

+ func (s *InnerTransactionResult) UnmarshalBinary(inp []byte) error

+ func (s InnerTransactionResult) MarshalBinary() ([]byte, error)

+ type InnerTransactionResultExt struct

+ V int32

+ func NewInnerTransactionResultExt(v int32, value interface{}) (result InnerTransactionResultExt, err error)

+ func (s *InnerTransactionResultExt) UnmarshalBinary(inp []byte) error

+ func (s InnerTransactionResultExt) MarshalBinary() ([]byte, error)

+ func (u *InnerTransactionResultExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u InnerTransactionResultExt) ArmForSwitch(sw int32) (string, bool)

+ func (u InnerTransactionResultExt) EncodeTo(e *xdr.Encoder) error

+ func (u InnerTransactionResultExt) SwitchFieldName() string

+ type InnerTransactionResultPair struct

+ Result InnerTransactionResult

+ TransactionHash Hash

+ func (s *InnerTransactionResultPair) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *InnerTransactionResultPair) EncodeTo(e *xdr.Encoder) error

+ func (s *InnerTransactionResultPair) UnmarshalBinary(inp []byte) error

+ func (s InnerTransactionResultPair) MarshalBinary() ([]byte, error)

+ type InnerTransactionResultResult struct

+ Code TransactionResultCode

+ Results *[]OperationResult

+ func NewInnerTransactionResultResult(code TransactionResultCode, value interface{}) (result InnerTransactionResultResult, err error)

+ func (s *InnerTransactionResultResult) UnmarshalBinary(inp []byte) error

+ func (s InnerTransactionResultResult) MarshalBinary() ([]byte, error)

+ func (u *InnerTransactionResultResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u InnerTransactionResultResult) ArmForSwitch(sw int32) (string, bool)

+ func (u InnerTransactionResultResult) EncodeTo(e *xdr.Encoder) error

+ func (u InnerTransactionResultResult) GetResults() (result []OperationResult, ok bool)

+ func (u InnerTransactionResultResult) MustResults() []OperationResult

+ func (u InnerTransactionResultResult) SwitchFieldName() string

+ type Int32 int32

+ func (s *Int32) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Int32) UnmarshalBinary(inp []byte) error

+ func (s Int32) EncodeTo(e *xdr.Encoder) error

+ func (s Int32) MarshalBinary() ([]byte, error)

+ type Int64 int64

+ func (s *Int64) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Int64) UnmarshalBinary(inp []byte) error

+ func (s Int64) EncodeTo(e *xdr.Encoder) error

+ func (s Int64) MarshalBinary() ([]byte, error)

+ func (t *Int64) Scan(src interface{}) error

+ type IpAddrType int32

+ const IpAddrTypeIPv4

+ const IpAddrTypeIPv6

+ func (e *IpAddrType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e IpAddrType) EncodeTo(enc *xdr.Encoder) error

+ func (e IpAddrType) String() string

+ func (e IpAddrType) ValidEnum(v int32) bool

+ func (s *IpAddrType) UnmarshalBinary(inp []byte) error

+ func (s IpAddrType) MarshalBinary() ([]byte, error)

+ type Keyer interface

+ LedgerKey func() LedgerKey

+ type LedgerCloseMeta struct

+ V int32

+ V0 *LedgerCloseMetaV0

+ func NewLedgerCloseMeta(v int32, value interface{}) (result LedgerCloseMeta, err error)

+ func (l LedgerCloseMeta) BucketListHash() Hash

+ func (l LedgerCloseMeta) LedgerHash() Hash

+ func (l LedgerCloseMeta) LedgerSequence() uint32

+ func (l LedgerCloseMeta) PreviousLedgerHash() Hash

+ func (l LedgerCloseMeta) ProtocolVersion() uint32

+ func (s *LedgerCloseMeta) UnmarshalBinary(inp []byte) error

+ func (s LedgerCloseMeta) MarshalBinary() ([]byte, error)

+ func (u *LedgerCloseMeta) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u LedgerCloseMeta) ArmForSwitch(sw int32) (string, bool)

+ func (u LedgerCloseMeta) EncodeTo(e *xdr.Encoder) error

+ func (u LedgerCloseMeta) GetV0() (result LedgerCloseMetaV0, ok bool)

+ func (u LedgerCloseMeta) MustV0() LedgerCloseMetaV0

+ func (u LedgerCloseMeta) SwitchFieldName() string

+ type LedgerCloseMetaV0 struct

+ LedgerHeader LedgerHeaderHistoryEntry

+ ScpInfo []ScpHistoryEntry

+ TxProcessing []TransactionResultMeta

+ TxSet TransactionSet

+ UpgradesProcessing []UpgradeEntryMeta

+ func (s *LedgerCloseMetaV0) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LedgerCloseMetaV0) EncodeTo(e *xdr.Encoder) error

+ func (s *LedgerCloseMetaV0) UnmarshalBinary(inp []byte) error

+ func (s LedgerCloseMetaV0) MarshalBinary() ([]byte, error)

+ type LedgerCloseValueSignature struct

+ NodeId NodeId

+ Signature Signature

+ func (s *LedgerCloseValueSignature) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LedgerCloseValueSignature) EncodeTo(e *xdr.Encoder) error

+ func (s *LedgerCloseValueSignature) UnmarshalBinary(inp []byte) error

+ func (s LedgerCloseValueSignature) MarshalBinary() ([]byte, error)

+ type LedgerEntry struct

+ Data LedgerEntryData

+ Ext LedgerEntryExt

+ LastModifiedLedgerSeq Uint32

+ func (entry *LedgerEntry) LedgerKey() LedgerKey

+ func (entry *LedgerEntry) Normalize() *LedgerEntry

+ func (entry *LedgerEntry) SponsoringID() SponsorshipDescriptor

+ func (s *LedgerEntry) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LedgerEntry) EncodeTo(e *xdr.Encoder) error

+ func (s *LedgerEntry) UnmarshalBinary(inp []byte) error

+ func (s LedgerEntry) MarshalBinary() ([]byte, error)

+ type LedgerEntryChange struct

+ Created *LedgerEntry

+ Removed *LedgerKey

+ State *LedgerEntry

+ Type LedgerEntryChangeType

+ Updated *LedgerEntry

+ func NewLedgerEntryChange(aType LedgerEntryChangeType, value interface{}) (result LedgerEntryChange, err error)

+ func (change *LedgerEntryChange) EntryType() LedgerEntryType

+ func (change *LedgerEntryChange) GetLedgerEntry() (LedgerEntry, bool)

+ func (change *LedgerEntryChange) LedgerKey() LedgerKey

+ func (change LedgerEntryChange) MarshalBinaryBase64() (string, error)

+ func (s *LedgerEntryChange) UnmarshalBinary(inp []byte) error

+ func (s LedgerEntryChange) MarshalBinary() ([]byte, error)

+ func (u *LedgerEntryChange) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u LedgerEntryChange) ArmForSwitch(sw int32) (string, bool)

+ func (u LedgerEntryChange) EncodeTo(e *xdr.Encoder) error

+ func (u LedgerEntryChange) GetCreated() (result LedgerEntry, ok bool)

+ func (u LedgerEntryChange) GetRemoved() (result LedgerKey, ok bool)

+ func (u LedgerEntryChange) GetState() (result LedgerEntry, ok bool)

+ func (u LedgerEntryChange) GetUpdated() (result LedgerEntry, ok bool)

+ func (u LedgerEntryChange) MustCreated() LedgerEntry

+ func (u LedgerEntryChange) MustRemoved() LedgerKey

+ func (u LedgerEntryChange) MustState() LedgerEntry

+ func (u LedgerEntryChange) MustUpdated() LedgerEntry

+ func (u LedgerEntryChange) SwitchFieldName() string

+ type LedgerEntryChangeType int32

+ const LedgerEntryChangeTypeLedgerEntryCreated

+ const LedgerEntryChangeTypeLedgerEntryRemoved

+ const LedgerEntryChangeTypeLedgerEntryState

+ const LedgerEntryChangeTypeLedgerEntryUpdated

+ func (e *LedgerEntryChangeType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e LedgerEntryChangeType) EncodeTo(enc *xdr.Encoder) error

+ func (e LedgerEntryChangeType) String() string

+ func (e LedgerEntryChangeType) ValidEnum(v int32) bool

+ func (s *LedgerEntryChangeType) UnmarshalBinary(inp []byte) error

+ func (s LedgerEntryChangeType) MarshalBinary() ([]byte, error)

+ type LedgerEntryChanges []LedgerEntryChange

+ func (s *LedgerEntryChanges) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LedgerEntryChanges) UnmarshalBinary(inp []byte) error

+ func (s LedgerEntryChanges) EncodeTo(e *xdr.Encoder) error

+ func (s LedgerEntryChanges) MarshalBinary() ([]byte, error)

+ func (t *LedgerEntryChanges) Scan(src interface{}) error

+ type LedgerEntryData struct

+ Account *AccountEntry

+ ClaimableBalance *ClaimableBalanceEntry

+ Data *DataEntry

+ LiquidityPool *LiquidityPoolEntry

+ Offer *OfferEntry

+ TrustLine *TrustLineEntry

+ Type LedgerEntryType

+ func NewLedgerEntryData(aType LedgerEntryType, value interface{}) (result LedgerEntryData, err error)

+ func (s *LedgerEntryData) UnmarshalBinary(inp []byte) error

+ func (s LedgerEntryData) MarshalBinary() ([]byte, error)

+ func (u *LedgerEntryData) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u LedgerEntryData) ArmForSwitch(sw int32) (string, bool)

+ func (u LedgerEntryData) EncodeTo(e *xdr.Encoder) error

+ func (u LedgerEntryData) GetAccount() (result AccountEntry, ok bool)

+ func (u LedgerEntryData) GetClaimableBalance() (result ClaimableBalanceEntry, ok bool)

+ func (u LedgerEntryData) GetData() (result DataEntry, ok bool)

+ func (u LedgerEntryData) GetLiquidityPool() (result LiquidityPoolEntry, ok bool)

+ func (u LedgerEntryData) GetOffer() (result OfferEntry, ok bool)

+ func (u LedgerEntryData) GetTrustLine() (result TrustLineEntry, ok bool)

+ func (u LedgerEntryData) MustAccount() AccountEntry

+ func (u LedgerEntryData) MustClaimableBalance() ClaimableBalanceEntry

+ func (u LedgerEntryData) MustData() DataEntry

+ func (u LedgerEntryData) MustLiquidityPool() LiquidityPoolEntry

+ func (u LedgerEntryData) MustOffer() OfferEntry

+ func (u LedgerEntryData) MustTrustLine() TrustLineEntry

+ func (u LedgerEntryData) SwitchFieldName() string

+ type LedgerEntryExt struct

+ V int32

+ V1 *LedgerEntryExtensionV1

+ func NewLedgerEntryExt(v int32, value interface{}) (result LedgerEntryExt, err error)

+ func (s *LedgerEntryExt) UnmarshalBinary(inp []byte) error

+ func (s LedgerEntryExt) MarshalBinary() ([]byte, error)

+ func (u *LedgerEntryExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u LedgerEntryExt) ArmForSwitch(sw int32) (string, bool)

+ func (u LedgerEntryExt) EncodeTo(e *xdr.Encoder) error

+ func (u LedgerEntryExt) GetV1() (result LedgerEntryExtensionV1, ok bool)

+ func (u LedgerEntryExt) MustV1() LedgerEntryExtensionV1

+ func (u LedgerEntryExt) SwitchFieldName() string

+ type LedgerEntryExtensionV1 struct

+ Ext LedgerEntryExtensionV1Ext

+ SponsoringId SponsorshipDescriptor

+ func (s *LedgerEntryExtensionV1) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LedgerEntryExtensionV1) EncodeTo(e *xdr.Encoder) error

+ func (s *LedgerEntryExtensionV1) UnmarshalBinary(inp []byte) error

+ func (s LedgerEntryExtensionV1) MarshalBinary() ([]byte, error)

+ type LedgerEntryExtensionV1Ext struct

+ V int32

+ func NewLedgerEntryExtensionV1Ext(v int32, value interface{}) (result LedgerEntryExtensionV1Ext, err error)

+ func (s *LedgerEntryExtensionV1Ext) UnmarshalBinary(inp []byte) error

+ func (s LedgerEntryExtensionV1Ext) MarshalBinary() ([]byte, error)

+ func (u *LedgerEntryExtensionV1Ext) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u LedgerEntryExtensionV1Ext) ArmForSwitch(sw int32) (string, bool)

+ func (u LedgerEntryExtensionV1Ext) EncodeTo(e *xdr.Encoder) error

+ func (u LedgerEntryExtensionV1Ext) SwitchFieldName() string

+ type LedgerEntryType int32

+ const LedgerEntryTypeAccount

+ const LedgerEntryTypeClaimableBalance

+ const LedgerEntryTypeData

+ const LedgerEntryTypeLiquidityPool

+ const LedgerEntryTypeOffer

+ const LedgerEntryTypeTrustline

+ func (e *LedgerEntryType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e LedgerEntryType) EncodeTo(enc *xdr.Encoder) error

+ func (e LedgerEntryType) String() string

+ func (e LedgerEntryType) ValidEnum(v int32) bool

+ func (s *LedgerEntryType) UnmarshalBinary(inp []byte) error

+ func (s LedgerEntryType) MarshalBinary() ([]byte, error)

+ type LedgerHeader struct

+ BaseFee Uint32

+ BaseReserve Uint32

+ BucketListHash Hash

+ Ext LedgerHeaderExt

+ FeePool Int64

+ IdPool Uint64

+ InflationSeq Uint32

+ LedgerSeq Uint32

+ LedgerVersion Uint32

+ MaxTxSetSize Uint32

+ PreviousLedgerHash Hash

+ ScpValue DiamcircleValue

+ SkipList [4]Hash

+ TotalCoins Int64

+ TxSetResultHash Hash

+ func (s *LedgerHeader) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LedgerHeader) EncodeTo(e *xdr.Encoder) error

+ func (s *LedgerHeader) UnmarshalBinary(inp []byte) error

+ func (s LedgerHeader) MarshalBinary() ([]byte, error)

+ func (t *LedgerHeader) Scan(src interface{}) error

+ type LedgerHeaderExt struct

+ V int32

+ V1 *LedgerHeaderExtensionV1

+ func NewLedgerHeaderExt(v int32, value interface{}) (result LedgerHeaderExt, err error)

+ func (s *LedgerHeaderExt) UnmarshalBinary(inp []byte) error

+ func (s LedgerHeaderExt) MarshalBinary() ([]byte, error)

+ func (u *LedgerHeaderExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u LedgerHeaderExt) ArmForSwitch(sw int32) (string, bool)

+ func (u LedgerHeaderExt) EncodeTo(e *xdr.Encoder) error

+ func (u LedgerHeaderExt) GetV1() (result LedgerHeaderExtensionV1, ok bool)

+ func (u LedgerHeaderExt) MustV1() LedgerHeaderExtensionV1

+ func (u LedgerHeaderExt) SwitchFieldName() string

+ type LedgerHeaderExtensionV1 struct

+ Ext LedgerHeaderExtensionV1Ext

+ Flags Uint32

+ func (s *LedgerHeaderExtensionV1) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LedgerHeaderExtensionV1) EncodeTo(e *xdr.Encoder) error

+ func (s *LedgerHeaderExtensionV1) UnmarshalBinary(inp []byte) error

+ func (s LedgerHeaderExtensionV1) MarshalBinary() ([]byte, error)

+ type LedgerHeaderExtensionV1Ext struct

+ V int32

+ func NewLedgerHeaderExtensionV1Ext(v int32, value interface{}) (result LedgerHeaderExtensionV1Ext, err error)

+ func (s *LedgerHeaderExtensionV1Ext) UnmarshalBinary(inp []byte) error

+ func (s LedgerHeaderExtensionV1Ext) MarshalBinary() ([]byte, error)

+ func (u *LedgerHeaderExtensionV1Ext) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u LedgerHeaderExtensionV1Ext) ArmForSwitch(sw int32) (string, bool)

+ func (u LedgerHeaderExtensionV1Ext) EncodeTo(e *xdr.Encoder) error

+ func (u LedgerHeaderExtensionV1Ext) SwitchFieldName() string

+ type LedgerHeaderFlags int32

+ const LedgerHeaderFlagsDisableLiquidityPoolDepositFlag

+ const LedgerHeaderFlagsDisableLiquidityPoolTradingFlag

+ const LedgerHeaderFlagsDisableLiquidityPoolWithdrawalFlag

+ func (e *LedgerHeaderFlags) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e LedgerHeaderFlags) EncodeTo(enc *xdr.Encoder) error

+ func (e LedgerHeaderFlags) String() string

+ func (e LedgerHeaderFlags) ValidEnum(v int32) bool

+ func (s *LedgerHeaderFlags) UnmarshalBinary(inp []byte) error

+ func (s LedgerHeaderFlags) MarshalBinary() ([]byte, error)

+ type LedgerHeaderHistoryEntry struct

+ Ext LedgerHeaderHistoryEntryExt

+ Hash Hash

+ Header LedgerHeader

+ func (s *LedgerHeaderHistoryEntry) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LedgerHeaderHistoryEntry) EncodeTo(e *xdr.Encoder) error

+ func (s *LedgerHeaderHistoryEntry) UnmarshalBinary(inp []byte) error

+ func (s LedgerHeaderHistoryEntry) MarshalBinary() ([]byte, error)

+ type LedgerHeaderHistoryEntryExt struct

+ V int32

+ func NewLedgerHeaderHistoryEntryExt(v int32, value interface{}) (result LedgerHeaderHistoryEntryExt, err error)

+ func (s *LedgerHeaderHistoryEntryExt) UnmarshalBinary(inp []byte) error

+ func (s LedgerHeaderHistoryEntryExt) MarshalBinary() ([]byte, error)

+ func (u *LedgerHeaderHistoryEntryExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u LedgerHeaderHistoryEntryExt) ArmForSwitch(sw int32) (string, bool)

+ func (u LedgerHeaderHistoryEntryExt) EncodeTo(e *xdr.Encoder) error

+ func (u LedgerHeaderHistoryEntryExt) SwitchFieldName() string

+ type LedgerKey struct

+ Account *LedgerKeyAccount

+ ClaimableBalance *LedgerKeyClaimableBalance

+ Data *LedgerKeyData

+ LiquidityPool *LedgerKeyLiquidityPool

+ Offer *LedgerKeyOffer

+ TrustLine *LedgerKeyTrustLine

+ Type LedgerEntryType

+ func NewLedgerKey(aType LedgerEntryType, value interface{}) (result LedgerKey, err error)

+ func (key *LedgerKey) Equals(other LedgerKey) bool

+ func (key *LedgerKey) LedgerKey() LedgerKey

+ func (key *LedgerKey) SetAccount(account AccountId) error

+ func (key *LedgerKey) SetClaimableBalance(balanceID ClaimableBalanceId) error

+ func (key *LedgerKey) SetData(account AccountId, name string) error

+ func (key *LedgerKey) SetLiquidityPool(poolID PoolId) error

+ func (key *LedgerKey) SetOffer(account AccountId, id uint64) error

+ func (key *LedgerKey) SetTrustline(account AccountId, line TrustLineAsset) error

+ func (key LedgerKey) MarshalBinaryBase64() (string, error)

+ func (s *LedgerKey) UnmarshalBinary(inp []byte) error

+ func (s LedgerKey) MarshalBinary() ([]byte, error)

+ func (u *LedgerKey) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u LedgerKey) ArmForSwitch(sw int32) (string, bool)

+ func (u LedgerKey) EncodeTo(e *xdr.Encoder) error

+ func (u LedgerKey) GetAccount() (result LedgerKeyAccount, ok bool)

+ func (u LedgerKey) GetClaimableBalance() (result LedgerKeyClaimableBalance, ok bool)

+ func (u LedgerKey) GetData() (result LedgerKeyData, ok bool)

+ func (u LedgerKey) GetLiquidityPool() (result LedgerKeyLiquidityPool, ok bool)

+ func (u LedgerKey) GetOffer() (result LedgerKeyOffer, ok bool)

+ func (u LedgerKey) GetTrustLine() (result LedgerKeyTrustLine, ok bool)

+ func (u LedgerKey) MustAccount() LedgerKeyAccount

+ func (u LedgerKey) MustClaimableBalance() LedgerKeyClaimableBalance

+ func (u LedgerKey) MustData() LedgerKeyData

+ func (u LedgerKey) MustLiquidityPool() LedgerKeyLiquidityPool

+ func (u LedgerKey) MustOffer() LedgerKeyOffer

+ func (u LedgerKey) MustTrustLine() LedgerKeyTrustLine

+ func (u LedgerKey) SwitchFieldName() string

+ type LedgerKeyAccount struct

+ AccountId AccountId

+ func (s *LedgerKeyAccount) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LedgerKeyAccount) EncodeTo(e *xdr.Encoder) error

+ func (s *LedgerKeyAccount) UnmarshalBinary(inp []byte) error

+ func (s LedgerKeyAccount) MarshalBinary() ([]byte, error)

+ type LedgerKeyClaimableBalance struct

+ BalanceId ClaimableBalanceId

+ func (s *LedgerKeyClaimableBalance) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LedgerKeyClaimableBalance) EncodeTo(e *xdr.Encoder) error

+ func (s *LedgerKeyClaimableBalance) UnmarshalBinary(inp []byte) error

+ func (s LedgerKeyClaimableBalance) MarshalBinary() ([]byte, error)

+ type LedgerKeyData struct

+ AccountId AccountId

+ DataName String64

+ func (s *LedgerKeyData) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LedgerKeyData) EncodeTo(e *xdr.Encoder) error

+ func (s *LedgerKeyData) UnmarshalBinary(inp []byte) error

+ func (s LedgerKeyData) MarshalBinary() ([]byte, error)

+ type LedgerKeyLiquidityPool struct

+ LiquidityPoolId PoolId

+ func (s *LedgerKeyLiquidityPool) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LedgerKeyLiquidityPool) EncodeTo(e *xdr.Encoder) error

+ func (s *LedgerKeyLiquidityPool) UnmarshalBinary(inp []byte) error

+ func (s LedgerKeyLiquidityPool) MarshalBinary() ([]byte, error)

+ type LedgerKeyOffer struct

+ OfferId Int64

+ SellerId AccountId

+ func (s *LedgerKeyOffer) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LedgerKeyOffer) EncodeTo(e *xdr.Encoder) error

+ func (s *LedgerKeyOffer) UnmarshalBinary(inp []byte) error

+ func (s LedgerKeyOffer) MarshalBinary() ([]byte, error)

+ type LedgerKeyTrustLine struct

+ AccountId AccountId

+ Asset TrustLineAsset

+ func (s *LedgerKeyTrustLine) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LedgerKeyTrustLine) EncodeTo(e *xdr.Encoder) error

+ func (s *LedgerKeyTrustLine) UnmarshalBinary(inp []byte) error

+ func (s LedgerKeyTrustLine) MarshalBinary() ([]byte, error)

+ type LedgerScpMessages struct

+ LedgerSeq Uint32

+ Messages []ScpEnvelope

+ func (s *LedgerScpMessages) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LedgerScpMessages) EncodeTo(e *xdr.Encoder) error

+ func (s *LedgerScpMessages) UnmarshalBinary(inp []byte) error

+ func (s LedgerScpMessages) MarshalBinary() ([]byte, error)

+ type LedgerUpgrade struct

+ NewBaseFee *Uint32

+ NewBaseReserve *Uint32

+ NewFlags *Uint32

+ NewLedgerVersion *Uint32

+ NewMaxTxSetSize *Uint32

+ Type LedgerUpgradeType

+ func NewLedgerUpgrade(aType LedgerUpgradeType, value interface{}) (result LedgerUpgrade, err error)

+ func (s *LedgerUpgrade) UnmarshalBinary(inp []byte) error

+ func (s LedgerUpgrade) MarshalBinary() ([]byte, error)

+ func (t *LedgerUpgrade) Scan(src interface{}) error

+ func (u *LedgerUpgrade) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u LedgerUpgrade) ArmForSwitch(sw int32) (string, bool)

+ func (u LedgerUpgrade) EncodeTo(e *xdr.Encoder) error

+ func (u LedgerUpgrade) GetNewBaseFee() (result Uint32, ok bool)

+ func (u LedgerUpgrade) GetNewBaseReserve() (result Uint32, ok bool)

+ func (u LedgerUpgrade) GetNewFlags() (result Uint32, ok bool)

+ func (u LedgerUpgrade) GetNewLedgerVersion() (result Uint32, ok bool)

+ func (u LedgerUpgrade) GetNewMaxTxSetSize() (result Uint32, ok bool)

+ func (u LedgerUpgrade) MustNewBaseFee() Uint32

+ func (u LedgerUpgrade) MustNewBaseReserve() Uint32

+ func (u LedgerUpgrade) MustNewFlags() Uint32

+ func (u LedgerUpgrade) MustNewLedgerVersion() Uint32

+ func (u LedgerUpgrade) MustNewMaxTxSetSize() Uint32

+ func (u LedgerUpgrade) SwitchFieldName() string

+ type LedgerUpgradeType int32

+ const LedgerUpgradeTypeLedgerUpgradeBaseFee

+ const LedgerUpgradeTypeLedgerUpgradeBaseReserve

+ const LedgerUpgradeTypeLedgerUpgradeFlags

+ const LedgerUpgradeTypeLedgerUpgradeMaxTxSetSize

+ const LedgerUpgradeTypeLedgerUpgradeVersion

+ func (e *LedgerUpgradeType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e LedgerUpgradeType) EncodeTo(enc *xdr.Encoder) error

+ func (e LedgerUpgradeType) String() string

+ func (e LedgerUpgradeType) ValidEnum(v int32) bool

+ func (s *LedgerUpgradeType) UnmarshalBinary(inp []byte) error

+ func (s LedgerUpgradeType) MarshalBinary() ([]byte, error)

+ type Liabilities struct

+ Buying Int64

+ Selling Int64

+ func (s *Liabilities) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Liabilities) EncodeTo(e *xdr.Encoder) error

+ func (s *Liabilities) UnmarshalBinary(inp []byte) error

+ func (s Liabilities) MarshalBinary() ([]byte, error)

+ type LiquidityPoolConstantProductParameters struct

+ AssetA Asset

+ AssetB Asset

+ Fee Int32

+ func (s *LiquidityPoolConstantProductParameters) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LiquidityPoolConstantProductParameters) EncodeTo(e *xdr.Encoder) error

+ func (s *LiquidityPoolConstantProductParameters) UnmarshalBinary(inp []byte) error

+ func (s LiquidityPoolConstantProductParameters) MarshalBinary() ([]byte, error)

+ type LiquidityPoolDepositOp struct

+ LiquidityPoolId PoolId

+ MaxAmountA Int64

+ MaxAmountB Int64

+ MaxPrice Price

+ MinPrice Price

+ func (s *LiquidityPoolDepositOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LiquidityPoolDepositOp) EncodeTo(e *xdr.Encoder) error

+ func (s *LiquidityPoolDepositOp) UnmarshalBinary(inp []byte) error

+ func (s LiquidityPoolDepositOp) MarshalBinary() ([]byte, error)

+ type LiquidityPoolDepositResult struct

+ Code LiquidityPoolDepositResultCode

+ func NewLiquidityPoolDepositResult(code LiquidityPoolDepositResultCode, value interface{}) (result LiquidityPoolDepositResult, err error)

+ func (s *LiquidityPoolDepositResult) UnmarshalBinary(inp []byte) error

+ func (s LiquidityPoolDepositResult) MarshalBinary() ([]byte, error)

+ func (u *LiquidityPoolDepositResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u LiquidityPoolDepositResult) ArmForSwitch(sw int32) (string, bool)

+ func (u LiquidityPoolDepositResult) EncodeTo(e *xdr.Encoder) error

+ func (u LiquidityPoolDepositResult) SwitchFieldName() string

+ type LiquidityPoolDepositResultCode int32

+ const LiquidityPoolDepositResultCodeLiquidityPoolDepositBadPrice

+ const LiquidityPoolDepositResultCodeLiquidityPoolDepositLineFull

+ const LiquidityPoolDepositResultCodeLiquidityPoolDepositMalformed

+ const LiquidityPoolDepositResultCodeLiquidityPoolDepositNoTrust

+ const LiquidityPoolDepositResultCodeLiquidityPoolDepositNotAuthorized

+ const LiquidityPoolDepositResultCodeLiquidityPoolDepositPoolFull

+ const LiquidityPoolDepositResultCodeLiquidityPoolDepositSuccess

+ const LiquidityPoolDepositResultCodeLiquidityPoolDepositUnderfunded

+ func (e *LiquidityPoolDepositResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e LiquidityPoolDepositResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e LiquidityPoolDepositResultCode) String() string

+ func (e LiquidityPoolDepositResultCode) ValidEnum(v int32) bool

+ func (s *LiquidityPoolDepositResultCode) UnmarshalBinary(inp []byte) error

+ func (s LiquidityPoolDepositResultCode) MarshalBinary() ([]byte, error)

+ type LiquidityPoolEntry struct

+ Body LiquidityPoolEntryBody

+ LiquidityPoolId PoolId

+ func (s *LiquidityPoolEntry) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LiquidityPoolEntry) EncodeTo(e *xdr.Encoder) error

+ func (s *LiquidityPoolEntry) UnmarshalBinary(inp []byte) error

+ func (s LiquidityPoolEntry) MarshalBinary() ([]byte, error)

+ type LiquidityPoolEntryBody struct

+ ConstantProduct *LiquidityPoolEntryConstantProduct

+ Type LiquidityPoolType

+ func NewLiquidityPoolEntryBody(aType LiquidityPoolType, value interface{}) (result LiquidityPoolEntryBody, err error)

+ func (s *LiquidityPoolEntryBody) UnmarshalBinary(inp []byte) error

+ func (s LiquidityPoolEntryBody) MarshalBinary() ([]byte, error)

+ func (u *LiquidityPoolEntryBody) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u LiquidityPoolEntryBody) ArmForSwitch(sw int32) (string, bool)

+ func (u LiquidityPoolEntryBody) EncodeTo(e *xdr.Encoder) error

+ func (u LiquidityPoolEntryBody) GetConstantProduct() (result LiquidityPoolEntryConstantProduct, ok bool)

+ func (u LiquidityPoolEntryBody) MustConstantProduct() LiquidityPoolEntryConstantProduct

+ func (u LiquidityPoolEntryBody) SwitchFieldName() string

+ type LiquidityPoolEntryConstantProduct struct

+ Params LiquidityPoolConstantProductParameters

+ PoolSharesTrustLineCount Int64

+ ReserveA Int64

+ ReserveB Int64

+ TotalPoolShares Int64

+ func (s *LiquidityPoolEntryConstantProduct) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LiquidityPoolEntryConstantProduct) EncodeTo(e *xdr.Encoder) error

+ func (s *LiquidityPoolEntryConstantProduct) UnmarshalBinary(inp []byte) error

+ func (s LiquidityPoolEntryConstantProduct) MarshalBinary() ([]byte, error)

+ type LiquidityPoolParameters struct

+ ConstantProduct *LiquidityPoolConstantProductParameters

+ Type LiquidityPoolType

+ func NewLiquidityPoolParameters(aType LiquidityPoolType, value interface{}) (result LiquidityPoolParameters, err error)

+ func (s *LiquidityPoolParameters) UnmarshalBinary(inp []byte) error

+ func (s LiquidityPoolParameters) MarshalBinary() ([]byte, error)

+ func (u *LiquidityPoolParameters) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u LiquidityPoolParameters) ArmForSwitch(sw int32) (string, bool)

+ func (u LiquidityPoolParameters) EncodeTo(e *xdr.Encoder) error

+ func (u LiquidityPoolParameters) GetConstantProduct() (result LiquidityPoolConstantProductParameters, ok bool)

+ func (u LiquidityPoolParameters) MustConstantProduct() LiquidityPoolConstantProductParameters

+ func (u LiquidityPoolParameters) SwitchFieldName() string

+ type LiquidityPoolType int32

+ const LiquidityPoolTypeLiquidityPoolConstantProduct

+ func (e *LiquidityPoolType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e LiquidityPoolType) EncodeTo(enc *xdr.Encoder) error

+ func (e LiquidityPoolType) String() string

+ func (e LiquidityPoolType) ValidEnum(v int32) bool

+ func (s *LiquidityPoolType) UnmarshalBinary(inp []byte) error

+ func (s LiquidityPoolType) MarshalBinary() ([]byte, error)

+ type LiquidityPoolWithdrawOp struct

+ Amount Int64

+ LiquidityPoolId PoolId

+ MinAmountA Int64

+ MinAmountB Int64

+ func (s *LiquidityPoolWithdrawOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *LiquidityPoolWithdrawOp) EncodeTo(e *xdr.Encoder) error

+ func (s *LiquidityPoolWithdrawOp) UnmarshalBinary(inp []byte) error

+ func (s LiquidityPoolWithdrawOp) MarshalBinary() ([]byte, error)

+ type LiquidityPoolWithdrawResult struct

+ Code LiquidityPoolWithdrawResultCode

+ func NewLiquidityPoolWithdrawResult(code LiquidityPoolWithdrawResultCode, value interface{}) (result LiquidityPoolWithdrawResult, err error)

+ func (s *LiquidityPoolWithdrawResult) UnmarshalBinary(inp []byte) error

+ func (s LiquidityPoolWithdrawResult) MarshalBinary() ([]byte, error)

+ func (u *LiquidityPoolWithdrawResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u LiquidityPoolWithdrawResult) ArmForSwitch(sw int32) (string, bool)

+ func (u LiquidityPoolWithdrawResult) EncodeTo(e *xdr.Encoder) error

+ func (u LiquidityPoolWithdrawResult) SwitchFieldName() string

+ type LiquidityPoolWithdrawResultCode int32

+ const LiquidityPoolWithdrawResultCodeLiquidityPoolWithdrawLineFull

+ const LiquidityPoolWithdrawResultCodeLiquidityPoolWithdrawMalformed

+ const LiquidityPoolWithdrawResultCodeLiquidityPoolWithdrawNoTrust

+ const LiquidityPoolWithdrawResultCodeLiquidityPoolWithdrawSuccess

+ const LiquidityPoolWithdrawResultCodeLiquidityPoolWithdrawUnderMinimum

+ const LiquidityPoolWithdrawResultCodeLiquidityPoolWithdrawUnderfunded

+ func (e *LiquidityPoolWithdrawResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e LiquidityPoolWithdrawResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e LiquidityPoolWithdrawResultCode) String() string

+ func (e LiquidityPoolWithdrawResultCode) ValidEnum(v int32) bool

+ func (s *LiquidityPoolWithdrawResultCode) UnmarshalBinary(inp []byte) error

+ func (s LiquidityPoolWithdrawResultCode) MarshalBinary() ([]byte, error)

+ type ManageBuyOfferOp struct

+ BuyAmount Int64

+ Buying Asset

+ OfferId Int64

+ Price Price

+ Selling Asset

+ func (s *ManageBuyOfferOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ManageBuyOfferOp) EncodeTo(e *xdr.Encoder) error

+ func (s *ManageBuyOfferOp) UnmarshalBinary(inp []byte) error

+ func (s ManageBuyOfferOp) MarshalBinary() ([]byte, error)

+ type ManageBuyOfferResult struct

+ Code ManageBuyOfferResultCode

+ Success *ManageOfferSuccessResult

+ func NewManageBuyOfferResult(code ManageBuyOfferResultCode, value interface{}) (result ManageBuyOfferResult, err error)

+ func (s *ManageBuyOfferResult) UnmarshalBinary(inp []byte) error

+ func (s ManageBuyOfferResult) MarshalBinary() ([]byte, error)

+ func (u *ManageBuyOfferResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ManageBuyOfferResult) ArmForSwitch(sw int32) (string, bool)

+ func (u ManageBuyOfferResult) EncodeTo(e *xdr.Encoder) error

+ func (u ManageBuyOfferResult) GetSuccess() (result ManageOfferSuccessResult, ok bool)

+ func (u ManageBuyOfferResult) MustSuccess() ManageOfferSuccessResult

+ func (u ManageBuyOfferResult) SwitchFieldName() string

+ type ManageBuyOfferResultCode int32

+ const ManageBuyOfferResultCodeManageBuyOfferBuyNoIssuer

+ const ManageBuyOfferResultCodeManageBuyOfferBuyNoTrust

+ const ManageBuyOfferResultCodeManageBuyOfferBuyNotAuthorized

+ const ManageBuyOfferResultCodeManageBuyOfferCrossSelf

+ const ManageBuyOfferResultCodeManageBuyOfferLineFull

+ const ManageBuyOfferResultCodeManageBuyOfferLowReserve

+ const ManageBuyOfferResultCodeManageBuyOfferMalformed

+ const ManageBuyOfferResultCodeManageBuyOfferNotFound

+ const ManageBuyOfferResultCodeManageBuyOfferSellNoIssuer

+ const ManageBuyOfferResultCodeManageBuyOfferSellNoTrust

+ const ManageBuyOfferResultCodeManageBuyOfferSellNotAuthorized

+ const ManageBuyOfferResultCodeManageBuyOfferSuccess

+ const ManageBuyOfferResultCodeManageBuyOfferUnderfunded

+ func (e *ManageBuyOfferResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ManageBuyOfferResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e ManageBuyOfferResultCode) String() string

+ func (e ManageBuyOfferResultCode) ValidEnum(v int32) bool

+ func (s *ManageBuyOfferResultCode) UnmarshalBinary(inp []byte) error

+ func (s ManageBuyOfferResultCode) MarshalBinary() ([]byte, error)

+ type ManageDataOp struct

+ DataName String64

+ DataValue *DataValue

+ func (s *ManageDataOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ManageDataOp) EncodeTo(e *xdr.Encoder) error

+ func (s *ManageDataOp) UnmarshalBinary(inp []byte) error

+ func (s ManageDataOp) GoString() string

+ func (s ManageDataOp) MarshalBinary() ([]byte, error)

+ type ManageDataResult struct

+ Code ManageDataResultCode

+ func NewManageDataResult(code ManageDataResultCode, value interface{}) (result ManageDataResult, err error)

+ func (s *ManageDataResult) UnmarshalBinary(inp []byte) error

+ func (s ManageDataResult) MarshalBinary() ([]byte, error)

+ func (u *ManageDataResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ManageDataResult) ArmForSwitch(sw int32) (string, bool)

+ func (u ManageDataResult) EncodeTo(e *xdr.Encoder) error

+ func (u ManageDataResult) SwitchFieldName() string

+ type ManageDataResultCode int32

+ const ManageDataResultCodeManageDataInvalidName

+ const ManageDataResultCodeManageDataLowReserve

+ const ManageDataResultCodeManageDataNameNotFound

+ const ManageDataResultCodeManageDataNotSupportedYet

+ const ManageDataResultCodeManageDataSuccess

+ func (e *ManageDataResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ManageDataResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e ManageDataResultCode) String() string

+ func (e ManageDataResultCode) ValidEnum(v int32) bool

+ func (s *ManageDataResultCode) UnmarshalBinary(inp []byte) error

+ func (s ManageDataResultCode) MarshalBinary() ([]byte, error)

+ type ManageOfferEffect int32

+ const ManageOfferEffectManageOfferCreated

+ const ManageOfferEffectManageOfferDeleted

+ const ManageOfferEffectManageOfferUpdated

+ func (e *ManageOfferEffect) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ManageOfferEffect) EncodeTo(enc *xdr.Encoder) error

+ func (e ManageOfferEffect) String() string

+ func (e ManageOfferEffect) ValidEnum(v int32) bool

+ func (s *ManageOfferEffect) UnmarshalBinary(inp []byte) error

+ func (s ManageOfferEffect) MarshalBinary() ([]byte, error)

+ type ManageOfferSuccessResult struct

+ Offer ManageOfferSuccessResultOffer

+ OffersClaimed []ClaimAtom

+ func (s *ManageOfferSuccessResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ManageOfferSuccessResult) EncodeTo(e *xdr.Encoder) error

+ func (s *ManageOfferSuccessResult) UnmarshalBinary(inp []byte) error

+ func (s ManageOfferSuccessResult) MarshalBinary() ([]byte, error)

+ type ManageOfferSuccessResultOffer struct

+ Effect ManageOfferEffect

+ Offer *OfferEntry

+ func NewManageOfferSuccessResultOffer(effect ManageOfferEffect, value interface{}) (result ManageOfferSuccessResultOffer, err error)

+ func (s *ManageOfferSuccessResultOffer) UnmarshalBinary(inp []byte) error

+ func (s ManageOfferSuccessResultOffer) MarshalBinary() ([]byte, error)

+ func (u *ManageOfferSuccessResultOffer) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ManageOfferSuccessResultOffer) ArmForSwitch(sw int32) (string, bool)

+ func (u ManageOfferSuccessResultOffer) EncodeTo(e *xdr.Encoder) error

+ func (u ManageOfferSuccessResultOffer) GetOffer() (result OfferEntry, ok bool)

+ func (u ManageOfferSuccessResultOffer) MustOffer() OfferEntry

+ func (u ManageOfferSuccessResultOffer) SwitchFieldName() string

+ type ManageSellOfferOp struct

+ Amount Int64

+ Buying Asset

+ OfferId Int64

+ Price Price

+ Selling Asset

+ func (s *ManageSellOfferOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ManageSellOfferOp) EncodeTo(e *xdr.Encoder) error

+ func (s *ManageSellOfferOp) UnmarshalBinary(inp []byte) error

+ func (s ManageSellOfferOp) MarshalBinary() ([]byte, error)

+ type ManageSellOfferResult struct

+ Code ManageSellOfferResultCode

+ Success *ManageOfferSuccessResult

+ func NewManageSellOfferResult(code ManageSellOfferResultCode, value interface{}) (result ManageSellOfferResult, err error)

+ func (s *ManageSellOfferResult) UnmarshalBinary(inp []byte) error

+ func (s ManageSellOfferResult) MarshalBinary() ([]byte, error)

+ func (u *ManageSellOfferResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ManageSellOfferResult) ArmForSwitch(sw int32) (string, bool)

+ func (u ManageSellOfferResult) EncodeTo(e *xdr.Encoder) error

+ func (u ManageSellOfferResult) GetSuccess() (result ManageOfferSuccessResult, ok bool)

+ func (u ManageSellOfferResult) MustSuccess() ManageOfferSuccessResult

+ func (u ManageSellOfferResult) SwitchFieldName() string

+ type ManageSellOfferResultCode int32

+ const ManageSellOfferResultCodeManageSellOfferBuyNoIssuer

+ const ManageSellOfferResultCodeManageSellOfferBuyNoTrust

+ const ManageSellOfferResultCodeManageSellOfferBuyNotAuthorized

+ const ManageSellOfferResultCodeManageSellOfferCrossSelf

+ const ManageSellOfferResultCodeManageSellOfferLineFull

+ const ManageSellOfferResultCodeManageSellOfferLowReserve

+ const ManageSellOfferResultCodeManageSellOfferMalformed

+ const ManageSellOfferResultCodeManageSellOfferNotFound

+ const ManageSellOfferResultCodeManageSellOfferSellNoIssuer

+ const ManageSellOfferResultCodeManageSellOfferSellNoTrust

+ const ManageSellOfferResultCodeManageSellOfferSellNotAuthorized

+ const ManageSellOfferResultCodeManageSellOfferSuccess

+ const ManageSellOfferResultCodeManageSellOfferUnderfunded

+ func (e *ManageSellOfferResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ManageSellOfferResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e ManageSellOfferResultCode) String() string

+ func (e ManageSellOfferResultCode) ValidEnum(v int32) bool

+ func (s *ManageSellOfferResultCode) UnmarshalBinary(inp []byte) error

+ func (s ManageSellOfferResultCode) MarshalBinary() ([]byte, error)

+ type Memo struct

+ Hash *Hash

+ Id *Uint64

+ RetHash *Hash

+ Text *string

+ Type MemoType

+ func MemoHash(hash Hash) Memo

+ func MemoID(id uint64) Memo

+ func MemoRetHash(hash Hash) Memo

+ func MemoText(text string) Memo

+ func NewMemo(aType MemoType, value interface{}) (result Memo, err error)

+ func (m Memo) GoString() string

+ func (s *Memo) UnmarshalBinary(inp []byte) error

+ func (s Memo) MarshalBinary() ([]byte, error)

+ func (u *Memo) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u Memo) ArmForSwitch(sw int32) (string, bool)

+ func (u Memo) EncodeTo(e *xdr.Encoder) error

+ func (u Memo) GetHash() (result Hash, ok bool)

+ func (u Memo) GetId() (result Uint64, ok bool)

+ func (u Memo) GetRetHash() (result Hash, ok bool)

+ func (u Memo) GetText() (result string, ok bool)

+ func (u Memo) MustHash() Hash

+ func (u Memo) MustId() Uint64

+ func (u Memo) MustRetHash() Hash

+ func (u Memo) MustText() string

+ func (u Memo) SwitchFieldName() string

+ type MemoType int32

+ const MemoTypeMemoHash

+ const MemoTypeMemoId

+ const MemoTypeMemoNone

+ const MemoTypeMemoReturn

+ const MemoTypeMemoText

+ func (e *MemoType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e MemoType) EncodeTo(enc *xdr.Encoder) error

+ func (e MemoType) String() string

+ func (e MemoType) ValidEnum(v int32) bool

+ func (s *MemoType) UnmarshalBinary(inp []byte) error

+ func (s MemoType) MarshalBinary() ([]byte, error)

+ type MessageType int32

+ const MessageTypeAuth

+ const MessageTypeDontHave

+ const MessageTypeErrorMsg

+ const MessageTypeGetPeers

+ const MessageTypeGetScpQuorumset

+ const MessageTypeGetScpState

+ const MessageTypeGetTxSet

+ const MessageTypeHello

+ const MessageTypePeers

+ const MessageTypeScpMessage

+ const MessageTypeScpQuorumset

+ const MessageTypeSurveyRequest

+ const MessageTypeSurveyResponse

+ const MessageTypeTransaction

+ const MessageTypeTxSet

+ func (e *MessageType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e MessageType) EncodeTo(enc *xdr.Encoder) error

+ func (e MessageType) String() string

+ func (e MessageType) ValidEnum(v int32) bool

+ func (s *MessageType) UnmarshalBinary(inp []byte) error

+ func (s MessageType) MarshalBinary() ([]byte, error)

+ type MuxedAccount struct

+ Ed25519 *Uint256

+ Med25519 *MuxedAccountMed25519

+ Type CryptoKeyType

+ func AddressToMuxedAccount(address string) (MuxedAccount, error)

+ func MustMuxedAddress(address string) MuxedAccount

+ func MustMuxedAddressPtr(address string) *MuxedAccount

+ func MuxedAccountFromAccountId(gAddress string, id uint64) (MuxedAccount, error)

+ func NewMuxedAccount(aType CryptoKeyType, value interface{}) (result MuxedAccount, err error)

+ func (m *MuxedAccount) Address() string

+ func (m *MuxedAccount) GetAddress() (string, error)

+ func (m *MuxedAccount) GetId() (uint64, error)

+ func (m *MuxedAccount) SetAddress(address string) error

+ func (m *MuxedAccount) SetEd25519Address(address string) error

+ func (m MuxedAccount) GoString() string

+ func (m MuxedAccount) ToAccountId() AccountId

+ func (s *MuxedAccount) UnmarshalBinary(inp []byte) error

+ func (s MuxedAccount) MarshalBinary() ([]byte, error)

+ func (u *MuxedAccount) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u MuxedAccount) ArmForSwitch(sw int32) (string, bool)

+ func (u MuxedAccount) EncodeTo(e *xdr.Encoder) error

+ func (u MuxedAccount) GetEd25519() (result Uint256, ok bool)

+ func (u MuxedAccount) GetMed25519() (result MuxedAccountMed25519, ok bool)

+ func (u MuxedAccount) MustEd25519() Uint256

+ func (u MuxedAccount) MustMed25519() MuxedAccountMed25519

+ func (u MuxedAccount) SwitchFieldName() string

+ type MuxedAccountMed25519 struct

+ Ed25519 Uint256

+ Id Uint64

+ func (s *MuxedAccountMed25519) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *MuxedAccountMed25519) EncodeTo(e *xdr.Encoder) error

+ func (s *MuxedAccountMed25519) UnmarshalBinary(inp []byte) error

+ func (s MuxedAccountMed25519) MarshalBinary() ([]byte, error)

+ type NodeId PublicKey

+ func NewNodeId(aType PublicKeyType, value interface{}) (result NodeId, err error)

+ func (s *NodeId) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *NodeId) UnmarshalBinary(inp []byte) error

+ func (s NodeId) EncodeTo(e *xdr.Encoder) error

+ func (s NodeId) MarshalBinary() ([]byte, error)

+ func (u NodeId) ArmForSwitch(sw int32) (string, bool)

+ func (u NodeId) GetEd25519() (result Uint256, ok bool)

+ func (u NodeId) MustEd25519() Uint256

+ func (u NodeId) SwitchFieldName() string

+ type OfferEntry struct

+ Amount Int64

+ Buying Asset

+ Ext OfferEntryExt

+ Flags Uint32

+ OfferId Int64

+ Price Price

+ SellerId AccountId

+ Selling Asset

+ func (s *OfferEntry) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *OfferEntry) EncodeTo(e *xdr.Encoder) error

+ func (s *OfferEntry) UnmarshalBinary(inp []byte) error

+ func (s OfferEntry) MarshalBinary() ([]byte, error)

+ type OfferEntryExt struct

+ V int32

+ func NewOfferEntryExt(v int32, value interface{}) (result OfferEntryExt, err error)

+ func (s *OfferEntryExt) UnmarshalBinary(inp []byte) error

+ func (s OfferEntryExt) MarshalBinary() ([]byte, error)

+ func (u *OfferEntryExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u OfferEntryExt) ArmForSwitch(sw int32) (string, bool)

+ func (u OfferEntryExt) EncodeTo(e *xdr.Encoder) error

+ func (u OfferEntryExt) SwitchFieldName() string

+ type OfferEntryFlags int32

+ const OfferEntryFlagsPassiveFlag

+ func (e *OfferEntryFlags) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e OfferEntryFlags) EncodeTo(enc *xdr.Encoder) error

+ func (e OfferEntryFlags) String() string

+ func (e OfferEntryFlags) ValidEnum(v int32) bool

+ func (s *OfferEntryFlags) UnmarshalBinary(inp []byte) error

+ func (s OfferEntryFlags) MarshalBinary() ([]byte, error)

+ type Operation struct

+ Body OperationBody

+ SourceAccount *MuxedAccount

+ func (o Operation) GoString() string

+ func (s *Operation) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Operation) EncodeTo(e *xdr.Encoder) error

+ func (s *Operation) UnmarshalBinary(inp []byte) error

+ func (s Operation) MarshalBinary() ([]byte, error)

+ type OperationBody struct

+ AllowTrustOp *AllowTrustOp

+ BeginSponsoringFutureReservesOp *BeginSponsoringFutureReservesOp

+ BumpSequenceOp *BumpSequenceOp

+ ChangeTrustOp *ChangeTrustOp

+ ClaimClaimableBalanceOp *ClaimClaimableBalanceOp

+ ClawbackClaimableBalanceOp *ClawbackClaimableBalanceOp

+ ClawbackOp *ClawbackOp

+ CreateAccountOp *CreateAccountOp

+ CreateClaimableBalanceOp *CreateClaimableBalanceOp

+ CreatePassiveSellOfferOp *CreatePassiveSellOfferOp

+ Destination *MuxedAccount

+ LiquidityPoolDepositOp *LiquidityPoolDepositOp

+ LiquidityPoolWithdrawOp *LiquidityPoolWithdrawOp

+ ManageBuyOfferOp *ManageBuyOfferOp

+ ManageDataOp *ManageDataOp

+ ManageSellOfferOp *ManageSellOfferOp

+ PathPaymentStrictReceiveOp *PathPaymentStrictReceiveOp

+ PathPaymentStrictSendOp *PathPaymentStrictSendOp

+ PaymentOp *PaymentOp

+ RevokeSponsorshipOp *RevokeSponsorshipOp

+ SetOptionsOp *SetOptionsOp

+ SetTrustLineFlagsOp *SetTrustLineFlagsOp

+ Type OperationType

+ func NewOperationBody(aType OperationType, value interface{}) (result OperationBody, err error)

+ func (o OperationBody) GoString() string

+ func (s *OperationBody) UnmarshalBinary(inp []byte) error

+ func (s OperationBody) MarshalBinary() ([]byte, error)

+ func (u *OperationBody) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u OperationBody) ArmForSwitch(sw int32) (string, bool)

+ func (u OperationBody) EncodeTo(e *xdr.Encoder) error

+ func (u OperationBody) GetAllowTrustOp() (result AllowTrustOp, ok bool)

+ func (u OperationBody) GetBeginSponsoringFutureReservesOp() (result BeginSponsoringFutureReservesOp, ok bool)

+ func (u OperationBody) GetBumpSequenceOp() (result BumpSequenceOp, ok bool)

+ func (u OperationBody) GetChangeTrustOp() (result ChangeTrustOp, ok bool)

+ func (u OperationBody) GetClaimClaimableBalanceOp() (result ClaimClaimableBalanceOp, ok bool)

+ func (u OperationBody) GetClawbackClaimableBalanceOp() (result ClawbackClaimableBalanceOp, ok bool)

+ func (u OperationBody) GetClawbackOp() (result ClawbackOp, ok bool)

+ func (u OperationBody) GetCreateAccountOp() (result CreateAccountOp, ok bool)

+ func (u OperationBody) GetCreateClaimableBalanceOp() (result CreateClaimableBalanceOp, ok bool)

+ func (u OperationBody) GetCreatePassiveSellOfferOp() (result CreatePassiveSellOfferOp, ok bool)

+ func (u OperationBody) GetDestination() (result MuxedAccount, ok bool)

+ func (u OperationBody) GetLiquidityPoolDepositOp() (result LiquidityPoolDepositOp, ok bool)

+ func (u OperationBody) GetLiquidityPoolWithdrawOp() (result LiquidityPoolWithdrawOp, ok bool)

+ func (u OperationBody) GetManageBuyOfferOp() (result ManageBuyOfferOp, ok bool)

+ func (u OperationBody) GetManageDataOp() (result ManageDataOp, ok bool)

+ func (u OperationBody) GetManageSellOfferOp() (result ManageSellOfferOp, ok bool)

+ func (u OperationBody) GetPathPaymentStrictReceiveOp() (result PathPaymentStrictReceiveOp, ok bool)

+ func (u OperationBody) GetPathPaymentStrictSendOp() (result PathPaymentStrictSendOp, ok bool)

+ func (u OperationBody) GetPaymentOp() (result PaymentOp, ok bool)

+ func (u OperationBody) GetRevokeSponsorshipOp() (result RevokeSponsorshipOp, ok bool)

+ func (u OperationBody) GetSetOptionsOp() (result SetOptionsOp, ok bool)

+ func (u OperationBody) GetSetTrustLineFlagsOp() (result SetTrustLineFlagsOp, ok bool)

+ func (u OperationBody) MustAllowTrustOp() AllowTrustOp

+ func (u OperationBody) MustBeginSponsoringFutureReservesOp() BeginSponsoringFutureReservesOp

+ func (u OperationBody) MustBumpSequenceOp() BumpSequenceOp

+ func (u OperationBody) MustChangeTrustOp() ChangeTrustOp

+ func (u OperationBody) MustClaimClaimableBalanceOp() ClaimClaimableBalanceOp

+ func (u OperationBody) MustClawbackClaimableBalanceOp() ClawbackClaimableBalanceOp

+ func (u OperationBody) MustClawbackOp() ClawbackOp

+ func (u OperationBody) MustCreateAccountOp() CreateAccountOp

+ func (u OperationBody) MustCreateClaimableBalanceOp() CreateClaimableBalanceOp

+ func (u OperationBody) MustCreatePassiveSellOfferOp() CreatePassiveSellOfferOp

+ func (u OperationBody) MustDestination() MuxedAccount

+ func (u OperationBody) MustLiquidityPoolDepositOp() LiquidityPoolDepositOp

+ func (u OperationBody) MustLiquidityPoolWithdrawOp() LiquidityPoolWithdrawOp

+ func (u OperationBody) MustManageBuyOfferOp() ManageBuyOfferOp

+ func (u OperationBody) MustManageDataOp() ManageDataOp

+ func (u OperationBody) MustManageSellOfferOp() ManageSellOfferOp

+ func (u OperationBody) MustPathPaymentStrictReceiveOp() PathPaymentStrictReceiveOp

+ func (u OperationBody) MustPathPaymentStrictSendOp() PathPaymentStrictSendOp

+ func (u OperationBody) MustPaymentOp() PaymentOp

+ func (u OperationBody) MustRevokeSponsorshipOp() RevokeSponsorshipOp

+ func (u OperationBody) MustSetOptionsOp() SetOptionsOp

+ func (u OperationBody) MustSetTrustLineFlagsOp() SetTrustLineFlagsOp

+ func (u OperationBody) SwitchFieldName() string

+ type OperationMeta struct

+ Changes LedgerEntryChanges

+ func (s *OperationMeta) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *OperationMeta) EncodeTo(e *xdr.Encoder) error

+ func (s *OperationMeta) UnmarshalBinary(inp []byte) error

+ func (s OperationMeta) MarshalBinary() ([]byte, error)

+ type OperationResult struct

+ Code OperationResultCode

+ Tr *OperationResultTr

+ func NewOperationResult(code OperationResultCode, value interface{}) (result OperationResult, err error)

+ func (s *OperationResult) UnmarshalBinary(inp []byte) error

+ func (s OperationResult) MarshalBinary() ([]byte, error)

+ func (u *OperationResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u OperationResult) ArmForSwitch(sw int32) (string, bool)

+ func (u OperationResult) EncodeTo(e *xdr.Encoder) error

+ func (u OperationResult) GetTr() (result OperationResultTr, ok bool)

+ func (u OperationResult) MustTr() OperationResultTr

+ func (u OperationResult) SwitchFieldName() string

+ type OperationResultCode int32

+ const OperationResultCodeOpBadAuth

+ const OperationResultCodeOpExceededWorkLimit

+ const OperationResultCodeOpInner

+ const OperationResultCodeOpNoAccount

+ const OperationResultCodeOpNotSupported

+ const OperationResultCodeOpTooManySponsoring

+ const OperationResultCodeOpTooManySubentries

+ func (e *OperationResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e OperationResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e OperationResultCode) String() string

+ func (e OperationResultCode) ValidEnum(v int32) bool

+ func (s *OperationResultCode) UnmarshalBinary(inp []byte) error

+ func (s OperationResultCode) MarshalBinary() ([]byte, error)

+ type OperationResultTr struct

+ AccountMergeResult *AccountMergeResult

+ AllowTrustResult *AllowTrustResult

+ BeginSponsoringFutureReservesResult *BeginSponsoringFutureReservesResult

+ BumpSeqResult *BumpSequenceResult

+ ChangeTrustResult *ChangeTrustResult

+ ClaimClaimableBalanceResult *ClaimClaimableBalanceResult

+ ClawbackClaimableBalanceResult *ClawbackClaimableBalanceResult

+ ClawbackResult *ClawbackResult

+ CreateAccountResult *CreateAccountResult

+ CreateClaimableBalanceResult *CreateClaimableBalanceResult

+ CreatePassiveSellOfferResult *ManageSellOfferResult

+ EndSponsoringFutureReservesResult *EndSponsoringFutureReservesResult

+ InflationResult *InflationResult

+ LiquidityPoolDepositResult *LiquidityPoolDepositResult

+ LiquidityPoolWithdrawResult *LiquidityPoolWithdrawResult

+ ManageBuyOfferResult *ManageBuyOfferResult

+ ManageDataResult *ManageDataResult

+ ManageSellOfferResult *ManageSellOfferResult

+ PathPaymentStrictReceiveResult *PathPaymentStrictReceiveResult

+ PathPaymentStrictSendResult *PathPaymentStrictSendResult

+ PaymentResult *PaymentResult

+ RevokeSponsorshipResult *RevokeSponsorshipResult

+ SetOptionsResult *SetOptionsResult

+ SetTrustLineFlagsResult *SetTrustLineFlagsResult

+ Type OperationType

+ func NewOperationResultTr(aType OperationType, value interface{}) (result OperationResultTr, err error)

+ func (s *OperationResultTr) UnmarshalBinary(inp []byte) error

+ func (s OperationResultTr) MarshalBinary() ([]byte, error)

+ func (u *OperationResultTr) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u OperationResultTr) ArmForSwitch(sw int32) (string, bool)

+ func (u OperationResultTr) EncodeTo(e *xdr.Encoder) error

+ func (u OperationResultTr) GetAccountMergeResult() (result AccountMergeResult, ok bool)

+ func (u OperationResultTr) GetAllowTrustResult() (result AllowTrustResult, ok bool)

+ func (u OperationResultTr) GetBeginSponsoringFutureReservesResult() (result BeginSponsoringFutureReservesResult, ok bool)

+ func (u OperationResultTr) GetBumpSeqResult() (result BumpSequenceResult, ok bool)

+ func (u OperationResultTr) GetChangeTrustResult() (result ChangeTrustResult, ok bool)

+ func (u OperationResultTr) GetClaimClaimableBalanceResult() (result ClaimClaimableBalanceResult, ok bool)

+ func (u OperationResultTr) GetClawbackClaimableBalanceResult() (result ClawbackClaimableBalanceResult, ok bool)

+ func (u OperationResultTr) GetClawbackResult() (result ClawbackResult, ok bool)

+ func (u OperationResultTr) GetCreateAccountResult() (result CreateAccountResult, ok bool)

+ func (u OperationResultTr) GetCreateClaimableBalanceResult() (result CreateClaimableBalanceResult, ok bool)

+ func (u OperationResultTr) GetCreatePassiveSellOfferResult() (result ManageSellOfferResult, ok bool)

+ func (u OperationResultTr) GetEndSponsoringFutureReservesResult() (result EndSponsoringFutureReservesResult, ok bool)

+ func (u OperationResultTr) GetInflationResult() (result InflationResult, ok bool)

+ func (u OperationResultTr) GetLiquidityPoolDepositResult() (result LiquidityPoolDepositResult, ok bool)

+ func (u OperationResultTr) GetLiquidityPoolWithdrawResult() (result LiquidityPoolWithdrawResult, ok bool)

+ func (u OperationResultTr) GetManageBuyOfferResult() (result ManageBuyOfferResult, ok bool)

+ func (u OperationResultTr) GetManageDataResult() (result ManageDataResult, ok bool)

+ func (u OperationResultTr) GetManageSellOfferResult() (result ManageSellOfferResult, ok bool)

+ func (u OperationResultTr) GetPathPaymentStrictReceiveResult() (result PathPaymentStrictReceiveResult, ok bool)

+ func (u OperationResultTr) GetPathPaymentStrictSendResult() (result PathPaymentStrictSendResult, ok bool)

+ func (u OperationResultTr) GetPaymentResult() (result PaymentResult, ok bool)

+ func (u OperationResultTr) GetRevokeSponsorshipResult() (result RevokeSponsorshipResult, ok bool)

+ func (u OperationResultTr) GetSetOptionsResult() (result SetOptionsResult, ok bool)

+ func (u OperationResultTr) GetSetTrustLineFlagsResult() (result SetTrustLineFlagsResult, ok bool)

+ func (u OperationResultTr) MustAccountMergeResult() AccountMergeResult

+ func (u OperationResultTr) MustAllowTrustResult() AllowTrustResult

+ func (u OperationResultTr) MustBeginSponsoringFutureReservesResult() BeginSponsoringFutureReservesResult

+ func (u OperationResultTr) MustBumpSeqResult() BumpSequenceResult

+ func (u OperationResultTr) MustChangeTrustResult() ChangeTrustResult

+ func (u OperationResultTr) MustClaimClaimableBalanceResult() ClaimClaimableBalanceResult

+ func (u OperationResultTr) MustClawbackClaimableBalanceResult() ClawbackClaimableBalanceResult

+ func (u OperationResultTr) MustClawbackResult() ClawbackResult

+ func (u OperationResultTr) MustCreateAccountResult() CreateAccountResult

+ func (u OperationResultTr) MustCreateClaimableBalanceResult() CreateClaimableBalanceResult

+ func (u OperationResultTr) MustCreatePassiveSellOfferResult() ManageSellOfferResult

+ func (u OperationResultTr) MustEndSponsoringFutureReservesResult() EndSponsoringFutureReservesResult

+ func (u OperationResultTr) MustInflationResult() InflationResult

+ func (u OperationResultTr) MustLiquidityPoolDepositResult() LiquidityPoolDepositResult

+ func (u OperationResultTr) MustLiquidityPoolWithdrawResult() LiquidityPoolWithdrawResult

+ func (u OperationResultTr) MustManageBuyOfferResult() ManageBuyOfferResult

+ func (u OperationResultTr) MustManageDataResult() ManageDataResult

+ func (u OperationResultTr) MustManageSellOfferResult() ManageSellOfferResult

+ func (u OperationResultTr) MustPathPaymentStrictReceiveResult() PathPaymentStrictReceiveResult

+ func (u OperationResultTr) MustPathPaymentStrictSendResult() PathPaymentStrictSendResult

+ func (u OperationResultTr) MustPaymentResult() PaymentResult

+ func (u OperationResultTr) MustRevokeSponsorshipResult() RevokeSponsorshipResult

+ func (u OperationResultTr) MustSetOptionsResult() SetOptionsResult

+ func (u OperationResultTr) MustSetTrustLineFlagsResult() SetTrustLineFlagsResult

+ func (u OperationResultTr) SwitchFieldName() string

+ type OperationType int32

+ const OperationTypeAccountMerge

+ const OperationTypeAllowTrust

+ const OperationTypeBeginSponsoringFutureReserves

+ const OperationTypeBumpSequence

+ const OperationTypeChangeTrust

+ const OperationTypeClaimClaimableBalance

+ const OperationTypeClawback

+ const OperationTypeClawbackClaimableBalance

+ const OperationTypeCreateAccount

+ const OperationTypeCreateClaimableBalance

+ const OperationTypeCreatePassiveSellOffer

+ const OperationTypeEndSponsoringFutureReserves

+ const OperationTypeInflation

+ const OperationTypeLiquidityPoolDeposit

+ const OperationTypeLiquidityPoolWithdraw

+ const OperationTypeManageBuyOffer

+ const OperationTypeManageData

+ const OperationTypeManageSellOffer

+ const OperationTypePathPaymentStrictReceive

+ const OperationTypePathPaymentStrictSend

+ const OperationTypePayment

+ const OperationTypeRevokeSponsorship

+ const OperationTypeSetOptions

+ const OperationTypeSetTrustLineFlags

+ func (e *OperationType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e OperationType) EncodeTo(enc *xdr.Encoder) error

+ func (e OperationType) String() string

+ func (e OperationType) ValidEnum(v int32) bool

+ func (s *OperationType) UnmarshalBinary(inp []byte) error

+ func (s OperationType) MarshalBinary() ([]byte, error)

+ type PathPaymentStrictReceiveOp struct

+ DestAmount Int64

+ DestAsset Asset

+ Destination MuxedAccount

+ Path []Asset

+ SendAsset Asset

+ SendMax Int64

+ func (s *PathPaymentStrictReceiveOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *PathPaymentStrictReceiveOp) EncodeTo(e *xdr.Encoder) error

+ func (s *PathPaymentStrictReceiveOp) UnmarshalBinary(inp []byte) error

+ func (s PathPaymentStrictReceiveOp) MarshalBinary() ([]byte, error)

+ type PathPaymentStrictReceiveResult struct

+ Code PathPaymentStrictReceiveResultCode

+ NoIssuer *Asset

+ Success *PathPaymentStrictReceiveResultSuccess

+ func NewPathPaymentStrictReceiveResult(code PathPaymentStrictReceiveResultCode, value interface{}) (result PathPaymentStrictReceiveResult, err error)

+ func (pr *PathPaymentStrictReceiveResult) SendAmount() Int64

+ func (s *PathPaymentStrictReceiveResult) UnmarshalBinary(inp []byte) error

+ func (s PathPaymentStrictReceiveResult) MarshalBinary() ([]byte, error)

+ func (u *PathPaymentStrictReceiveResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u PathPaymentStrictReceiveResult) ArmForSwitch(sw int32) (string, bool)

+ func (u PathPaymentStrictReceiveResult) EncodeTo(e *xdr.Encoder) error

+ func (u PathPaymentStrictReceiveResult) GetNoIssuer() (result Asset, ok bool)

+ func (u PathPaymentStrictReceiveResult) GetSuccess() (result PathPaymentStrictReceiveResultSuccess, ok bool)

+ func (u PathPaymentStrictReceiveResult) MustNoIssuer() Asset

+ func (u PathPaymentStrictReceiveResult) MustSuccess() PathPaymentStrictReceiveResultSuccess

+ func (u PathPaymentStrictReceiveResult) SwitchFieldName() string

+ type PathPaymentStrictReceiveResultCode int32

+ const PathPaymentStrictReceiveResultCodePathPaymentStrictReceiveLineFull

+ const PathPaymentStrictReceiveResultCodePathPaymentStrictReceiveMalformed

+ const PathPaymentStrictReceiveResultCodePathPaymentStrictReceiveNoDestination

+ const PathPaymentStrictReceiveResultCodePathPaymentStrictReceiveNoIssuer

+ const PathPaymentStrictReceiveResultCodePathPaymentStrictReceiveNoTrust

+ const PathPaymentStrictReceiveResultCodePathPaymentStrictReceiveNotAuthorized

+ const PathPaymentStrictReceiveResultCodePathPaymentStrictReceiveOfferCrossSelf

+ const PathPaymentStrictReceiveResultCodePathPaymentStrictReceiveOverSendmax

+ const PathPaymentStrictReceiveResultCodePathPaymentStrictReceiveSrcNoTrust

+ const PathPaymentStrictReceiveResultCodePathPaymentStrictReceiveSrcNotAuthorized

+ const PathPaymentStrictReceiveResultCodePathPaymentStrictReceiveSuccess

+ const PathPaymentStrictReceiveResultCodePathPaymentStrictReceiveTooFewOffers

+ const PathPaymentStrictReceiveResultCodePathPaymentStrictReceiveUnderfunded

+ func (e *PathPaymentStrictReceiveResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e PathPaymentStrictReceiveResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e PathPaymentStrictReceiveResultCode) String() string

+ func (e PathPaymentStrictReceiveResultCode) ValidEnum(v int32) bool

+ func (s *PathPaymentStrictReceiveResultCode) UnmarshalBinary(inp []byte) error

+ func (s PathPaymentStrictReceiveResultCode) MarshalBinary() ([]byte, error)

+ type PathPaymentStrictReceiveResultSuccess struct

+ Last SimplePaymentResult

+ Offers []ClaimAtom

+ func (s *PathPaymentStrictReceiveResultSuccess) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *PathPaymentStrictReceiveResultSuccess) EncodeTo(e *xdr.Encoder) error

+ func (s *PathPaymentStrictReceiveResultSuccess) UnmarshalBinary(inp []byte) error

+ func (s PathPaymentStrictReceiveResultSuccess) MarshalBinary() ([]byte, error)

+ type PathPaymentStrictSendOp struct

+ DestAsset Asset

+ DestMin Int64

+ Destination MuxedAccount

+ Path []Asset

+ SendAmount Int64

+ SendAsset Asset

+ func (s *PathPaymentStrictSendOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *PathPaymentStrictSendOp) EncodeTo(e *xdr.Encoder) error

+ func (s *PathPaymentStrictSendOp) UnmarshalBinary(inp []byte) error

+ func (s PathPaymentStrictSendOp) MarshalBinary() ([]byte, error)

+ type PathPaymentStrictSendResult struct

+ Code PathPaymentStrictSendResultCode

+ NoIssuer *Asset

+ Success *PathPaymentStrictSendResultSuccess

+ func NewPathPaymentStrictSendResult(code PathPaymentStrictSendResultCode, value interface{}) (result PathPaymentStrictSendResult, err error)

+ func (pr *PathPaymentStrictSendResult) DestAmount() Int64

+ func (s *PathPaymentStrictSendResult) UnmarshalBinary(inp []byte) error

+ func (s PathPaymentStrictSendResult) MarshalBinary() ([]byte, error)

+ func (u *PathPaymentStrictSendResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u PathPaymentStrictSendResult) ArmForSwitch(sw int32) (string, bool)

+ func (u PathPaymentStrictSendResult) EncodeTo(e *xdr.Encoder) error

+ func (u PathPaymentStrictSendResult) GetNoIssuer() (result Asset, ok bool)

+ func (u PathPaymentStrictSendResult) GetSuccess() (result PathPaymentStrictSendResultSuccess, ok bool)

+ func (u PathPaymentStrictSendResult) MustNoIssuer() Asset

+ func (u PathPaymentStrictSendResult) MustSuccess() PathPaymentStrictSendResultSuccess

+ func (u PathPaymentStrictSendResult) SwitchFieldName() string

+ type PathPaymentStrictSendResultCode int32

+ const PathPaymentStrictSendResultCodePathPaymentStrictSendLineFull

+ const PathPaymentStrictSendResultCodePathPaymentStrictSendMalformed

+ const PathPaymentStrictSendResultCodePathPaymentStrictSendNoDestination

+ const PathPaymentStrictSendResultCodePathPaymentStrictSendNoIssuer

+ const PathPaymentStrictSendResultCodePathPaymentStrictSendNoTrust

+ const PathPaymentStrictSendResultCodePathPaymentStrictSendNotAuthorized

+ const PathPaymentStrictSendResultCodePathPaymentStrictSendOfferCrossSelf

+ const PathPaymentStrictSendResultCodePathPaymentStrictSendSrcNoTrust

+ const PathPaymentStrictSendResultCodePathPaymentStrictSendSrcNotAuthorized

+ const PathPaymentStrictSendResultCodePathPaymentStrictSendSuccess

+ const PathPaymentStrictSendResultCodePathPaymentStrictSendTooFewOffers

+ const PathPaymentStrictSendResultCodePathPaymentStrictSendUnderDestmin

+ const PathPaymentStrictSendResultCodePathPaymentStrictSendUnderfunded

+ func (e *PathPaymentStrictSendResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e PathPaymentStrictSendResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e PathPaymentStrictSendResultCode) String() string

+ func (e PathPaymentStrictSendResultCode) ValidEnum(v int32) bool

+ func (s *PathPaymentStrictSendResultCode) UnmarshalBinary(inp []byte) error

+ func (s PathPaymentStrictSendResultCode) MarshalBinary() ([]byte, error)

+ type PathPaymentStrictSendResultSuccess struct

+ Last SimplePaymentResult

+ Offers []ClaimAtom

+ func (s *PathPaymentStrictSendResultSuccess) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *PathPaymentStrictSendResultSuccess) EncodeTo(e *xdr.Encoder) error

+ func (s *PathPaymentStrictSendResultSuccess) UnmarshalBinary(inp []byte) error

+ func (s PathPaymentStrictSendResultSuccess) MarshalBinary() ([]byte, error)

+ type PaymentOp struct

+ Amount Int64

+ Asset Asset

+ Destination MuxedAccount

+ func (s *PaymentOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *PaymentOp) EncodeTo(e *xdr.Encoder) error

+ func (s *PaymentOp) UnmarshalBinary(inp []byte) error

+ func (s PaymentOp) MarshalBinary() ([]byte, error)

+ type PaymentResult struct

+ Code PaymentResultCode

+ func NewPaymentResult(code PaymentResultCode, value interface{}) (result PaymentResult, err error)

+ func (s *PaymentResult) UnmarshalBinary(inp []byte) error

+ func (s PaymentResult) MarshalBinary() ([]byte, error)

+ func (u *PaymentResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u PaymentResult) ArmForSwitch(sw int32) (string, bool)

+ func (u PaymentResult) EncodeTo(e *xdr.Encoder) error

+ func (u PaymentResult) SwitchFieldName() string

+ type PaymentResultCode int32

+ const PaymentResultCodePaymentLineFull

+ const PaymentResultCodePaymentMalformed

+ const PaymentResultCodePaymentNoDestination

+ const PaymentResultCodePaymentNoIssuer

+ const PaymentResultCodePaymentNoTrust

+ const PaymentResultCodePaymentNotAuthorized

+ const PaymentResultCodePaymentSrcNoTrust

+ const PaymentResultCodePaymentSrcNotAuthorized

+ const PaymentResultCodePaymentSuccess

+ const PaymentResultCodePaymentUnderfunded

+ func (e *PaymentResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e PaymentResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e PaymentResultCode) String() string

+ func (e PaymentResultCode) ValidEnum(v int32) bool

+ func (s *PaymentResultCode) UnmarshalBinary(inp []byte) error

+ func (s PaymentResultCode) MarshalBinary() ([]byte, error)

+ type PeerAddress struct

+ Ip PeerAddressIp

+ NumFailures Uint32

+ Port Uint32

+ func (s *PeerAddress) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *PeerAddress) EncodeTo(e *xdr.Encoder) error

+ func (s *PeerAddress) UnmarshalBinary(inp []byte) error

+ func (s PeerAddress) MarshalBinary() ([]byte, error)

+ type PeerAddressIp struct

+ Ipv4 *[4]byte

+ Ipv6 *[16]byte

+ Type IpAddrType

+ func NewPeerAddressIp(aType IpAddrType, value interface{}) (result PeerAddressIp, err error)

+ func (s *PeerAddressIp) UnmarshalBinary(inp []byte) error

+ func (s PeerAddressIp) MarshalBinary() ([]byte, error)

+ func (u *PeerAddressIp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u PeerAddressIp) ArmForSwitch(sw int32) (string, bool)

+ func (u PeerAddressIp) EncodeTo(e *xdr.Encoder) error

+ func (u PeerAddressIp) GetIpv4() (result [4]byte, ok bool)

+ func (u PeerAddressIp) GetIpv6() (result [16]byte, ok bool)

+ func (u PeerAddressIp) MustIpv4() [4]byte

+ func (u PeerAddressIp) MustIpv6() [16]byte

+ func (u PeerAddressIp) SwitchFieldName() string

+ type PeerStatList []PeerStats

+ func (e PeerStatList) XDRMaxSize() int

+ func (s *PeerStatList) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *PeerStatList) UnmarshalBinary(inp []byte) error

+ func (s PeerStatList) EncodeTo(e *xdr.Encoder) error

+ func (s PeerStatList) MarshalBinary() ([]byte, error)

+ type PeerStats struct

+ BytesRead Uint64

+ BytesWritten Uint64

+ DuplicateFetchBytesRecv Uint64

+ DuplicateFetchMessageRecv Uint64

+ DuplicateFloodBytesRecv Uint64

+ DuplicateFloodMessageRecv Uint64

+ Id NodeId

+ MessagesRead Uint64

+ MessagesWritten Uint64

+ SecondsConnected Uint64

+ UniqueFetchBytesRecv Uint64

+ UniqueFetchMessageRecv Uint64

+ UniqueFloodBytesRecv Uint64

+ UniqueFloodMessageRecv Uint64

+ VersionStr string

+ func (s *PeerStats) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *PeerStats) EncodeTo(e *xdr.Encoder) error

+ func (s *PeerStats) UnmarshalBinary(inp []byte) error

+ func (s PeerStats) MarshalBinary() ([]byte, error)

+ type PoolId Hash

+ func NewPoolId(a, b Asset, fee Int32) (PoolId, error)

+ func (s *PoolId) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *PoolId) EncodeTo(e *xdr.Encoder) error

+ func (s *PoolId) UnmarshalBinary(inp []byte) error

+ func (s PoolId) MarshalBinary() ([]byte, error)

+ type Price struct

+ D Int32

+ N Int32

+ func (p *Price) Invert()

+ func (p *Price) Normalize()

+ func (p Price) Cheaper(q Price) bool

+ func (p Price) Equal(q Price) bool

+ func (p Price) String() string

+ func (s *Price) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Price) EncodeTo(e *xdr.Encoder) error

+ func (s *Price) UnmarshalBinary(inp []byte) error

+ func (s Price) MarshalBinary() ([]byte, error)

+ type PublicKey struct

+ Ed25519 *Uint256

+ Type PublicKeyType

+ func NewPublicKey(aType PublicKeyType, value interface{}) (result PublicKey, err error)

+ func (s *PublicKey) UnmarshalBinary(inp []byte) error

+ func (s PublicKey) MarshalBinary() ([]byte, error)

+ func (u *PublicKey) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u PublicKey) ArmForSwitch(sw int32) (string, bool)

+ func (u PublicKey) EncodeTo(e *xdr.Encoder) error

+ func (u PublicKey) GetEd25519() (result Uint256, ok bool)

+ func (u PublicKey) MustEd25519() Uint256

+ func (u PublicKey) SwitchFieldName() string

+ type PublicKeyType int32

+ const PublicKeyTypePublicKeyTypeEd25519

+ func (e *PublicKeyType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e PublicKeyType) EncodeTo(enc *xdr.Encoder) error

+ func (e PublicKeyType) String() string

+ func (e PublicKeyType) ValidEnum(v int32) bool

+ func (s *PublicKeyType) UnmarshalBinary(inp []byte) error

+ func (s PublicKeyType) MarshalBinary() ([]byte, error)

+ type RevokeSponsorshipOp struct

+ LedgerKey *LedgerKey

+ Signer *RevokeSponsorshipOpSigner

+ Type RevokeSponsorshipType

+ func NewRevokeSponsorshipOp(aType RevokeSponsorshipType, value interface{}) (result RevokeSponsorshipOp, err error)

+ func (s *RevokeSponsorshipOp) UnmarshalBinary(inp []byte) error

+ func (s RevokeSponsorshipOp) MarshalBinary() ([]byte, error)

+ func (u *RevokeSponsorshipOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u RevokeSponsorshipOp) ArmForSwitch(sw int32) (string, bool)

+ func (u RevokeSponsorshipOp) EncodeTo(e *xdr.Encoder) error

+ func (u RevokeSponsorshipOp) GetLedgerKey() (result LedgerKey, ok bool)

+ func (u RevokeSponsorshipOp) GetSigner() (result RevokeSponsorshipOpSigner, ok bool)

+ func (u RevokeSponsorshipOp) MustLedgerKey() LedgerKey

+ func (u RevokeSponsorshipOp) MustSigner() RevokeSponsorshipOpSigner

+ func (u RevokeSponsorshipOp) SwitchFieldName() string

+ type RevokeSponsorshipOpSigner struct

+ AccountId AccountId

+ SignerKey SignerKey

+ func (s *RevokeSponsorshipOpSigner) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *RevokeSponsorshipOpSigner) EncodeTo(e *xdr.Encoder) error

+ func (s *RevokeSponsorshipOpSigner) UnmarshalBinary(inp []byte) error

+ func (s RevokeSponsorshipOpSigner) MarshalBinary() ([]byte, error)

+ type RevokeSponsorshipResult struct

+ Code RevokeSponsorshipResultCode

+ func NewRevokeSponsorshipResult(code RevokeSponsorshipResultCode, value interface{}) (result RevokeSponsorshipResult, err error)

+ func (s *RevokeSponsorshipResult) UnmarshalBinary(inp []byte) error

+ func (s RevokeSponsorshipResult) MarshalBinary() ([]byte, error)

+ func (u *RevokeSponsorshipResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u RevokeSponsorshipResult) ArmForSwitch(sw int32) (string, bool)

+ func (u RevokeSponsorshipResult) EncodeTo(e *xdr.Encoder) error

+ func (u RevokeSponsorshipResult) SwitchFieldName() string

+ type RevokeSponsorshipResultCode int32

+ const RevokeSponsorshipResultCodeRevokeSponsorshipDoesNotExist

+ const RevokeSponsorshipResultCodeRevokeSponsorshipLowReserve

+ const RevokeSponsorshipResultCodeRevokeSponsorshipMalformed

+ const RevokeSponsorshipResultCodeRevokeSponsorshipNotSponsor

+ const RevokeSponsorshipResultCodeRevokeSponsorshipOnlyTransferable

+ const RevokeSponsorshipResultCodeRevokeSponsorshipSuccess

+ func (e *RevokeSponsorshipResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e RevokeSponsorshipResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e RevokeSponsorshipResultCode) String() string

+ func (e RevokeSponsorshipResultCode) ValidEnum(v int32) bool

+ func (s *RevokeSponsorshipResultCode) UnmarshalBinary(inp []byte) error

+ func (s RevokeSponsorshipResultCode) MarshalBinary() ([]byte, error)

+ type RevokeSponsorshipType int32

+ const RevokeSponsorshipTypeRevokeSponsorshipLedgerEntry

+ const RevokeSponsorshipTypeRevokeSponsorshipSigner

+ func (e *RevokeSponsorshipType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e RevokeSponsorshipType) EncodeTo(enc *xdr.Encoder) error

+ func (e RevokeSponsorshipType) String() string

+ func (e RevokeSponsorshipType) ValidEnum(v int32) bool

+ func (s *RevokeSponsorshipType) UnmarshalBinary(inp []byte) error

+ func (s RevokeSponsorshipType) MarshalBinary() ([]byte, error)

+ type ScpBallot struct

+ Counter Uint32

+ Value Value

+ func (s *ScpBallot) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ScpBallot) EncodeTo(e *xdr.Encoder) error

+ func (s *ScpBallot) UnmarshalBinary(inp []byte) error

+ func (s ScpBallot) MarshalBinary() ([]byte, error)

+ type ScpEnvelope struct

+ Signature Signature

+ Statement ScpStatement

+ func (s *ScpEnvelope) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ScpEnvelope) EncodeTo(e *xdr.Encoder) error

+ func (s *ScpEnvelope) UnmarshalBinary(inp []byte) error

+ func (s ScpEnvelope) MarshalBinary() ([]byte, error)

+ func (t *ScpEnvelope) Scan(src interface{}) error

+ type ScpHistoryEntry struct

+ V int32

+ V0 *ScpHistoryEntryV0

+ func NewScpHistoryEntry(v int32, value interface{}) (result ScpHistoryEntry, err error)

+ func (s *ScpHistoryEntry) UnmarshalBinary(inp []byte) error

+ func (s ScpHistoryEntry) MarshalBinary() ([]byte, error)

+ func (u *ScpHistoryEntry) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ScpHistoryEntry) ArmForSwitch(sw int32) (string, bool)

+ func (u ScpHistoryEntry) EncodeTo(e *xdr.Encoder) error

+ func (u ScpHistoryEntry) GetV0() (result ScpHistoryEntryV0, ok bool)

+ func (u ScpHistoryEntry) MustV0() ScpHistoryEntryV0

+ func (u ScpHistoryEntry) SwitchFieldName() string

+ type ScpHistoryEntryV0 struct

+ LedgerMessages LedgerScpMessages

+ QuorumSets []ScpQuorumSet

+ func (s *ScpHistoryEntryV0) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ScpHistoryEntryV0) EncodeTo(e *xdr.Encoder) error

+ func (s *ScpHistoryEntryV0) UnmarshalBinary(inp []byte) error

+ func (s ScpHistoryEntryV0) MarshalBinary() ([]byte, error)

+ type ScpNomination struct

+ Accepted []Value

+ QuorumSetHash Hash

+ Votes []Value

+ func (s *ScpNomination) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ScpNomination) EncodeTo(e *xdr.Encoder) error

+ func (s *ScpNomination) UnmarshalBinary(inp []byte) error

+ func (s ScpNomination) MarshalBinary() ([]byte, error)

+ type ScpQuorumSet struct

+ InnerSets []ScpQuorumSet

+ Threshold Uint32

+ Validators []NodeId

+ func (s *ScpQuorumSet) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ScpQuorumSet) EncodeTo(e *xdr.Encoder) error

+ func (s *ScpQuorumSet) UnmarshalBinary(inp []byte) error

+ func (s ScpQuorumSet) MarshalBinary() ([]byte, error)

+ func (t *ScpQuorumSet) Scan(src interface{}) error

+ type ScpStatement struct

+ NodeId NodeId

+ Pledges ScpStatementPledges

+ SlotIndex Uint64

+ func (s *ScpStatement) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ScpStatement) EncodeTo(e *xdr.Encoder) error

+ func (s *ScpStatement) UnmarshalBinary(inp []byte) error

+ func (s ScpStatement) MarshalBinary() ([]byte, error)

+ type ScpStatementConfirm struct

+ Ballot ScpBallot

+ NCommit Uint32

+ NH Uint32

+ NPrepared Uint32

+ QuorumSetHash Hash

+ func (s *ScpStatementConfirm) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ScpStatementConfirm) EncodeTo(e *xdr.Encoder) error

+ func (s *ScpStatementConfirm) UnmarshalBinary(inp []byte) error

+ func (s ScpStatementConfirm) MarshalBinary() ([]byte, error)

+ type ScpStatementExternalize struct

+ Commit ScpBallot

+ CommitQuorumSetHash Hash

+ NH Uint32

+ func (s *ScpStatementExternalize) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ScpStatementExternalize) EncodeTo(e *xdr.Encoder) error

+ func (s *ScpStatementExternalize) UnmarshalBinary(inp []byte) error

+ func (s ScpStatementExternalize) MarshalBinary() ([]byte, error)

+ type ScpStatementPledges struct

+ Confirm *ScpStatementConfirm

+ Externalize *ScpStatementExternalize

+ Nominate *ScpNomination

+ Prepare *ScpStatementPrepare

+ Type ScpStatementType

+ func NewScpStatementPledges(aType ScpStatementType, value interface{}) (result ScpStatementPledges, err error)

+ func (s *ScpStatementPledges) UnmarshalBinary(inp []byte) error

+ func (s ScpStatementPledges) MarshalBinary() ([]byte, error)

+ func (u *ScpStatementPledges) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u ScpStatementPledges) ArmForSwitch(sw int32) (string, bool)

+ func (u ScpStatementPledges) EncodeTo(e *xdr.Encoder) error

+ func (u ScpStatementPledges) GetConfirm() (result ScpStatementConfirm, ok bool)

+ func (u ScpStatementPledges) GetExternalize() (result ScpStatementExternalize, ok bool)

+ func (u ScpStatementPledges) GetNominate() (result ScpNomination, ok bool)

+ func (u ScpStatementPledges) GetPrepare() (result ScpStatementPrepare, ok bool)

+ func (u ScpStatementPledges) MustConfirm() ScpStatementConfirm

+ func (u ScpStatementPledges) MustExternalize() ScpStatementExternalize

+ func (u ScpStatementPledges) MustNominate() ScpNomination

+ func (u ScpStatementPledges) MustPrepare() ScpStatementPrepare

+ func (u ScpStatementPledges) SwitchFieldName() string

+ type ScpStatementPrepare struct

+ Ballot ScpBallot

+ NC Uint32

+ NH Uint32

+ Prepared *ScpBallot

+ PreparedPrime *ScpBallot

+ QuorumSetHash Hash

+ func (s *ScpStatementPrepare) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *ScpStatementPrepare) EncodeTo(e *xdr.Encoder) error

+ func (s *ScpStatementPrepare) UnmarshalBinary(inp []byte) error

+ func (s ScpStatementPrepare) MarshalBinary() ([]byte, error)

+ type ScpStatementType int32

+ const ScpStatementTypeScpStConfirm

+ const ScpStatementTypeScpStExternalize

+ const ScpStatementTypeScpStNominate

+ const ScpStatementTypeScpStPrepare

+ func (e *ScpStatementType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ScpStatementType) EncodeTo(enc *xdr.Encoder) error

+ func (e ScpStatementType) String() string

+ func (e ScpStatementType) ValidEnum(v int32) bool

+ func (s *ScpStatementType) UnmarshalBinary(inp []byte) error

+ func (s ScpStatementType) MarshalBinary() ([]byte, error)

+ type SequenceNumber Int64

+ func (s *SequenceNumber) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *SequenceNumber) UnmarshalBinary(inp []byte) error

+ func (s SequenceNumber) EncodeTo(e *xdr.Encoder) error

+ func (s SequenceNumber) MarshalBinary() ([]byte, error)

+ type SetOptionsOp struct

+ ClearFlags *Uint32

+ HighThreshold *Uint32

+ HomeDomain *String32

+ InflationDest *AccountId

+ LowThreshold *Uint32

+ MasterWeight *Uint32

+ MedThreshold *Uint32

+ SetFlags *Uint32

+ Signer *Signer

+ func (s *SetOptionsOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *SetOptionsOp) EncodeTo(e *xdr.Encoder) error

+ func (s *SetOptionsOp) UnmarshalBinary(inp []byte) error

+ func (s SetOptionsOp) GoString() string

+ func (s SetOptionsOp) MarshalBinary() ([]byte, error)

+ type SetOptionsResult struct

+ Code SetOptionsResultCode

+ func NewSetOptionsResult(code SetOptionsResultCode, value interface{}) (result SetOptionsResult, err error)

+ func (s *SetOptionsResult) UnmarshalBinary(inp []byte) error

+ func (s SetOptionsResult) MarshalBinary() ([]byte, error)

+ func (u *SetOptionsResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u SetOptionsResult) ArmForSwitch(sw int32) (string, bool)

+ func (u SetOptionsResult) EncodeTo(e *xdr.Encoder) error

+ func (u SetOptionsResult) SwitchFieldName() string

+ type SetOptionsResultCode int32

+ const SetOptionsResultCodeSetOptionsAuthRevocableRequired

+ const SetOptionsResultCodeSetOptionsBadFlags

+ const SetOptionsResultCodeSetOptionsBadSigner

+ const SetOptionsResultCodeSetOptionsCantChange

+ const SetOptionsResultCodeSetOptionsInvalidHomeDomain

+ const SetOptionsResultCodeSetOptionsInvalidInflation

+ const SetOptionsResultCodeSetOptionsLowReserve

+ const SetOptionsResultCodeSetOptionsSuccess

+ const SetOptionsResultCodeSetOptionsThresholdOutOfRange

+ const SetOptionsResultCodeSetOptionsTooManySigners

+ const SetOptionsResultCodeSetOptionsUnknownFlag

+ func (e *SetOptionsResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e SetOptionsResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e SetOptionsResultCode) String() string

+ func (e SetOptionsResultCode) ValidEnum(v int32) bool

+ func (s *SetOptionsResultCode) UnmarshalBinary(inp []byte) error

+ func (s SetOptionsResultCode) MarshalBinary() ([]byte, error)

+ type SetTrustLineFlagsOp struct

+ Asset Asset

+ ClearFlags Uint32

+ SetFlags Uint32

+ Trustor AccountId

+ func (s *SetTrustLineFlagsOp) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *SetTrustLineFlagsOp) EncodeTo(e *xdr.Encoder) error

+ func (s *SetTrustLineFlagsOp) UnmarshalBinary(inp []byte) error

+ func (s SetTrustLineFlagsOp) MarshalBinary() ([]byte, error)

+ type SetTrustLineFlagsResult struct

+ Code SetTrustLineFlagsResultCode

+ func NewSetTrustLineFlagsResult(code SetTrustLineFlagsResultCode, value interface{}) (result SetTrustLineFlagsResult, err error)

+ func (s *SetTrustLineFlagsResult) UnmarshalBinary(inp []byte) error

+ func (s SetTrustLineFlagsResult) MarshalBinary() ([]byte, error)

+ func (u *SetTrustLineFlagsResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u SetTrustLineFlagsResult) ArmForSwitch(sw int32) (string, bool)

+ func (u SetTrustLineFlagsResult) EncodeTo(e *xdr.Encoder) error

+ func (u SetTrustLineFlagsResult) SwitchFieldName() string

+ type SetTrustLineFlagsResultCode int32

+ const SetTrustLineFlagsResultCodeSetTrustLineFlagsCantRevoke

+ const SetTrustLineFlagsResultCodeSetTrustLineFlagsInvalidState

+ const SetTrustLineFlagsResultCodeSetTrustLineFlagsLowReserve

+ const SetTrustLineFlagsResultCodeSetTrustLineFlagsMalformed

+ const SetTrustLineFlagsResultCodeSetTrustLineFlagsNoTrustLine

+ const SetTrustLineFlagsResultCodeSetTrustLineFlagsSuccess

+ func (e *SetTrustLineFlagsResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e SetTrustLineFlagsResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e SetTrustLineFlagsResultCode) String() string

+ func (e SetTrustLineFlagsResultCode) ValidEnum(v int32) bool

+ func (s *SetTrustLineFlagsResultCode) UnmarshalBinary(inp []byte) error

+ func (s SetTrustLineFlagsResultCode) MarshalBinary() ([]byte, error)

+ type Signature []byte

+ func (e Signature) XDRMaxSize() int

+ func (s *Signature) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Signature) UnmarshalBinary(inp []byte) error

+ func (s Signature) EncodeTo(e *xdr.Encoder) error

+ func (s Signature) MarshalBinary() ([]byte, error)

+ type SignatureHint [4]byte

+ func (e SignatureHint) XDRMaxSize() int

+ func (s *SignatureHint) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *SignatureHint) EncodeTo(e *xdr.Encoder) error

+ func (s *SignatureHint) UnmarshalBinary(inp []byte) error

+ func (s SignatureHint) MarshalBinary() ([]byte, error)

+ type SignedSurveyRequestMessage struct

+ Request SurveyRequestMessage

+ RequestSignature Signature

+ func (s *SignedSurveyRequestMessage) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *SignedSurveyRequestMessage) EncodeTo(e *xdr.Encoder) error

+ func (s *SignedSurveyRequestMessage) UnmarshalBinary(inp []byte) error

+ func (s SignedSurveyRequestMessage) MarshalBinary() ([]byte, error)

+ type SignedSurveyResponseMessage struct

+ Response SurveyResponseMessage

+ ResponseSignature Signature

+ func (s *SignedSurveyResponseMessage) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *SignedSurveyResponseMessage) EncodeTo(e *xdr.Encoder) error

+ func (s *SignedSurveyResponseMessage) UnmarshalBinary(inp []byte) error

+ func (s SignedSurveyResponseMessage) MarshalBinary() ([]byte, error)

+ type Signer struct

+ Key SignerKey

+ Weight Uint32

+ func SortSignersByKey(signers []Signer) []Signer

+ func (s *Signer) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Signer) EncodeTo(e *xdr.Encoder) error

+ func (s *Signer) UnmarshalBinary(inp []byte) error

+ func (s Signer) GoString() string

+ func (s Signer) MarshalBinary() ([]byte, error)

+ type SignerKey struct

+ Ed25519 *Uint256

+ HashX *Uint256

+ PreAuthTx *Uint256

+ Type SignerKeyType

+ func MustSigner(address string) SignerKey

+ func NewSignerKey(aType SignerKeyType, value interface{}) (result SignerKey, err error)

+ func (s *SignerKey) UnmarshalBinary(inp []byte) error

+ func (s SignerKey) MarshalBinary() ([]byte, error)

+ func (skey *SignerKey) Address() string

+ func (skey *SignerKey) Equals(other SignerKey) bool

+ func (skey *SignerKey) GetAddress() (string, error)

+ func (skey *SignerKey) SetAddress(address string) error

+ func (u *SignerKey) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u SignerKey) ArmForSwitch(sw int32) (string, bool)

+ func (u SignerKey) EncodeTo(e *xdr.Encoder) error

+ func (u SignerKey) GetEd25519() (result Uint256, ok bool)

+ func (u SignerKey) GetHashX() (result Uint256, ok bool)

+ func (u SignerKey) GetPreAuthTx() (result Uint256, ok bool)

+ func (u SignerKey) MustEd25519() Uint256

+ func (u SignerKey) MustHashX() Uint256

+ func (u SignerKey) MustPreAuthTx() Uint256

+ func (u SignerKey) SwitchFieldName() string

+ type SignerKeyType int32

+ const SignerKeyTypeSignerKeyTypeEd25519

+ const SignerKeyTypeSignerKeyTypeHashX

+ const SignerKeyTypeSignerKeyTypePreAuthTx

+ func (e *SignerKeyType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e SignerKeyType) EncodeTo(enc *xdr.Encoder) error

+ func (e SignerKeyType) String() string

+ func (e SignerKeyType) ValidEnum(v int32) bool

+ func (s *SignerKeyType) UnmarshalBinary(inp []byte) error

+ func (s SignerKeyType) MarshalBinary() ([]byte, error)

+ type SimplePaymentResult struct

+ Amount Int64

+ Asset Asset

+ Destination AccountId

+ func (s *SimplePaymentResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *SimplePaymentResult) EncodeTo(e *xdr.Encoder) error

+ func (s *SimplePaymentResult) UnmarshalBinary(inp []byte) error

+ func (s SimplePaymentResult) MarshalBinary() ([]byte, error)

+ type SponsorshipDescriptor = *AccountId

+ type String32 string

+ func String32Ptr(val string) *String32

+ func (e String32) XDRMaxSize() int

+ func (s *String32) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *String32) UnmarshalBinary(inp []byte) error

+ func (s String32) EncodeTo(e *xdr.Encoder) error

+ func (s String32) MarshalBinary() ([]byte, error)

+ type String64 string

+ func (e String64) XDRMaxSize() int

+ func (s *String64) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *String64) UnmarshalBinary(inp []byte) error

+ func (s String64) EncodeTo(e *xdr.Encoder) error

+ func (s String64) MarshalBinary() ([]byte, error)

+ type SurveyMessageCommandType int32

+ const SurveyMessageCommandTypeSurveyTopology

+ func (e *SurveyMessageCommandType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e SurveyMessageCommandType) EncodeTo(enc *xdr.Encoder) error

+ func (e SurveyMessageCommandType) String() string

+ func (e SurveyMessageCommandType) ValidEnum(v int32) bool

+ func (s *SurveyMessageCommandType) UnmarshalBinary(inp []byte) error

+ func (s SurveyMessageCommandType) MarshalBinary() ([]byte, error)

+ type SurveyRequestMessage struct

+ CommandType SurveyMessageCommandType

+ EncryptionKey Curve25519Public

+ LedgerNum Uint32

+ SurveyedPeerId NodeId

+ SurveyorPeerId NodeId

+ func (s *SurveyRequestMessage) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *SurveyRequestMessage) EncodeTo(e *xdr.Encoder) error

+ func (s *SurveyRequestMessage) UnmarshalBinary(inp []byte) error

+ func (s SurveyRequestMessage) MarshalBinary() ([]byte, error)

+ type SurveyResponseBody struct

+ TopologyResponseBody *TopologyResponseBody

+ Type SurveyMessageCommandType

+ func NewSurveyResponseBody(aType SurveyMessageCommandType, value interface{}) (result SurveyResponseBody, err error)

+ func (s *SurveyResponseBody) UnmarshalBinary(inp []byte) error

+ func (s SurveyResponseBody) MarshalBinary() ([]byte, error)

+ func (u *SurveyResponseBody) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u SurveyResponseBody) ArmForSwitch(sw int32) (string, bool)

+ func (u SurveyResponseBody) EncodeTo(e *xdr.Encoder) error

+ func (u SurveyResponseBody) GetTopologyResponseBody() (result TopologyResponseBody, ok bool)

+ func (u SurveyResponseBody) MustTopologyResponseBody() TopologyResponseBody

+ func (u SurveyResponseBody) SwitchFieldName() string

+ type SurveyResponseMessage struct

+ CommandType SurveyMessageCommandType

+ EncryptedBody EncryptedBody

+ LedgerNum Uint32

+ SurveyedPeerId NodeId

+ SurveyorPeerId NodeId

+ func (s *SurveyResponseMessage) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *SurveyResponseMessage) EncodeTo(e *xdr.Encoder) error

+ func (s *SurveyResponseMessage) UnmarshalBinary(inp []byte) error

+ func (s SurveyResponseMessage) MarshalBinary() ([]byte, error)

+ type ThresholdIndexes int32

+ const ThresholdIndexesThresholdHigh

+ const ThresholdIndexesThresholdLow

+ const ThresholdIndexesThresholdMasterWeight

+ const ThresholdIndexesThresholdMed

+ func (e *ThresholdIndexes) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e ThresholdIndexes) EncodeTo(enc *xdr.Encoder) error

+ func (e ThresholdIndexes) String() string

+ func (e ThresholdIndexes) ValidEnum(v int32) bool

+ func (s *ThresholdIndexes) UnmarshalBinary(inp []byte) error

+ func (s ThresholdIndexes) MarshalBinary() ([]byte, error)

+ type Thresholds [4]byte

+ func NewThreshold(masterKey, low, medium, high byte) Thresholds

+ func (e Thresholds) XDRMaxSize() int

+ func (s *Thresholds) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Thresholds) EncodeTo(e *xdr.Encoder) error

+ func (s *Thresholds) UnmarshalBinary(inp []byte) error

+ func (s Thresholds) MarshalBinary() ([]byte, error)

+ func (t *Thresholds) Scan(src interface{}) error

+ func (t Thresholds) MasterKeyWeight() byte

+ func (t Thresholds) ThresholdHigh() byte

+ func (t Thresholds) ThresholdLow() byte

+ func (t Thresholds) ThresholdMedium() byte

+ type TimeBounds struct

+ MaxTime TimePoint

+ MinTime TimePoint

+ func (s *TimeBounds) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TimeBounds) EncodeTo(e *xdr.Encoder) error

+ func (s *TimeBounds) UnmarshalBinary(inp []byte) error

+ func (s TimeBounds) MarshalBinary() ([]byte, error)

+ func (t *TimeBounds) GoString() string

+ type TimePoint Uint64

+ func (s *TimePoint) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TimePoint) UnmarshalBinary(inp []byte) error

+ func (s TimePoint) EncodeTo(e *xdr.Encoder) error

+ func (s TimePoint) MarshalBinary() ([]byte, error)

+ type TopologyResponseBody struct

+ InboundPeers PeerStatList

+ OutboundPeers PeerStatList

+ TotalInboundPeerCount Uint32

+ TotalOutboundPeerCount Uint32

+ func (s *TopologyResponseBody) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TopologyResponseBody) EncodeTo(e *xdr.Encoder) error

+ func (s *TopologyResponseBody) UnmarshalBinary(inp []byte) error

+ func (s TopologyResponseBody) MarshalBinary() ([]byte, error)

+ type Transaction struct

+ Ext TransactionExt

+ Fee Uint32

+ Memo Memo

+ Operations []Operation

+ SeqNum SequenceNumber

+ SourceAccount MuxedAccount

+ TimeBounds *TimeBounds

+ func (s *Transaction) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Transaction) EncodeTo(e *xdr.Encoder) error

+ func (s *Transaction) UnmarshalBinary(inp []byte) error

+ func (s Transaction) MarshalBinary() ([]byte, error)

+ type TransactionEnvelope struct

+ FeeBump *FeeBumpTransactionEnvelope

+ Type EnvelopeType

+ V0 *TransactionV0Envelope

+ V1 *TransactionV1Envelope

+ func NewTransactionEnvelope(aType EnvelopeType, value interface{}) (result TransactionEnvelope, err error)

+ func (e TransactionEnvelope) Fee() uint32

+ func (e TransactionEnvelope) FeeBumpAccount() MuxedAccount

+ func (e TransactionEnvelope) FeeBumpFee() int64

+ func (e TransactionEnvelope) FeeBumpSignatures() []DecoratedSignature

+ func (e TransactionEnvelope) GoString() string

+ func (e TransactionEnvelope) IsFeeBump() bool

+ func (e TransactionEnvelope) Memo() Memo

+ func (e TransactionEnvelope) Operations() []Operation

+ func (e TransactionEnvelope) SeqNum() int64

+ func (e TransactionEnvelope) Signatures() []DecoratedSignature

+ func (e TransactionEnvelope) SourceAccount() MuxedAccount

+ func (e TransactionEnvelope) TimeBounds() *TimeBounds

+ func (s *TransactionEnvelope) UnmarshalBinary(inp []byte) error

+ func (s TransactionEnvelope) MarshalBinary() ([]byte, error)

+ func (t *TransactionEnvelope) Scan(src interface{}) error

+ func (u *TransactionEnvelope) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u TransactionEnvelope) ArmForSwitch(sw int32) (string, bool)

+ func (u TransactionEnvelope) EncodeTo(e *xdr.Encoder) error

+ func (u TransactionEnvelope) GetFeeBump() (result FeeBumpTransactionEnvelope, ok bool)

+ func (u TransactionEnvelope) GetV0() (result TransactionV0Envelope, ok bool)

+ func (u TransactionEnvelope) GetV1() (result TransactionV1Envelope, ok bool)

+ func (u TransactionEnvelope) MustFeeBump() FeeBumpTransactionEnvelope

+ func (u TransactionEnvelope) MustV0() TransactionV0Envelope

+ func (u TransactionEnvelope) MustV1() TransactionV1Envelope

+ func (u TransactionEnvelope) SwitchFieldName() string

+ type TransactionExt struct

+ V int32

+ func NewTransactionExt(v int32, value interface{}) (result TransactionExt, err error)

+ func (s *TransactionExt) UnmarshalBinary(inp []byte) error

+ func (s TransactionExt) MarshalBinary() ([]byte, error)

+ func (u *TransactionExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u TransactionExt) ArmForSwitch(sw int32) (string, bool)

+ func (u TransactionExt) EncodeTo(e *xdr.Encoder) error

+ func (u TransactionExt) SwitchFieldName() string

+ type TransactionHistoryEntry struct

+ Ext TransactionHistoryEntryExt

+ LedgerSeq Uint32

+ TxSet TransactionSet

+ func (s *TransactionHistoryEntry) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TransactionHistoryEntry) EncodeTo(e *xdr.Encoder) error

+ func (s *TransactionHistoryEntry) UnmarshalBinary(inp []byte) error

+ func (s TransactionHistoryEntry) MarshalBinary() ([]byte, error)

+ type TransactionHistoryEntryExt struct

+ V int32

+ func NewTransactionHistoryEntryExt(v int32, value interface{}) (result TransactionHistoryEntryExt, err error)

+ func (s *TransactionHistoryEntryExt) UnmarshalBinary(inp []byte) error

+ func (s TransactionHistoryEntryExt) MarshalBinary() ([]byte, error)

+ func (u *TransactionHistoryEntryExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u TransactionHistoryEntryExt) ArmForSwitch(sw int32) (string, bool)

+ func (u TransactionHistoryEntryExt) EncodeTo(e *xdr.Encoder) error

+ func (u TransactionHistoryEntryExt) SwitchFieldName() string

+ type TransactionHistoryResultEntry struct

+ Ext TransactionHistoryResultEntryExt

+ LedgerSeq Uint32

+ TxResultSet TransactionResultSet

+ func (s *TransactionHistoryResultEntry) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TransactionHistoryResultEntry) EncodeTo(e *xdr.Encoder) error

+ func (s *TransactionHistoryResultEntry) UnmarshalBinary(inp []byte) error

+ func (s TransactionHistoryResultEntry) MarshalBinary() ([]byte, error)

+ type TransactionHistoryResultEntryExt struct

+ V int32

+ func NewTransactionHistoryResultEntryExt(v int32, value interface{}) (result TransactionHistoryResultEntryExt, err error)

+ func (s *TransactionHistoryResultEntryExt) UnmarshalBinary(inp []byte) error

+ func (s TransactionHistoryResultEntryExt) MarshalBinary() ([]byte, error)

+ func (u *TransactionHistoryResultEntryExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u TransactionHistoryResultEntryExt) ArmForSwitch(sw int32) (string, bool)

+ func (u TransactionHistoryResultEntryExt) EncodeTo(e *xdr.Encoder) error

+ func (u TransactionHistoryResultEntryExt) SwitchFieldName() string

+ type TransactionMeta struct

+ Operations *[]OperationMeta

+ V int32

+ V1 *TransactionMetaV1

+ V2 *TransactionMetaV2

+ func NewTransactionMeta(v int32, value interface{}) (result TransactionMeta, err error)

+ func (s *TransactionMeta) UnmarshalBinary(inp []byte) error

+ func (s TransactionMeta) MarshalBinary() ([]byte, error)

+ func (t *TransactionMeta) Scan(src interface{}) error

+ func (transactionMeta *TransactionMeta) OperationsMeta() []OperationMeta

+ func (u *TransactionMeta) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u TransactionMeta) ArmForSwitch(sw int32) (string, bool)

+ func (u TransactionMeta) EncodeTo(e *xdr.Encoder) error

+ func (u TransactionMeta) GetOperations() (result []OperationMeta, ok bool)

+ func (u TransactionMeta) GetV1() (result TransactionMetaV1, ok bool)

+ func (u TransactionMeta) GetV2() (result TransactionMetaV2, ok bool)

+ func (u TransactionMeta) MustOperations() []OperationMeta

+ func (u TransactionMeta) MustV1() TransactionMetaV1

+ func (u TransactionMeta) MustV2() TransactionMetaV2

+ func (u TransactionMeta) SwitchFieldName() string

+ type TransactionMetaV1 struct

+ Operations []OperationMeta

+ TxChanges LedgerEntryChanges

+ func (s *TransactionMetaV1) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TransactionMetaV1) EncodeTo(e *xdr.Encoder) error

+ func (s *TransactionMetaV1) UnmarshalBinary(inp []byte) error

+ func (s TransactionMetaV1) MarshalBinary() ([]byte, error)

+ type TransactionMetaV2 struct

+ Operations []OperationMeta

+ TxChangesAfter LedgerEntryChanges

+ TxChangesBefore LedgerEntryChanges

+ func (s *TransactionMetaV2) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TransactionMetaV2) EncodeTo(e *xdr.Encoder) error

+ func (s *TransactionMetaV2) UnmarshalBinary(inp []byte) error

+ func (s TransactionMetaV2) MarshalBinary() ([]byte, error)

+ type TransactionResult struct

+ Ext TransactionResultExt

+ FeeCharged Int64

+ Result TransactionResultResult

+ func (r TransactionResult) ExtractBalanceID(opIndex int) (*ClaimableBalanceId, error)

+ func (r TransactionResult) ExtractBalanceIDHex(opIndex int) (string, error)

+ func (r TransactionResult) OperationResults() ([]OperationResult, bool)

+ func (r TransactionResult) Successful() bool

+ func (s *TransactionResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TransactionResult) EncodeTo(e *xdr.Encoder) error

+ func (s *TransactionResult) UnmarshalBinary(inp []byte) error

+ func (s TransactionResult) MarshalBinary() ([]byte, error)

+ func (t *TransactionResult) Scan(src interface{}) error

+ type TransactionResultCode int32

+ const TransactionResultCodeTxBadAuth

+ const TransactionResultCodeTxBadAuthExtra

+ const TransactionResultCodeTxBadSeq

+ const TransactionResultCodeTxBadSponsorship

+ const TransactionResultCodeTxFailed

+ const TransactionResultCodeTxFeeBumpInnerFailed

+ const TransactionResultCodeTxFeeBumpInnerSuccess

+ const TransactionResultCodeTxInsufficientBalance

+ const TransactionResultCodeTxInsufficientFee

+ const TransactionResultCodeTxInternalError

+ const TransactionResultCodeTxMissingOperation

+ const TransactionResultCodeTxNoAccount

+ const TransactionResultCodeTxNotSupported

+ const TransactionResultCodeTxSuccess

+ const TransactionResultCodeTxTooEarly

+ const TransactionResultCodeTxTooLate

+ func (e *TransactionResultCode) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e TransactionResultCode) EncodeTo(enc *xdr.Encoder) error

+ func (e TransactionResultCode) String() string

+ func (e TransactionResultCode) ValidEnum(v int32) bool

+ func (s *TransactionResultCode) UnmarshalBinary(inp []byte) error

+ func (s TransactionResultCode) MarshalBinary() ([]byte, error)

+ type TransactionResultExt struct

+ V int32

+ func NewTransactionResultExt(v int32, value interface{}) (result TransactionResultExt, err error)

+ func (s *TransactionResultExt) UnmarshalBinary(inp []byte) error

+ func (s TransactionResultExt) MarshalBinary() ([]byte, error)

+ func (u *TransactionResultExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u TransactionResultExt) ArmForSwitch(sw int32) (string, bool)

+ func (u TransactionResultExt) EncodeTo(e *xdr.Encoder) error

+ func (u TransactionResultExt) SwitchFieldName() string

+ type TransactionResultMeta struct

+ FeeProcessing LedgerEntryChanges

+ Result TransactionResultPair

+ TxApplyProcessing TransactionMeta

+ func (s *TransactionResultMeta) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TransactionResultMeta) EncodeTo(e *xdr.Encoder) error

+ func (s *TransactionResultMeta) UnmarshalBinary(inp []byte) error

+ func (s TransactionResultMeta) MarshalBinary() ([]byte, error)

+ type TransactionResultPair struct

+ Result TransactionResult

+ TransactionHash Hash

+ func (r TransactionResultPair) InnerHash() Hash

+ func (r TransactionResultPair) OperationResults() ([]OperationResult, bool)

+ func (r TransactionResultPair) Successful() bool

+ func (s *TransactionResultPair) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TransactionResultPair) EncodeTo(e *xdr.Encoder) error

+ func (s *TransactionResultPair) UnmarshalBinary(inp []byte) error

+ func (s TransactionResultPair) MarshalBinary() ([]byte, error)

+ func (t *TransactionResultPair) Scan(src interface{}) error

+ type TransactionResultResult struct

+ Code TransactionResultCode

+ InnerResultPair *InnerTransactionResultPair

+ Results *[]OperationResult

+ func NewTransactionResultResult(code TransactionResultCode, value interface{}) (result TransactionResultResult, err error)

+ func (s *TransactionResultResult) UnmarshalBinary(inp []byte) error

+ func (s TransactionResultResult) MarshalBinary() ([]byte, error)

+ func (u *TransactionResultResult) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u TransactionResultResult) ArmForSwitch(sw int32) (string, bool)

+ func (u TransactionResultResult) EncodeTo(e *xdr.Encoder) error

+ func (u TransactionResultResult) GetInnerResultPair() (result InnerTransactionResultPair, ok bool)

+ func (u TransactionResultResult) GetResults() (result []OperationResult, ok bool)

+ func (u TransactionResultResult) MustInnerResultPair() InnerTransactionResultPair

+ func (u TransactionResultResult) MustResults() []OperationResult

+ func (u TransactionResultResult) SwitchFieldName() string

+ type TransactionResultSet struct

+ Results []TransactionResultPair

+ func (s *TransactionResultSet) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TransactionResultSet) EncodeTo(e *xdr.Encoder) error

+ func (s *TransactionResultSet) UnmarshalBinary(inp []byte) error

+ func (s TransactionResultSet) MarshalBinary() ([]byte, error)

+ type TransactionSet struct

+ PreviousLedgerHash Hash

+ Txs []TransactionEnvelope

+ func (s *TransactionSet) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TransactionSet) EncodeTo(e *xdr.Encoder) error

+ func (s *TransactionSet) UnmarshalBinary(inp []byte) error

+ func (s TransactionSet) MarshalBinary() ([]byte, error)

+ type TransactionSignaturePayload struct

+ NetworkId Hash

+ TaggedTransaction TransactionSignaturePayloadTaggedTransaction

+ func (s *TransactionSignaturePayload) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TransactionSignaturePayload) EncodeTo(e *xdr.Encoder) error

+ func (s *TransactionSignaturePayload) UnmarshalBinary(inp []byte) error

+ func (s TransactionSignaturePayload) MarshalBinary() ([]byte, error)

+ type TransactionSignaturePayloadTaggedTransaction struct

+ FeeBump *FeeBumpTransaction

+ Tx *Transaction

+ Type EnvelopeType

+ func NewTransactionSignaturePayloadTaggedTransaction(aType EnvelopeType, value interface{}) (result TransactionSignaturePayloadTaggedTransaction, err error)

+ func (s *TransactionSignaturePayloadTaggedTransaction) UnmarshalBinary(inp []byte) error

+ func (s TransactionSignaturePayloadTaggedTransaction) MarshalBinary() ([]byte, error)

+ func (u *TransactionSignaturePayloadTaggedTransaction) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u TransactionSignaturePayloadTaggedTransaction) ArmForSwitch(sw int32) (string, bool)

+ func (u TransactionSignaturePayloadTaggedTransaction) EncodeTo(e *xdr.Encoder) error

+ func (u TransactionSignaturePayloadTaggedTransaction) GetFeeBump() (result FeeBumpTransaction, ok bool)

+ func (u TransactionSignaturePayloadTaggedTransaction) GetTx() (result Transaction, ok bool)

+ func (u TransactionSignaturePayloadTaggedTransaction) MustFeeBump() FeeBumpTransaction

+ func (u TransactionSignaturePayloadTaggedTransaction) MustTx() Transaction

+ func (u TransactionSignaturePayloadTaggedTransaction) SwitchFieldName() string

+ type TransactionV0 struct

+ Ext TransactionV0Ext

+ Fee Uint32

+ Memo Memo

+ Operations []Operation

+ SeqNum SequenceNumber

+ SourceAccountEd25519 Uint256

+ TimeBounds *TimeBounds

+ func (s *TransactionV0) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TransactionV0) EncodeTo(e *xdr.Encoder) error

+ func (s *TransactionV0) UnmarshalBinary(inp []byte) error

+ func (s TransactionV0) MarshalBinary() ([]byte, error)

+ type TransactionV0Envelope struct

+ Signatures []DecoratedSignature

+ Tx TransactionV0

+ func (s *TransactionV0Envelope) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TransactionV0Envelope) EncodeTo(e *xdr.Encoder) error

+ func (s *TransactionV0Envelope) UnmarshalBinary(inp []byte) error

+ func (s TransactionV0Envelope) MarshalBinary() ([]byte, error)

+ type TransactionV0Ext struct

+ V int32

+ func NewTransactionV0Ext(v int32, value interface{}) (result TransactionV0Ext, err error)

+ func (s *TransactionV0Ext) UnmarshalBinary(inp []byte) error

+ func (s TransactionV0Ext) MarshalBinary() ([]byte, error)

+ func (u *TransactionV0Ext) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u TransactionV0Ext) ArmForSwitch(sw int32) (string, bool)

+ func (u TransactionV0Ext) EncodeTo(e *xdr.Encoder) error

+ func (u TransactionV0Ext) SwitchFieldName() string

+ type TransactionV1Envelope struct

+ Signatures []DecoratedSignature

+ Tx Transaction

+ func (s *TransactionV1Envelope) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TransactionV1Envelope) EncodeTo(e *xdr.Encoder) error

+ func (s *TransactionV1Envelope) UnmarshalBinary(inp []byte) error

+ func (s TransactionV1Envelope) MarshalBinary() ([]byte, error)

+ type TrustLineAsset struct

+ AlphaNum12 *AlphaNum12

+ AlphaNum4 *AlphaNum4

+ LiquidityPoolId *PoolId

+ Type AssetType

+ func NewTrustLineAsset(aType AssetType, value interface{}) (result TrustLineAsset, err error)

+ func (a TrustLineAsset) Equals(other TrustLineAsset) bool

+ func (a TrustLineAsset) Extract(typ interface{}, code interface{}, issuer interface{}) error

+ func (a TrustLineAsset) MustExtract(typ interface{}, code interface{}, issuer interface{})

+ func (s *TrustLineAsset) UnmarshalBinary(inp []byte) error

+ func (s TrustLineAsset) MarshalBinary() ([]byte, error)

+ func (tla TrustLineAsset) ToAsset() Asset

+ func (u *TrustLineAsset) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u TrustLineAsset) ArmForSwitch(sw int32) (string, bool)

+ func (u TrustLineAsset) EncodeTo(e *xdr.Encoder) error

+ func (u TrustLineAsset) GetAlphaNum12() (result AlphaNum12, ok bool)

+ func (u TrustLineAsset) GetAlphaNum4() (result AlphaNum4, ok bool)

+ func (u TrustLineAsset) GetLiquidityPoolId() (result PoolId, ok bool)

+ func (u TrustLineAsset) MustAlphaNum12() AlphaNum12

+ func (u TrustLineAsset) MustAlphaNum4() AlphaNum4

+ func (u TrustLineAsset) MustLiquidityPoolId() PoolId

+ func (u TrustLineAsset) SwitchFieldName() string

+ type TrustLineEntry struct

+ AccountId AccountId

+ Asset TrustLineAsset

+ Balance Int64

+ Ext TrustLineEntryExt

+ Flags Uint32

+ Limit Int64

+ func (s *TrustLineEntry) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TrustLineEntry) EncodeTo(e *xdr.Encoder) error

+ func (s *TrustLineEntry) UnmarshalBinary(inp []byte) error

+ func (s TrustLineEntry) MarshalBinary() ([]byte, error)

+ func (trustLine *TrustLineEntry) Liabilities() Liabilities

+ type TrustLineEntryExt struct

+ V int32

+ V1 *TrustLineEntryV1

+ func NewTrustLineEntryExt(v int32, value interface{}) (result TrustLineEntryExt, err error)

+ func (s *TrustLineEntryExt) UnmarshalBinary(inp []byte) error

+ func (s TrustLineEntryExt) MarshalBinary() ([]byte, error)

+ func (u *TrustLineEntryExt) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u TrustLineEntryExt) ArmForSwitch(sw int32) (string, bool)

+ func (u TrustLineEntryExt) EncodeTo(e *xdr.Encoder) error

+ func (u TrustLineEntryExt) GetV1() (result TrustLineEntryV1, ok bool)

+ func (u TrustLineEntryExt) MustV1() TrustLineEntryV1

+ func (u TrustLineEntryExt) SwitchFieldName() string

+ type TrustLineEntryExtensionV2 struct

+ Ext TrustLineEntryExtensionV2Ext

+ LiquidityPoolUseCount Int32

+ func (s *TrustLineEntryExtensionV2) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TrustLineEntryExtensionV2) EncodeTo(e *xdr.Encoder) error

+ func (s *TrustLineEntryExtensionV2) UnmarshalBinary(inp []byte) error

+ func (s TrustLineEntryExtensionV2) MarshalBinary() ([]byte, error)

+ type TrustLineEntryExtensionV2Ext struct

+ V int32

+ func NewTrustLineEntryExtensionV2Ext(v int32, value interface{}) (result TrustLineEntryExtensionV2Ext, err error)

+ func (s *TrustLineEntryExtensionV2Ext) UnmarshalBinary(inp []byte) error

+ func (s TrustLineEntryExtensionV2Ext) MarshalBinary() ([]byte, error)

+ func (u *TrustLineEntryExtensionV2Ext) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u TrustLineEntryExtensionV2Ext) ArmForSwitch(sw int32) (string, bool)

+ func (u TrustLineEntryExtensionV2Ext) EncodeTo(e *xdr.Encoder) error

+ func (u TrustLineEntryExtensionV2Ext) SwitchFieldName() string

+ type TrustLineEntryV1 struct

+ Ext TrustLineEntryV1Ext

+ Liabilities Liabilities

+ func (s *TrustLineEntryV1) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *TrustLineEntryV1) EncodeTo(e *xdr.Encoder) error

+ func (s *TrustLineEntryV1) UnmarshalBinary(inp []byte) error

+ func (s TrustLineEntryV1) MarshalBinary() ([]byte, error)

+ type TrustLineEntryV1Ext struct

+ V int32

+ V2 *TrustLineEntryExtensionV2

+ func NewTrustLineEntryV1Ext(v int32, value interface{}) (result TrustLineEntryV1Ext, err error)

+ func (s *TrustLineEntryV1Ext) UnmarshalBinary(inp []byte) error

+ func (s TrustLineEntryV1Ext) MarshalBinary() ([]byte, error)

+ func (u *TrustLineEntryV1Ext) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (u TrustLineEntryV1Ext) ArmForSwitch(sw int32) (string, bool)

+ func (u TrustLineEntryV1Ext) EncodeTo(e *xdr.Encoder) error

+ func (u TrustLineEntryV1Ext) GetV2() (result TrustLineEntryExtensionV2, ok bool)

+ func (u TrustLineEntryV1Ext) MustV2() TrustLineEntryExtensionV2

+ func (u TrustLineEntryV1Ext) SwitchFieldName() string

+ type TrustLineFlags int32

+ const TrustLineFlagsAuthorizedFlag

+ const TrustLineFlagsAuthorizedToMaintainLiabilitiesFlag

+ const TrustLineFlagsTrustlineClawbackEnabledFlag

+ func (e *TrustLineFlags) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (e TrustLineFlags) EncodeTo(enc *xdr.Encoder) error

+ func (e TrustLineFlags) IsAuthorized() bool

+ func (e TrustLineFlags) IsAuthorizedToMaintainLiabilitiesFlag() bool

+ func (e TrustLineFlags) IsClawbackEnabledFlag() bool

+ func (e TrustLineFlags) String() string

+ func (e TrustLineFlags) ValidEnum(v int32) bool

+ func (s *TrustLineFlags) UnmarshalBinary(inp []byte) error

+ func (s TrustLineFlags) MarshalBinary() ([]byte, error)

+ type Uint256 [32]byte

+ func (e Uint256) XDRMaxSize() int

+ func (s *Uint256) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Uint256) EncodeTo(e *xdr.Encoder) error

+ func (s *Uint256) UnmarshalBinary(inp []byte) error

+ func (s Uint256) MarshalBinary() ([]byte, error)

+ type Uint32 uint32

+ func (s *Uint32) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Uint32) UnmarshalBinary(inp []byte) error

+ func (s Uint32) EncodeTo(e *xdr.Encoder) error

+ func (s Uint32) MarshalBinary() ([]byte, error)

+ func (u Uint32) GoString() string

+ type Uint64 uint64

+ func (s *Uint64) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Uint64) UnmarshalBinary(inp []byte) error

+ func (s Uint64) EncodeTo(e *xdr.Encoder) error

+ func (s Uint64) MarshalBinary() ([]byte, error)

+ type UpgradeEntryMeta struct

+ Changes LedgerEntryChanges

+ Upgrade LedgerUpgrade

+ func (s *UpgradeEntryMeta) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *UpgradeEntryMeta) EncodeTo(e *xdr.Encoder) error

+ func (s *UpgradeEntryMeta) UnmarshalBinary(inp []byte) error

+ func (s UpgradeEntryMeta) MarshalBinary() ([]byte, error)

+ type UpgradeType []byte

+ func (e UpgradeType) XDRMaxSize() int

+ func (s *UpgradeType) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *UpgradeType) UnmarshalBinary(inp []byte) error

+ func (s UpgradeType) EncodeTo(e *xdr.Encoder) error

+ func (s UpgradeType) MarshalBinary() ([]byte, error)

+ type Value []byte

+ func (s *Value) DecodeFrom(d *xdr.Decoder) (int, error)

+ func (s *Value) UnmarshalBinary(inp []byte) error

+ func (s Value) EncodeTo(e *xdr.Encoder) error

+ func (s Value) MarshalBinary() ([]byte, error)