interpreter

type AccountAddress ¶

type AccountAddress struct {
	Name  string
	Scope string
}

AccountAddress is an account, optionally partitioned by a scope. The scope is a separate dimension of the account rather than part of its name, so it is modeled as its own field instead of being encoded into the name string.

func (v AccountAddress) String() string

type AccountBalance ¶

type AccountBalance struct {
	Asset  string
	Color  string
	Amount *big.Int
}

A single balance entry for an account: an (asset, color) pair and its amount.

type AccountDependency ¶ added in v0.0.25

type AccountDependency struct {
	Account string
	Scope   string
	Color   string
	Asset   string
}

type AccountMetadataRow ¶ added in v0.0.25

type AccountMetadataRow struct {
	Account string `json:"account"`
	Key     string `json:"key"`
	Value   string `json:"value"`
	Scope   string `json:"scope,omitempty"`
}

type AccountsMetadata ¶

type AccountsMetadata []AccountMetadataRow

AccountsMetadata is the external, serialized representation of account metadata. The runtime works with the in-memory InternalAccountsMetadata and converts to this at the boundaries (store queries, execution result).

func (rows AccountsMetadata) FirstDuplicate() (AccountMetadataRow, bool)

func (m AccountsMetadata) PrettyPrint() string

type Asset ¶

type Asset string

func (asset Asset) GetBaseAndScale() (string, int64)

func (v Asset) String() string

type BadArityErr ¶

type BadArityErr struct {
	parser.Range
	ExpectedArity  int
	GivenArguments int
}

func (e BadArityErr) Error() string

type BadPortionParsingErr ¶ added in v0.0.10

type BadPortionParsingErr struct {
	parser.Range
	Source string
	Reason string
}

func (e BadPortionParsingErr) Error() string

type BalanceQuery ¶

type BalanceQuery []BalanceQueryItem

type BalanceQueryItem ¶ added in v0.0.25

type BalanceQueryItem struct {
	Account string
	Asset   string
	Color   string
	Scope   string
}

For each account, list of the needed assets

type BalanceRow ¶ added in v0.0.25

type BalanceRow struct {
	Account string   `json:"account"`
	Asset   string   `json:"asset"`
	Amount  *big.Int `json:"amount"`
	Color   string   `json:"color,omitempty"`
	Scope   string   `json:"scope,omitempty"`
}

type Balances ¶

type Balances []BalanceRow

func (rows Balances) FirstDuplicate() (BalanceRow, bool)

func (rows Balances) PrettyPrint() string

type CannotCastScopedAccountToString ¶ added in v0.0.25

type CannotCastScopedAccountToString struct {
	parser.Range
	Account string
	Scope   string
}

func (e CannotCastScopedAccountToString) Error() string

type CannotCastToString ¶ added in v0.0.12

type CannotCastToString struct {
	parser.Range
	Value Value
}

func (e CannotCastToString) Error() string

type CannotStoreScopedAccountInMeta ¶ added in v0.0.25

type CannotStoreScopedAccountInMeta struct {
	parser.Range
	Account string
	Scope   string
}

func (e CannotStoreScopedAccountInMeta) Error() string

type DivideByZero ¶ added in v0.0.11

type DivideByZero struct {
	parser.Range
	Numerator *big.Int
}

func (e DivideByZero) Error() string

type ExecutionResult ¶

type ExecutionResult struct {
	Postings []Posting `json:"postings"`

	Metadata Metadata `json:"txMeta"`

	AccountsMetadata SetAccountsMetadata `json:"accountsMeta"`
}

type ExperimentalFeature ¶ added in v0.0.10

type ExperimentalFeature struct {
	parser.Range
	FlagName string
}

func (e ExperimentalFeature) Error() string

type InternalAccountsMetadata ¶ added in v0.0.25

type InternalAccountsMetadata map[AccountAddress]map[string]string

An internal representation of the account metadata. Used to cache metadata we get from external store. Whereas the external representation (interpreter.AccountsMetadata) is user-facing and a stable contract, this one is used internally by the runtime, and could change over time, for example to add more indexes for faster lookups. It mirrors InternalBalances: keyed by the (account, scope) pair, holding that account's (key -> value) entries.

func (m InternalAccountsMetadata) Get(account AccountAddress, key string) (string, bool)

func (m InternalAccountsMetadata) Merge(rows AccountsMetadata)

func (m InternalAccountsMetadata) Set(account AccountAddress, key string, value string)

type InternalBalances ¶ added in v0.0.25

type InternalBalances map[AccountAddress][]AccountBalance

An internal representation of the balances. Used to cache balances we get from external store. Whereas the external representation (interpreter.Balances) is user-facing and be a stable contract, (for example, allowing more columns if we need an higher level of fungibility), this one is used internally by the runtime, and could change over time, for example to add more indexes for faster lookups

func FromBalancesRows(b Balances) InternalBalances

func (b InternalBalances) DeepClone() InternalBalances

func (b InternalBalances) Merge(update []BalanceRow)

func (b InternalBalances) Set(account AccountAddress, asset string, color string, amount *big.Int)

type InternalError ¶ added in v0.0.21

type InternalError struct {
	parser.Range
	Posting Posting
}

func (e InternalError) Error() string

type InterpreterError ¶

type InterpreterError interface {
	error
	parser.Ranged
}

func ParsePortionSpecific(input string) (*big.Rat, InterpreterError)

type InvalidAccountName ¶ added in v0.0.12

type InvalidAccountName struct {
	parser.Range
	Name string
}

func (e InvalidAccountName) Error() string

type InvalidAllotmentInSendAll ¶

type InvalidAllotmentInSendAll struct {
	parser.Range
}

func (e InvalidAllotmentInSendAll) Error() string

type InvalidAllotmentSum ¶

type InvalidAllotmentSum struct {
	parser.Range
	ActualSum big.Rat
}

func (e InvalidAllotmentSum) Error() string

type InvalidAsset ¶ added in v0.0.21

type InvalidAsset struct {
	parser.Range
	Name string
}

func (e InvalidAsset) Error() string

type InvalidColor ¶ added in v0.0.17

type InvalidColor struct {
	parser.Range
	Color string
}

func (e InvalidColor) Error() string

type InvalidFeature ¶ added in v0.0.24

type InvalidFeature struct {
	parser.Range
	Feature string
}

func (e InvalidFeature) Error() string

type InvalidMonetaryLiteral ¶

type InvalidMonetaryLiteral struct {
	parser.Range
	Source string
}

func (e InvalidMonetaryLiteral) Error() string

type InvalidNestedMeta ¶ added in v0.0.15

type InvalidNestedMeta struct {
	parser.Range
}

func (InvalidNestedMeta) Error() string

type InvalidNumberLiteral ¶

type InvalidNumberLiteral struct {
	parser.Range
	Source string
}

func (e InvalidNumberLiteral) Error() string

type InvalidOperatorErr ¶ added in v0.0.25

type InvalidOperatorErr struct {
	parser.Range
	Operator string
}

func (e InvalidOperatorErr) Error() string

type InvalidRemainingAllotment ¶ added in v0.0.25

type InvalidRemainingAllotment struct {
	parser.Range
}

func (e InvalidRemainingAllotment) Error() string

type InvalidScope ¶ added in v0.0.25

type InvalidScope struct {
	parser.Range
	Scope string
}

func (e InvalidScope) Error() string

type InvalidTypeErr ¶

type InvalidTypeErr struct {
	parser.Range
	Name string
}

func (e InvalidTypeErr) Error() string

type InvalidUnboundedAddressInScalingAddress ¶ added in v0.0.24

type InvalidUnboundedAddressInScalingAddress struct {
	parser.Range
}

func (InvalidUnboundedAddressInScalingAddress) Error() string

type InvalidUnboundedInSendAll ¶

type InvalidUnboundedInSendAll struct {
	parser.Range
	Name  string
	Scope string
}

func (e InvalidUnboundedInSendAll) Error() string

type MetaDependency ¶ added in v0.0.25

type MetaDependency struct {
	Account string
	Scope   string
	Key     string
}

type Metadata ¶

type Metadata = map[string]string

Metadata is the external representation of transaction metadata: keys mapped to their rendered value (see MetaString). The runtime keeps the typed values in programState.TxMeta and renders them when building the ExecutionResult.

type MetadataNotFound ¶

type MetadataNotFound struct {
	parser.Range
	Account string
	Scope   string
	Key     string
}

func (e MetadataNotFound) Error() string

type MetadataQuery ¶

type MetadataQuery []MetadataQueryItem

type MetadataQueryItem ¶ added in v0.0.25

type MetadataQueryItem = struct {
	Account string
	Scope   string
	Keys    []string
}

type MismatchedCurrencyError ¶

type MismatchedCurrencyError struct {
	parser.Range
	Expected string
	Got      string
}

func (e MismatchedCurrencyError) Error() string

type MissingFundsErr ¶

type MissingFundsErr struct {
	parser.Range
	Asset     string
	Needed    big.Int
	Available big.Int
}

func (e MissingFundsErr) Error() string

func (e MissingFundsErr) Is(target error) bool

type MissingVariableErr ¶

type MissingVariableErr struct {
	parser.Range
	Name string
}

func (e MissingVariableErr) Error() string

type Monetary ¶

type Monetary struct {
	Amount MonetaryInt
	Asset  Asset
}

