cosmos

package
v0.2.7 Latest Latest
Warning

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

 Go to latest Published: Sep 10, 2020 License: GPL-3.0 Imports: 19 Imported by: 1

Documentation

Index

Constants

View Source 
const (
	// DefaultClientTimeout used by the Client.
	DefaultClientTimeout = time.Minute
	// DefaultClientTimeoutRetry used by the Client.
	DefaultClientTimeoutRetry = time.Second
	// DefaultClientHost used by the Client. This should only be used for local
	// deployments of the multichain.
	DefaultClientHost = "http://0.0.0.0:26657"
	// DefaultBroadcastMode configures the behaviour of a cosmos client while it
	// interacts with the cosmos node. Allowed broadcast modes can be async, sync
	// and block. "async" returns immediately after broadcasting, "sync" returns
	// after the transaction has been checked and "block" waits until the
	// transaction is committed to the chain.
	DefaultBroadcastMode = "sync"
)

Variables

This section is empty.

Functions

func NewClient 

func NewClient(opts ClientOptions, cdc *codec.Codec) account.Client

NewClient returns a new Client.

func NewGasEstimator 

func NewGasEstimator(gasPerByte pack.U256) gas.Estimator

NewGasEstimator returns a simple gas estimator that always returns the same amount of gas-per-byte.

func NewTxBuilder 

func NewTxBuilder(options TxBuilderOptions) account.TxBuilder

NewTxBuilder returns an implementation of the transaction builder interface from the Cosmos Compat API, and exposes the functionality to build simple Cosmos based transactions.

Types

type Address 

type Address sdk.AccAddress

An Address is a public address that can be encoded/decoded to/from strings. Addresses are usually formatted different between different network configurations.

func (Address) AccAddress 

func (addr Address) AccAddress() sdk.AccAddress

AccAddress convert Address to sdk.AccAddress

func (Address) String 

func (addr Address) String() string

String implements the Stringer interface

type AddressDecoder 

type AddressDecoder struct {
	// contains filtered or unexported fields
}

AddressDecoder implements the address.Decoder interface

func NewAddressDecoder 

func NewAddressDecoder(hrp string) AddressDecoder

NewAddressDecoder creates a new address decoder

func (AddressDecoder) DecodeAddress 

func (decoder AddressDecoder) DecodeAddress(addr address.Address) (address.RawAddress, error)

DecodeAddress consumes a human-readable representation of a cosmos compatible address and decodes it to its raw bytes representation.

type AddressEncodeDecoder 

type AddressEncodeDecoder struct {
	AddressEncoder
	AddressDecoder
}

AddressEncodeDecoder encapsulates fields that implement the address.EncodeDecoder interface

func NewAddressEncodeDecoder 

func NewAddressEncodeDecoder(hrp string) AddressEncodeDecoder

NewAddressEncodeDecoder creates a new address encoder-decoder

type AddressEncoder 

type AddressEncoder struct{}

AddressEncoder implements the address.Encoder interface

func NewAddressEncoder 

func NewAddressEncoder() AddressEncoder

NewAddressEncoder creates a new address encoder

func (AddressEncoder) EncodeAddress 

func (encoder AddressEncoder) EncodeAddress(rawAddr address.RawAddress) (address.Address, error)

EncodeAddress consumes raw bytes and encodes them to a human-readable address format.

type Client 

type Client struct {
	// contains filtered or unexported fields
}

Client interacts with an instance of the Cosmos based network using the REST interface exposed by a lightclient node.

func (*Client) SubmitTx 

func (client *Client) SubmitTx(ctx context.Context, tx account.Tx) error

SubmitTx to the Cosmos based network.

func (*Client) Tx 

func (client *Client) Tx(ctx context.Context, txHash pack.Bytes) (account.Tx, pack.U64, error)

Tx query transaction with txHash

type ClientOptions 

type ClientOptions struct {
	Timeout       time.Duration
	TimeoutRetry  time.Duration
	Host          pack.String
	BroadcastMode pack.String
}

ClientOptions are used to parameterise the behaviour of the Client.

func DefaultClientOptions 

func DefaultClientOptions() ClientOptions

DefaultClientOptions returns ClientOptions with the default settings. These settings are valid for use with the default local deployment of the multichain. In production, the host, user, and password should be changed.

func (ClientOptions) WithHost 

func (opts ClientOptions) WithHost(host pack.String) ClientOptions

WithHost sets the URL of the Bitcoin node.

type Coin 

type Coin struct {
	Denom  pack.String `json:"denom"`
	Amount pack.U64    `json:"amount"`
}

Coin copy type from types.coin

type Coins 

type Coins []Coin

Coins array of Coin

func (Coins) Coins 

func (coins Coins) Coins() types.Coins

Coins parse pack coins to sdk coins

type GasEstimator 

type GasEstimator struct {
	// contains filtered or unexported fields
}

A GasEstimator returns the gas-per-byte that is needed in order to confirm transactions with an estimated maximum delay of one block. In distributed networks that collectively build, sign, and submit transactions, it is important that all nodes in the network have reached consensus on the gas-per-byte.

func (*GasEstimator) EstimateGasPrice 

func (gasEstimator *GasEstimator) EstimateGasPrice(ctx context.Context) (pack.U256, error)

EstimateGasPrice returns gas required per byte for Cosmos-compatible chains.

type MsgSend 

type MsgSend struct {
	FromAddress Address `json:"from_address" yaml:"from_address"`
	ToAddress   Address `json:"to_address" yaml:"to_address"`
	Amount      Coins   `json:"amount" yaml:"amount"`
}

MsgSend - high level transaction of the coin module

func (MsgSend) Msg 

func (msg MsgSend) Msg() types.Msg

Msg convert MsgSend to types.Msg

type StdFee 

type StdFee struct {
	Amount Coins    `json:"amount" yaml:"amount"`
	Gas    pack.U64 `json:"gas" yaml:"gas"`
}

StdFee auth.StdFee wrapper

type StdSignature 

type StdSignature struct {
	PubKey    pack.Bytes `json:"pub_key" yaml:"pub_key"`
	Signature pack.Bytes `json:"signature" yaml:"signature"`
}

StdSignature auth.StdStdSignature wrapper

type StdTx 

type StdTx struct {
	// contains filtered or unexported fields
}

StdTx auth.StStdTx wrapper

func (StdTx) From 

func (tx StdTx) From() address.Address

From returns the sender of the transaction

func (StdTx) Hash 

func (tx StdTx) Hash() pack.Bytes

Hash return txhash bytes.

func (StdTx) Nonce 

func (tx StdTx) Nonce() pack.U256

Nonce returns the transaction count of the transaction sender.

func (StdTx) Payload 

func (tx StdTx) Payload() contract.CallData

Payload returns the memo attached to the transaction.

func (StdTx) Serialize 

func (tx StdTx) Serialize() (pack.Bytes, error)

Serialize the transaction.

func (StdTx) Sighashes 

func (tx StdTx) Sighashes() ([]pack.Bytes32, error)

Sighashes that need to be signed before this transaction can be submitted.

func (*StdTx) Sign 

func (tx *StdTx) Sign(signatures []pack.Bytes65, pubKey pack.Bytes) error

Sign the transaction by injecting signatures and the serialized pubkey of the signer.

func (StdTx) To 

func (tx StdTx) To() address.Address

To returns the recipients of the transaction. For the cosmos chain, there can be multiple recipients from a single transaction.

func (StdTx) Value 

func (tx StdTx) Value() pack.U256

Value returns the values being transferred in a transaction. For the cosmos chain, there can be multiple messages (each with a different value being transferred) in a single transaction.

type TxBuilderOptions 

type TxBuilderOptions struct {
	Cdc           *codec.Codec `json:"cdc"`
	AccountNumber pack.U64     `json:"account_number"`
	ChainID       pack.String  `json:"chain_id"`
	CoinDenom     pack.String  `json:"coin_denom"`
}

TxBuilderOptions only contains necessary options to build tx from tx builder

Source Files

View all Source files

Jump to

Keyboard shortcuts

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