transaction

type Builder ¶

type Builder struct {
	ChainID ChainID
}

func NewBuilder(chainID ChainID) *Builder

func (b *Builder) NewTransaction(data DataInterface) (Interface, error)

type BuyCoinData ¶

type BuyCoinData struct {
	CoinToBuy          Coin
	ValueToBuy         *big.Int
	CoinToSell         Coin
	MaximumValueToSell *big.Int
}

Transaction for buy a coin paying another coin (owned by sender). CoinToBuy - Symbol of a coin to get. ValueToBuy - Amount of CoinToBuy to get. CoinToSell - Symbol of a coin to give. MaximumValueToSell - Maximum value of coins to sell.

func NewBuyCoinData() *BuyCoinData

func (d *BuyCoinData) SetCoinToBuy(symbol string) *BuyCoinData

func (d *BuyCoinData) SetCoinToSell(symbol string) *BuyCoinData

func (d *BuyCoinData) SetMaximumValueToSell(value *big.Int) *BuyCoinData

func (d *BuyCoinData) SetValueToBuy(value *big.Int) *BuyCoinData

type ChainID ¶

type ChainID byte

const (
	MainNetChainID ChainID
	TestNetChainID
)

type Check ¶

type Check struct {
	*CheckData
	// contains filtered or unexported fields
}

func (check *Check) Encode() (string, error)

func (check *Check) SetPassphrase(passphrase string) CheckInterface

func (check *Check) Sign(prKey string) (Signed, error)

type CheckAddress ¶

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

func NewCheckAddress(address string, passphrase string) (*CheckAddress, error)

func (check *CheckAddress) Proof() (string, error)

type CheckData ¶

type CheckData struct {
	Nonce    []byte
	ChainID  ChainID
	DueBlock uint64
	Coin     Coin
	Value    *big.Int
	GasCoin  Coin
	Lock     *big.Int
	V        *big.Int
	R        *big.Int
	S        *big.Int
}

Issue a check that will later be redeemed by the person of your choice.

func DecodeCheck(rawCheck string) (*CheckData, error)

func (check *CheckData) PublicKey() (string, error)

func (check *CheckData) Sender() (string, error)

func (check *CheckData) String() string

type CheckInterface ¶

type CheckInterface interface {
	SetPassphrase(passphrase string) CheckInterface
	Sign(prKey string) (Signed, error)
}

func NewCheck(nonce uint64, chainID ChainID, dueBlock uint64, coin string, value *big.Int, gasCoin string) CheckInterface

type Coin ¶

type Coin [10]byte

func (c Coin) String() string

type CreateCoinData ¶

type CreateCoinData struct {
	Name                 string
	Symbol               Coin
	InitialAmount        *big.Int
	InitialReserve       *big.Int
	ConstantReserveRatio uint
	MaxSupply            *big.Int
}

Transaction for creating new coin in a system. Name - Name of a coin. Arbitrary string up to 64 letters length. Symbol - Symbol of a coin. Must be unique, alphabetic, uppercase, 3 to 10 symbols length. InitialAmount - Amount of coins to issue. Issued coins will be available to sender account. InitialReserve - Initial reserve in BIP's. ConstantReserveRatio - CRR, uint, should be from 10 to 100.

func NewCreateCoinData() *CreateCoinData

func (d *CreateCoinData) SetConstantReserveRatio(ratio uint) *CreateCoinData

func (d *CreateCoinData) SetInitialAmount(value *big.Int) *CreateCoinData

func (d *CreateCoinData) SetInitialReserve(value *big.Int) *CreateCoinData

func (d *CreateCoinData) SetMaxSupply(maxSupply *big.Int) *CreateCoinData

func (d *CreateCoinData) SetName(name string) *CreateCoinData

func (d *CreateCoinData) SetSymbol(symbol string) *CreateCoinData

type CreateMultisigData ¶

type CreateMultisigData struct {
	Threshold uint
	Weights   []uint
	Addresses [][20]byte
}

func NewCreateMultisigData() *CreateMultisigData

func (d *CreateMultisigData) AddSigData(address string, weight uint) (*CreateMultisigData, error)

func (d *CreateMultisigData) AddressBytes() [20]byte

func (d *CreateMultisigData) AddressString() string

func (d *CreateMultisigData) MustAddSigData(address string, weight uint) *CreateMultisigData

func (d *CreateMultisigData) SetThreshold(threshold uint) *CreateMultisigData

type DataInterface ¶

type DataInterface interface {
	// contains filtered or unexported methods
}

type DeclareCandidacyData ¶

type DeclareCandidacyData struct {
	Address    [20]byte
	PubKey     []byte
	Commission uint
	Coin       Coin
	Stake      *big.Int
}

Transaction for declaring new validator candidacy. Address - Address of candidate in Minter Network. This address would be able to control candidate. Also all rewards will be sent to this address. PubKey - Public key of a validator. Commission - Commission (from 0 to 100) from rewards which delegators will pay to validator. Coin - Symbol of coin to stake. Stake - Amount of coins to stake.

func NewDeclareCandidacyData() *DeclareCandidacyData