func NewMonetary(asset string, n int64) Monetary

func (v Monetary) String() string

type MonetaryInt ¶

type MonetaryInt big.Int

func NewMonetaryInt(n int64) MonetaryInt

func NewMonetaryIntBig(n *big.Int) MonetaryInt

func (m MonetaryInt) Add(other MonetaryInt) MonetaryInt

func (v MonetaryInt) String() string

func (m MonetaryInt) Sub(other MonetaryInt) MonetaryInt

type NegativeAmountErr ¶

type NegativeAmountErr struct {
	parser.Range
	Amount MonetaryInt
}

func (e NegativeAmountErr) Error() string

type NegativeBalanceError ¶

type NegativeBalanceError struct {
	parser.Range
	Account string
	Scope   string
	Amount  big.Int
}

func (e NegativeBalanceError) Error() string

type Portion ¶

type Portion big.Rat

func (p Portion) String() string

type Posting ¶

type Posting struct {
	Source           string   `json:"source"`
	SourceScope      string   `json:"sourceScope,omitempty"`
	Destination      string   `json:"destination"`
	DestinationScope string   `json:"destinationScope,omitempty"`
	Amount           *big.Int `json:"amount"`
	Asset            string   `json:"asset"`
	Color            string   `json:"color,omitempty"`
}

type QueryBalanceError ¶

type QueryBalanceError struct {
	parser.Range
	WrappedError error
}

func (e QueryBalanceError) Error() string

func (e QueryBalanceError) Unwrap() error

type QueryMetadataError ¶

type QueryMetadataError struct {
	parser.Range
	WrappedError error
}

func (e QueryMetadataError) Error() string

func (e QueryMetadataError) Unwrap() error

type ResolvedDependencies ¶ added in v0.0.25

type ResolvedDependencies struct {
	AccountsReads  map[AccountDependency]struct{}
	AccountsWrites map[AccountDependency]struct{}
	MetaReads      map[MetaDependency]struct{}
	MetaWrites     map[MetaDependency]struct{}
	TxMetaWrites   map[string]struct{}
}

func ResolveDependencies(ctx context.Context, store Store, vars map[string]string, program parser.Program) (ResolvedDependencies, error)

type Sender ¶

type Sender struct {
	Account AccountAddress
	Amount  *big.Int
	Color   string
}

type SetAccountMetadataRow ¶ added in v0.0.25

type SetAccountMetadataRow struct {
	Account string `json:"account"`
	Key     string `json:"key"`
	Value   string `json:"value"`
	Scope   string `json:"scope,omitempty"`
}

SetAccountMetadataRow is a single piece of account metadata set by the script during execution. The value is carried as the rendered text produced by MetaString, matching the input metadata: the wire format is untyped, so a value's type is not part of what gets stored or asserted.

type SetAccountsMetadata ¶ added in v0.0.25

type SetAccountsMetadata []SetAccountMetadataRow

SetAccountsMetadata is the account metadata produced by the script (the execution result's accountsMeta, and a spec's expect.metadata).

type StaticStore ¶

type StaticStore struct {
	Balances Balances
	Meta     AccountsMetadata
}

func (s StaticStore) GetAccountsMetadata(_ context.Context, q MetadataQuery) (AccountsMetadata, error)

func (s StaticStore) GetBalances(_ context.Context, q BalanceQuery) (Balances, error)

type Store ¶

type Store interface {
	// Returns the batched balances for a given batched query.
	//
	// Note: the "Balances" result is expected not to have duplicate entries.
	// Malformed Balances will result it undefined behaviour, and the implementation doesn't guarantee keys are deduped.
	GetBalances(context.Context, BalanceQuery) (Balances, error)
	GetAccountsMetadata(context.Context, MetadataQuery) (AccountsMetadata, error)
}

type String ¶

type String string

func (v String) String() string

type TypeError ¶

type TypeError struct {
	parser.Range
	Expected string
	Value    Value
}

func (e TypeError) Error() string

type UnboundFunctionErr ¶

type UnboundFunctionErr struct {
	parser.Range
	Name string
}

func (e UnboundFunctionErr) Error() string

type UnboundVariableErr ¶

type UnboundVariableErr struct {
	parser.Range
	Name string
}

func (e UnboundVariableErr) Error() string

type UnhandledError ¶ added in v0.0.25

type UnhandledError struct {
	parser.Range
	Node string
}

UnhandledError is returned instead of panicking when expression evaluation or dependency resolution meets an AST node it doesn't handle (e.g. a language construct added after this code was written).

func (e UnhandledError) Error() string

type Value ¶

type Value interface {
	String() string
	// contains filtered or unexported methods
}

type VariablesMap ¶

type VariablesMap map[string]string