djtx

package
v1.0.0 Latest Latest
Warning

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

Go to latest
Published: Jun 19, 2022 License: BSD-3-Clause Imports: 24 Imported by: 8

Documentation

Index

Constants

View Source
const (
	IsInitializedKey byte = iota
)
View Source
const MaxMemoSize = 256

MaxMemoSize is the maximum number of bytes in the memo field

Variables

This section is empty.

Functions

func GetBalance

func GetBalance(db UTXOReader, addrs ids.ShortSet) (uint64, error)

GetBalance returns the current balance of [addrs]

func IsSortedAndUniqueTransferableInputs

func IsSortedAndUniqueTransferableInputs(ins []*TransferableInput) bool

func IsSortedAndUniqueTransferableInputsWithSigners

func IsSortedAndUniqueTransferableInputsWithSigners(ins []*TransferableInput, signers [][]*crypto.PrivateKeySECP256K1R) bool

IsSortedAndUniqueTransferableInputsWithSigners returns true if the inputs are sorted and unique

func IsSortedAndUniqueUTXOIDs

func IsSortedAndUniqueUTXOIDs(utxos []*UTXOID) bool

func IsSortedTransferableOutputs

func IsSortedTransferableOutputs(outs []*TransferableOutput, c codec.Manager) bool

IsSortedTransferableOutputs returns true if output objects are sorted

func ParseLocalAddresses

func ParseLocalAddresses(a AddressManager, addrStrs []string) (ids.ShortSet, error)

func SortTransferableInputs

func SortTransferableInputs(ins []*TransferableInput)

func SortTransferableInputsWithSigners

func SortTransferableInputsWithSigners(ins []*TransferableInput, signers [][]*crypto.PrivateKeySECP256K1R)

SortTransferableInputsWithSigners sorts the inputs and signers based on the input's utxo ID

func SortTransferableOutputs

func SortTransferableOutputs(outs []*TransferableOutput, c codec.Manager)

SortTransferableOutputs sorts output objects

func SortUTXOIDs

func SortUTXOIDs(utxos []*UTXOID)

func VerifyTx

func VerifyTx(
	feeAmount uint64,
	feeAssetID ids.ID,
	allIns [][]*TransferableInput,
	allOuts [][]*TransferableOutput,
	c codec.Manager,
) error

VerifyTx verifies that the inputs and outputs flowcheck, including a fee. Additionally, this verifies that the inputs and outputs are sorted.

Types

type AddressManager

type AddressManager interface {
	// ParseLocalAddress takes in an address for this chain and produces the ID
	ParseLocalAddress(addrStr string) (ids.ShortID, error)

	// ParseAddress takes in an address and produces the ID of the chain it's
	// for and the ID of the address
	ParseAddress(addrStr string) (ids.ID, ids.ShortID, error)

	// FormatLocalAddress takes in a raw address and produces the formatted
	// address for this chain
	FormatLocalAddress(addr ids.ShortID) (string, error)

	// FormatAddress takes in a chainID and a raw address and produces the
	// formatted address for that chain
	FormatAddress(chainID ids.ID, addr ids.ShortID) (string, error)
}

func NewAddressManager

func NewAddressManager(ctx *snow.Context) AddressManager

type Addressable

type Addressable interface {
	Addresses() [][]byte
}

Addressable is the interface a feature extension must provide to be able to be tracked as a part of the utxo set for a set of addresses

type Amounter

type Amounter interface {
	snow.ContextInitializable
	// Amount returns how much value this element represents of the asset in its
	// transaction.
	Amount() uint64
}

Amounter is a data structure that has an amount of something associated with it

type Asset

type Asset struct {
	ID ids.ID `serialize:"true" json:"assetID"`
}

func (*Asset) AssetID

func (asset *Asset) AssetID() ids.ID

AssetID returns the ID of the contained asset

func (*Asset) Verify

func (asset *Asset) Verify() error

type AtomicUTXOManager

type AtomicUTXOManager interface {
	// GetAtomicUTXOs returns exported UTXOs such that at least one of the
	// addresses in [addrs] is referenced.
	//
	// Returns at most [limit] UTXOs.
	//
	// Returns:
	// * The fetched UTXOs
	// * The address associated with the last UTXO fetched
	// * The ID of the last UTXO fetched
	// * Any error that may have occurred upstream.
	GetAtomicUTXOs(
		chainID ids.ID,
		addrs ids.ShortSet,
		startAddr ids.ShortID,
		startUTXOID ids.ID,
		limit int,
	) ([]*UTXO, ids.ShortID, ids.ID, error)
}

func NewAtomicUTXOManager

func NewAtomicUTXOManager(sm atomic.SharedMemory, codec codec.Manager) AtomicUTXOManager

type BaseTx