func (d *DeclareCandidacyData) MustSetAddress(address string) *DeclareCandidacyData

func (d *DeclareCandidacyData) MustSetPubKey(key string) *DeclareCandidacyData

func (d *DeclareCandidacyData) SetAddress(address string) (*DeclareCandidacyData, error)

func (d *DeclareCandidacyData) SetCoin(symbol string) *DeclareCandidacyData

func (d *DeclareCandidacyData) SetCommission(value uint) *DeclareCandidacyData

func (d *DeclareCandidacyData) SetPubKey(key string) (*DeclareCandidacyData, error)

func (d *DeclareCandidacyData) SetStake(value *big.Int) *DeclareCandidacyData

type DeepLink ¶

type DeepLink struct {
	Type    Type
	Data    []byte
	Payload []byte

	Nonce    *uint // optional
	GasPrice *uint // optional
	GasCoin  *Coin // optional
}

func NewDeepLink(data DataInterface) (*DeepLink, error)

func (d *DeepLink) CreateLink(pass string) (string, error)

func (d *DeepLink) Encode() (string, error)

func (d *DeepLink) SetGasCoin(symbol string) *DeepLink

func (d *DeepLink) SetPayload(payload []byte) *DeepLink

type DelegateData ¶

type DelegateData struct {
	PubKey []byte
	Coin   Coin
	Value  *big.Int
}

Transaction for delegating funds to validator. PubKey - Public key of a validator. Coin - Symbol of coin to stake. Value - Amount of coins to stake.

func NewDelegateData() *DelegateData

func (d *DelegateData) MustSetPubKey(key string) *DelegateData

func (d *DelegateData) SetCoin(symbol string) *DelegateData

func (d *DelegateData) SetPubKey(key string) (*DelegateData, error)

func (d *DelegateData) SetValue(value *big.Int) *DelegateData

type EditCandidateData ¶

type EditCandidateData struct {
	PubKey        []byte
	RewardAddress [20]byte
	OwnerAddress  [20]byte
}

Transaction for editing existing candidate.

func NewEditCandidateData() *EditCandidateData

func (d *EditCandidateData) MustSetOwnerAddress(address string) *EditCandidateData

func (d *EditCandidateData) MustSetPubKey(key string) *EditCandidateData

func (d *EditCandidateData) MustSetRewardAddress(address string) *EditCandidateData

func (d *EditCandidateData) SetOwnerAddress(address string) (*EditCandidateData, error)

func (d *EditCandidateData) SetPubKey(key string) (*EditCandidateData, error)

func (d *EditCandidateData) SetRewardAddress(address string) (*EditCandidateData, error)

type EncodeInterface ¶

type EncodeInterface interface {
	Encode() (string, error)
}

type Interface ¶

type Interface interface {
	EncodeInterface

	SetSignatureType(signatureType SignatureType) Interface
	SetMultiSignatureType() Interface

	SetNonce(nonce uint64) Interface
	SetGasCoin(name string) Interface
	SetGasPrice(price uint8) Interface
	SetPayload(payload []byte) Interface
	SetServiceData(serviceData []byte) Interface
	Sign(prKey string, multisigPrKeys ...string) (SignedTransaction, error)
	// contains filtered or unexported methods
}

type MultisendData ¶

type MultisendData struct {
	List []MultisendDataItem
}

Transaction for sending coins to multiple addresses.

func NewMultisendData() *MultisendData

func (d *MultisendData) AddItem(item MultisendDataItem) *MultisendData

type MultisendDataItem ¶

type MultisendDataItem SendData

func NewMultisendDataItem() *MultisendDataItem

func (d *MultisendDataItem) MustSetTo(address string) *MultisendDataItem

func (d *MultisendDataItem) SetCoin(symbol string) *MultisendDataItem

func (d *MultisendDataItem) SetTo(address string) (*MultisendDataItem, error)

func (d *MultisendDataItem) SetValue(value *big.Int) *MultisendDataItem

type RedeemCheckData ¶

type RedeemCheckData struct {
	RawCheck []byte
	Proof    [65]byte
}

Transaction for redeeming a check. RawCheck - Raw check received from sender. Proof - Proof of owning a check. Note that maximum GasPrice is limited to 1 to prevent fraud, because GasPrice is set by redeem tx sender but commission is charded from check issuer.

func NewRedeemCheckData() *RedeemCheckData

func (d *RedeemCheckData) MustSetProof(proof string) *RedeemCheckData

func (d *RedeemCheckData) MustSetRawCheck(raw string) *RedeemCheckData

func (d *RedeemCheckData) SetProof(proof string) (*RedeemCheckData, error)

func (d *RedeemCheckData) SetRawCheck(raw string) (*RedeemCheckData, error)

type SellAllCoinData ¶

type SellAllCoinData struct {
	CoinToSell        Coin
	CoinToBuy         Coin
	MinimumValueToBuy *big.Int
}

Transaction for selling one coin (owned by sender) in favour of another coin in a system. CoinToSell - Symbol of a coin to give. ValueToSell - Amount of CoinToSell to give. CoinToBuy - Symbol of a coin to get. MinimumValueToBuy - Minimum value of coins to get.

