types

package

Go to main page

Versions in this module

v1

v1.3.1

Jan 14, 2020

v1.2.0

Sep 23, 2019

Changes in this version

+ const TransactionNonceLength

+ var ErrBlockStakeInputOutputMismatch = errors.New("blockstake inputs do not equal blockstake outputs for transaction")

+ var ErrCoinInputOutputMismatch = errors.New("coin inputs do not equal coin outputs for transaction")

+ var ErrMissingMinerFee = errors.New("transaction does not specify any miner fees")

+ var SignatureAlgoEd25519Specifier = Specifier

+ var SignatureAlgoNilSpecifier = Specifier

+ func DefaultNetworkName() string

type Block

+ func (b *Block) UnmarshalRivine(r io.Reader) error

+ func (b Block) MarshalRivine(w io.Writer) error

type ChainConstants

+ func DevnetChainConstants() ChainConstants

+ func StandardnetChainConstants() ChainConstants

+ func TestnetChainConstants() ChainConstants

+ type ClientError struct

+ Err error

+ Kind ClientErrorKind

+ func NewClientError(err error, kind ClientErrorKind) ClientError

+ func (ce ClientError) Error() string

+ type ClientErrorKind uint32

+ const ClientErrorBadRequest

+ const ClientErrorForbidden

+ const ClientErrorNotFound

+ const ClientErrorPaymentRequired

+ const ClientErrorTimeout

+ const ClientErrorUnauthorized

+ func (kind ClientErrorKind) AsHTTPStatusCode() int

+ func (kind ClientErrorKind) String() string

+ type CommonTransactionExtensionData struct

+ UnlockConditions []UnlockConditionProxy

type ConditionType

+ func (ct *ConditionType) UnmarshalRivine(r io.Reader) error

+ func (ct ConditionType) MarshalRivine(w io.Writer) error

type Currency

+ func (c *Currency) LoadString(str string) error

+ func (c *Currency) UnmarshalRivine(r io.Reader) error

+ func (c Currency) MarshalRivine(w io.Writer) error

type Difficulty

+ func (c *Difficulty) UnmarshalRivine(r io.Reader) error

+ func (c Difficulty) MarshalRivine(w io.Writer) error

+ type DisabledTransactionController struct

+ func (dtc DisabledTransactionController) DecodeTransactionData(r io.Reader) (TransactionData, error)

+ func (dtc DisabledTransactionController) EncodeTransactionData(w io.Writer, td TransactionData) error

+ func (dtc DisabledTransactionController) JSONDecodeTransactionData(b []byte) (TransactionData, error)

+ func (dtc DisabledTransactionController) JSONEncodeTransactionData(td TransactionData) ([]byte, error)

type FulfillContext

+ ExtraObjects []interface{}

type FulfillmentSignContext

+ ExtraObjects []interface{}

type FulfillmentType

+ func (ft *FulfillmentType) UnmarshalRivin(r io.Reader) error

+ func (ft FulfillmentType) MarshalRivine(w io.Writer) error

+ type FundValidationContext struct

+ BlockHeight BlockHeight

+ BlockTime Timestamp

type LegacyTransactionController

+ func (ltc LegacyTransactionController) SignatureHash(t Transaction, extraObjects ...interface{}) (crypto.Hash, error)

+ type MarshalFunc = func(...interface{}) ([]byte, error)

+ type PublicKey struct

+ Algorithm SignatureAlgoType

+ Key ByteSlice

+ func (pk *PublicKey) LoadString(s string) error

+ func (pk *PublicKey) String() string

+ func (pk *PublicKey) UnmarshalJSON(b []byte) error

+ func (pk *PublicKey) UnmarshalRivine(r io.Reader) error

+ func (pk *PublicKey) UnmarshalSia(r io.Reader) error

+ func (pk PublicKey) MarshalJSON() ([]byte, error)

+ func (pk PublicKey) MarshalRivine(w io.Writer) error

+ func (pk PublicKey) MarshalSia(w io.Writer) error

+ type SignatureAlgoType uint8

+ const SignatureAlgoEd25519

+ const SignatureAlgoNil

+ func (sat *SignatureAlgoType) LoadSpecifier(specifier Specifier) error

+ func (sat *SignatureAlgoType) LoadString(str string) error

+ func (sat SignatureAlgoType) Specifier() Specifier

+ func (sat SignatureAlgoType) String() string

type Transaction

+ func (t *Transaction) SignExtension(sign func(*UnlockFulfillmentProxy, UnlockConditionProxy, ...interface{}) error) error

+ func (t *Transaction) UnmarshalRivine(r io.Reader) error

+ func (t Transaction) CommonExtensionData() (CommonTransactionExtensionData, error)

+ func (t Transaction) CustomMinerPayouts() ([]MinerPayout, error)

+ func (t Transaction) MarshalRivine(w io.Writer) error

+ func (t Transaction) SignatureHash(extraObjects ...interface{}) (crypto.Hash, error)

+ type TransactionCommonExtensionDataGetter interface

+ GetCommonExtensionData func(extension interface{}) (CommonTransactionExtensionData, error)

+ type TransactionCreationValidationContext struct

+ ArbitraryDataSizeLimit uint64

+ BlockSizeLimit uint64

+ MinimumMinerFee Currency

+ type TransactionCustomMinerPayoutGetter interface

+ GetCustomMinerPayouts func(extension interface{}) ([]MinerPayout, error)

type TransactionData

+ func (td *TransactionData) UnmarshalRivine(r io.Reader) error

+ func (td TransactionData) MarshalRivine(w io.Writer) error

+ type TransactionExtensionSigner interface

+ SignExtension func(extension interface{}, ...) (interface{}, error)

+ type TransactionNonce [TransactionNonceLength]byte

+ func RandomTransactionNonce() (nonce TransactionNonce)

+ func (tn *TransactionNonce) UnmarshalJSON(in []byte) error

+ func (tn TransactionNonce) MarshalJSON() ([]byte, error)

type TransactionShortID

+ func (txsid *TransactionShortID) UnmarshalRivine(r io.Reader) error

+ func (txsid TransactionShortID) MarshalRivine(w io.Writer) error

+ type TransactionSignatureHasher interface

+ SignatureHash func(t Transaction, extraObjects ...interface{}) (crypto.Hash, error)

type TransactionValidationContext

+ ArbitraryDataSizeLimit uint64

+ MinimumMinerFee Currency

type TransactionVersion

+ func (v *TransactionVersion) UnmarshalRivine(r io.Reader) error

+ func (v TransactionVersion) MarshalRivine(w io.Writer) error

type UnlockConditionProxy

+ func (up *UnlockConditionProxy) UnmarshalRivine(r io.Reader) error

+ func (up UnlockConditionProxy) MarshalRivine(w io.Writer) error

type UnlockFulfillmentProxy

+ func (fp *UnlockFulfillmentProxy) UnmarshalRivine(r io.Reader) error

+ func (fp UnlockFulfillmentProxy) MarshalRivine(w io.Writer) error

type UnlockHash

+ func (uh *UnlockHash) UnmarshalRivine(r io.Reader) error

+ func (uh UnlockHash) MarshalRivine(w io.Writer) error

type UnlockType

+ func (t *UnlockType) UnmarshalRivine(r io.Reader) error

