transaction

Documentation

Index

• Constants
• Variables
• func AppIDFromTextMemo(memo string) (appID string, ok bool)
• func SignEnvelope(envelope *xdr.TransactionEnvelope, network build.Network, seed string) (*xdr.TransactionEnvelope, error)
• type Authorization
• type AuthorizationResult
• type Authorizer
  • func NewAuthorizer(mapper app.Mapper, configStore app.ConfigStore, webhookClient *webhook.Client, ...) (Authorizer, error)
• type Limiter
  • func NewLimiter(ctor rate.LimiterCtor, globalLimit, appLimit int) *Limiter
  • func (t *Limiter) Allow(appIndex int) (bool, error)
• type Memo
• type Transaction

Constants

const (
	AuthorizationResultOK = iota
	AuthorizationResultRejected
	AuthorizationResultInvoiceError
)

Variables

var (
	SubmitTransactionCounter = prometheus.NewCounterVec(prometheus.CounterOpts{
		Namespace: "agora",
		Name:      "submit_transaction",
		Help:      "Number of submit transaction requests",
	}, []string{"api_version"})
)

Functions

func AppIDFromTextMemo

func AppIDFromTextMemo(memo string) (appID string, ok bool)

AppIDFromTextMemo returns the canonical string AppID given a memo string.

If the provided memo is in the incorrect format, ok will be false.

func SignEnvelope

func SignEnvelope(envelope *xdr.TransactionEnvelope, network build.Network, seed string) (*xdr.TransactionEnvelope, error)

SignEnvelope signs a transaction envelope with the specified seed and network passphrase.

Types

type Authorization

type Authorization struct {
	Result        int
	InvoiceErrors []*commonpb.InvoiceError
	SignResponse  *signtransaction.SuccessResponse
}

type AuthorizationResult

type AuthorizationResult int

type Authorizer

type Authorizer interface {
	// Authorize authorizes the provided transaction.
	//
	// Callers must perform actual submission, and any persistence
	// related to the transaction, such as invoice storing.
	Authorize(context.Context, Transaction) (Authorization, error)
}

Authorizer authorizes transactions.

func NewAuthorizer

func NewAuthorizer(
	mapper app.Mapper,
	configStore app.ConfigStore,
	webhookClient *webhook.Client,
	limiter *Limiter,
) (Authorizer, error)

NewAuthorizer returns an authorizer.

type Limiter

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

Limiter limits transaction based on app index.

If no app index is provided, only the global rate limit applies.

func NewLimiter

func NewLimiter(ctor rate.LimiterCtor, globalLimit, appLimit int) *Limiter

NewLimiter creates a new TransactionLimiter.

func (*Limiter) Allow

func (t *Limiter) Allow(appIndex int) (bool, error)

Allow returns whether or not a transaction for a given app index is allowed to be processed.

type Memo

type Memo struct {
	Memo *kin.Memo
	Text *string
}

type Transaction

type Transaction struct {
	Version     version.KinVersion
	ID          []byte
	Memo        Memo
	OpCount     int
	InvoiceList *commonpb.InvoiceList
	SignRequest *signtransaction.RequestBody
}