type BaseTx struct {
	Metadata

	NetworkID    uint32                `serialize:"true" json:"networkID"`    // ID of the network this chain lives on
	BlockchainID ids.ID                `serialize:"true" json:"blockchainID"` // ID of the chain on which this transaction exists (prevents replay attacks)
	Outs         []*TransferableOutput `serialize:"true" json:"outputs"`      // The outputs of this transaction
	Ins          []*TransferableInput  `serialize:"true" json:"inputs"`       // The inputs to this transaction
	Memo         types.JSONByteSlice   `serialize:"true" json:"memo"`         // Memo field contains arbitrary bytes, up to maxMemoSize
}

BaseTx is the basis of all standard transactions.

func (*BaseTx) AssetIDs

func (t *BaseTx) AssetIDs() ids.Set

AssetIDs returns the IDs of the assets this transaction depends on

func (*BaseTx) ConsumedAssetIDs

func (t *BaseTx) ConsumedAssetIDs() ids.Set

ConsumedAssetIDs returns the IDs of the assets this transaction consumes

func (*BaseTx) InputUTXOs

func (t *BaseTx) InputUTXOs() []*UTXOID

InputUTXOs track which UTXOs this transaction is consuming.

func (*BaseTx) MetadataVerify

func (t *BaseTx) MetadataVerify(ctx *snow.Context) error

MetadataVerify ensures that transaction metadata is valid

func (*BaseTx) NumCredentials

func (t *BaseTx) NumCredentials() int

NumCredentials returns the number of expected credentials

func (*BaseTx) UTXOs

func (t *BaseTx) UTXOs() []*UTXO

UTXOs returns the UTXOs transaction is producing.

type Coster

type Coster interface {
	// Cost returns how much this element costs to be included in its
	// transaction.
	Cost() (uint64, error)
}

Coster is a data structure that has a cost associated with it

type FlowChecker

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

func NewFlowChecker

func NewFlowChecker() *FlowChecker

func (*FlowChecker) Consume

func (fc *FlowChecker) Consume(assetID ids.ID, amount uint64)

func (*FlowChecker) Produce

func (fc *FlowChecker) Produce(assetID ids.ID, amount uint64)

func (*FlowChecker) Verify

func (fc *FlowChecker) Verify() error

type Metadata

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

func (*Metadata) Bytes

func (md *Metadata) Bytes() []byte

Bytes returns the binary representation of this data

func (*Metadata) ID

func (md *Metadata) ID() ids.ID

ID returns the unique ID of this data

func (*Metadata) Initialize

func (md *Metadata) Initialize(unsignedBytes, bytes []byte)

Initialize set the bytes and ID

func (*Metadata) UnsignedBytes

func (md *Metadata) UnsignedBytes() []byte

UnsignedBytes returns the unsigned binary representation of this data

func (*Metadata) Verify

func (md *Metadata) Verify() error

type SingletonState

type SingletonState interface {
	IsInitialized() (bool, error)
	SetInitialized() error
}

SingletonState is a thin wrapper around a database to provide, caching, serialization, and de-serialization of singletons.

func NewSingletonState

func NewSingletonState(db database.Database) SingletonState

type StatusState

type StatusState interface {
	// Status returns a status from storage.
	GetStatus(id ids.ID) (choices.Status, error)

	// PutStatus saves a status in storage.
	PutStatus(id ids.ID, status choices.Status) error

	// DeleteStatus removes a status from storage.
	DeleteStatus(id ids.ID) error
}

StatusState is a thin wrapper around a database to provide, caching, serialization, and de-serialization for statuses.

func NewMeteredStatusState

func NewMeteredStatusState(db database.Database, metrics prometheus.Registerer) (StatusState, error)

func NewStatusState

func NewStatusState(db database.Database) StatusState

type TestAddressable

type TestAddressable struct {
	TestTransferable `serialize:"true"`

	Addrs [][]byte `serialize:"true"`
}

func (*TestAddressable) Addresses

func (a *TestAddressable) Addresses() [][]byte

type TestTransferable

type TestTransferable struct {
	TestVerifiable

	Val uint64 `serialize:"true"`
}

func (*TestTransferable) Amount

func (t *TestTransferable) Amount() uint64

func (*TestTransferable) Cost

func (t *TestTransferable) Cost() (uint64, error)

func (*TestTransferable) InitCtx

func (t *TestTransferable) InitCtx(*snow.Context)

type TestVerifiable

type TestVerifiable struct{ Err error }

func (*TestVerifiable) InitCtx

func (v *TestVerifiable) InitCtx(ctx *snow.Context)

func (*TestVerifiable) Verify

func (v *TestVerifiable) Verify() error

func (*TestVerifiable) VerifyState

func (v *TestVerifiable) VerifyState() error

type TransferableIn

type TransferableIn interface {
	verify.Verifiable
	Amounter
	Coster
}

TransferableIn is the interface a feature extension must provide to transfer value between features extensions.

type TransferableInput