+ func (t UnlockType) MarshalRivine(w io.Writer) error

+ type UnmarshalFunc = func([]byte, ...interface{}) error

type ValidationContext

+ BlockTime Timestamp

+ IsBlockCreatingTx bool

v1.0.7

Jun 27, 2018

Changes in this version

+ var ErrTooSmallMinerFee = errors.New("transaction has a too small miner fee")

+ func ArbitraryDataFits(arbitraryData []byte, sizeLimit uint64) error

+ func DefaultTransactionValidation(t Transaction, ctx ValidationContext, constants TransactionValidationConstants) (err error)

+ func TransactionFitsInABlock(t Transaction, blockSizeLimit uint64) error

+ func TransactionFollowsMinimumValues(t Transaction, minimumMinerFee Currency) error

+ func ValidateNoDoubleSpendsWithinTransaction(t Transaction) (err error)

type BlockchainInfo

+ CoinUnit string

+ NetworkName string

type ChainConstants

+ TransactionPool TransactionPoolConstants

+ type LegacyTransactionController struct

+ func (ltc LegacyTransactionController) DecodeTransactionData(r io.Reader) (TransactionData, error)

+ func (ltc LegacyTransactionController) EncodeTransactionData(w io.Writer, td TransactionData) error

+ func (ltc LegacyTransactionController) EncodeTransactionIDInput(w io.Writer, td TransactionData) error

+ func (ltc LegacyTransactionController) InputSigHash(t Transaction, inputIndex uint64, extraObjects ...interface{}) (crypto.Hash, error)

+ func (ltc LegacyTransactionController) JSONDecodeTransactionData(b []byte) (TransactionData, error)

+ func (ltc LegacyTransactionController) JSONEncodeTransactionData(td TransactionData) ([]byte, error)

+ type MarshalableUnlockConditionGetter interface

+ GetMarshalableUnlockCondition func() MarshalableUnlockCondition

type MultiSignatureCondition

+ func (ms *MultiSignatureCondition) GetMinimumSignatureCount() uint64

+ func (ms *MultiSignatureCondition) UnlockHashSlice() []UnlockHash

type TimeLockCondition

+ func (tl *TimeLockCondition) GetMarshalableUnlockCondition() MarshalableUnlockCondition

+ type TransactionIDEncoder interface

+ EncodeTransactionIDInput func(io.Writer, TransactionData) error

+ type TransactionPoolConstants struct

+ PoolSizeLimit int

+ TransactionSetSizeLimit int

+ TransactionSizeLimit int

+ func DefaultTransactionPoolConstants() TransactionPoolConstants

type TransactionValidationConstants

+ MinimumMinerFee Currency

+ type UnlockHashSliceGetter interface

+ UnlockHashSlice func() []UnlockHash

+ type ValidationContext struct

+ BlockHeight BlockHeight

+ Confirmed bool

v1.0.6

Jun 4, 2018

Changes in this version

+ var ErrArbitraryDataTooLarge = errors.New("arbitrary data is too large to fit in a transaction")

+ var ErrInsufficientSignatures = errors.New("not enough signatures")

+ var ErrPrematureRefund = errors.New("contract cannot yet be refunded")

+ var ErrUnauthorizedPubKey = errors.New("public key used which is not allowed to sign this input")

type ChainConstants

+ ArbitraryDataSizeLimit uint64

type ConditionType

+ const ConditionTypeMultiSignature

type FulfillmentType

+ const FulfillmentTypeMultiSignature

+ type KeyPair struct

+ PrivateKey ByteSlice

+ PublicKey SiaPublicKey

+ type MultiSignatureCondition struct

+ MinimumSignatureCount uint64

+ UnlockHashes UnlockHashSlice

+ func NewMultiSignatureCondition(uhs UnlockHashSlice, minsigs uint64) *MultiSignatureCondition

+ func (ms *MultiSignatureCondition) ConditionType() ConditionType

+ func (ms *MultiSignatureCondition) Equal(c UnlockCondition) bool

+ func (ms *MultiSignatureCondition) Fulfill(fulfillment UnlockFulfillment, ctx FulfillContext) error

+ func (ms *MultiSignatureCondition) Fulfillable(ctx FulfillableContext) bool

+ func (ms *MultiSignatureCondition) IsStandardCondition(StandardCheckContext) error

+ func (ms *MultiSignatureCondition) Marshal() []byte

+ func (ms *MultiSignatureCondition) UnlockHash() UnlockHash

+ func (ms *MultiSignatureCondition) Unmarshal(b []byte) error

+ type MultiSignatureFulfillment struct

+ Pairs []PublicKeySignaturePair

+ func NewMultiSignatureFulfillment(pairs []PublicKeySignaturePair) *MultiSignatureFulfillment

+ func (ms *MultiSignatureFulfillment) Equal(f UnlockFulfillment) bool

+ func (ms *MultiSignatureFulfillment) FulfillmentType() FulfillmentType

+ func (ms *MultiSignatureFulfillment) IsStandardFulfillment(StandardCheckContext) error

+ func (ms *MultiSignatureFulfillment) Marshal() []byte

+ func (ms *MultiSignatureFulfillment) Sign(ctx FulfillmentSignContext) (err error)

+ func (ms *MultiSignatureFulfillment) Unmarshal(b []byte) error

+ type PublicKeySignaturePair struct

+ PublicKey SiaPublicKey

+ Signature ByteSlice

+ type StandardCheckContext struct

+ BlockHeight BlockHeight

+ type TransactionValidationConstants struct

+ ArbitraryDataSizeLimit uint64

+ BlockSizeLimit uint64

type UnlockHash

+ func ComputeLegacyFulfillmentUnlockHash(ff UnlockFulfillment) UnlockHash

type UnlockType

+ const UnlockTypeMultiSig

v1.0.6-beta

May 31, 2018

v1.0.5

May 9, 2018

Changes in this version

+ const LockTimeMinTimestampValue

+ var ErrFulfillmentDoubleSign = errors.New("cannot sign a fulfillment which is already signed")

+ var ErrNilFulfillmentType = errors.New("nil fulfillment type")

+ var ErrUnexpectedExtensionType = errors.New("unexpected transaction data extension type")

+ var ErrUnexpectedUnlockCondition = errors.New("unexpected unlock condition")

+ var ErrUnexpectedUnlockFulfillment = errors.New("unexpected unlock fulfillment")

+ var ErrUnexpectedUnlockType = errors.New("unexpected unlock (hash) type")

+ var ErrUnknownConditionType = errors.New("unknown condition type")

+ var ErrUnknownFulfillmentType = errors.New("unknown fulfillment type")

+ var ErrUnknownTransactionType = errors.New("unknown transaction type")

+ func RegisterTransactionVersion(v TransactionVersion, c TransactionController)

+ func RegisterUnlockConditionType(ct ConditionType, cc MarshalableUnlockConditionConstructor)

+ func RegisterUnlockFulfillmentType(ft FulfillmentType, fc MarshalableUnlockFulfillmentConstructor)

type AtomicSwapCondition

+ func (as *AtomicSwapCondition) ConditionType() ConditionType

+ func (as *AtomicSwapCondition) Equal(c UnlockCondition) bool

+ func (as *AtomicSwapCondition) Fulfill(fulfillment UnlockFulfillment, ctx FulfillContext) error

+ func (as *AtomicSwapCondition) Fulfillable(FulfillableContext) bool

+ func (as *AtomicSwapCondition) IsStandardCondition() error

+ func (as *AtomicSwapCondition) Marshal() []byte

+ func (as *AtomicSwapCondition) UnlockHash() UnlockHash

+ func (as *AtomicSwapCondition) Unmarshal(b []byte) error

type AtomicSwapFulfillment

+ func NewAtomicSwapClaimFulfillment(pk SiaPublicKey, secret AtomicSwapSecret) *AtomicSwapFulfillment

+ func NewAtomicSwapRefundFulfillment(pk SiaPublicKey) *AtomicSwapFulfillment

+ func (as *AtomicSwapFulfillment) AtomicSwapSecret() AtomicSwapSecret

+ func (as *AtomicSwapFulfillment) Equal(f UnlockFulfillment) bool

+ func (as *AtomicSwapFulfillment) FulfillmentType() FulfillmentType

+ func (as *AtomicSwapFulfillment) IsStandardFulfillment() error

+ func (as *AtomicSwapFulfillment) Marshal() []byte

+ func (as *AtomicSwapFulfillment) Sign(ctx FulfillmentSignContext) error

+ func (as *AtomicSwapFulfillment) UnlockHash() UnlockHash

+ func (as *AtomicSwapFulfillment) Unmarshal(b []byte) error

type BlockStakeInput

+ Fulfillment UnlockFulfillmentProxy

type BlockStakeOutput

+ Condition UnlockConditionProxy

type ChainConstants

+ DefaultTransactionVersion TransactionVersion

+ GenesisTransactionVersion TransactionVersion

+ TransactionFeeCondition UnlockConditionProxy

type CoinInput

+ Fulfillment UnlockFulfillmentProxy

type CoinOutput

+ Condition UnlockConditionProxy

+ type ConditionType byte

+ const ConditionTypeAtomicSwap

+ const ConditionTypeNil

+ const ConditionTypeTimeLock

+ const ConditionTypeUnlockHash

+ func (ct *ConditionType) UnmarshalSia(r io.Reader) error

+ func (ct ConditionType) MarshalSia(w io.Writer) error

+ type DefaultTransactionController struct

+ func (dtc DefaultTransactionController) DecodeTransactionData(b []byte) (td TransactionData, err error)

+ func (dtc DefaultTransactionController) EncodeTransactionData(td TransactionData) ([]byte, error)

+ func (dtc DefaultTransactionController) JSONDecodeTransactionData(b []byte) (td TransactionData, err error)

+ func (dtc DefaultTransactionController) JSONEncodeTransactionData(td TransactionData) ([]byte, error)

+ type FulfillContext struct

+ BlockHeight BlockHeight

+ BlockTime Timestamp

+ InputIndex uint64

+ Transaction Transaction

+ type FulfillableContext struct

+ BlockHeight BlockHeight

+ BlockTime Timestamp

+ type FulfillmentSignContext struct

+ InputIndex uint64

+ Key interface{}

+ Transaction Transaction

+ type FulfillmentType byte

+ const FulfillmentTypeAtomicSwap

+ const FulfillmentTypeNil

+ const FulfillmentTypeSingleSignature

+ func (ft *FulfillmentType) UnmarshalSia(r io.Reader) error

+ func (ft FulfillmentType) MarshalSia(w io.Writer) error

+ type LegacyAtomicSwapFulfillment struct

+ HashedSecret AtomicSwapHashedSecret

+ PublicKey SiaPublicKey

+ Receiver UnlockHash

+ Secret AtomicSwapSecret

+ Sender UnlockHash

+ Signature ByteSlice

+ TimeLock Timestamp

+ func (as *LegacyAtomicSwapFulfillment) AtomicSwapSecret() AtomicSwapSecret

+ func (as *LegacyAtomicSwapFulfillment) Equal(f UnlockFulfillment) bool

+ func (as *LegacyAtomicSwapFulfillment) FulfillmentType() FulfillmentType

+ func (as *LegacyAtomicSwapFulfillment) IsStandardFulfillment() error

+ func (as *LegacyAtomicSwapFulfillment) Marshal() []byte

+ func (as *LegacyAtomicSwapFulfillment) Sign(ctx FulfillmentSignContext) error

+ func (as *LegacyAtomicSwapFulfillment) UnlockHash() UnlockHash

+ func (as *LegacyAtomicSwapFulfillment) Unmarshal(b []byte) error

+ type MarshalableUnlockCondition interface

+ Marshal func() []byte

+ Unmarshal func([]byte) error

+ type MarshalableUnlockConditionConstructor func() MarshalableUnlockCondition

+ type MarshalableUnlockFulfillment interface

+ Marshal func() []byte

+ Unmarshal func([]byte) error

+ type MarshalableUnlockFulfillmentConstructor func() MarshalableUnlockFulfillment

+ type MinerPayout struct

+ UnlockHash UnlockHash

+ Value Currency

+ type NilCondition struct

+ func (n *NilCondition) ConditionType() ConditionType

+ func (n *NilCondition) Equal(c UnlockCondition) bool

+ func (n *NilCondition) Fulfill(fulfillment UnlockFulfillment, ctx FulfillContext) error

+ func (n *NilCondition) Fulfillable(FulfillableContext) bool

+ func (n *NilCondition) IsStandardCondition() error

+ func (n *NilCondition) Marshal() []byte

+ func (n *NilCondition) UnlockHash() UnlockHash

+ func (n *NilCondition) Unmarshal(b []byte) error

+ type NilFulfillment struct

+ func (n *NilFulfillment) Equal(f UnlockFulfillment) bool

+ func (n *NilFulfillment) FulfillmentType() FulfillmentType

+ func (n *NilFulfillment) IsStandardFulfillment() error

+ func (n *NilFulfillment) Marshal() []byte

+ func (n *NilFulfillment) Sign(FulfillmentSignContext) error

+ func (n *NilFulfillment) UnlockHash() UnlockHash

+ func (n *NilFulfillment) Unmarshal([]byte) error

+ type SingleSignatureFulfillment struct

+ PublicKey SiaPublicKey

+ Signature ByteSlice

+ func NewSingleSignatureFulfillment(pk SiaPublicKey) *SingleSignatureFulfillment

+ func (ss *SingleSignatureFulfillment) Equal(f UnlockFulfillment) bool

+ func (ss *SingleSignatureFulfillment) FulfillmentType() FulfillmentType

+ func (ss *SingleSignatureFulfillment) IsStandardFulfillment() error

+ func (ss *SingleSignatureFulfillment) Marshal() []byte

+ func (ss *SingleSignatureFulfillment) Sign(ctx FulfillmentSignContext) (err error)

+ func (ss *SingleSignatureFulfillment) UnlockHash() UnlockHash

+ func (ss *SingleSignatureFulfillment) Unmarshal(b []byte) error

+ type TimeLockCondition struct

+ Condition MarshalableUnlockCondition

+ LockTime uint64

+ func NewTimeLockCondition(lockTime uint64, condition MarshalableUnlockCondition) *TimeLockCondition

+ func (tl *TimeLockCondition) ConditionType() ConditionType

+ func (tl *TimeLockCondition) Equal(c UnlockCondition) bool

+ func (tl *TimeLockCondition) Fulfill(fulfillment UnlockFulfillment, ctx FulfillContext) error

+ func (tl *TimeLockCondition) Fulfillable(ctx FulfillableContext) bool

+ func (tl *TimeLockCondition) IsStandardCondition() error

+ func (tl *TimeLockCondition) Marshal() []byte

+ func (tl *TimeLockCondition) MarshalJSON() ([]byte, error)

+ func (tl *TimeLockCondition) UnlockHash() UnlockHash

+ func (tl *TimeLockCondition) Unmarshal(b []byte) error

+ func (tl *TimeLockCondition) UnmarshalJSON(b []byte) error

+ type TransactionController interface

+ DecodeTransactionData func([]byte) (TransactionData, error)

+ EncodeTransactionData func(TransactionData) ([]byte, error)

+ JSONDecodeTransactionData func([]byte) (TransactionData, error)

+ JSONEncodeTransactionData func(TransactionData) ([]byte, error)

+ type TransactionData struct

+ ArbitraryData []byte

+ BlockStakeInputs []BlockStakeInput

+ BlockStakeOutputs []BlockStakeOutput

+ CoinInputs []CoinInput

+ CoinOutputs []CoinOutput

+ Extension interface{}

+ MinerFees []Currency

+ func (td *TransactionData) UnmarshalSia(r io.Reader) error

+ func (td TransactionData) MarshalSia(w io.Writer) error

+ type TransactionIsStandardChecker interface

+ IsStandardTransaction func(t Transaction) error

type TransactionVersion

+ func (v TransactionVersion) IsValidTransactionVersion() error

+ type UnlockCondition interface

+ ConditionType func() ConditionType

+ Equal func(UnlockCondition) bool

+ Fulfill func(fulfillment UnlockFulfillment, ctx FulfillContext) error

+ Fulfillable func(FulfillableContext) bool

+ IsStandardCondition func() error

+ UnlockHash func() UnlockHash

+ type UnlockConditionProxy struct

+ Condition MarshalableUnlockCondition

+ func NewCondition(c MarshalableUnlockCondition) UnlockConditionProxy

+ func (up *UnlockConditionProxy) UnmarshalJSON(b []byte) error

+ func (up *UnlockConditionProxy) UnmarshalSia(r io.Reader) error

+ func (up UnlockConditionProxy) ConditionType() ConditionType

+ func (up UnlockConditionProxy) Equal(o UnlockCondition) bool

+ func (up UnlockConditionProxy) Fulfill(fulfillment UnlockFulfillment, ctx FulfillContext) error

+ func (up UnlockConditionProxy) Fulfillable(ctx FulfillableContext) bool

+ func (up UnlockConditionProxy) IsStandardCondition() error

+ func (up UnlockConditionProxy) MarshalJSON() ([]byte, error)

+ func (up UnlockConditionProxy) MarshalSia(w io.Writer) error

+ func (up UnlockConditionProxy) UnlockHash() UnlockHash

+ type UnlockFulfillment interface

+ Equal func(UnlockFulfillment) bool

+ FulfillmentType func() FulfillmentType

+ IsStandardFulfillment func() error

+ Sign func(ctx FulfillmentSignContext) error

+ UnlockHash func() UnlockHash

+ type UnlockFulfillmentProxy struct

+ Fulfillment MarshalableUnlockFulfillment

+ func NewFulfillment(f MarshalableUnlockFulfillment) UnlockFulfillmentProxy

+ func (fp *UnlockFulfillmentProxy) UnmarshalJSON(b []byte) error

+ func (fp *UnlockFulfillmentProxy) UnmarshalSia(r io.Reader) error

+ func (fp UnlockFulfillmentProxy) Equal(f UnlockFulfillment) bool

+ func (fp UnlockFulfillmentProxy) FulfillmentType() FulfillmentType

+ func (fp UnlockFulfillmentProxy) IsStandardFulfillment() error

+ func (fp UnlockFulfillmentProxy) MarshalJSON() ([]byte, error)

+ func (fp UnlockFulfillmentProxy) MarshalSia(w io.Writer) error

+ func (fp UnlockFulfillmentProxy) Sign(ctx FulfillmentSignContext) error

+ func (fp UnlockFulfillmentProxy) UnlockHash() UnlockHash

type UnlockHash

+ var NilUnlockHash UnlockHash

+ var UnknownUnlockHash = UnlockHash{ ... }

+ func NewEd25519PubKeyUnlockHash(pk crypto.PublicKey) UnlockHash

+ func NewPubKeyUnlockHash(pk SiaPublicKey) UnlockHash

+ type UnlockHashCondition struct

+ TargetUnlockHash UnlockHash

+ func NewUnlockHashCondition(uh UnlockHash) *UnlockHashCondition

+ func (uh *UnlockHashCondition) ConditionType() ConditionType

+ func (uh *UnlockHashCondition) Equal(c UnlockCondition) bool

+ func (uh *UnlockHashCondition) Fulfill(fulfillment UnlockFulfillment, ctx FulfillContext) error

+ func (uh *UnlockHashCondition) Fulfillable(FulfillableContext) bool

+ func (uh *UnlockHashCondition) IsStandardCondition() error

+ func (uh *UnlockHashCondition) Marshal() []byte

+ func (uh *UnlockHashCondition) UnlockHash() UnlockHash

+ func (uh *UnlockHashCondition) Unmarshal(b []byte) error

type UnlockType

+ const UnlockTypePubKey

type UnspentBlockStakeOutput

+ Condition UnlockConditionProxy

v1.0.4

May 3, 2018

v1.0.4-lts

Dec 2, 2016

v1.0.3

Apr 19, 2018

Changes in this version

+ func RegisterTransactionDecoder(v TransactionVersion, d TransactionDecoder)

+ type InputSigHasher interface

+ InputSigHash func(t Transaction, inputIndex uint64, extraObjects ...interface{}) crypto.Hash

type Transaction

+ Extension interface{}

+ Version TransactionVersion

+ func (t Transaction) IsStandardTransaction() error

+ func (t Transaction) ValidateTransaction(ctx TransactionValidationContext) error

+ type TransactionDataEncoder interface

+ EncodeTransactionData func(Transaction) ([]byte, error)

+ JSONEncodeTransactionData func(Transaction) ([]byte, error)

+ type TransactionDecoder interface

+ DecodeTransactionData func(TransactionVersion, []byte) (Transaction, error)

+ JSONDecodeTransactionData func(TransactionVersion, []byte) (Transaction, error)

+ type TransactionValidationContext struct

+ BlockSizeLimit uint64

+ CurrentBlockHeight BlockHeight

+ type TransactionValidator interface

+ ValidateTransaction func(TransactionValidationContext, Transaction) error

type TransactionVersion

+ const TransactionVersionZero

v1.0.2

Apr 8, 2018

Changes in this version

type BlockchainInfo

+ ChainVersion build.ProtocolVersion

+ ProtocolVersion build.ProtocolVersion

v1.0.1

Jul 26, 2016

Changes in this version

+ var ErrFileContractOutputSumViolation = errors.New("file contract has invalid output sums")

+ var ErrFileContractWindowEndViolation = errors.New("file contract window must end at least one block after it starts")