func NewSellAllCoinData() *SellAllCoinData

func (d *SellAllCoinData) SetCoinToBuy(symbol string) *SellAllCoinData

func (d *SellAllCoinData) SetCoinToSell(symbol string) *SellAllCoinData

func (d *SellAllCoinData) SetMinimumValueToBuy(value *big.Int) *SellAllCoinData

type SellCoinData ¶

type SellCoinData struct {
	CoinToSell        Coin
	ValueToSell       *big.Int
	CoinToBuy         Coin
	MinimumValueToBuy *big.Int
}

Transaction for selling one coin (owned by sender) in favour of another coin in a system. CoinToSell - Symbol of a coin to give. ValueToSell - Amount of CoinToSell to give. CoinToBuy - Symbol of a coin to get. MinimumValueToBuy - Minimum value of coins to get.

func NewSellCoinData() *SellCoinData

func (d *SellCoinData) SetCoinToBuy(symbol string) *SellCoinData

func (d *SellCoinData) SetCoinToSell(symbol string) *SellCoinData

func (d *SellCoinData) SetMinimumValueToBuy(value *big.Int) *SellCoinData

func (d *SellCoinData) SetValueToSell(value *big.Int) *SellCoinData

type SendData ¶

type SendData struct {
	Coin  Coin
	To    [20]byte
	Value *big.Int
}

Transaction for sending arbitrary coin. Coin - Symbol of a coin. To - Recipient address in Minter Network. Value - Amount of Coin to send.

func NewSendData() *SendData

func (d *SendData) MustSetTo(address string) *SendData

func (d *SendData) SetCoin(symbol string) *SendData

func (d *SendData) SetTo(address string) (*SendData, error)

func (d *SendData) SetValue(value *big.Int) *SendData

type SetCandidateOffData ¶

type SetCandidateOffData struct {
	PubKey []byte
}

Transaction for turning candidate off. This transaction should be sent from address which is set in the "Declare candidacy transaction". PubKey - Public key of a validator.

func NewSetCandidateOffData() *SetCandidateOffData

func (d *SetCandidateOffData) MustSetPubKey(key string) *SetCandidateOffData

func (d *SetCandidateOffData) SetPubKey(key string) (*SetCandidateOffData, error)

type SetCandidateOnData ¶

type SetCandidateOnData struct {
	PubKey []byte
}

Transaction for turning candidate on. This transaction should be sent from address which is set in the "Declare candidacy transaction". PubKey - Public key of a validator.

func NewSetCandidateOnData() *SetCandidateOnData

func (d *SetCandidateOnData) MustSetPubKey(key string) *SetCandidateOnData

func (d *SetCandidateOnData) SetPubKey(key string) (*SetCandidateOnData, error)

type Signature ¶

type Signature struct {
	V *big.Int
	R *big.Int
	S *big.Int
}

type SignatureMulti ¶

type SignatureMulti struct {
	Multisig   [20]byte
	Signatures []*Signature
}

type SignatureType ¶

type SignatureType byte

const (
	SignatureTypeSingle SignatureType
	SignatureTypeMulti
)

type Signed ¶

type Signed interface {
	Encode() (string, error)
}

type SignedTransaction ¶

type SignedTransaction interface {
	EncodeInterface
	GetTransaction() *Transaction
	Fee() *big.Int
	Hash() (string, error)
	Data() DataInterface
	Signature() (signatureInterface, error)
	AddSignature(signatures ...[]byte) (SignedTransaction, error)
	SignatureData() []byte
	SimpleSignatureData() ([]byte, error)
	SenderAddress() (string, error)
	Sign(prKey string, multisigPrKeys ...string) (SignedTransaction, error)
}

func Decode(tx string) (SignedTransaction, error)

type Transaction ¶

type Transaction struct {
	Nonce         uint64
	ChainID       ChainID
	GasPrice      uint8
	GasCoin       Coin
	Type          Type
	Data          []byte
	Payload       []byte
	ServiceData   []byte
	SignatureType SignatureType
	SignatureData []byte
}

func (tx *Transaction) Encode() (string, error)

type Type ¶

type Type byte

const (
	TypeSend Type = iota + 1
	TypeSellCoin
	TypeSellAllCoin
	TypeBuyCoin
	TypeCreateCoin
	TypeDeclareCandidacy
	TypeDelegate
	TypeUnbond
	TypeRedeemCheck
	TypeSetCandidateOnline
	TypeSetCandidateOffline
	TypeCreateMultisig
	TypeMultisend
	TypeEditCandidate
)

type UnbondData ¶

type UnbondData struct {
	PubKey []byte
	Coin   Coin
	Value  *big.Int
}

Transaction for unbonding funds from validator's stake. PubKey - Public key of a validator. Coin - Symbol of coin to stake. Value - Amount of coins to stake.

func NewUnbondData() *UnbondData

func (d *UnbondData) MustSetPubKey(key string) *UnbondData

func (d *UnbondData) SetCoin(symbol string) *UnbondData

func (d *UnbondData) SetPubKey(key string) (*UnbondData, error)

func (d *UnbondData) SetValue(value *big.Int) *UnbondData