transaction

Documentation

Index

• Constants
• Variables
• type Signer
• type Transaction
  • func Decode(buf []byte) (Transaction, error)
  • func New(subject string, spice spice.Melange, data []byte, receiverAddress string, ...) (Transaction, error)
  • func (t *Transaction) CompareIssuerData(tx *Transaction) (bool, error)
  • func (t *Transaction) Encode() ([]byte, error)
  • func (t *Transaction) GetMessage() []byte
  • func (t Transaction) IsContract() bool
  • func (t Transaction) IsEmpty() bool
  • func (t Transaction) IsSpiceTransfer() bool
  • func (t *Transaction) Sign(receiver Signer, v Verifier) ([32]byte, error)
  • func (t *Transaction) String() string
  • func (t *Transaction) VerifyIssuer(v Verifier) error
  • func (t *Transaction) VerifyIssuerReceiver(v Verifier) error
• type TransactionAwaitingReceiverSignature
• type TrxAddressesSubscriberCallback
• type Verifier

Constants

const (
	ExpirationTimeInDays = 7 // transaction validity expiration time in days. TODO: move to config
)

Variables

var (
	ErrTransactionHasAFutureTime        = errors.New("transaction has a future time")
	ErrExpiredTransaction               = errors.New("transaction has expired")
	ErrTransactionHashIsInvalid         = errors.New("transaction hash is invalid")
	ErrSignatureNotValidOrDataCorrupted = errors.New("signature not valid or data are corrupted")
	ErrSubjectIsEmpty                   = errors.New("subject cannot be empty")
	ErrAddressIsInvalid                 = errors.New("address is invalid")
	ErrNilTransaction                   = errors.New("nil transaction")
)

Types

type Signer

type Signer interface {
	Sign(message []byte) (digest [32]byte, signature []byte)
	Address() string
}

Signer provides signing and address methods.

type Transaction

type Transaction struct {
	ID                any           `json:"-"                  bson:"_id"                db:"id"                    msgpack:"-"`
	CreatedAt         time.Time     `json:"created_at"         bson:"created_at"         db:"created_at"            msgpack:"created_at"`
	IssuerAddress     string        `json:"issuer_address"     bson:"issuer_address"     db:"issuer_address"        msgpack:"issuer_address"`
	ReceiverAddress   string        `json:"receiver_address"   bson:"receiver_address"   db:"receiver_address"      msgpack:"receiver_address"`
	Subject           string        `json:"subject"            bson:"subject"            db:"subject"               msgpack:"subject"`
	Data              []byte        `json:"data"               bson:"data"               db:"data"                  msgpack:"data"`
	IssuerSignature   []byte        `json:"issuer_signature"   bson:"issuer_signature"   db:"issuer_signature"      msgpack:"issuer_signature"`
	ReceiverSignature []byte        `json:"receiver_signature" bson:"receiver_signature" db:"receiver_signature"    msgpack:"receiver_signature"`
	Hash              [32]byte      `json:"hash"               bson:"hash"               db:"hash"                  msgpack:"hash"`
	Spice             spice.Melange `json:"spice"              bson:"spice"              db:"spice"                 msgpack:"spice"`
}

Transaction contains transaction information, subject type, subject data, signatures and public keys. Transaction is valid for a week from being issued.

func Decode

func Decode(buf []byte) (Transaction, error)

Decode decodes slice buffer to transaction.

func New

func New(subject string, spice spice.Melange, data []byte, receiverAddress string, issuer Signer) (Transaction, error)

New creates new transaction signed by the issuer.

func (*Transaction) CompareIssuerData

func (t *Transaction) CompareIssuerData(tx *Transaction) (bool, error)

CompareIssuerData compare transactions from Issuer perspective.

func (*Transaction) Encode

func (t *Transaction) Encode() ([]byte, error)

Encode encodes transaction to bytes slice.

func (*Transaction) GetMessage

func (t *Transaction) GetMessage() []byte

GeMessage returns message used for signature validation.

func (Transaction) IsContract

func (t Transaction) IsContract() bool

IsContract returns true if the transaction contains not empty data buffer that is recognised as transaction with contract.

func (Transaction) IsEmpty

func (t Transaction) IsEmpty() bool

IsEmpty returns true if transaction doesn't transfers tokens or has no data.

func (Transaction) IsSpiceTransfer

func (t Transaction) IsSpiceTransfer() bool

IsSpiceTransfer returns true if the transaction transfers spice.

func (*Transaction) Sign

func (t *Transaction) Sign(receiver Signer, v Verifier) ([32]byte, error)

Sign verifies issuer signature and signs Transaction by the receiver.

func (*Transaction) String

func (t *Transaction) String() string

String stringifies the transaction

func (*Transaction) VerifyIssuer

func (t *Transaction) VerifyIssuer(v Verifier) error

func (*Transaction) VerifyIssuerReceiver

func (t *Transaction) VerifyIssuerReceiver(v Verifier) error

Verify verifies transaction signatures.

type TransactionAwaitingReceiverSignature

type TransactionAwaitingReceiverSignature struct {
	ID              any         `json:"-"                bson:"_id,omitempty"    db:"id"`
	ReceiverAddress string      `json:"receiver_address" bson:"receiver_address" db:"receiver_address"`
	IssuerAddress   string      `json:"issuer_address"   bson:"issuer_address"   db:"issuer_address"`
	Transaction     Transaction `json:"transaction"      bson:"transaction"      db:"-"`
	TransactionHash [32]byte    `json:"transaction_hash" bson:"transaction_hash" db:"hash"`
}

TransactionAwaitingReceiverSignature represents transaction awaiting receiver signature. It is as well the entity of all issued transactions that has not been signed by receiver yet.

type TrxAddressesSubscriberCallback

type TrxAddressesSubscriberCallback func(addresses []string, storageNodeURL string)

TrxAddressesSubscriberCallback is a method or function performing compotation on the transactions addresses.

type Verifier

type Verifier interface {
	Verify(message, signature []byte, hash [32]byte, issuer string) error
}

Verifier provides signature verification method.