+ var ErrFileContractWindowStartViolation = errors.New("file contract window must start in the future")

+ var ErrNonZeroClaimStart = errors.New("transaction has a siafund output with a non-zero siafund claim")

+ var ErrStorageProofWithOutputs = errors.New("transaction has both a storage proof and other outputs")

+ var ErrZeroRevision = errors.New("transaction has a file contract revision with RevisionNumber=0")

+ var GenesisSiafundAllocation []SiafundOutput

+ var SpecifierClaimOutput = Specifier

+ var SpecifierFileContract = Specifier

+ var SpecifierFileContractRevision = Specifier

+ var SpecifierSiafundInput = Specifier

+ var SpecifierSiafundOutput = Specifier

+ var SpecifierStorageProof = Specifier

+ var SpecifierStorageProofOutput = Specifier

type CoveredFields

+ FileContractRevisions []uint64

+ FileContracts []uint64

+ SiafundInputs []uint64

+ SiafundOutputs []uint64

+ StorageProofs []uint64

type Currency

+ func PostTax(height BlockHeight, payout Currency) Currency

+ func Tax(height BlockHeight, payout Currency) Currency

+ type FileContract struct

+ FileMerkleRoot crypto.Hash

+ FileSize uint64

+ MissedProofOutputs []SiacoinOutput

+ Payout Currency

+ RevisionNumber uint64

+ UnlockHash UnlockHash

+ ValidProofOutputs []SiacoinOutput

+ WindowEnd BlockHeight

+ WindowStart BlockHeight

+ type FileContractID crypto.Hash

+ func (fcid *FileContractID) UnmarshalJSON(b []byte) error

+ func (fcid FileContractID) MarshalJSON() ([]byte, error)

+ func (fcid FileContractID) StorageProofOutputID(proofStatus ProofStatus, i uint64) SiacoinOutputID

+ func (fcid FileContractID) String() string

+ type FileContractRevision struct

+ NewFileMerkleRoot crypto.Hash

+ NewFileSize uint64

+ NewMissedProofOutputs []SiacoinOutput

+ NewRevisionNumber uint64

+ NewUnlockHash UnlockHash

+ NewValidProofOutputs []SiacoinOutput

+ NewWindowEnd BlockHeight

+ NewWindowStart BlockHeight

+ ParentID FileContractID

+ UnlockConditions UnlockConditions

+ type ProofStatus bool

+ var ProofMissed ProofStatus = false

+ var ProofValid ProofStatus = true

+ type SiafundInput struct

+ ClaimUnlockHash UnlockHash

+ ParentID SiafundOutputID

+ UnlockConditions UnlockConditions

+ type SiafundOutput struct

+ ClaimStart Currency

+ UnlockHash UnlockHash

+ Value Currency

+ type SiafundOutputID crypto.Hash

+ func (id SiafundOutputID) SiaClaimOutputID() SiacoinOutputID

+ func (sfoid *SiafundOutputID) UnmarshalJSON(b []byte) error

+ func (sfoid SiafundOutputID) MarshalJSON() ([]byte, error)

+ func (sfoid SiafundOutputID) String() string

+ type StorageProof struct

+ HashSet []crypto.Hash

+ ParentID FileContractID

+ Segment [crypto.SegmentSize]byte

type Transaction

+ FileContractRevisions []FileContractRevision

+ FileContracts []FileContract

+ SiafundInputs []SiafundInput

+ SiafundOutputs []SiafundOutput

+ StorageProofs []StorageProof

+ func (t Transaction) FileContractID(i uint64) FileContractID

+ func (t Transaction) SiafundOutputID(i uint64) SiafundOutputID

v1.0.0

Mar 31, 2018

Changes in this version

type AtomicSwapHashedSecret

+ func NewAtomicSwapHashedSecret(secret AtomicSwapSecret) AtomicSwapHashedSecret

type AtomicSwapSecret

+ func NewAtomicSwapSecret() (ass AtomicSwapSecret, err error)

type Block

+ func (b Block) CalculateTotalMinerFees() Currency

type ChainConstants

+ MinimumTransactionFee Currency

+ TransactionFeeBeneficiary UnlockHash

type InputLockProxy

+ func (p InputLockProxy) AtomicSwapInputLock() (*AtomicSwapInputLock, bool)

type Timestamp

+ func (t *Timestamp) LoadString(str string) error

type UnlockHash

+ func (uh UnlockHash) Cmp(other UnlockHash) int

v0

v0.6.0

Mar 29, 2018

Changes in this version

+ const AtomicSwapHashedSecretLen

+ const AtomicSwapSecretLen

+ var ErrFrivolousSignature = errors.New("transaction contains a frivolous signature")

+ var ErrInvalidInputLockType = errors.New("invalid input lock type")

+ var ErrInvalidPreImageSha256 = errors.New("invalid pre-image sha256")

+ var ErrInvalidRedeemer = errors.New("invalid input redeemer")

+ var ErrInvalidTransactionVersion = errors.New("invalid transaction version")

+ var ErrUnknownSignAlgorithmType = errors.New("unknown signature algorithm type")

+ var ErrUnknownUnlockType = errors.New("unknown unlock type")

+ var ErrUnlockConditionLocked = errors.New("unlock condition is already locked")

+ func RegisterUnlockType(t UnlockType, ilc InputLockConstructor)

+ func UnregisterUnlockType(t UnlockType)

+ type AtomicSwapClaimKey struct

+ PublicKey SiaPublicKey

+ Secret AtomicSwapSecret

+ SecretKey ByteSlice

+ type AtomicSwapCondition struct

+ HashedSecret AtomicSwapHashedSecret

+ Receiver UnlockHash

+ Sender UnlockHash

+ TimeLock Timestamp

+ type AtomicSwapFulfillment struct

+ PublicKey SiaPublicKey

+ Secret AtomicSwapSecret

+ Signature ByteSlice

+ type AtomicSwapHashedSecret [sha256.Size]byte

+ func (hs *AtomicSwapHashedSecret) LoadString(str string) error

+ func (hs *AtomicSwapHashedSecret) UnmarshalJSON(b []byte) error

+ func (hs AtomicSwapHashedSecret) MarshalJSON() ([]byte, error)

+ func (hs AtomicSwapHashedSecret) String() string

+ type AtomicSwapInputLock struct

+ HashedSecret AtomicSwapHashedSecret

+ PublicKey SiaPublicKey

+ Receiver UnlockHash

+ Secret AtomicSwapSecret

+ Sender UnlockHash

+ Signature ByteSlice

+ TimeLock Timestamp

+ func (as *AtomicSwapInputLock) Decode(rf RawInputLockFormat) error

+ func (as *AtomicSwapInputLock) EncodeCondition() []byte

+ func (as *AtomicSwapInputLock) EncodeFulfillment() []byte

+ func (as *AtomicSwapInputLock) Lock(inputIndex uint64, tx Transaction, key interface{}) error

+ func (as *AtomicSwapInputLock) StrictCheck() error

+ func (as *AtomicSwapInputLock) Unlock(inputIndex uint64, tx Transaction) error

+ type AtomicSwapRefundKey struct

+ PublicKey SiaPublicKey

+ SecretKey ByteSlice

+ type AtomicSwapSecret [sha256.Size]byte

+ func (s *AtomicSwapSecret) LoadString(str string) error