type TransferableInput struct {
	UTXOID `serialize:"true"`
	Asset  `serialize:"true"`
	// FxID has serialize false because we don't want this to be encoded in bytes
	FxID ids.ID         `serialize:"false" json:"fxID"`
	In   TransferableIn `serialize:"true" json:"input"`
}

func (*TransferableInput) Input

func (in *TransferableInput) Input() TransferableIn

Input returns the feature extension input that this Input is using.

func (*TransferableInput) Verify

func (in *TransferableInput) Verify() error

type TransferableOut

type TransferableOut interface {
	snow.ContextInitializable
	verify.State
	Amounter
}

TransferableOut is the interface a feature extension must provide to transfer value between features extensions.

type TransferableOutput

type TransferableOutput struct {
	Asset `serialize:"true"`
	// FxID has serialize false because we don't want this to be encoded in bytes
	FxID ids.ID          `serialize:"false" json:"fxID"`
	Out  TransferableOut `serialize:"true" json:"output"`
}

func (*TransferableOutput) InitCtx

func (out *TransferableOutput) InitCtx(ctx *snow.Context)

func (*TransferableOutput) Output

func (out *TransferableOutput) Output() TransferableOut

Output returns the feature extension output that this Output is using.

func (*TransferableOutput) Verify

func (out *TransferableOutput) Verify() error

type UTXO

type UTXO struct {
	UTXOID `serialize:"true"`
	Asset  `serialize:"true"`

	Out verify.State `serialize:"true" json:"output"`
}

func GetAllUTXOs

func GetAllUTXOs(db UTXOReader, addrs ids.ShortSet) ([]*UTXO, error)

func GetPaginatedUTXOs

func GetPaginatedUTXOs(
	db UTXOReader,
	addrs ids.ShortSet,
	lastAddr ids.ShortID,
	lastUTXOID ids.ID,
	limit int,
) ([]*UTXO, ids.ShortID, ids.ID, error)

GetPaginatedUTXOs returns UTXOs such that at least one of the addresses in [addrs] is referenced.

Returns at most [limit] UTXOs.

Only returns UTXOs associated with addresses >= [startAddr].

For address [startAddr], only returns UTXOs whose IDs are greater than [startUTXOID].

Returns: * The fetched UTXOs * The address associated with the last UTXO fetched * The ID of the last UTXO fetched

func (*UTXO) Verify

func (utxo *UTXO) Verify() error

type UTXOGetter

type UTXOGetter interface {
	// GetUTXO attempts to load a utxo.
	GetUTXO(utxoID ids.ID) (*UTXO, error)
}

UTXOGetter is a thin wrapper around a database to provide fetching of a UTXO.

type UTXOID

type UTXOID struct {
	// Serialized:
	TxID        ids.ID `serialize:"true" json:"txID"`
	OutputIndex uint32 `serialize:"true" json:"outputIndex"`

	// Symbol is false if the UTXO should be part of the DB
	Symbol bool `json:"-"`
	// contains filtered or unexported fields
}

func (*UTXOID) InputID

func (utxo *UTXOID) InputID() ids.ID

InputID returns a unique ID of the UTXO that this input is spending

func (*UTXOID) InputSource

func (utxo *UTXOID) InputSource() (ids.ID, uint32)

InputSource returns the source of the UTXO that this input is spending

func (*UTXOID) String

func (utxo *UTXOID) String() string

func (*UTXOID) Symbolic

func (utxo *UTXOID) Symbolic() bool

Symbolic returns if this is the ID of a UTXO in the DB, or if it is a symbolic input

func (*UTXOID) Verify

func (utxo *UTXOID) Verify() error

type UTXOReader

type UTXOReader interface {
	UTXOGetter

	// UTXOIDs returns the slice of IDs associated with [addr], starting after
	// [previous].
	// If [previous] is not in the list, starts at beginning.
	// Returns at most [limit] IDs.
	UTXOIDs(addr []byte, previous ids.ID, limit int) ([]ids.ID, error)
}

UTXOReader is a thin wrapper around a database to provide fetching of UTXOs.

type UTXOState

type UTXOState interface {
	UTXOReader
	UTXOWriter
}

UTXOState is a thin wrapper around a database to provide, caching, serialization, and de-serialization for UTXOs.

func NewMeteredUTXOState

func NewMeteredUTXOState(db database.Database, codec codec.Manager, metrics prometheus.Registerer) (UTXOState, error)

func NewUTXOState

func NewUTXOState(db database.Database, codec codec.Manager) UTXOState

type UTXOWriter

type UTXOWriter interface {
	// PutUTXO saves the provided utxo to storage.
	PutUTXO(utxoID ids.ID, utxo *UTXO) error

	// DeleteUTXO deletes the provided utxo.
	DeleteUTXO(utxoID ids.ID) error
}

UTXOWriter is a thin wrapper around a database to provide storage and deletion of UTXOs.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL