Largest 64-bit signed integer (9223372036854775807).
const MaxInt64 = 0x7fffffffffffffff
When a user does not have an stc.conf configuration file, the library searches for one in $STCDIR/stc.conf, then /etc/stc.conf, then ../share/stc.conf (relative to the executable path). If none of those paths exists, then it uses the built-in contents specified by this variable.
var DefaultGlobalConfigContents = []byte( `# Default Stellar network configurations for stc. [net "main"] network-id = "Public Global Stellar Network ; September 2015" horizon = https://horizon.stellar.org/ native-asset = XLM [net "test"] horizon = https://horizon-testnet.stellar.org/ native-asset = TestXLM [net "standalone"] network-id = "Standalone Network ; February 2017" horizon = http://localhost:8000/ native-asset = StandaloneXLM `)
var ErrInvalidNetName = errors.New("Invalid or missing Stellar network name")
var ErrNoNetworkId = errors.New("Cannot obtain Stellar network-id")
var InvalidKeyFile = errors.New("Invalid private key file")
var InvalidPassphrase = errors.New("Invalid passphrase")
func ConfigPath(components ...string) string
Return the path to a file under the user's configuration directory. The configuration directory is found based on environment variables. From highest to lowest precedence tries $STCDIR, UserConfigDir() (i.e., on Unix $XDG_CONFIG_HOME/.stc or $HOME/.config/stc), or ./.stc, using the first one with for which the environment variable exists. If the configuration directory doesn't exist, it gets created, but the underlying path requested will not be created.
func IsTemporary(err error) bool
Try to determine whether a request to Horizon indicates the operation is worth retrying. Specifically, this function repeatedly unwraps errors and returns true if either A) one of the errors has a Temporary() method that returns true, or B) one of the errors is a net.OpError for Op "dial" and that is not wrapping a DNS error. The logic here is that if the DNS name of a horizon server does not exist (permanent DNS error), there is likely some misconfiguration. However, if the horizon server is refusing TCP connections, it may be undergoing maintenance.
func MemoHash(arg [32]uint8) (ret stx.Memo)
Helper function for initializing a Memo with Type == MEMO_HASH
func MemoId(arg uint64) (ret stx.Memo)
Helper function for initializing a Memo with Type == MEMO_ID
func MemoNone() stx.Memo
Helper function for initializing a Memo with Type == MEMO_NONE
func MemoReturn(arg [32]uint8) (ret stx.Memo)
Helper function for initializing a Memo with Type == MEMO_RETURN
func MemoText(arg string) (ret stx.Memo)
Helper function for initializing a Memo with Type == MEMO_TEXT
func MkAsset(acc AccountID, code string) stx.Asset
func MkAssetCode(code string) stx.AssetCode
func NativeAsset() stx.Asset
func NewHyper(v int64) *int64
Allocate an int64 when initializing types that take an XDR hyper*.
func NewSignerHashX(x stx.Hash, weight uint32) *stx.Signer
Create a signer that requires the hash pre-image of some hash value x
func NewSignerKey(pk PublicKey, weight uint32) *stx.Signer
Create a signer for a particular public key and weight
func NewString(v string) *string
Allocate a string when initializing types that take an XDR *string<>.
func NewUhyper(v uint64) *uint64
Allocate a uint64 when initializing types that take an XDR unsigned hyper*.
func NewUint(v uint32) *uint32
Allocate a uint32 when initializing types that take an XDR int*.
func ParseConfigFiles(sink ini.IniSink, paths ...string) error
Parse a series of INI configuration files specified by paths, followed by the global or built-in stc.conf file.
func Set(t xdr.XdrType, fieldValues ...interface{})
Assign a set of values to successive fields of an XDR structure in a type-safe way, flattening out nested structures. For example, given the following XDR:
union Asset switch (AssetType type) { case ASSET_TYPE_NATIVE: // Not credit void; case ASSET_TYPE_CREDIT_ALPHANUM4: struct { opaque assetCode[4]; // 1 to 4 characters AccountID issuer; } alphaNum4; case ASSET_TYPE_CREDIT_ALPHANUM12: struct { opaque assetCode[12]; // 5 to 12 characters AccountID issuer; } alphaNum12; };
You can initalize it with the following:
var asset Asset Set(&asset, ASSET_TYPE_CREDIT_ALPHANUM12, "Asset Code", AccountID{})
Fixed-length arrays of size n must be assigned from n successive arguments passed to Set and cannot be passed as an array. Slices, by contrast, must be assigned from slices. The one exception is fixed-size array of bytes opaque[n], which can be initialized from a string, a slice []byte, or an array [n]byte. The string or slice may be shorter than n (in which case the remainig bytes are filled with 0), but a byte array must be exactly the same length. (If you really must assign from a shorter fixed-length byte array, just slice the array.)
Note that aggregates can be passed as arguments to assign, in which case Set will take fewer arguments. The recursive traversal of structures stops when it is possible to assign the next value to the current aggregate. For example, it is valid to say:
var asset Asset Set(&asset, ASSET_TYPE_CREDIT_ALPHANUM12, otherAsset.AlphaNum12)
func TxToBase64(tx *TransactionEnvelope) string
Convert a TransactionEnvelope to base64-encoded binary XDR format.
func ValidNetName(name string) bool
Set of annotations to show as comments when showing Stellar AccountID values.
type AccountHints map[string]string
func (h AccountHints) String() string
Renders an account hint as the AccountID in StrKey format, a space, and the comment (if any).
type AccountID = stx.AccountID
func DemuxAcct(macct *MuxedAccount) (*AccountID, *uint64)
Break a MuxedAccount into its consituent parts. Note that the second return value of type *uint64 may be nil for MuxedAccounts that don't include an embedded identifier.
func NewAccountID(id AccountID) *AccountID
Return a pointer to an account ID
AccountMerge is a type with the same fields as stx.MuxedAccount that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == ACCOUNT_MERGE and *Body.Destination() initialized from the fields of the AccountMerge.
type AccountMerge stx.MuxedAccount
func (arg AccountMerge) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
AllowTrust is a type with the same fields as stx.AllowTrustOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == ALLOW_TRUST and *Body.AllowTrustOp() initialized from the fields of the AllowTrust.
type AllowTrust stx.AllowTrustOp
func (arg AllowTrust) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
BeginSponsoringFutureReserves is a type with the same fields as stx.BeginSponsoringFutureReservesOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == BEGIN_SPONSORING_FUTURE_RESERVES and *Body.BeginSponsoringFutureReservesOp() initialized from the fields of the BeginSponsoringFutureReserves.
type BeginSponsoringFutureReserves stx.BeginSponsoringFutureReservesOp
func (arg BeginSponsoringFutureReserves) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
BumpSequence is a type with the same fields as stx.BumpSequenceOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == BUMP_SEQUENCE and *Body.BumpSequenceOp() initialized from the fields of the BumpSequence.
type BumpSequence stx.BumpSequenceOp
func (arg BumpSequence) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
ChangeTrust is a type with the same fields as stx.ChangeTrustOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == CHANGE_TRUST and *Body.ChangeTrustOp() initialized from the fields of the ChangeTrust.
type ChangeTrust stx.ChangeTrustOp
func (arg ChangeTrust) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
ClaimClaimableBalance is a type with the same fields as stx.ClaimClaimableBalanceOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == CLAIM_CLAIMABLE_BALANCE and *Body.ClaimClaimableBalanceOp() initialized from the fields of the ClaimClaimableBalance.
type ClaimClaimableBalance stx.ClaimClaimableBalanceOp
func (arg ClaimClaimableBalance) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
Clawback is a type with the same fields as stx.ClawbackOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == CLAWBACK and *Body.ClawbackOp() initialized from the fields of the Clawback.
type Clawback stx.ClawbackOp
func (arg Clawback) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
ClawbackClaimableBalance is a type with the same fields as stx.ClawbackClaimableBalanceOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == CLAWBACK_CLAIMABLE_BALANCE and *Body.ClawbackClaimableBalanceOp() initialized from the fields of the ClawbackClaimableBalance.
type ClawbackClaimableBalance stx.ClawbackClaimableBalanceOp
func (arg ClawbackClaimableBalance) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
CreateAccount is a type with the same fields as stx.CreateAccountOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == CREATE_ACCOUNT and *Body.CreateAccountOp() initialized from the fields of the CreateAccount.
type CreateAccount stx.CreateAccountOp
func (arg CreateAccount) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
CreateClaimableBalance is a type with the same fields as stx.CreateClaimableBalanceOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == CREATE_CLAIMABLE_BALANCE and *Body.CreateClaimableBalanceOp() initialized from the fields of the CreateClaimableBalance.
type CreateClaimableBalance stx.CreateClaimableBalanceOp
func (arg CreateClaimableBalance) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
CreatePassiveSellOffer is a type with the same fields as stx.CreatePassiveSellOfferOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == CREATE_PASSIVE_SELL_OFFER and *Body.CreatePassiveSellOfferOp() initialized from the fields of the CreatePassiveSellOffer.
type CreatePassiveSellOffer stx.CreatePassiveSellOfferOp
func (arg CreatePassiveSellOffer) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
EndSponsoringFutureReserves is an empty type that can be passed to TransactionEnvelope.Append() to append a new Operation with Body.Type == END_SPONSORING_FUTURE_RESERVES.
type EndSponsoringFutureReserves struct{}
func (EndSponsoringFutureReserves) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
type ErrEventStream string
func (e ErrEventStream) Error() string
Distribution of offered or charged fees.
type FeeDist struct { Max FeeVal Min FeeVal Mode FeeVal Percentiles []FeePercentile }
func (fd *FeeDist) Percentile(target int) FeeVal
Conservatively returns a fee that is a known fee for the target or the closest higher known percentile. Does not interpolate--e.g., if you ask for the 51st percentile but only the 50th and 60th are known, returns the 60th percentile. Never returns a value less than the base fee.
func (fd *FeeDist) UnmarshalJSON(data []byte) error
type FeePercentile = struct { Percentile int Fee FeeVal }
Go representation of the Horizon Fee Stats structure response. The fees are per operation in a transaction, and the individual fields are documented here: https://www.stellar.org/developers/horizon/reference/endpoints/fee-stats.html
type FeeStats struct { Last_ledger uint64 Last_ledger_base_fee uint32 Ledger_capacity_usage float64 Charged FeeDist Offered FeeDist }
func (fs *FeeStats) Percentile(target int) FeeVal
Conservatively a known offered fee for the target or a higher percentile. Never returns a value less than the base fee.
func (fs FeeStats) String() string
func (fs *FeeStats) UnmarshalJSON(data []byte) error
A Fee Value is currently 32 bits, but could become 64 bits if CAP-0015 is adopted.
type FeeVal = uint32
Structure into which you can unmarshal JSON returned by a query to horizon for an account endpoint
type HorizonAccountEntry struct { Net *StellarNet `json:"-"` Sequence stcdetail.JsonInt64 Balance stcdetail.JsonInt64e7 Subentry_count uint32 Inflation_destination *AccountID Home_domain string Last_modified_ledger uint32 Flags HorizonFlags Thresholds HorizonThresholds Balances []HorizonBalance Signers []HorizonSigner Data map[string]string }
func (ae *HorizonAccountEntry) NextSeq() stx.SequenceNumber
Return the next sequence number (1 + Sequence) as an int64 (or 0 if an invalid sequence number was returned by horizon).
func (hs *HorizonAccountEntry) String() string
func (ae *HorizonAccountEntry) UnmarshalJSON(data []byte) error
type HorizonBalance struct { Balance stcdetail.JsonInt64e7 Buying_liabilities stcdetail.JsonInt64e7 Selling_liabilities stcdetail.JsonInt64e7 Limit stcdetail.JsonInt64e7 Asset stx.Asset `json:"-"` }
func (hb *HorizonBalance) UnmarshalJSON(data []byte) error
type HorizonFlags struct { Auth_required bool Auth_revocable bool Auth_immutable bool }
type HorizonSigner struct { Key SignerKey Weight uint32 }
type HorizonThresholds struct { Low_threshold uint8 Med_threshold uint8 High_threshold uint8 }
type HorizonTxResult struct { Net *StellarNet Txhash stx.Hash Ledger uint32 Time time.Time Env stx.TransactionEnvelope Result stx.TransactionResult StellarMetas PagingToken string }
func (r HorizonTxResult) String() string
func (r *HorizonTxResult) Success() bool
func (r *HorizonTxResult) UnmarshalJSON(data []byte) error
Inflation is an empty type that can be passed to TransactionEnvelope.Append() to append a new Operation with Body.Type == INFLATION.
type Inflation struct{}
func (Inflation) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
type LedgerHeader = stx.LedgerHeader
LiquidityPoolDeposit is a type with the same fields as stx.LiquidityPoolDepositOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == LIQUIDITY_POOL_DEPOSIT and *Body.LiquidityPoolDepositOp() initialized from the fields of the LiquidityPoolDeposit.
type LiquidityPoolDeposit stx.LiquidityPoolDepositOp
func (arg LiquidityPoolDeposit) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
LiquidityPoolWithdraw is a type with the same fields as stx.LiquidityPoolWithdrawOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == LIQUIDITY_POOL_WITHDRAW and *Body.LiquidityPoolWithdrawOp() initialized from the fields of the LiquidityPoolWithdraw.
type LiquidityPoolWithdraw stx.LiquidityPoolWithdrawOp
func (arg LiquidityPoolWithdraw) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
ManageBuyOffer is a type with the same fields as stx.ManageBuyOfferOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == MANAGE_BUY_OFFER and *Body.ManageBuyOfferOp() initialized from the fields of the ManageBuyOffer.
type ManageBuyOffer stx.ManageBuyOfferOp
func (arg ManageBuyOffer) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
ManageData is a type with the same fields as stx.ManageDataOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == MANAGE_DATA and *Body.ManageDataOp() initialized from the fields of the ManageData.
type ManageData stx.ManageDataOp
func (arg ManageData) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
ManageSellOffer is a type with the same fields as stx.ManageSellOfferOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == MANAGE_SELL_OFFER and *Body.ManageSellOfferOp() initialized from the fields of the ManageSellOffer.
type ManageSellOffer stx.ManageSellOfferOp
func (arg ManageSellOffer) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
type MuxedAccount = stx.MuxedAccount
func MuxAcct(acct *AccountID, id *uint64) *MuxedAccount
Created a MuxedAccount from its consituent parts. id may be nil to indicate there is no embedded identifier.
Interface for placeholder types that are named by camel-cased versions of the OperationType enum and can be transformed into the body of an Operation
type OperationBody interface { To_Operation_Body() stx.XdrAnon_Operation_Body }
PathPaymentStrictReceive is a type with the same fields as stx.PathPaymentStrictReceiveOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == PATH_PAYMENT_STRICT_RECEIVE and *Body.PathPaymentStrictReceiveOp() initialized from the fields of the PathPaymentStrictReceive.
type PathPaymentStrictReceive stx.PathPaymentStrictReceiveOp
func (arg PathPaymentStrictReceive) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
PathPaymentStrictSend is a type with the same fields as stx.PathPaymentStrictSendOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == PATH_PAYMENT_STRICT_SEND and *Body.PathPaymentStrictSendOp() initialized from the fields of the PathPaymentStrictSend.
type PathPaymentStrictSend stx.PathPaymentStrictSendOp
func (arg PathPaymentStrictSend) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
Payment is a type with the same fields as stx.PaymentOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == PAYMENT and *Body.PaymentOp() initialized from the fields of the Payment.
type Payment stx.PaymentOp
func (arg Payment) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
Abstract type representing a Stellar private key. Prints and scans in StrKey format.
type PrivateKey struct { stcdetail.PrivateKeyInterface }
func InputPrivateKey(prompt string) (PrivateKey, error)
Reads a private key from standard input. If standard input is a terminal, disables echo and prints prompt to standard error.
func LoadPrivateKey(file string) (PrivateKey, error)
Reads a private key from a file, prompting for a passphrase if the key is in ASCII-armored symmetrically-encrypted GPG format.
func NewPrivateKey(pkt stx.PublicKeyType) PrivateKey
Generates a new Stellar keypair and returns the PrivateKey. Currently the only valid value for pkt is stx.PUBLIC_KEY_TYPE_ED25519.
func (sk PrivateKey) Save(file string, passphrase []byte) error
Writes the a private key to a file in strkey format. If passphrase has non-zero length, then the key is symmetrically encrypted in ASCII-armored GPG format.
func (sec *PrivateKey) Scan(ss fmt.ScanState, _ rune) error
func (sec PrivateKey) Valid() bool
type PublicKey = stx.PublicKey
RevokeSponsorship is a type with the same fields as stx.RevokeSponsorshipOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == REVOKE_SPONSORSHIP and *Body.RevokeSponsorshipOp() initialized from the fields of the RevokeSponsorship.
type RevokeSponsorship stx.RevokeSponsorshipOp
func (arg RevokeSponsorship) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
SetOptions is a type with the same fields as stx.SetOptionsOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == SET_OPTIONS and *Body.SetOptionsOp() initialized from the fields of the SetOptions.
type SetOptions stx.SetOptionsOp
func (arg SetOptions) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
SetTrustLineFlags is a type with the same fields as stx.SetTrustLineFlagsOp that can be passed to TransactionEnvelope.Append() to append a new operation with Body.Type == SET_TRUST_LINE_FLAGS and *Body.SetTrustLineFlagsOp() initialized from the fields of the SetTrustLineFlags.
type SetTrustLineFlags stx.SetTrustLineFlagsOp
func (arg SetTrustLineFlags) To_Operation_Body() (ret stx.XdrAnon_Operation_Body)
type Signature = stx.Signature
A SignerCache contains a set of possible Stellar signers. Because a TransactionEnvelope contains an array of signatures without public keys, it is not possible to verify the signatures without having the Signers. The signatures in a TransactionEnvelope envelope are, however, accompanied by a 4-byte SignatureHint, making it efficient to look up signers if they are in a SignerCache.
type SignerCache map[stx.SignatureHint][]SignerKeyInfo
func (c SignerCache) Add(strkey, comment string) error
Adds a signer to a SignerCache if the signer is not already in the cache. If the signer is already in the cache, the comment is left unchanged.
func (c SignerCache) Del(strkey string) error
Deletes a signer from the cache.
func (c SignerCache) Lookup(networkID string, e *stx.TransactionEnvelope, ds *stx.DecoratedSignature) *SignerKeyInfo
Finds the signer in a SignerCache that corresponds to a particular signature on a transaction.
func (c SignerCache) LookupComment(key *stx.SignerKey) string
func (c SignerCache) String() string
Renders SignerCache as a a set of SignerKeyInfo structures, one per line, suitable for saving to a file.
type SignerKey = stx.SignerKey
An annotated SignerKey that can be used to authenticate transactions. Prints and Scans as a StrKey-format SignerKey, a space, and then the comment.
type SignerKeyInfo struct { Key stx.SignerKey Comment string }
func (ski *SignerKeyInfo) Scan(ss fmt.ScanState, c rune) error
func (ski SignerKeyInfo) String() string
Ledger entries changed by a transaction.
type StellarMetas struct { FeeMeta stx.LedgerEntryChanges ResultMeta stx.TransactionMeta }
type StellarNet struct { // Short name for network (used only in error messages). Name string // Network password used for hashing and signing transactions. NetworkId string // Name to use for native asset NativeAsset string // Base URL of horizon (including trailing slash). Horizon string // Set of signers to recognize when checking signatures on // transactions and annotations to show when printing signers. Signers SignerCache // Annotations to show on particular accounts when rendering them // in human-readable txrep format. Accounts AccountHints // Changes will be saved to this file. SavePath string // Changes to be applied by Save(). Edits ini.IniEdits // Cache of fee stats FeeCache *FeeStats FeeCacheTime time.Time }
func DefaultStellarNet(name string) *StellarNet
Load a network from under the ConfigPath() ($STCDIR) directory. If name is "", then it will look at the $STCNET environment variable and if that is unset load a default network. Returns nil if the network name does not exist. After loading the netname.net file, also parses $STCDIR/global.conf.
Two pre-defined names are "main" and "test", with "main" being the default. Other networks can be created under ConfigPath(), or can be pre-specified (and created on demand) in stc.conf.
func LoadStellarNet(name string, paths ...string) (*StellarNet, error)
Load a Stellar network from an INI files. If path[0] does not exist but name is valid, the path will be created and net.name will be set to name. Otherwise the name argument is ignored. After all files in paths are parsed, the global stc.conf file will be parsed. After that, there must be a valid NetworkId or the function will return nil.
func (net *StellarNet) AccountDelta( m *StellarMetas, acct *AccountID, prefix string) string
func (net *StellarNet) AccountIDNote(acct string) string
func (net *StellarNet) AddHint(acct string, hint string)
func (net *StellarNet) AddSigner(signer, comment string)
func (net *StellarNet) Get(query string) ([]byte, error)
Send an HTTP request to horizon
func (net *StellarNet) GetAccountEntry(acct string) ( *HorizonAccountEntry, error)
Fetch the sequence number and signers of an account over the network.
func (net *StellarNet) GetFeeCache() (*FeeStats, error)
Like GetFeeStats but a version cached for 1 minute
func (net *StellarNet) GetFeeStats() (*FeeStats, error)
Queries the network for the latest fee statistics.
func (net *StellarNet) GetJSON(query string, out interface{}) error
Send an HTTP request to horizon and perse the result as JSON
func (net *StellarNet) GetLedgerHeader() (*LedgerHeader, error)
Fetch the latest ledger header over the network.
func (net *StellarNet) GetNativeAsset() string
func (net *StellarNet) GetNetworkId() string
Returns the network ID, a string that is hashed into transaction IDs to ensure that signature are not valid across networks (e.g., a testnet signature cannot work on the public network). If the network ID is not cached in the StellarNet structure itself, then this function fetches it from the network.
Note StellarMainNet already contains the network ID, while StellarTestNet requires fetching the network ID since the Stellar test network is periodically reset.
func (net *StellarNet) GetTxResult(txid string) (*HorizonTxResult, error)
func (net *StellarNet) HashTx(tx stx.Signable) *stx.Hash
Return a transaction hash (which in Stellar is defined as the hash of the constant ENVELOPE_TYPE_TX, the NetworkID, and the marshaled XDR of the Transaction).
func (net *StellarNet) IniSink() ini.IniSink
func (net *StellarNet) IterateJSON( ctx context.Context, query string, cb interface{}) error
Send a request to horizon and iterate through a series of embedded records in the response, continuing to fetch more records until zero records are returned. cb is a callback function which must have type func(obj *T)error or func(obj *T), where *T is a type into which JSON can be unmarshalled. Returns if there is an error or the ctx argument is Done.
func (net *StellarNet) NewSignerPreauth(tx stx.Signable, weight uint32) *stx.Signer
Create a pre-signed transaction from a transaction and weight.
func (net *StellarNet) Post(e *TransactionEnvelope) ( *TransactionResult, error)
Post a new transaction to the network. In the event that the transaction is successfully submitted to horizon but rejected by the Stellar network, the error will be of type TxFailure, which contains the transaction result.
func (net *StellarNet) Save() error
Save any changes to to SavePath. Equivalent to SavePerm(0666).
func (net *StellarNet) SavePerm(perm os.FileMode) error
Save any changes to SavePath. If SavePath does not exist, then create it with permissions Perm (subject to umask, of course).
func (net *StellarNet) SigNote(txe *stx.TransactionEnvelope, sig *stx.DecoratedSignature) string
func (net *StellarNet) SignTx(sk stcdetail.PrivateKeyInterface, e *TransactionEnvelope) error
Sign a transaction and append the signature to the TransactionEnvelope.
func (net *StellarNet) SignerNote(key *stx.SignerKey) string
func (net *StellarNet) StreamJSON( ctx context.Context, query string, cb interface{}) error
Stream a series of events. cb is a callback function which must have type func(obj *T)error or func(obj *T), where *T is a type into which JSON can be unmarshalled. Returns if there is an error or the ctx argument is Done. You likely want to call this in a goroutine, and might want to call it in a loop to try again after errors.
func (net *StellarNet) ToRep(txe xdr.XdrType) string
Convert an arbitrary XDR data structure to human-readable Txrep format.
func (net *StellarNet) TxToRep(txe *TransactionEnvelope) string
Convert a TransactionEnvelope to human-readable Txrep format.
func (net *StellarNet) Validate() error
func (net *StellarNet) VerifySig( pk *SignerKey, tx stx.Signable, sig Signature) bool
Returns true only if sig is a valid signature on e for public key pk.
func (net *StellarNet) WriteRep(out io.Writer, name string, txe xdr.XdrType)
Write the human-readable Txrep of an XDR structure to a Writer.
This is a wrapper around the XDR TransactionEnvelope structure. The wrapper allows transactions to be built up more easily via the Append() method and various helper types. When parsing and generating Txrep format, it also keeps track of which enums were followed by '?' indicating a request for help.
type TransactionEnvelope struct { *stx.TransactionEnvelope Help map[string]struct{} }
func NewTransactionEnvelope() *TransactionEnvelope
func TxFromBase64(input string) (*TransactionEnvelope, error)
Parse a TransactionEnvelope from base64-encoded binary XDR format.
func TxFromRep(rep string) (*TransactionEnvelope, error)
Parse a transaction in human-readable Txrep format into a TransactionEnvelope.
func (txe *TransactionEnvelope) Append( sourceAccount *stx.MuxedAccount, body OperationBody)
Append an operation to a transaction envelope. To facilitate initialization of the transaction body (which is a union and so doesn't support direct initialization), a suite of helper types have the same fields as each of the operation types. The helper types are named after camel-cased versions of the OperationType constants. E.g., to append an operation of type CREATE_ACCOUNT, use type type CreateAccount:
txe.Append(nil, CreateAccount{ Destination: myNewAccountID, StartingBalance: 15000000, })
The helper types are:
type CreateAccount stx.CreateAccountOp type Payment stx.PaymentOp type PathPaymentStrictReceive stx.PathPaymentStrictReceiveOp type ManageSellOffer stx.ManageSellOfferOp type CreatePassiveSellOffer stx.CreatePassiveSellOfferOp type SetOptions stx.SetOptionsOp type ChangeTrust stx.ChangeTrustOp type AllowTrust stx.AllowTrustOp type AccountMerge stx.PublicKey type Inflation struct{} type ManageData stx.ManageDataOp type BumpSequence stx.BumpSequenceOp type ManageBuyOffer stx.ManageBuyOfferOp type PathPaymentStrictSend stx.PathPaymentStrictSendOp
func (txe *TransactionEnvelope) GetHelp(name string) bool
func (txe *TransactionEnvelope) SetFee(baseFee uint32)
Set the fee of a transaction to baseFee times the number of operations. If the result would exceed the maximum fee of 0xffffffff (~430 XLM), then just set the fee to 0xffffffff. (Obviously only call this once you have finished adding operations to the transaction with Append.)
func (txe *TransactionEnvelope) SetHelp(name string)
func (txe *TransactionEnvelope) SetSourceAccount(m0 stx.IsAccount)
func (txe *TransactionEnvelope) SourceAccount() *stx.MuxedAccount
type TransactionResult = stx.TransactionResult
An error representing the failure of a transaction submitted to the Stellar network, and from which you can extract the full TransactionResult.
type TxFailure struct { *TransactionResult }
func (e TxFailure) Error() string
Name | Synopsis |
---|---|
.. | |
cmd | |
ini | This program is just for testing the ini parser/editor in the stc library. |
stc | Please see the stc.1 man page for complete documentation of this command. |
ini | Ini file parser library. |
stcdetail | Internal functions for the stc library. |
stx | The stx package provides a compiled go representation of Stellar's XDR data structures. |
uniontool | Ignore this program. |