+ func (s *AtomicSwapSecret) UnmarshalJSON(b []byte) error

+ func (s AtomicSwapSecret) MarshalJSON() ([]byte, error)

+ func (s AtomicSwapSecret) String() string

type BlockStakeInput

+ Unlocker InputLockProxy

type BlockStakeOutputID

+ func (bsoid *BlockStakeOutputID) LoadString(str string) error

+ type BlockchainInfo struct

+ Name string

+ Version build.ProtocolVersion

+ func DefaultBlockchainInfo() BlockchainInfo

+ type ByteSlice []byte

+ func (bs *ByteSlice) LoadString(str string) error

+ func (bs *ByteSlice) UnmarshalJSON(b []byte) error

+ func (bs ByteSlice) MarshalJSON() ([]byte, error)

+ func (bs ByteSlice) String() string

+ type ChainConstants struct

+ BlockCreatorFee Currency

+ BlockFrequency BlockHeight

+ BlockSizeLimit uint64

+ BlockStakeAging uint64

+ CurrencyUnits CurrencyUnits

+ ExtremeFutureThreshold Timestamp

+ FutureThreshold Timestamp

+ GenesisBlockStakeAllocation []BlockStakeOutput

+ GenesisCoinDistribution []CoinOutput

+ GenesisTimestamp Timestamp

+ MaturityDelay BlockHeight

+ MaxAdjustmentDown *big.Rat

+ MaxAdjustmentUp *big.Rat

+ MedianTimestampWindow uint64

+ RootDepth Target

+ StakeModifierDelay BlockHeight

+ TargetWindow BlockHeight

+ func DefaultChainConstants() ChainConstants

+ func (c *ChainConstants) GenesisBlock() Block

+ func (c *ChainConstants) GenesisBlockID() BlockID

+ func (c *ChainConstants) GenesisBlockStakeCount() (bsc Currency)

+ func (c *ChainConstants) GenesisCoinCount() (cc Currency)

+ func (c *ChainConstants) RootTarget() Target

+ func (c *ChainConstants) StartDifficulty() Difficulty

+ func (c *ChainConstants) Validate() error

type CoinInput

+ Unlocker InputLockProxy

type CoinOutputID

+ func (coid *CoinOutputID) LoadString(str string) error

type Currency

+ func (x Currency) Cmp64(y uint64) int

+ func (x Currency) Equals(y Currency) bool

+ func (x Currency) Equals64(y uint64) bool

+ type CurrencyUnits struct

+ OneCoin Currency

+ func DefaultCurrencyUnits() CurrencyUnits

+ type InputLock interface

+ Decode func(rf RawInputLockFormat) error

+ EncodeCondition func() []byte

+ EncodeFulfillment func() []byte

+ Lock func(inputIndex uint64, tx Transaction, key interface{}) error

+ StrictCheck func() error

+ Unlock func(inputIndex uint64, tx Transaction) error

+ type InputLockConstructor func() InputLock

+ type InputLockProxy struct

+ func NewAtomicSwapInputLock(condition AtomicSwapCondition) InputLockProxy

+ func NewInputLockProxy(t UnlockType, il InputLock) InputLockProxy

+ func NewSingleSignatureInputLock(pk SiaPublicKey) InputLockProxy

+ func (p *InputLockProxy) UnmarshalJSON(b []byte) error

+ func (p *InputLockProxy) UnmarshalSia(r io.Reader) error

+ func (p InputLockProxy) Lock(inputIndex uint64, tx Transaction, key interface{}) error

+ func (p InputLockProxy) MarshalJSON() ([]byte, error)

+ func (p InputLockProxy) MarshalSia(w io.Writer) error

+ func (p InputLockProxy) StrictCheck() error

+ func (p InputLockProxy) Unlock(inputIndex uint64, tx Transaction) error

+ func (p InputLockProxy) UnlockHash() UnlockHash

type OutputID

+ func (oid *OutputID) LoadString(str string) error

+ type RawInputLockFormat struct

+ Condition []byte

+ Fulfillment []byte

+ func (rf *RawInputLockFormat) UnmarshalSia(r io.Reader) error

+ func (rf RawInputLockFormat) MarshalSia(w io.Writer) error

type SiaPublicKey

+ func Ed25519PublicKey(pk crypto.PublicKey) SiaPublicKey

+ func (spk *SiaPublicKey) LoadString(s string) error

+ func (spk *SiaPublicKey) UnmarshalJSON(b []byte) error

+ func (spk SiaPublicKey) MarshalJSON() ([]byte, error)

+ type SingleSignatureInputLock struct

+ PublicKey SiaPublicKey

+ Signature ByteSlice

+ func (ss *SingleSignatureInputLock) Decode(rf RawInputLockFormat) error

+ func (ss *SingleSignatureInputLock) EncodeCondition() []byte

+ func (ss *SingleSignatureInputLock) EncodeFulfillment() []byte

+ func (ss *SingleSignatureInputLock) Lock(inputIndex uint64, tx Transaction, key interface{}) error

+ func (ss *SingleSignatureInputLock) MarshalSia(w io.Writer) error

+ func (ss *SingleSignatureInputLock) StrictCheck() error

+ func (ss *SingleSignatureInputLock) Unlock(inputIndex uint64, tx Transaction) error

+ func (ss *SingleSignatureInputLock) UnmarshalSia(r io.Reader) error

type Specifier

+ func (s *Specifier) LoadString(str string) error

type Timestamp

+ func OffsetTimestamp(offset time.Duration) Timestamp

+ func (t Timestamp) String() string

type Transaction

+ func (t *Transaction) UnmarshalJSON(b []byte) error

+ func (t *Transaction) UnmarshalSia(r io.Reader) error

+ func (t Transaction) InputSigHash(inputIndex uint64, extraObjects ...interface{}) (hash crypto.Hash)

+ func (t Transaction) MarshalJSON() ([]byte, error)

+ func (t Transaction) MarshalSia(w io.Writer) error

type TransactionID

+ func (tid *TransactionID) LoadString(str string) error

+ type TransactionShortID uint64

+ func NewTransactionShortID(height BlockHeight, txSequenceID uint16) TransactionShortID

+ func (txsid *TransactionShortID) UnmarshalSia(r io.Reader) error

+ func (txsid TransactionShortID) BlockHeight() BlockHeight

+ func (txsid TransactionShortID) MarshalSia(w io.Writer) error

+ func (txsid TransactionShortID) TransactionSequenceIndex() uint16

+ type TransactionVersion byte

+ const TransactionVersionOne

+ func (v *TransactionVersion) UnmarshalSia(r io.Reader) error

+ func (v TransactionVersion) MarshalSia(w io.Writer) error

+ type UnknownInputLock struct

+ Condition []byte

+ Fulfillment []byte

+ func (u *UnknownInputLock) Decode(rf RawInputLockFormat) error

+ func (u *UnknownInputLock) EncodeCondition() []byte

+ func (u *UnknownInputLock) EncodeFulfillment() []byte

+ func (u *UnknownInputLock) Lock(_ uint64, _ Transaction, _ interface{}) error

+ func (u *UnknownInputLock) StrictCheck() error

+ func (u *UnknownInputLock) Unlock(_ uint64, _ Transaction) error

type UnlockHash

+ Hash crypto.Hash

+ Type UnlockType

+ func NewUnlockHash(t UnlockType, h crypto.Hash) UnlockHash

+ func (uh *UnlockHash) UnmarshalSia(r io.Reader) error

+ func (uh UnlockHash) MarshalSia(w io.Writer) error

+ type UnlockType byte

+ const UnlockTypeAtomicSwap

+ const UnlockTypeNil

+ const UnlockTypeSingleSignature

+ func (t *UnlockType) UnmarshalSia(r io.Reader) error

+ func (t UnlockType) MarshalSia(w io.Writer) error

v0.6.0-beta

May 21, 2016

v0.1.2

Feb 21, 2018

Changes in this version

+ func CalculateGenesis()

v0.1.1

Feb 18, 2018

v0.1.0

Jun 6, 2017

Changes in this version

+ var BlockCreatorFee Currency

+ var BlockStakeAging uint64

+ var ErrNegativeDifficulty = errors.New("negative difficulty not allowed")

+ var GenesisBlockStakeCount Currency

+ var GenesisCoinCount Currency

+ var GenesisCoinDistribution = []CoinOutput

+ var OneCoin = NewCurrency(new(big.Int).Exp(big.NewInt(10), big.NewInt(24), nil))

+ var SpecifierCoinInput = Specifier

+ var SpecifierCoinOutput = Specifier

+ var StakeModifierDelay BlockHeight

+ var StartDifficulty Difficulty

type Block

+ POBSOutput BlockStakeOutputIndexes

+ func (b *Block) UnmarshalBlockHeadersParentIDAndTS(raw []byte) (BlockID, Timestamp)

type BlockHeader

+ POBSOutput BlockStakeOutputIndexes

+ type BlockStakeOutputIndexes struct

+ BlockHeight BlockHeight

+ OutputIndex uint64

+ TransactionIndex uint64

+ type CoinInput struct

+ ParentID CoinOutputID

+ UnlockConditions UnlockConditions

+ type CoinOutput struct

+ UnlockHash UnlockHash

+ Value Currency

+ type CoinOutputID crypto.Hash

+ func (scoid *CoinOutputID) UnmarshalJSON(b []byte) error

+ func (scoid CoinOutputID) MarshalJSON() ([]byte, error)

+ func (scoid CoinOutputID) String() string

type CoveredFields

+ CoinInputs []uint64

+ CoinOutputs []uint64

+ type Difficulty struct

+ func NewDifficulty(b *big.Int) (d Difficulty)

+ func (c *Difficulty) Scan(s fmt.ScanState, ch rune) error

+ func (c *Difficulty) UnmarshalJSON(b []byte) error

+ func (c *Difficulty) UnmarshalSia(r io.Reader) error

+ func (c Difficulty) MarshalJSON() ([]byte, error)

+ func (c Difficulty) MarshalSia(w io.Writer) error

+ func (c Difficulty) String() string

+ func (x Difficulty) Big() *big.Int

+ func (x Difficulty) Cmp(y Difficulty) int

+ func (x Difficulty) Div64(y uint64) (c Difficulty)

type SiaPublicKey

+ func (spk *SiaPublicKey) String() string

type Target

+ func NewTarget(difficulty Difficulty) Target

type Transaction

+ CoinInputs []CoinInput

+ CoinOutputs []CoinOutput

+ func (t Transaction) CoinOutputID(i uint64) CoinOutputID

+ func (t Transaction) CoinOutputSum() (sum Currency)

+ type UnspentBlockStakeOutput struct

+ BlockStakeOutputID BlockStakeOutputID

+ Indexes BlockStakeOutputIndexes

+ UnlockHash UnlockHash

+ Value Currency

v0.0.0

Sep 28, 2016

Changes in this version

+ const BlockHeaderSize

+ const SpecifierLen

+ const UnlockHashChecksumSize

+ var BlockFrequency BlockHeight

+ var BlockSizeLimit = uint64(2e6)

+ var ErrDoubleSpend = errors.New("transaction uses a parent object twice")

+ var ErrEntropyKey = errors.New("transaction tries to sign an entproy public key")

+ var ErrFrivilousSignature = errors.New("transaction contains a frivilous siganture")

+ var ErrInvalidPubKeyIndex = errors.New("transaction contains a signature that points to a nonexistent public key")

+ var ErrInvalidUnlockHashChecksum = errors.New("provided unlock hash has an invalid checksum")

+ var ErrMissingSignatures = errors.New("transaction has inputs with missing signatures")

+ var ErrNegativeCurrency = errors.New("negative currency not allowed")

+ var ErrNegativeTarget = errors.New("negative value used when converting to target")

+ var ErrNonZeroRevision = errors.New("new file contract has a nonzero revision number")

+ var ErrPrematureSignature = errors.New("timelock on signature has not expired")

+ var ErrPublicKeyOveruse = errors.New("public key was used multiple times while signing transaction")

+ var ErrSortedUniqueViolation = errors.New("sorted unique violation")

+ var ErrTimelockNotSatisfied = errors.New("timelock has not been met")

+ var ErrTransactionIDWrongLen = errors.New("input has wrong length to be an encoded transaction id")

+ var ErrTransactionTooLarge = errors.New("transaction is too large to fit in a block")

+ var ErrUint64Overflow = errors.New("cannot return the uint64 of this currency - result is an overflow")

+ var ErrUnlockHashWrongLen = errors.New("marshalled unlock hash is the wrong length")

+ var ErrWholeTransactionViolation = errors.New("covered fields violation")

+ var ErrZeroMinerFee = errors.New("transaction has a zero value miner fee")

+ var ErrZeroOutput = errors.New("transaction cannot have an output or payout that has zero value")

+ var ExtremeFutureThreshold Timestamp

+ var FullCoveredFields = CoveredFields

+ var FutureThreshold Timestamp

+ var GenesisBlock Block

+ var GenesisBlockStakeAllocation []BlockStakeOutput

+ var GenesisID BlockID

+ var GenesisTimestamp Timestamp

+ var InitialCoinbase = uint64(300e3)

+ var MaturityDelay BlockHeight

+ var MaxAdjustmentDown *big.Rat

+ var MaxAdjustmentUp *big.Rat

+ var MedianTimestampWindow = uint64(11)

+ var MinimumCoinbase uint64

+ var RootDepth = Target

+ var RootTarget Target

+ var SiacoinPrecision = NewCurrency(new(big.Int).Exp(big.NewInt(10), big.NewInt(24), nil))

+ var SiafundCount = NewCurrency64(10000)

+ var SiafundPortion = big.NewRat(39, 1000)

+ var SignatureEd25519 = Specifier

+ var SignatureEntropy = Specifier

+ var SpecifierBlockStakeInput = Specifier

+ var SpecifierBlockStakeOutput = Specifier

+ var SpecifierMinerFee = Specifier

+ var SpecifierMinerPayout = Specifier

+ var SpecifierSiacoinInput = Specifier

+ var SpecifierSiacoinOutput = Specifier

+ var TargetWindow BlockHeight

+ var ZeroCurrency = NewCurrency64(0)

+ type Block struct

+ MinerPayouts []SiacoinOutput

+ Nonce BlockNonce

+ ParentID BlockID

+ Timestamp Timestamp

+ Transactions []Transaction

+ func (b *Block) UnmarshalSia(r io.Reader) error

+ func (b Block) CalculateSubsidy(height BlockHeight) Currency

+ func (b Block) Header() BlockHeader

+ func (b Block) ID() BlockID

+ func (b Block) MarshalSia(w io.Writer) error

+ func (b Block) MerkleRoot() crypto.Hash

+ func (b Block) MinerPayoutID(i uint64) SiacoinOutputID

+ type BlockHeader struct

+ MerkleRoot crypto.Hash

+ Nonce BlockNonce

+ ParentID BlockID

+ Timestamp Timestamp

+ func (h BlockHeader) ID() BlockID

+ type BlockHeight uint64

+ type BlockID crypto.Hash

+ func (bid *BlockID) UnmarshalJSON(b []byte) error

+ func (bid BlockID) MarshalJSON() ([]byte, error)

+ func (bid BlockID) String() string

+ type BlockNonce [8]byte

+ type BlockStakeInput struct

+ ParentID BlockStakeOutputID

+ UnlockConditions UnlockConditions

+ type BlockStakeOutput struct

+ UnlockHash UnlockHash

+ Value Currency

+ type BlockStakeOutputID crypto.Hash

+ func (bsoid *BlockStakeOutputID) UnmarshalJSON(b []byte) error

+ func (bsoid BlockStakeOutputID) MarshalJSON() ([]byte, error)

+ func (bsoid BlockStakeOutputID) String() string

+ type Clock interface

+ Now func() Timestamp

+ type CoveredFields struct

+ ArbitraryData []uint64

+ BlockStakeInputs []uint64

+ BlockStakeOutputs []uint64

+ MinerFees []uint64

+ SiacoinInputs []uint64

+ SiacoinOutputs []uint64

+ TransactionSignatures []uint64

+ WholeTransaction bool

+ type Currency struct

+ func CalculateCoinbase(height BlockHeight) Currency

+ func CalculateNumSiacoins(height BlockHeight) Currency

+ func NewCurrency(b *big.Int) (c Currency)

+ func NewCurrency64(x uint64) (c Currency)

+ func (c *Currency) Scan(s fmt.ScanState, ch rune) error

+ func (c *Currency) UnmarshalJSON(b []byte) error

+ func (c *Currency) UnmarshalSia(r io.Reader) error

+ func (c Currency) Big() *big.Int

+ func (c Currency) IsZero() bool

+ func (c Currency) MarshalJSON() ([]byte, error)

+ func (c Currency) MarshalSia(w io.Writer) error

+ func (c Currency) String() string

+ func (c Currency) Uint64() (u uint64, err error)

+ func (x Currency) Add(y Currency) (c Currency)

+ func (x Currency) Cmp(y Currency) int

+ func (x Currency) Div(y Currency) (c Currency)

+ func (x Currency) Div64(y uint64) (c Currency)

+ func (x Currency) Mul(y Currency) (c Currency)

+ func (x Currency) Mul64(y uint64) (c Currency)

+ func (x Currency) MulFloat(y float64) (c Currency)

+ func (x Currency) MulRat(y *big.Rat) (c Currency)

+ func (x Currency) MulTax() (c Currency)

+ func (x Currency) RoundDown(y Currency) (c Currency)

+ func (x Currency) Sqrt() (c Currency)

+ func (x Currency) Sub(y Currency) (c Currency)

+ type OutputID crypto.Hash

+ func (oid *OutputID) UnmarshalJSON(b []byte) error

+ func (oid OutputID) MarshalJSON() ([]byte, error)

+ func (oid OutputID) String() string

+ type SiaPublicKey struct

+ Algorithm Specifier

+ Key []byte

+ type SiacoinInput struct

+ ParentID SiacoinOutputID

+ UnlockConditions UnlockConditions

+ type SiacoinOutput struct

+ UnlockHash UnlockHash

+ Value Currency

+ type SiacoinOutputID crypto.Hash

+ func (scoid *SiacoinOutputID) UnmarshalJSON(b []byte) error

+ func (scoid SiacoinOutputID) MarshalJSON() ([]byte, error)

+ func (scoid SiacoinOutputID) String() string

+ type Specifier [SpecifierLen]byte

+ func (s *Specifier) UnmarshalJSON(b []byte) error

+ func (s Specifier) MarshalJSON() ([]byte, error)

+ func (s Specifier) String() string

+ type StdClock struct

+ func (c StdClock) Now() Timestamp

+ type Target crypto.Hash

+ func IntToTarget(i *big.Int) (t Target)

+ func RatToTarget(r *big.Rat) (t Target)

+ func (t Target) Difficulty() Currency

+ func (t Target) Int() *big.Int

+ func (t Target) Inverse() *big.Rat

+ func (t Target) Rat() *big.Rat

+ func (x Target) AddDifficulties(y Target) (t Target)

+ func (x Target) Cmp(y Target) int

+ func (x Target) MulDifficulty(y *big.Rat) (t Target)

+ func (x Target) SubtractDifficulties(y Target) (t Target)

+ type Timestamp uint64

+ func CurrentTimestamp() Timestamp

+ type TimestampSlice []Timestamp

+ func (ts TimestampSlice) Len() int

+ func (ts TimestampSlice) Less(i, j int) bool

+ func (ts TimestampSlice) Swap(i, j int)

+ type Transaction struct

+ ArbitraryData [][]byte

+ BlockStakeInputs []BlockStakeInput

+ BlockStakeOutputs []BlockStakeOutput

+ MinerFees []Currency

+ SiacoinInputs []SiacoinInput

+ SiacoinOutputs []SiacoinOutput

+ TransactionSignatures []TransactionSignature

+ func (t Transaction) BlockStakeOutputID(i uint64) BlockStakeOutputID

+ func (t Transaction) ID() TransactionID

+ func (t Transaction) SiacoinOutputID(i uint64) SiacoinOutputID

+ func (t Transaction) SiacoinOutputSum() (sum Currency)

+ func (t Transaction) SigHash(i int) crypto.Hash

+ func (t Transaction) StandaloneValid(currentHeight BlockHeight) (err error)

+ type TransactionID crypto.Hash

+ func (tid *TransactionID) UnmarshalJSON(b []byte) error

+ func (tid TransactionID) MarshalJSON() ([]byte, error)

+ func (tid TransactionID) String() string

+ type TransactionSignature struct

+ CoveredFields CoveredFields

+ ParentID crypto.Hash

+ PublicKeyIndex uint64

+ Signature []byte

+ Timelock BlockHeight

+ type UnlockConditions struct

+ PublicKeys []SiaPublicKey

+ SignaturesRequired uint64

+ Timelock BlockHeight

+ func (uc UnlockConditions) UnlockHash() UnlockHash

+ type UnlockHash crypto.Hash

+ func (uh *UnlockHash) LoadString(strUH string) error

+ func (uh *UnlockHash) UnmarshalJSON(b []byte) error

+ func (uh UnlockHash) MarshalJSON() ([]byte, error)

+ func (uh UnlockHash) String() string

+ type UnlockHashSlice []UnlockHash

+ func (uhs UnlockHashSlice) Len() int

+ func (uhs UnlockHashSlice) Less(i, j int) bool

+ func (uhs UnlockHashSlice) Swap(i, j int)

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