lib

package

Go to main page

Versions in this module

v2

v2.2.6

Sep 1, 2022

Changes in this version

+ func GetParamUpdaterPublicKeys(blockHeight uint32, params *DeSoParams) map[PkMapKey]bool

type DeSoParams

+ ExtraRegtestParamUpdaterKeys map[PkMapKey]bool

type ForkHeights

+ ParamUpdaterRefactorBlockHeight uint32

v2.2.5

Jun 11, 2022

v2.2.4

Jun 10, 2022

Changes in this version

+ func TextAndHash(data []byte) ([]byte, string)

type ForkHeights

+ DerivedKeyEthSignatureCompatibilityBlockHeight uint32

+ OrderBookDBFetchOptimizationBlockHeight uint32

v2.2.3

May 23, 2022

v2.2.2

May 14, 2022

Changes in this version

+ func SignTransactionBytes(txnBytes []byte, privateKey *btcec.PrivateKey, isDerived bool) ([]byte, []byte, error)

type Blockchain

+ func (bc *Blockchain) Postgres() *Postgres

type DAOCoinLimitOrderOperationType

+ func (tp DAOCoinLimitOrderOperationType) String() string

type UtxoView

+ func (bav *UtxoView) GetNextLimitOrdersToFill(transactorOrder *DAOCoinLimitOrderEntry, lastSeenOrder *DAOCoinLimitOrderEntry) ([]*DAOCoinLimitOrderEntry, error)

v2.2.1

May 11, 2022

Changes in this version

+ const NodeSyncTypeAny

+ const NodeSyncTypeBlockSync

+ const NodeSyncTypeHyperSync

+ const NodeSyncTypeHyperSyncArchival

+ var IsBlacklisted = []byte

+ var IsGraylisted = []byte

+ var NotBlacklisted = []byte

+ var NotGraylisted = []byte

+ func CheckRBF(bitcoinTxn *wire.MsgTx, bitcoinTxnHash chainhash.Hash, desoParams *DeSoParams) (bool, error)

+ func IsNodeArchival(syncType NodeSyncType) bool

+ func NodeCanHypersyncState(syncType NodeSyncType) bool

+ func ScaleFloatFormatStringToUint256(floatStr string, scaleFactor *uint256.Int) (*uint256.Int, error)

+ func ValidateHyperSyncFlags(isHypersync bool, syncType NodeSyncType)

type BlockCypherAPITxnResponse

+ TxnHex string

type ConnectionManager

+ SyncType NodeSyncType

+ type NodeSyncType string

type ServiceFlag

+ const SFFullNodeDeprecated

v2.1.3

May 5, 2022

Changes in this version

+ const BadgerDbFolder

+ const DBVersionString

+ const DatabaseCacheSize

+ const DisableTimer

+ const EnableTimer

+ const GetSnapshotTimeout

+ const HashToCurveCache

+ const MaxPrefixLen

+ const MetadataRetryCount

+ const PerformanceLogValueSize

+ const PerformanceMemTableSize

+ const PublicKeyLenCompressed

+ const SnapshotBatchSize

+ const SnapshotBlockHeightPeriod

+ var Blue = color.New(color.FgBlue)

+ var Cyan = color.New(color.FgCyan)

+ var GlobalDeSoParams = DeSoTestnetParams

+ var Green = color.New(color.FgHiGreen)

+ var Magenta = color.New(color.FgMagenta)

+ var MainnetForkHeights = ForkHeights

+ var Mode = DisableTimer

+ var Prefixes = GetPrefixes()

+ var Red = color.New(color.FgRed)

+ var RegtestForkHeights = ForkHeights

+ var StatePrefixes = GetStatePrefixes()

+ var TestnetForkHeights = ForkHeights

+ var Yellow = color.New(color.FgHiYellow)

+ func CLog(c *color.Color, str string) string

+ func DBDeleteAllStateRecords(db *badger.DB) (_shouldErase bool, _error error)

+ func DBDeleteWithTxn(txn *badger.Txn, snap *Snapshot, key []byte) error

+ func DBGetWithTxn(txn *badger.Txn, snap *Snapshot, key []byte) ([]byte, error)

+ func DBSetWithTxn(txn *badger.Txn, snap *Snapshot, key []byte, value []byte) error

+ func DbDeleteAllRepostMappingsWithTxn(txn *badger.Txn, snap *Snapshot, userPubKey []byte, repostedPostHash BlockHash) error

+ func DecodeFromBytes(encoder DeSoEncoder, rr *bytes.Reader) (_existenceByte bool, _error error)

+ func DecodeMapStringUint64(rr *bytes.Reader) (map[string]uint64, error)

+ func DecodePKIDuint64Map(rr io.Reader) (map[PKID]uint64, error)

+ func DecodeUint256(rr *bytes.Reader) (*uint256.Int, error)

+ func DeleteBlockReward(handle *badger.DB, snap *Snapshot, desoBlock *MsgDeSoBlock) error

+ func DeleteBlockRewardWithTxn(txn *badger.Txn, snap *Snapshot, desoBlock *MsgDeSoBlock) error

+ func EncodeKeyAndValueForChecksum(key []byte, value []byte, blockHeight uint64) []byte

+ func EncodeKeyValue(key []byte, value []byte) []byte

+ func EncodeMapStringUint64(mapStruct map[string]uint64) []byte

+ func EncodePKIDuint64Map(pkidMap map[PKID]uint64) []byte

+ func EncodeToBytes(blockHeight uint64, encoder DeSoEncoder, skipMetadata ...bool) []byte

+ func GetMigrationVersion(blockHeight uint64, appliedMigrationNames ...MigrationName) byte

+ func MigrationTriggered(blockHeight uint64, migrationName MigrationName) bool

+ func PerformanceBadgerOptions(dir string) badger.Options

+ func VersionByteToMigrationHeight(version byte, params *DeSoParams) (_blockHeight uint64)

type AcceptNFTBidTxindexMetadata

+ NFTRoyaltiesMetadata *NFTRoyaltiesMetadata

+ func (txnMeta *AcceptNFTBidTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *AcceptNFTBidTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *AcceptNFTBidTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *AcceptNFTBidTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type AcceptNFTTransferTxindexMetadata

+ func (txnMeta *AcceptNFTTransferTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *AcceptNFTTransferTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *AcceptNFTTransferTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *AcceptNFTTransferTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type AffectedPublicKey

+ func (pk *AffectedPublicKey) GetEncoderType() EncoderType

+ func (pk *AffectedPublicKey) GetVersionByte(blockHeight uint64) byte

+ func (pk *AffectedPublicKey) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (pk *AffectedPublicKey) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

+ type AncestralCache struct

+ AncestralRecordsMap map[string]*AncestralRecordValue

+ func NewAncestralCache(id uint64, blockHeight uint64) *AncestralCache

+ type AncestralRecordValue struct

+ Existed bool

+ Value []byte

type BalanceEntry

+ func (be *BalanceEntry) GetEncoderType() EncoderType

+ func (be *BalanceEntry) GetVersionByte(blockHeight uint64) byte

+ func (be *BalanceEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (be *BalanceEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type BasicTransferTxindexMetadata

+ func (txnMeta *BasicTransferTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *BasicTransferTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *BasicTransferTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *BasicTransferTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type BitcoinExchangeTxindexMetadata

+ func (txnMeta *BitcoinExchangeTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *BitcoinExchangeTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *BitcoinExchangeTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *BitcoinExchangeTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type BlockHash

+ func (bh *BlockHash) GetEncoderType() EncoderType

+ func (bh *BlockHash) GetVersionByte(blockHeight uint64) byte

+ func (bh *BlockHash) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (bh *BlockHash) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type BlockStatus

+ func (blockStatus BlockStatus) IsFullyProcessed() bool

type Blockchain

+ MaxSyncBlockHeight uint32

+ func (bc *Blockchain) DisconnectBlocksToHeight(blockHeight uint64) error

+ func (bc *Blockchain) GetBlockNodeWithHash(hash *BlockHash) *BlockNode

+ func (bc *Blockchain) IsFullyStored() bool

+ func (bc *Blockchain) Snapshot() *Snapshot

type BurnNFTTxindexMetadata

+ func (txnMeta *BurnNFTTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *BurnNFTTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *BurnNFTTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *BurnNFTTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type CoinEntry

+ func (ce *CoinEntry) GetEncoderType() EncoderType

+ func (ce *CoinEntry) GetVersionByte(blockHeight uint64) byte

+ func (ce *CoinEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (ce *CoinEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type ConnectionManager

+ AddrMgr *addrmgr.AddrManager

+ DisableSlowSync bool

+ HyperSync bool

type CreateNFTTxindexMetadata

+ func (txnMeta *CreateNFTTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *CreateNFTTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *CreateNFTTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *CreateNFTTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type CreatorCoinTransferTxindexMetadata

+ func (txnMeta *CreatorCoinTransferTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *CreatorCoinTransferTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *CreatorCoinTransferTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *CreatorCoinTransferTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type CreatorCoinTxindexMetadata

+ func (txnMeta *CreatorCoinTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *CreatorCoinTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *CreatorCoinTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *CreatorCoinTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type DAOCoinLimitOrderEntry

+ func (order *DAOCoinLimitOrderEntry) GetEncoderType() EncoderType

+ func (order *DAOCoinLimitOrderEntry) GetVersionByte(blockHeight uint64) byte

+ func (order *DAOCoinLimitOrderEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (order *DAOCoinLimitOrderEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type DAOCoinLimitOrderTxindexMetadata

+ func (daoMeta *DAOCoinLimitOrderTxindexMetadata) GetEncoderType() EncoderType

+ func (daoMeta *DAOCoinLimitOrderTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (daoMeta *DAOCoinLimitOrderTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (daoMeta *DAOCoinLimitOrderTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type DAOCoinTransferTxindexMetadata

+ func (txnMeta *DAOCoinTransferTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *DAOCoinTransferTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *DAOCoinTransferTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *DAOCoinTransferTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type DAOCoinTxindexMetadata

+ func (txnMeta *DAOCoinTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *DAOCoinTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *DAOCoinTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *DAOCoinTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

+ type DBEntry struct

+ Key []byte

+ Value []byte

+ func DBIteratePrefixKeys(db *badger.DB, prefix []byte, startKey []byte, targetBytes uint32) (_dbEntries []*DBEntry, _isChunkFull bool, _err error)

+ func EmptyDBEntry() *DBEntry

+ func KeyValueToDBEntry(key []byte, value []byte) *DBEntry

+ func (entry *DBEntry) FromBytes(rr *bytes.Reader) error

+ func (entry *DBEntry) IsEmpty() bool

+ func (entry *DBEntry) ToBytes() []byte

+ type DBPrefixes struct

+ PrefixAuthorizeDerivedKey []byte

+ PrefixBestBitcoinHeaderHash []byte

+ PrefixBestDeSoBlockHash []byte

+ PrefixBidderPKIDPostHashSerialNumberToBidNanos []byte

+ PrefixBitcoinBurnTxIDs []byte

+ PrefixBitcoinHeightHashToNodeInfo []byte

+ PrefixBlockHashToBlock []byte

+ PrefixBlockHashToUtxoOperations []byte

+ PrefixCommentParentStakeIDToPostHash []byte

+ PrefixCreatorBpsPostHash []byte

+ PrefixCreatorDeSoLockedNanosCreatorPKID []byte

+ PrefixCreatorPKIDHODLerPKIDToBalanceEntry []byte

+ PrefixCreatorPKIDHODLerPKIDToDAOCoinBalanceEntry []byte

+ PrefixDAOCoinLimitOrder []byte

+ PrefixDAOCoinLimitOrderByOrderID []byte

+ PrefixDAOCoinLimitOrderByTransactorPKID []byte

+ PrefixDiamondReceiverPKIDDiamondSenderPKIDPostHash []byte

+ PrefixDiamondSenderPKIDDiamondReceiverPKIDPostHash []byte

+ PrefixDiamondedPostHashDiamonderPKIDDiamondLevel []byte

+ PrefixFollowedPKIDToFollowerPKID []byte

+ PrefixFollowerPKIDToFollowedPKID []byte

+ PrefixForbiddenBlockSignaturePubKeys []byte

+ PrefixGlobalParams []byte

+ PrefixHODLerPKIDCreatorPKIDToBalanceEntry []byte

+ PrefixHODLerPKIDCreatorPKIDToDAOCoinBalanceEntry []byte

+ PrefixHeightHashToNodeInfo []byte

+ PrefixLikedPostHashToLikerPubKey []byte

+ PrefixLikerPubKeyToLikedPostHash []byte

+ PrefixMempoolTxnHashToMsgDeSoTxn []byte

+ PrefixMessagingGroupEntriesByOwnerPubKeyAndGroupKeyName []byte

+ PrefixMessagingGroupMetadataByMemberPubKeyAndGroupMessagingPubKey []byte

+ PrefixMultipleBpsPostHash []byte

+ PrefixNanosPurchased []byte

+ PrefixPKIDIsForSaleBidAmountNanosPostHashSerialNumberToNFTEntry []byte

+ PrefixPKIDToProfileEntry []byte

+ PrefixPKIDToPublicKey []byte

+ PrefixPostHashSerialNumberBidNanosBidderPKID []byte

+ PrefixPostHashSerialNumberToAcceptedBidEntries []byte

+ PrefixPostHashSerialNumberToNFTEntry []byte

+ PrefixPostHashToPostEntry []byte

+ PrefixPosterPublicKeyPostHash []byte

+ PrefixPosterPublicKeyTimestampPostHash []byte

+ PrefixProfileUsernameToPKID []byte

+ PrefixPubKeyUtxoKey []byte

+ PrefixPublicKeyBlockHashToBlockReward []byte

+ PrefixPublicKeyIndexToTransactionIDs []byte

+ PrefixPublicKeyTimestampToPrivateMessage []byte

+ PrefixPublicKeyToDeSoBalanceNanos []byte

+ PrefixPublicKeyToNextIndex []byte

+ PrefixPublicKeyToPKID []byte

+ PrefixRepostedPostHashReposterPubKey []byte

+ PrefixRepostedPostHashReposterPubKeyRepostPostHash []byte

+ PrefixReposterPubKeyRepostedPostHashToRepostPostHash []byte

+ PrefixStakeIDTypeAmountStakeIDIndex []byte

+ PrefixTransactionIDToMetadata []byte

+ PrefixTransactionIndexTip []byte

+ PrefixTstampNanosPostHash []byte

+ PrefixUSDCentsPerBitcoinExchangeRate []byte

+ PrefixUtxoKeyToUtxoEntry []byte

+ PrefixUtxoNumEntries []byte

+ func GetPrefixes() *DBPrefixes

+ type DBStatePrefixes struct

+ Prefixes *DBPrefixes

+ StatePrefixesList [][]byte

+ StatePrefixesMap map[byte]bool

+ TxIndexPrefixes [][]byte

+ func GetStatePrefixes() *DBStatePrefixes

+ type DeSoEncoder interface

+ GetEncoderType func() EncoderType

+ GetVersionByte func(blockHeight uint64) byte

+ RawDecodeWithoutMetadata func(blockHeight uint64, rr *bytes.Reader) error

+ RawEncodeWithoutMetadata func(blockHeight uint64, skipMetadata ...bool) []byte

+ func StateKeyToDeSoEncoder(key []byte) (_isEncoder bool, _encoder DeSoEncoder)

+ func StatePrefixToDeSoEncoder(prefix []byte) (_isEncoder bool, _encoder DeSoEncoder)

type DeSoOutput

+ func (desoOutput *DeSoOutput) GetEncoderType() EncoderType

+ func (desoOutput *DeSoOutput) GetVersionByte(blockHeight uint64) byte

+ func (desoOutput *DeSoOutput) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (desoOutput *DeSoOutput) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type DeSoParams

+ EncoderMigrationHeights *EncoderMigrationHeights

+ EncoderMigrationHeightsList []*MigrationHeight

type DerivedKeyEntry

+ func (key *DerivedKeyEntry) GetEncoderType() EncoderType

+ func (key *DerivedKeyEntry) GetVersionByte(blockHeight uint64) byte

+ func (key *DerivedKeyEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (key *DerivedKeyEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type DiamondEntry

+ func (de *DiamondEntry) GetEncoderType() EncoderType

+ func (de *DiamondEntry) GetVersionByte(blockHeight uint64) byte

+ func (de *DiamondEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (de *DiamondEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

+ type EncoderMigration struct

+ func (migration *EncoderMigration) CleanupMigrations(blockHeight uint64)

+ func (migration *EncoderMigration) GetMigrationChecksumAtBlockheight(blockHeight uint64) *StateChecksum

+ func (migration *EncoderMigration) Initialize(mainDb *badger.DB, snapshotDb *badger.DB, snapshotDbMutex *sync.Mutex, ...) error

+ func (migration *EncoderMigration) InitializeSingleHeight(mainDb *badger.DB, snapshotDb *badger.DB, snapshotDbMutex *sync.Mutex, ...)

+ func (migration *EncoderMigration) ResetChecksums()

+ func (migration *EncoderMigration) SaveMigrations() error

+ func (migration *EncoderMigration) StartMigrations() error

+ type EncoderMigrationChecksum struct

+ BlockHeight uint64

+ Checksum *StateChecksum

+ Completed bool

+ Version byte

+ type EncoderMigrationHeights struct

+ DefaultMigration MigrationHeight

+ func GetEncoderMigrationHeights(forkHeights *ForkHeights) *EncoderMigrationHeights

+ type EncoderType uint32

+ const EncoderTypeAcceptNFTBidTxindexMetadata

+ const EncoderTypeAcceptNFTTransferTxindexMetadata

+ const EncoderTypeAffectedPublicKey

+ const EncoderTypeBalanceEntry

+ const EncoderTypeBasicTransferTxindexMetadata

+ const EncoderTypeBitcoinExchangeTxindexMetadata

+ const EncoderTypeBlockHash

+ const EncoderTypeBurnNFTTxindexMetadata

+ const EncoderTypeCoinEntry

+ const EncoderTypeCreateNFTTxindexMetadata

+ const EncoderTypeCreatorCoinTransferTxindexMetadata

+ const EncoderTypeCreatorCoinTxindexMetadata

+ const EncoderTypeDAOCoinLimitOrderEntry

+ const EncoderTypeDAOCoinLimitOrderTxindexMetadata

+ const EncoderTypeDAOCoinTransferTxindexMetadata

+ const EncoderTypeDAOCoinTxindexMetadata

+ const EncoderTypeDeSoOutput

+ const EncoderTypeDerivedKeyEntry

+ const EncoderTypeDiamondEntry

+ const EncoderTypeEndBlockView

+ const EncoderTypeEndTxIndex

+ const EncoderTypeFilledDAOCoinLimitOrder

+ const EncoderTypeFilledDAOCoinLimitOrderMetadata

+ const EncoderTypeFollowTxindexMetadata

+ const EncoderTypeForbiddenPubKeyEntry

+ const EncoderTypeGlobalParamsEntry

+ const EncoderTypeGroupKeyName

+ const EncoderTypeLikeEntry

+ const EncoderTypeLikeTxindexMetadata

+ const EncoderTypeMessageEntry

+ const EncoderTypeMessagingGroupEntry

+ const EncoderTypeMessagingGroupMember

+ const EncoderTypeNFTBidEntry

+ const EncoderTypeNFTBidEntryBundle

+ const EncoderTypeNFTBidTxindexMetadata

+ const EncoderTypeNFTEntry

+ const EncoderTypeNFTRoyaltiesMetadata

+ const EncoderTypeNFTTransferTxindexMetadata

+ const EncoderTypePKID

+ const EncoderTypePKIDEntry

+ const EncoderTypePostEntry

+ const EncoderTypePrivateMessageTxindexMetadata

+ const EncoderTypeProfileEntry

+ const EncoderTypePublicKey

+ const EncoderTypePublicKeyRoyaltyPair

+ const EncoderTypeRepostEntry

+ const EncoderTypeSubmitPostTxindexMetadata

+ const EncoderTypeSwapIdentityTxindexMetadata

+ const EncoderTypeTransactionMetadata

+ const EncoderTypeUpdateNFTTxindexMetadata

+ const EncoderTypeUpdateProfileTxindexMetadata

+ const EncoderTypeUtxoEntry

+ const EncoderTypeUtxoKey

+ const EncoderTypeUtxoOperation

+ const EncoderTypeUtxoOperationBundle

+ func (encoderType EncoderType) New() DeSoEncoder

type EventManager

+ func (em *EventManager) OnSnapshotCompleted(handler SnapshotCompletedEventFunc)

type FilledDAOCoinLimitOrder

+ func (order *FilledDAOCoinLimitOrder) GetEncoderType() EncoderType

+ func (order *FilledDAOCoinLimitOrder) GetVersionByte(blockHeight uint64) byte

+ func (order *FilledDAOCoinLimitOrder) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (order *FilledDAOCoinLimitOrder) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type FilledDAOCoinLimitOrderMetadata

+ func (orderMeta *FilledDAOCoinLimitOrderMetadata) GetEncoderType() EncoderType

+ func (orderMeta *FilledDAOCoinLimitOrderMetadata) GetVersionByte(blockHeight uint64) byte

+ func (orderMeta *FilledDAOCoinLimitOrderMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (orderMeta *FilledDAOCoinLimitOrderMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type FollowTxindexMetadata

+ func (txnMeta *FollowTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *FollowTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *FollowTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *FollowTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type ForbiddenPubKeyEntry

+ func (entry *ForbiddenPubKeyEntry) GetEncoderType() EncoderType

+ func (entry *ForbiddenPubKeyEntry) GetVersionByte(blockHeight uint64) byte

+ func (entry *ForbiddenPubKeyEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (entry *ForbiddenPubKeyEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type ForkHeights

+ DefaultHeight uint64

type GlobalParamsEntry

+ func (gp *GlobalParamsEntry) GetEncoderType() EncoderType

+ func (gp *GlobalParamsEntry) GetVersionByte(blockHeight uint64) byte

+ func (gp *GlobalParamsEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (gp *GlobalParamsEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type GroupKeyName

+ func (name *GroupKeyName) GetEncoderType() EncoderType

+ func (name *GroupKeyName) GetVersionByte(blockHeight uint64) byte

+ func (name *GroupKeyName) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (name *GroupKeyName) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type LikeEntry

+ func (likeEntry *LikeEntry) GetEncoderType() EncoderType

+ func (likeEntry *LikeEntry) GetVersionByte(blockHeight uint64) byte

+ func (likeEntry *LikeEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (likeEntry *LikeEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type LikeTxindexMetadata

+ func (txnMeta *LikeTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *LikeTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *LikeTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *LikeTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type MessageEntry

+ func (message *MessageEntry) GetEncoderType() EncoderType

+ func (message *MessageEntry) GetVersionByte(blockHeight uint64) byte

+ func (message *MessageEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (message *MessageEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type MessagingGroupEntry

+ func (entry *MessagingGroupEntry) GetEncoderType() EncoderType

+ func (entry *MessagingGroupEntry) GetVersionByte(blockHeight uint64) byte

+ func (entry *MessagingGroupEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (entry *MessagingGroupEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type MessagingGroupMember

+ func (rec *MessagingGroupMember) FromBytes(rr *bytes.Reader) error

+ func (rec *MessagingGroupMember) GetEncoderType() EncoderType

+ func (rec *MessagingGroupMember) GetVersionByte(blockHeight uint64) byte

+ func (rec *MessagingGroupMember) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (rec *MessagingGroupMember) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

+ func (rec *MessagingGroupMember) ToBytes() []byte

+ type MigrationHeight struct

+ Height uint64

+ Name MigrationName

+ Version byte

+ func GetEncoderMigrationHeightsList(forkHeights *ForkHeights) (_migrationHeightsList []*MigrationHeight)

+ type MigrationName string

+ const DefaultMigration

+ type MsgDeSoGetSnapshot struct

+ SnapshotStartKey []byte

+ func (msg *MsgDeSoGetSnapshot) FromBytes(data []byte) error

+ func (msg *MsgDeSoGetSnapshot) GetMsgType() MsgType

+ func (msg *MsgDeSoGetSnapshot) GetPrefix() []byte

+ func (msg *MsgDeSoGetSnapshot) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoSnapshotData struct

+ Prefix []byte

+ SnapshotChunk []*DBEntry

+ SnapshotChunkFull bool

+ SnapshotMetadata *SnapshotEpochMetadata

+ func (msg *MsgDeSoSnapshotData) FromBytes(data []byte) error

+ func (msg *MsgDeSoSnapshotData) GetMsgType() MsgType

+ func (msg *MsgDeSoSnapshotData) ToBytes(preSignature bool) ([]byte, error)

type MsgType

+ const MsgTypeGetSnapshot

+ const MsgTypeSnapshotData

type NFTBidEntry

+ func (be *NFTBidEntry) GetEncoderType() EncoderType

+ func (be *NFTBidEntry) GetVersionByte(blockHeight uint64) byte

+ func (be *NFTBidEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (be *NFTBidEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

+ type NFTBidEntryBundle struct

+ func (bundle *NFTBidEntryBundle) GetEncoderType() EncoderType

+ func (bundle *NFTBidEntryBundle) GetVersionByte(blockHeight uint64) byte

+ func (bundle *NFTBidEntryBundle) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (bundle *NFTBidEntryBundle) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type NFTBidTxindexMetadata

+ NFTRoyaltiesMetadata *NFTRoyaltiesMetadata

+ func (txnMeta *NFTBidTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *NFTBidTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *NFTBidTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *NFTBidTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type NFTEntry

+ func (nft *NFTEntry) GetEncoderType() EncoderType

+ func (nft *NFTEntry) GetVersionByte(blockHeight uint64) byte

+ func (nft *NFTEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (nft *NFTEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type NFTRoyaltiesMetadata

+ func (txnMeta *NFTRoyaltiesMetadata) GetEncoderType() EncoderType

+ func (txnMeta *NFTRoyaltiesMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *NFTRoyaltiesMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *NFTRoyaltiesMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type NFTTransferTxindexMetadata

+ func (txnMeta *NFTTransferTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *NFTTransferTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *NFTTransferTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *NFTTransferTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

+ type NodeMessage uint32

+ const NodeErase

+ const NodeRestart

type PKID

+ func (pkid *PKID) FromBytes(rr *bytes.Reader) error

+ func (pkid *PKID) GetEncoderType() EncoderType

+ func (pkid *PKID) GetVersionByte(blockHeight uint64) byte

+ func (pkid *PKID) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (pkid *PKID) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

+ func (pkid *PKID) ToString() string

type PKIDEntry

+ func (pkid *PKIDEntry) GetEncoderType() EncoderType

+ func (pkid *PKIDEntry) GetVersionByte(blockHeight uint64) byte

+ func (pkid *PKIDEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (pkid *PKIDEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type Peer

+ Conn net.Conn

+ TimeConnected time.Time

+ TimeOffsetSecs int64

+ VersionNegotiated bool

+ VersionNonceReceived uint64

+ VersionNonceSent uint64

+ func (pp *Peer) HandleGetSnapshot(msg *MsgDeSoGetSnapshot)

+ func (pp *Peer) HandlePingMsg(msg *MsgDeSoPing)

+ func (pp *Peer) HandlePongMsg(msg *MsgDeSoPong)

+ func (pp *Peer) PingHandler()

+ func (pp *Peer) ReadWithTimeout(readFunc func() error, readTimeout time.Duration) error

type PostEntry

+ func (pe *PostEntry) GetEncoderType() EncoderType

+ func (pe *PostEntry) GetVersionByte(blockHeight uint64) byte

+ func (pe *PostEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (pe *PostEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type PrivateMessageTxindexMetadata

+ func (txnMeta *PrivateMessageTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *PrivateMessageTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *PrivateMessageTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *PrivateMessageTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type ProfileEntry

+ func (pe *ProfileEntry) GetEncoderType() EncoderType

+ func (pe *ProfileEntry) GetVersionByte(blockHeight uint64) byte

+ func (pe *ProfileEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (pe *ProfileEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type PublicKey

+ func (publicKey *PublicKey) GetEncoderType() EncoderType

+ func (publicKey *PublicKey) GetVersionByte(blockHeight uint64) byte

+ func (publicKey *PublicKey) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (publicKey *PublicKey) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type PublicKeyRoyaltyPair

+ func (pair *PublicKeyRoyaltyPair) GetEncoderType() EncoderType

+ func (pair *PublicKeyRoyaltyPair) GetVersionByte(blockHeight uint64) byte

+ func (pair *PublicKeyRoyaltyPair) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (pair *PublicKeyRoyaltyPair) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type RepostEntry

+ func (re *RepostEntry) GetEncoderType() EncoderType

+ func (re *RepostEntry) GetVersionByte(blockHeight uint64) byte

+ func (re *RepostEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (re *RepostEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type RuleError

+ const RuleErrorBlockAlreadyExists

+ const RuleErrorDerivedKeyInvalidDAOCoinLimitOrderOrderID

type Server

+ DisableNetworking bool

+ HyperSyncProgress SyncProgress

+ IgnoreInboundPeerInvMessages bool

+ ReadOnlyMode bool

+ TxIndex *TXIndex

+ func (srv *Server) GetBlocksToStore(pp *Peer)

+ func (srv *Server) GetSnapshot(pp *Peer)

type ServiceFlag

+ const SFArchivalNode

+ const SFHyperSync

+ type Snapshot struct

+ AncestralFlushCounter uint64

+ AncestralMemory *lane.Deque

+ Checksum *StateChecksum

+ CurrentEpochSnapshotMetadata *SnapshotEpochMetadata

+ DatabaseCache lru.KVCache

+ ExitChannel chan bool

+ Migrations *EncoderMigration

+ OperationChannel *SnapshotOperationChannel

+ SnapshotBlockHeightPeriod uint64

+ SnapshotDb *badger.DB

+ SnapshotDbMutex *sync.Mutex

+ Status *SnapshotStatus

+ func NewSnapshot(mainDb *badger.DB, mainDbDirectory string, snapshotBlockHeightPeriod uint64, ...) (_snap *Snapshot, _err error, _shouldRestart bool)

+ func (snap *Snapshot) AddChecksumBytes(key []byte, value []byte)

+ func (snap *Snapshot) AncestralRecordToDBEntry(ancestralEntry *DBEntry) *DBEntry

+ func (snap *Snapshot) CheckAnceststralRecordExistenceByte(value []byte) bool

+ func (snap *Snapshot) DBSetAncestralRecordWithTxn(txn *badger.Txn, blockHeight uint64, keyBytes []byte, ...) error

+ func (snap *Snapshot) DeleteAncestralRecords(height uint64) error

+ func (snap *Snapshot) FinishProcessBlock(blockNode *BlockNode)

+ func (snap *Snapshot) FlushAncestralRecords()

+ func (snap *Snapshot) ForceResetToLastSnapshot(chain *Blockchain) error

+ func (snap *Snapshot) GetAncestralRecordsKey(key []byte, blockHeight uint64) []byte

+ func (snap *Snapshot) GetAncestralRecordsKeyWithTxn(txn *badger.Txn, key []byte, blockHeight uint64) (_record *badger.Item, _err error)

+ func (snap *Snapshot) GetSnapshotChunk(mainDb *badger.DB, prefix []byte, startKey []byte) (_snapshotEntriesBatch []*DBEntry, _snapshotEntriesFilled bool, ...)

+ func (snap *Snapshot) PrepareAncestralRecord(key string, value []byte, existed bool) error

+ func (snap *Snapshot) PrepareAncestralRecordsFlush()

+ func (snap *Snapshot) PrintChecksum(text string)

+ func (snap *Snapshot) ProcessSnapshotChunk(mainDb *badger.DB, mainDbMutex *deadlock.RWMutex, snapshotChunk []*DBEntry, ...)

+ func (snap *Snapshot) RemoveChecksumBytes(key []byte, value []byte)

+ func (snap *Snapshot) Run()

+ func (snap *Snapshot) SetSnapshotChunk(mainDb *badger.DB, mainDbMutex *deadlock.RWMutex, chunk []*DBEntry, ...) error

+ func (snap *Snapshot) SnapshotProcessBlock(blockNode *BlockNode)

+ func (snap *Snapshot) StartAncestralRecordsFlush(shouldIncrement bool)

+ func (snap *Snapshot) Stop()

+ func (snap *Snapshot) String() string

+ func (snap *Snapshot) WaitForAllOperationsToFinish()

+ type SnapshotCompletedEventFunc func()

+ type SnapshotEpochMetadata struct

+ CurrentEpochBlockHash *BlockHash

+ CurrentEpochChecksumBytes []byte

+ FirstSnapshotBlockHeight uint64

+ SnapshotBlockHeight uint64

+ func (metadata *SnapshotEpochMetadata) FromBytes(rr *bytes.Reader) error

+ func (metadata *SnapshotEpochMetadata) Initialize(snapshotDb *badger.DB, snapshotDbMutex *sync.Mutex) error

+ func (metadata *SnapshotEpochMetadata) ToBytes() []byte

+ type SnapshotOperation struct

+ type SnapshotOperationChannel struct

+ OperationChannel chan *SnapshotOperation

+ StateSemaphore int32

+ StateSemaphoreLock sync.Mutex

+ func (opChan *SnapshotOperationChannel) DequeueOperationStateless() *SnapshotOperation

+ func (opChan *SnapshotOperationChannel) EnqueueOperation(op *SnapshotOperation)

+ func (opChan *SnapshotOperationChannel) FinishOperation()

+ func (opChan *SnapshotOperationChannel) GetStatus() int32

+ func (opChan *SnapshotOperationChannel) Initialize(snapshotDb *badger.DB, snapshotDbMutex *sync.Mutex) error

+ func (opChan *SnapshotOperationChannel) SaveOperationChannel() error

+ type SnapshotOperationType uint8

+ const SnapshotOperationChecksumAdd

+ const SnapshotOperationChecksumPrint

+ const SnapshotOperationChecksumRemove

+ const SnapshotOperationExit

+ const SnapshotOperationFlush

+ const SnapshotOperationProcessBlock

+ const SnapshotOperationProcessChunk

+ type SnapshotStatus struct

+ AncestralDBSemaphore uint64

+ CurrentBlockHeight uint64

+ MainDBSemaphore uint64

+ MemoryLock sync.Mutex

+ func (status *SnapshotStatus) FromBytes(rr *bytes.Reader) error

+ func (status *SnapshotStatus) GetSemaphores() (_mainDbSemaphore uint64, _ancestralDBSemaphore uint64)

+ func (status *SnapshotStatus) IncrementAncestralDBSemaphoreMemoryLockRequired()

+ func (status *SnapshotStatus) IncrementMainDbSemaphoreMemoryLockRequired()

+ func (status *SnapshotStatus) Initialize(snapshotDb *badger.DB, snapshotDbMutex *sync.Mutex) error

+ func (status *SnapshotStatus) IsFlushing() bool

+ func (status *SnapshotStatus) IsFlushingToAncestralMemoryLockRequired() bool

+ func (status *SnapshotStatus) IsFlushingToMainDBMemoryLockRequired() bool

+ func (status *SnapshotStatus) IsFlushingWithoutLock() bool

+ func (status *SnapshotStatus) ReadStatus() error

+ func (status *SnapshotStatus) SaveStatus()

+ func (status *SnapshotStatus) ToBytes() []byte

+ type StateChecksum struct

+ func (sc *StateChecksum) AddBytes(bytes []byte) error

+ func (sc *StateChecksum) AddOrRemoveBytesWithMigrations(keyInput []byte, valueInput []byte, blockHeight uint64, ...) error

+ func (sc *StateChecksum) AddToChecksum(elem group.Element)

+ func (sc *StateChecksum) FromBytes(checksumBytes []byte) error

+ func (sc *StateChecksum) GetChecksum() (group.Element, error)

+ func (sc *StateChecksum) HashToCurve(bytes []byte) group.Element

+ func (sc *StateChecksum) Initialize(snapshotDb *badger.DB, snapshotDbMutex *sync.Mutex) error

+ func (sc *StateChecksum) RemoveBytes(bytes []byte) error

+ func (sc *StateChecksum) ResetChecksum()

+ func (sc *StateChecksum) SaveChecksum() error

+ func (sc *StateChecksum) ToBytes() ([]byte, error)

+ func (sc *StateChecksum) Wait() error

type SubmitPostTxindexMetadata

+ func (txnMeta *SubmitPostTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *SubmitPostTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *SubmitPostTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *SubmitPostTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type SwapIdentityTxindexMetadata

+ func (txnMeta *SwapIdentityTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *SwapIdentityTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *SwapIdentityTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *SwapIdentityTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

+ type SyncPrefixProgress struct

+ Completed bool

+ LastReceivedKey []byte

+ Prefix []byte

+ PrefixSyncPeer *Peer

+ type SyncProgress struct

+ Completed bool

+ PrefixProgress []*SyncPrefixProgress

+ SnapshotMetadata *SnapshotEpochMetadata

+ func (progress *SyncProgress) PrintLoop()

type SyncState

+ const SyncStateSyncingHistoricalBlocks

+ const SyncStateSyncingSnapshot

type TXIndex

+ func (txi *TXIndex) FinishedSyncing() bool

+ type Timer struct

+ func (t *Timer) End(eventName string)

+ func (t *Timer) Initialize()

+ func (t *Timer) Print(eventName string)

+ func (t *Timer) Start(eventName string)

type TransactionMetadata

+ func (txnMeta *TransactionMetadata) GetEncoderType() EncoderType

+ func (txnMeta *TransactionMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *TransactionMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *TransactionMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type UpdateNFTTxindexMetadata

+ func (txnMeta *UpdateNFTTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *UpdateNFTTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *UpdateNFTTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *UpdateNFTTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type UpdateProfileTxindexMetadata

+ func (txnMeta *UpdateProfileTxindexMetadata) GetEncoderType() EncoderType

+ func (txnMeta *UpdateProfileTxindexMetadata) GetVersionByte(blockHeight uint64) byte

+ func (txnMeta *UpdateProfileTxindexMetadata) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (txnMeta *UpdateProfileTxindexMetadata) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type UtxoEntry

+ func (utxo *UtxoEntry) GetEncoderType() EncoderType

+ func (utxo *UtxoEntry) GetVersionByte(blockHeight uint64) byte

+ func (utxo *UtxoEntry) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (utxo *UtxoEntry) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type UtxoKey

+ func (utxoKey *UtxoKey) GetEncoderType() EncoderType

+ func (utxoKey *UtxoKey) GetVersionByte(blockHeight uint64) byte

+ func (utxoKey *UtxoKey) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (utxoKey *UtxoKey) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type UtxoOperation

+ func (op *UtxoOperation) GetEncoderType() EncoderType

+ func (op *UtxoOperation) GetVersionByte(blockHeight uint64) byte

+ func (op *UtxoOperation) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (op *UtxoOperation) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

+ type UtxoOperationBundle struct

+ UtxoOpBundle [][]*UtxoOperation

+ func (opBundle *UtxoOperationBundle) GetEncoderType() EncoderType

+ func (opBundle *UtxoOperationBundle) GetVersionByte(blockHeight uint64) byte

+ func (opBundle *UtxoOperationBundle) RawDecodeWithoutMetadata(blockHeight uint64, rr *bytes.Reader) error

+ func (opBundle *UtxoOperationBundle) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte

type UtxoView

+ Snapshot *Snapshot

v2.1.2

Apr 27, 2022

Changes in this version

type DAOCoinLimitOrderEntry

+ FillType DAOCoinLimitOrderFillType

+ func (order *DAOCoinLimitOrderEntry) IsMarketOrder() bool

+ type DAOCoinLimitOrderFillType uint8

+ const DAOCoinLimitOrderFillTypeFillOrKill

+ const DAOCoinLimitOrderFillTypeGoodTillCancelled

+ const DAOCoinLimitOrderFillTypeImmediateOrCancel

type DAOCoinLimitOrderMetadata

+ FillType DAOCoinLimitOrderFillType

type PGDAOCoinLimitOrder

+ FillType uint8

type PGMetadataDAOCoinLimitOrder

+ FillType uint8

type RuleError

+ const RuleErrorDAOCoinLimitOrderFillOrKillOrderUnfulfilled

+ const RuleErrorDAOCoinLimitOrderInvalidFillType

+ const RuleErrorDAOCoinLimitOrderInvalidTransactorPKID

type UtxoView

+ func (bav *UtxoView) IsValidDAOCoinLimitOrderMetadata(transactorPK []byte, metadata *DAOCoinLimitOrderMetadata) error

v2.1.1

Apr 21, 2022

Changes in this version

+ const DerivedKeyMemoKey

+ const TransactionSpendingLimitKey

+ var BaseUnitsPerCoin = uint256.FromHex("0xde0b6b3a7640000")

+ var MaxPKID = PKID

+ var OneE38 = uint256.FromHex("0x4b3b4ca85a86c47a098a224000000000")

+ var ZeroBlockHash = BlockHash

+ var ZeroPKID = PKID

+ var ZeroPublicKey = PublicKey

+ func CalculateScaledExchangeRate(price float64) (*uint256.Int, error)

+ func CalculateScaledExchangeRateFromString(priceStr string) (*uint256.Int, error)

+ func ComputeBaseUnitsToBuyUint256(scaledExchangeRateCoinsToSellPerCoinToBuy *uint256.Int, ...) (*uint256.Int, error)

+ func ComputeBaseUnitsToSellUint256(scaledExchangeRateCoinsToSellPerCoinToBuy *uint256.Int, ...) (*uint256.Int, error)

+ func DBDeleteDAOCoinLimitOrderWithTxn(txn *badger.Txn, order *DAOCoinLimitOrderEntry) error

+ func DBKeyForDAOCoinLimitOrder(order *DAOCoinLimitOrderEntry) []byte

+ func DBKeyForDAOCoinLimitOrderByOrderID(order *DAOCoinLimitOrderEntry) []byte

+ func DBKeyForDAOCoinLimitOrderByTransactorPKID(order *DAOCoinLimitOrderEntry) []byte

+ func DBPrefixKeyForDAOCoinLimitOrder(order *DAOCoinLimitOrderEntry) []byte

+ func DBPutDAOCoinLimitOrderWithTxn(txn *badger.Txn, order *DAOCoinLimitOrderEntry) error

+ func DecodeExtraData(rr io.Reader) (map[string][]byte, error)

+ func EncodeExtraData(extraData map[string][]byte) []byte

+ func EncodeOptionalBlockHash(val *BlockHash) []byte

+ func EncodeOptionalPublicKey(val *PublicKey) []byte

+ func EncodeOptionalUint256(val *uint256.Int) []byte

+ func EncodeUint256(val *uint256.Int) []byte

+ func HexToUint256(input string) *uint256.Int

+ func IsDerivedSignature(txn *MsgDeSoTxn) (_derivedPkBytes []byte, _isDerived bool)

+ func LeftPaddedHexToUint256(input string) *uint256.Int

+ func ParsePostgresURI(pgURI string) *pg.Options

+ func ReadOptionalUint256(rr *bytes.Reader) (*uint256.Int, error)

+ func ReadUint256(rr io.Reader) (*uint256.Int, error)

+ func SafeUint256() *_SafeUint256

+ func SafeUint64() *_SafeUint64

+ func Uint256ToLeftPaddedHex(input *uint256.Int) string

type BalanceEntry

+ func (entry *BalanceEntry) Copy() *BalanceEntry

type BlockHash

+ func ReadBlockHash(rr io.Reader) (*BlockHash, error)

+ func ReadOptionalBlockHash(rr *bytes.Reader) (*BlockHash, error)

type Blockchain

+ func (bc *Blockchain) CreateDAOCoinLimitOrderTxn(UpdaterPublicKey []byte, metadata *DAOCoinLimitOrderMetadata, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ type CreatorCoinLimitOperation uint8

+ const AnyCreatorCoinOperation

+ const BuyCreatorCoinOperation

+ const SellCreatorCoinOperation

+ const TransferCreatorCoinOperation

+ const UndefinedCreatorCoinOperation

+ func (creatorCoinLimitOperation CreatorCoinLimitOperation) IsUndefined() bool

+ func (creatorCoinLimitOperation CreatorCoinLimitOperation) ToCreatorCoinLimitOperationString() CreatorCoinLimitOperationString

+ func (creatorCoinLimitOperation CreatorCoinLimitOperation) ToString() string

+ type CreatorCoinLimitOperationString string

+ const AnyCreatorCoinOperationString

+ const BuyCreatorCoinOperationString

+ const SellCreatorCoinOperationString

+ const TransferCreatorCoinOperationString

+ const UndefinedCreatorCoinOperationString

+ func (creatorCoinLimitOperationString CreatorCoinLimitOperationString) ToCreatorCoinLimitOperation() CreatorCoinLimitOperation

+ type CreatorCoinOperationLimitKey struct

+ CreatorPKID PKID

+ Operation CreatorCoinLimitOperation

+ func MakeCreatorCoinOperationLimitKey(creatorPKID PKID, operation CreatorCoinLimitOperation) CreatorCoinOperationLimitKey

+ func (creatorCoinOperationLimitKey *CreatorCoinOperationLimitKey) Decode(rr *bytes.Reader) error

+ func (creatorCoinOperationLimitKey CreatorCoinOperationLimitKey) Encode() []byte

+ type DAOCoinLimitOperation uint8

+ const AnyDAOCoinOperation

+ const BurnDAOCoinOperation

+ const DisableMintingDAOCoinOperation

+ const MintDAOCoinOperation

+ const TransferDAOCoinOperation

+ const UndefinedDAOCoinOperation

+ const UpdateTransferRestrictionStatusDAOCoinOperation

+ func (daoCoinLimitOperation DAOCoinLimitOperation) IsUndefined() bool

+ func (daoCoinLimitOperation DAOCoinLimitOperation) ToDAOCoinLimitOperationString() DAOCoinLimitOperationString

+ func (daoCoinLimitOperation DAOCoinLimitOperation) ToString() string

+ type DAOCoinLimitOperationString string

+ const AnyDAOCoinOperationString

+ const BurnDAOCoinOperationString

+ const DisableMintingDAOCoinOperationString

+ const MintDAOCoinOperationString

+ const TransferDAOCoinOperationString

+ const UndefinedDAOCoinOperationString

+ const UpdateTransferRestrictionStatusDAOCoinOperationString

+ func (daoCoinLimitOperationString DAOCoinLimitOperationString) ToDAOCoinLimitOperation() DAOCoinLimitOperation

+ type DAOCoinLimitOrderEntry struct

+ BlockHeight uint32

+ BuyingDAOCoinCreatorPKID *PKID

+ OperationType DAOCoinLimitOrderOperationType

+ OrderID *BlockHash

+ QuantityToFillInBaseUnits *uint256.Int

+ ScaledExchangeRateCoinsToSellPerCoinToBuy *uint256.Int

+ SellingDAOCoinCreatorPKID *PKID

+ TransactorPKID *PKID

+ func DBGetAllDAOCoinLimitOrders(handle *badger.DB) ([]*DAOCoinLimitOrderEntry, error)

+ func DBGetAllDAOCoinLimitOrdersForThisDAOCoinPair(handle *badger.DB, buyingDAOCoinCreatorPKID *PKID, ...) ([]*DAOCoinLimitOrderEntry, error)

+ func DBGetAllDAOCoinLimitOrdersForThisTransactor(handle *badger.DB, transactorPKID *PKID) ([]*DAOCoinLimitOrderEntry, error)

+ func DBGetDAOCoinLimitOrder(handle *badger.DB, orderID *BlockHash) (*DAOCoinLimitOrderEntry, error)

+ func DBGetDAOCoinLimitOrderWithTxn(txn *badger.Txn, orderID *BlockHash) (*DAOCoinLimitOrderEntry, error)

+ func DBGetMatchingDAOCoinLimitOrders(txn *badger.Txn, inputOrder *DAOCoinLimitOrderEntry, ...) ([]*DAOCoinLimitOrderEntry, error)

+ func (order *DAOCoinLimitOrderEntry) BaseUnitsToBuyUint256() (*uint256.Int, error)

+ func (order *DAOCoinLimitOrderEntry) BaseUnitsToSellUint256() (*uint256.Int, error)

+ func (order *DAOCoinLimitOrderEntry) Copy() *DAOCoinLimitOrderEntry

+ func (order *DAOCoinLimitOrderEntry) FromBytes(data []byte) error

+ func (order *DAOCoinLimitOrderEntry) IsBetterMatchingOrderThan(other *DAOCoinLimitOrderEntry) bool

+ func (order *DAOCoinLimitOrderEntry) IsValidMatchingOrderPrice(matchingOrder *DAOCoinLimitOrderEntry) bool

+ func (order *DAOCoinLimitOrderEntry) ToBytes() ([]byte, error)

+ func (order *DAOCoinLimitOrderEntry) ToMapKey() DAOCoinLimitOrderMapKey

+ type DAOCoinLimitOrderLimitKey struct

+ BuyingDAOCoinCreatorPKID PKID

+ SellingDAOCoinCreatorPKID PKID

+ func MakeDAOCoinLimitOrderLimitKey(buyingDAOCoinCreatorPKID PKID, sellingDAOCoinCreatorPKID PKID) DAOCoinLimitOrderLimitKey

+ func (daoCoinLimitOrderLimitKey *DAOCoinLimitOrderLimitKey) Decode(rr *bytes.Reader) error

+ func (daoCoinLimitOrderLimitKey DAOCoinLimitOrderLimitKey) Encode() []byte

+ type DAOCoinLimitOrderMapKey struct

+ OrderID BlockHash

+ type DAOCoinLimitOrderMetadata struct

+ BidderInputs []*DeSoInputsByTransactor

+ BuyingDAOCoinCreatorPublicKey *PublicKey

+ CancelOrderID *BlockHash

+ FeeNanos uint64

+ OperationType DAOCoinLimitOrderOperationType

+ QuantityToFillInBaseUnits *uint256.Int

+ ScaledExchangeRateCoinsToSellPerCoinToBuy *uint256.Int

+ SellingDAOCoinCreatorPublicKey *PublicKey

+ func (txnData *DAOCoinLimitOrderMetadata) FromBytes(data []byte) error

+ func (txnData *DAOCoinLimitOrderMetadata) GetTxnType() TxnType

+ func (txnData *DAOCoinLimitOrderMetadata) New() DeSoTxnMetadata

+ func (txnData *DAOCoinLimitOrderMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type DAOCoinLimitOrderOperationType uint64

+ const DAOCoinLimitOrderOperationTypeASK

+ const DAOCoinLimitOrderOperationTypeBID

+ type DAOCoinLimitOrderTxindexMetadata struct

+ BuyingDAOCoinCreatorPublicKey string

+ FilledDAOCoinLimitOrdersMetadata []*FilledDAOCoinLimitOrderMetadata

+ QuantityToFillInBaseUnits *uint256.Int

+ ScaledExchangeRateCoinsToSellPerCoinToBuy *uint256.Int

+ SellingDAOCoinCreatorPublicKey string

+ type DAOCoinOperationLimitKey struct

+ CreatorPKID PKID

+ Operation DAOCoinLimitOperation

+ func MakeDAOCoinOperationLimitKey(creatorPKID PKID, operation DAOCoinLimitOperation) DAOCoinOperationLimitKey

+ func (daoCoinOperationLimitKey *DAOCoinOperationLimitKey) Decode(rr *bytes.Reader) error

+ func (daoCoinOperationLimitKey DAOCoinOperationLimitKey) Encode() []byte

+ type DbAdapter struct

+ func (adapter *DbAdapter) GetAllDAOCoinLimitOrders() ([]*DAOCoinLimitOrderEntry, error)

+ func (adapter *DbAdapter) GetAllDAOCoinLimitOrdersForThisDAOCoinPair(buyingDAOCoinCreatorPKID *PKID, sellingDAOCoinCreatorPKID *PKID) ([]*DAOCoinLimitOrderEntry, error)

+ func (adapter *DbAdapter) GetAllDAOCoinLimitOrdersForThisTransactor(transactorPKID *PKID) ([]*DAOCoinLimitOrderEntry, error)

+ func (adapter *DbAdapter) GetBalanceEntry(holder *PKID, creator *PKID, isDAOCoin bool) *BalanceEntry

+ func (adapter *DbAdapter) GetDAOCoinLimitOrder(orderID *BlockHash) (*DAOCoinLimitOrderEntry, error)

+ func (adapter *DbAdapter) GetMatchingDAOCoinLimitOrders(inputOrder *DAOCoinLimitOrderEntry, lastSeenOrder *DAOCoinLimitOrderEntry) ([]*DAOCoinLimitOrderEntry, error)

+ func (adapter *DbAdapter) GetPKIDForPublicKey(pkBytes []byte) *PKID

+ type DeSoInputsByTransactor struct

+ Inputs []*DeSoInput

+ TransactorPublicKey *PublicKey

type DerivedKeyEntry

+ ExtraData map[string][]byte

+ Memo []byte

+ TransactionSpendingLimitTracker *TransactionSpendingLimit

+ func (dk *DerivedKeyEntry) Copy() *DerivedKeyEntry

+ type FilledDAOCoinLimitOrder struct

+ BuyingDAOCoinCreatorPKID *PKID

+ CoinQuantityInBaseUnitsBought *uint256.Int

+ CoinQuantityInBaseUnitsSold *uint256.Int

+ IsFulfilled bool

+ OrderID *BlockHash

+ SellingDAOCoinCreatorPKID *PKID

+ TransactorPKID *PKID

+ type FilledDAOCoinLimitOrderMetadata struct

+ BuyingDAOCoinCreatorPublicKey string

+ CoinQuantityInBaseUnitsBought *uint256.Int

+ CoinQuantityInBaseUnitsSold *uint256.Int

+ IsFulfilled bool

+ SellingDAOCoinCreatorPublicKey string

+ TransactorPublicKeyBase58Check string

type ForkHeights

+ DAOCoinLimitOrderBlockHeight uint32

+ DerivedKeySetSpendingLimitsBlockHeight uint32

+ DerivedKeyTrackSpendingLimitsBlockHeight uint32

+ ExtraDataOnEntriesBlockHeight uint32

type MessageEntry

+ ExtraData map[string][]byte

type MessagingGroupEntry

+ ExtraData map[string][]byte

type NFTEntry

+ ExtraData map[string][]byte

+ type NFTLimitOperation uint8

+ const AcceptNFTBidOperation

+ const AcceptNFTTransferOperation

+ const AnyNFTOperation

+ const BurnNFTOperation

+ const NFTBidOperation

+ const TransferNFTOperation

+ const UndefinedNFTOperation

+ const UpdateNFTOperation

+ func (nftLimitOperation NFTLimitOperation) IsUndefined() bool

+ func (nftLimitOperation NFTLimitOperation) ToNFTLimitOperationString() NFTLimitOperationString

+ func (nftLimitOperation NFTLimitOperation) ToString() string

+ type NFTLimitOperationString string

+ const AcceptNFTBidOperationString

+ const AcceptNFTTransferOperationString

+ const AnyNFTOperationString

+ const BurnNFTOperationString

+ const NFTBidOperationString

+ const TransferNFTOperationString

+ const UndefinedNFTOperationString

+ const UpdateNFTOperationString

+ func (nftLimitOperationString NFTLimitOperationString) ToNFTLimitOperation() NFTLimitOperation

+ type NFTOperationLimitKey struct

+ BlockHash BlockHash

+ Operation NFTLimitOperation

+ SerialNumber uint64

+ func MakeNFTOperationLimitKey(blockHash BlockHash, serialNumber uint64, operation NFTLimitOperation) NFTOperationLimitKey

+ func (nftOperationLimitKey *NFTOperationLimitKey) Decode(rr *bytes.Reader) error

+ func (nftOperationLimitKey NFTOperationLimitKey) Encode() []byte

type OperationType

+ const OperationTypeDAOCoinLimitOrder

+ const OperationTypeSpendingLimitAccounting

+ type PGDAOCoinLimitOrder struct

+ BlockHeight uint32

+ BuyingDAOCoinCreatorPKID *PKID

+ OperationType uint32

+ OrderID *BlockHash

+ QuantityToFillInBaseUnits string

+ ScaledExchangeRateCoinsToSellPerCoinToBuy string

+ SellingDAOCoinCreatorPKID *PKID

+ TransactorPKID *PKID

+ func (order *PGDAOCoinLimitOrder) FromDAOCoinLimitOrderEntry(orderEntry *DAOCoinLimitOrderEntry)

+ func (order *PGDAOCoinLimitOrder) ToDAOCoinLimitOrderEntry() *DAOCoinLimitOrderEntry

type PGDerivedKey

+ ExtraData map[string][]byte

+ Memo []byte

+ TransactionSpendingLimitTracker *TransactionSpendingLimit

type PGMessage

+ ExtraData map[string][]byte

type PGMessagingGroup

+ ExtraData map[string][]byte

+ type PGMetadataDAOCoinLimitOrder struct

+ BidderInputs []*PGMetadataDAOCoinLimitOrderBidderInputs

+ BuyingDAOCoinCreatorPublicKey *PublicKey

+ CancelOrderID *BlockHash

+ FeeNanos uint64

+ OperationType uint64

+ QuantityToFillInBaseUnits string

+ ScaledExchangeRateCoinsToSellPerCoinToBuy string

+ SellingDAOCoinCreatorPublicKey *PublicKey

+ TransactionHash *BlockHash

+ type PGMetadataDAOCoinLimitOrderBidderInputs struct

+ InputHash *BlockHash

+ InputIndex uint32

+ TransactionHash *BlockHash

type PGNFT

+ ExtraData map[string][]byte

type PGProfile

+ ExtraData map[string][]byte

type PGTransaction

+ MetadataDAOCoinLimitOrder *PGMetadataDAOCoinLimitOrder

type PKID

+ func ReadPKID(rr io.Reader) (*PKID, error)

+ func SortPKIDs(pkids []PKID) []PKID

+ func (pkid *PKID) Encode() []byte

+ func (pkid *PKID) Eq(other *PKID) bool

+ func (pkid *PKID) IsZeroPKID() bool

type Postgres

+ func (postgres *Postgres) GetAllDAOCoinLimitOrders() ([]*DAOCoinLimitOrderEntry, error)

+ func (postgres *Postgres) GetAllDAOCoinLimitOrdersForThisDAOCoinPair(buyingDAOCoinCreatorPKID *PKID, sellingDAOCoinCreatorPKID *PKID) ([]*DAOCoinLimitOrderEntry, error)

+ func (postgres *Postgres) GetAllDAOCoinLimitOrdersForThisTransactor(transactorPKID *PKID) ([]*DAOCoinLimitOrderEntry, error)

+ func (postgres *Postgres) GetDAOCoinLimitOrder(orderID *BlockHash) (*DAOCoinLimitOrderEntry, error)

+ func (postgres *Postgres) GetMatchingDAOCoinLimitOrders(inputOrder *DAOCoinLimitOrderEntry, lastSeenOrder *DAOCoinLimitOrderEntry) ([]*DAOCoinLimitOrderEntry, error)

type ProfileEntry

+ ExtraData map[string][]byte

type PublicKey

+ func ReadOptionalPublicKey(rr *bytes.Reader) (*PublicKey, error)

+ func ReadPublicKey(rr io.Reader) (*PublicKey, error)

+ func (publicKey *PublicKey) IsZeroPublicKey() bool

type RuleError

+ const RuleErrorDAOCoinLimitOrderBalanceDeltasNonZero

+ const RuleErrorDAOCoinLimitOrderBalanceEntryDoesNotExist

+ const RuleErrorDAOCoinLimitOrderBeforeBlockHeight

+ const RuleErrorDAOCoinLimitOrderBidderInputNoLongerExists

+ const RuleErrorDAOCoinLimitOrderBuyingDAOCoinCreatorMissingProfile

+ const RuleErrorDAOCoinLimitOrderCannotBuyAndSellSameCoin

+ const RuleErrorDAOCoinLimitOrderFeeNanosBelowMinTxFee

+ const RuleErrorDAOCoinLimitOrderFeeNanosOverflow

+ const RuleErrorDAOCoinLimitOrderInsufficientDAOCoinsToOpenOrder

+ const RuleErrorDAOCoinLimitOrderInsufficientDESOToOpenOrder

+ const RuleErrorDAOCoinLimitOrderInvalidBuyingDAOCoinCreatorPKID

+ const RuleErrorDAOCoinLimitOrderInvalidExchangeRate

+ const RuleErrorDAOCoinLimitOrderInvalidOperationType

+ const RuleErrorDAOCoinLimitOrderInvalidOrderID

+ const RuleErrorDAOCoinLimitOrderInvalidQuantity

+ const RuleErrorDAOCoinLimitOrderInvalidSellingDAOCoinCreatorPKID

+ const RuleErrorDAOCoinLimitOrderMatchingOrderBuyingDifferentCoins

+ const RuleErrorDAOCoinLimitOrderMatchingOrderIsDeleted

+ const RuleErrorDAOCoinLimitOrderMatchingOrderSellingDifferentCoins

+ const RuleErrorDAOCoinLimitOrderMatchingOwnOrder

+ const RuleErrorDAOCoinLimitOrderOverflowsDAOCoin

+ const RuleErrorDAOCoinLimitOrderOverflowsDESO

+ const RuleErrorDAOCoinLimitOrderOverspendingDAOCoin

+ const RuleErrorDAOCoinLimitOrderOverspendingDESO

+ const RuleErrorDAOCoinLimitOrderSellingDAOCoinCreatorMissingProfile

+ const RuleErrorDAOCoinLimitOrderToCancelNotFound

+ const RuleErrorDAOCoinLimitOrderToCancelNotYours

+ const RuleErrorDAOCoinLimitOrderTotalCostIsLessThanOneNano

+ const RuleErrorDAOCoinLimitOrderTotalCostOverflowsUint256

+ const RuleErrorDAOCoinLimitOrderTotalCostOverflowsUint64

+ const RuleErrorDAOCoinLimitOrderTotalInputMinusTotalOutputNotEqualToFee

+ const RuleErrorDerivedKeyCreatorCoinOperationNotAuthorized

+ const RuleErrorDerivedKeyDAOCoinLimitOrderNotAuthorized

+ const RuleErrorDerivedKeyDAOCoinOperationNotAuthorized

+ const RuleErrorDerivedKeyInvalidCreatorCoinLimitOperation

+ const RuleErrorDerivedKeyInvalidDAOCoinLimitOperation

+ const RuleErrorDerivedKeyNFTOperationNotAuthorized

+ const RuleErrorDerivedKeyTxnSpendsMoreThanGlobalDESOLimit

+ const RuleErrorDerivedKeyTxnTypeNotAuthorized

type TransactionMetadata

+ DAOCoinLimitOrderTxindexMetadata *DAOCoinLimitOrderTxindexMetadata

+ type TransactionSpendingLimit struct

+ CreatorCoinOperationLimitMap map[CreatorCoinOperationLimitKey]uint64

+ DAOCoinLimitOrderLimitMap map[DAOCoinLimitOrderLimitKey]uint64

+ DAOCoinOperationLimitMap map[DAOCoinOperationLimitKey]uint64

+ GlobalDESOLimit uint64

+ NFTOperationLimitMap map[NFTOperationLimitKey]uint64

+ TransactionCountLimitMap map[TxnType]uint64

+ func (tsl *TransactionSpendingLimit) Copy() *TransactionSpendingLimit

+ func (tsl *TransactionSpendingLimit) FromBytes(data []byte) error

+ func (tsl *TransactionSpendingLimit) ToBytes() ([]byte, error)

type TxnString

+ const TxnStringDAOCoinLimitOrder

type TxnType

+ const TxnTypeDAOCoinLimitOrder

type UtxoOperation

+ FilledDAOCoinLimitOrders []*FilledDAOCoinLimitOrder

+ PrevBalanceEntries map[PKID]map[PKID]*BalanceEntry

+ PrevMatchingOrders []*DAOCoinLimitOrderEntry

+ PrevTransactorDAOCoinLimitOrderEntry *DAOCoinLimitOrderEntry

type UtxoType

+ const UtxoTypeDAOCoinLimitOrderPayout

type UtxoView

+ DAOCoinLimitOrderMapKeyToDAOCoinLimitOrderEntry map[DAOCoinLimitOrderMapKey]*DAOCoinLimitOrderEntry

+ func (bav *UtxoView) GetAllDAOCoinLimitOrdersForThisDAOCoinPair(buyingDAOCoinCreatorPKID *PKID, sellingDAOCoinCreatorPKID *PKID) ([]*DAOCoinLimitOrderEntry, error)

+ func (bav *UtxoView) GetAllDAOCoinLimitOrdersForThisTransactor(transactorPKID *PKID) ([]*DAOCoinLimitOrderEntry, error)

+ func (bav *UtxoView) GetDbAdapter() *DbAdapter

+ func (bav *UtxoView) IsValidDAOCoinLimitOrder(order *DAOCoinLimitOrderEntry) error

+ func (bav *UtxoView) IsValidDAOCoinLimitOrderMatch(transactorOrder *DAOCoinLimitOrderEntry, matchingOrder *DAOCoinLimitOrderEntry) error

v2.0.7

Mar 29, 2022

Changes in this version

+ const AddrRelayIntervalSeconds

+ const BlocksPerDay

+ const BlocksPerYear

+ const BuyNowPriceKey

+ const ChainTypeBitcoinHeader

+ const ChainTypeDeSoBlock

+ const CoinRoyaltiesMapKey

+ const ConfigDirAppName

+ const ConfigDirVendorName

+ const CreateNFTFeeNanosKey

+ const CreateProfileFeeNanosKey

+ const CurrentHeaderVersion

+ const DESORoyaltiesMapKey

+ const DerivedPublicKey

+ const DiamondLevelKey

+ const DiamondPostHashKey

+ const FloatPrecision

+ const ForbiddenBlockSignaturePubKeyKey

+ const HashSizeBytes

+ const HeaderVersion0

+ const HeaderVersion1

+ const IsQuotedRepostKey

+ const MAIN_CHAIN

+ const MaxAddrsPerAddrMsg

+ const MaxBlockIndexNodes

+ const MaxBlocksInFlight

+ const MaxCopiesPerNFTKey

+ const MaxCreateNFTFeeNanos

+ const MaxCreateProfileFeeNanos

+ const MaxDeSoInputSizeBytes

+ const MaxDeSoOutputSizeBytes

+ const MaxMaxCopiesPerNFT

+ const MaxMessagePayload

+ const MaxMessagingKeyNameCharacters

+ const MaxNanos

+ const MaxNetworkFeeNanosPerKBValue

+ const MaxOrphansInMemory

+ const MaxTotalTransactionSizeBytes

+ const MaxUSDCentsPerBitcoin

+ const MaxUnconnectedTransactions

+ const MaxUnconnectedTxSizeBytes

+ const MaxUsernameLengthBytes

+ const MaxVarintLen16

+ const MaxVarintLen32

+ const MaxVarintLen64

+ const MessagesToFetchPerInboxCall

+ const MessagesVersion1

+ const MessagesVersion2

+ const MessagesVersion3

+ const MessagesVersionString

+ const MessagingPublicKey

+ const MinCreateNFTFeeNanos

+ const MinCreateProfileFeeNanos

+ const MinMaxCopiesPerNFT

+ const MinMessagingKeyNameCharacters

+ const MinNanosToCreate

+ const MinNetworkFeeNanosPerKBKey

+ const MinNetworkFeeNanosPerKBValue

+ const MinUSDCentsPerBitcoin

+ const NanosPerUnit

+ const NodeSourceMapKey

+ const RebroadcastNodeAddrIntervalMinutes

+ const RecipientMessagingGroupKeyName

+ const RecipientMessagingPublicKey

+ const RepostedPostHash

+ const SECURE_MIDDLEWARE_RESTRICTIVE_CONTENT_SECURITY_POLICY

+ const SatoshisPerBitcoin

+ const SecondsIn3Days

+ const SecondsIn4Days

+ const SenderMessagingGroupKeyName

+ const SenderMessagingPublicKey

+ const StartDeSoPriceUSDCents

+ const StatusBitcoinHeaderValidateFailed

+ const StatusBitcoinHeaderValidated

+ const StatusBlockProcessed

+ const StatusBlockStored

+ const StatusBlockValidateFailed

+ const StatusBlockValidated

+ const StatusHeaderValidateFailed

+ const StatusHeaderValidated

+ const StatusNone

+ const TrancheSizeNanos

+ const USDCentsPerBitcoinKey

+ const Uint32Dec

+ const Uint64Dec

+ const UnconnectedTxnExpirationInterval

+ const UseridLengthBytes

+ var AllTxnString = []TxnString

+ var AllTxnTypes = []TxnType

+ var ArchitectPubKeyBase58Check = "BC1YLg3oh6Boj8e2boCo1vQCYHLk1rjsHF6jthBdvSw79bixQvKK6Qa"

+ var BurnPubKeyBase58Check = "BC1YLjWBf2qnDJmi8HZzzCPeXqy4dCKq95oqqzerAyW8MUTbuXTb1QT"

+ var DeSoMainnetParams = DeSoParams

+ var DeSoTestnetParams = DeSoParams

+ var DeflationBombBlockRewardAdjustmentBlockHeight = uint32(32060)

+ var ForgivenProfileUsernameClaims = map[BlockHash]string

+ var GenesisBlock = MsgDeSoBlock

+ var GenesisBlockHash = mustDecodeHexBlockHash(GenesisBlockHashHex)

+ var GenesisBlockHashHex = "5567c45b7b83b604f9ff5cb5e88dfc9ad7d5a1dd5818dd19e6d02466f47cbd62"

+ var InitialGlobalParamsEntry = GlobalParamsEntry

+ var InitialUSDCentsPerBitcoinExchangeRate = uint64(3000000)

+ var IsReserved = map[string]bool

+ var LowFeeTxLimitBytesPerTenMinutes = 150000

+ var MaxBitcoinHeadersPerMsg = uint32(2000)

+ var MaxBlockRewardDataSizeBytes = 250

+ var MaxHeadersPerMsg = uint32(2000)

+ var MaxUint256 = uint256.FromHex("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")

+ var MiningSupplyIntervals = []*MiningSupplyIntervalStart

+ var NODES = map[uint64]DeSoNode

+ var NaturalLogOfTwo = BigFloatLog(NewFloat().SetUint64(2))

+ var NotQuotedRepostVal = []byte

+ var ParamUpdaterPublicKeys = map[PkMapKey]bool

+ var PostExtraDataConsensusKeys = [2]string

+ var ProfilePicRegex = regexp.MustCompile("^[a-zA-Z0-9+/:;,]+$")

+ var QuotedRepostVal = []byte

+ var ReadOnlyUtxoViewRegenerationIntervalSeconds = float64(1.0)

+ var ReadOnlyUtxoViewRegenerationIntervalTxns = int64(1000)

+ var SeedBalances = []*DeSoOutput

+ var SeedTxns = []string

+ var TestSeedTxns = []string

+ var TikTokFullURLRegex = regexp.MustCompile(...)

+ var TikTokShortURLRegex = regexp.MustCompile("^.*(vm\\.tiktok\\.com/)([A-Za-z0-9]{6,12}).*")

+ var UsernameRegex = regexp.MustCompile("^[a-zA-Z0-9_]+$")

+ func Add(a *big.Float, b *big.Float) *big.Float

+ func Base58CheckDecode(input string) (_result []byte, _prefix []byte, _err error)

+ func Base58CheckDecodePrefix(input string, prefixLen int) (_result []byte, _prefix []byte, _err error)

+ func Base58CheckEncode(input []byte, isPrivate bool, params *DeSoParams) string

+ func Base58CheckEncodeWithPrefix(input []byte, prefix [3]byte) string

+ func BigFloatExp(z *big.Float) *big.Float

+ func BigFloatExpMulti(hi, lo *big.Float, k int64) *big.Float

+ func BigFloatLog(x *big.Float) *big.Float

+ func BigFloatLog2(x *big.Float) *big.Float

+ func BigFloatPow(z *big.Float, w *big.Float) *big.Float

+ func BigintToBytes(bigint *big.Int) []byte

+ func BlockCypherCheckBitcoinDoubleSpend(txnHash *chainhash.Hash, blockCypherAPIKey string, params *DeSoParams) (_isDoubleSpend bool, _err error)

+ func BlockCypherPushAndWaitForTxn(txnHex string, txnHash *chainhash.Hash, blockCypherAPIKey string, ...) (_isDoubleSpend bool, _err error)

+ func BlockCypherPushTransaction(txnHex string, txnHash *chainhash.Hash, blockCypherAPIKey string, ...) (_added bool, _err error)

+ func BlockHashToBlockKey(blockHash *BlockHash) []byte

+ func BlockchainInfoCheckBitcoinDoubleSpend(txnHash *chainhash.Hash, blockCypherAPIKey string, params *DeSoParams) (_isDoubleSpend bool, _err error)

+ func BlockonomicsCheckRBF(bitcoinTxnHash string) (_hasRBF bool, _err error)

+ func BlocksPerDuration(duration time.Duration, timeBetweenBlocks time.Duration) uint32

+ func BoolToByte(val bool) byte

+ func BytesToBigint(bb []byte) *big.Int

+ func CalcBlockRewardNanos(blockHeight uint32) uint64

+ func CalcNanosToCreate(startNanos uint64, satoshisToBurn uint64, ...) (_nanosToCreate uint64)

+ func CalculateCreatorCoinToMint(desoToSellNanos uint64, coinsInCirculationNanos uint64, desoLockedNanos uint64, ...) uint64

+ func CalculateCreatorCoinToMintBancor(deltaDeSoNanos uint64, currentCreatorCoinSupplyNanos uint64, ...) uint64

+ func CalculateCreatorCoinToMintPolynomial(deltaDeSoNanos uint64, currentCreatorCoinSupplyNanos uint64, ...) uint64

+ func CalculateDeSoToReturn(deltaCreatorCoinNanos uint64, currentCreatorCoinSupplyNanos uint64, ...) uint64

+ func CheckBitcoinDoubleSpend(txnHash *chainhash.Hash, blockCypherAPIKey string, params *DeSoParams) error

+ func CheckTransactionSanity(txn *MsgDeSoTxn) error

+ func ComputeKeysFromSeed(seedBytes []byte, index uint32, params *DeSoParams) (_pubKey *btcec.PublicKey, _privKey *btcec.PrivateKey, _btcAddress string, ...)

+ func ComputeKeysFromSeedWithNet(seedBytes []byte, index uint32, isTestnet bool) (_pubKey *btcec.PublicKey, _privKey *btcec.PrivateKey, _btcAddress string, ...)

+ func ComputeMerkleRoot(txns []*MsgDeSoTxn) (_merkle *BlockHash, _txHashes []*BlockHash, _err error)

+ func CreateBitcoinSpendTransaction(spendAmountSatoshis uint64, feeRateSatoshisPerKB uint64, ...) (_txn *wire.MsgTx, _totalInput uint64, _fee uint64, _unsignedHashes []string, ...)

+ func CreateUnsignedBitcoinSpendTransaction(spendAmountSatoshis uint64, feeRateSatoshisPerKB uint64, ...) (_txn *wire.MsgTx, _totalInput uint64, _fee uint64, _err error)

+ func DBCheckTxnExistenceWithTxn(txn *badger.Txn, txID *BlockHash) bool

+ func DBDeleteAcceptedNFTBidEntriesMappingsWithTxn(txn *badger.Txn, nftPostHash *BlockHash, serialNumber uint64) error

+ func DBDeleteAcceptedNFTBidMappings(handle *badger.DB, postHash *BlockHash, serialNumber uint64) error

+ func DBDeleteBalanceEntryMappings(handle *badger.DB, hodlerPKID *PKID, creatorPKID *PKID, isDAOCoin bool) error

+ func DBDeleteBalanceEntryMappingsWithTxn(txn *badger.Txn, hodlerPKID *PKID, creatorPKID *PKID, isDAOCoin bool) error

+ func DBDeleteDerivedKeyMapping(handle *badger.DB, ownerPublicKey PublicKey, derivedPublicKey PublicKey) error

+ func DBDeleteDerivedKeyMappingWithTxn(txn *badger.Txn, ownerPublicKey PublicKey, derivedPublicKey PublicKey) error

+ func DBDeleteMessageEntryMappings(handle *badger.DB, publicKey []byte, tstampNanos uint64) error

+ func DBDeleteMessageEntryMappingsWithTxn(txn *badger.Txn, publicKey []byte, tstampNanos uint64) error

+ func DBDeleteMessagingGroupEntry(handle *badger.DB, messagingGroupKey *MessagingGroupKey) error

+ func DBDeleteMessagingGroupEntryWithTxn(txn *badger.Txn, messagingGroupKey *MessagingGroupKey) error

+ func DBDeleteMessagingGroupMemberMappingWithTxn(txn *badger.Txn, messagingGroupMember *MessagingGroupMember, ...) error

+ func DBDeleteMessagingGroupMemberMappings(handle *badger.DB, messagingGroupMember *MessagingGroupMember, ...) error

+ func DBDeleteNFTBidMappings(handle *badger.DB, nftBidKey *NFTBidKey) error

+ func DBDeleteNFTBidMappingsWithTxn(txn *badger.Txn, nftBidKey *NFTBidKey) error

+ func DBDeleteNFTMappings(handle *badger.DB, postHash *BlockHash, serialNumber uint64) error

+ func DBDeleteNFTMappingsWithTxn(txn *badger.Txn, nftPostHash *BlockHash, serialNumber uint64) error

+ func DBDeletePKIDMappingsWithTxn(txn *badger.Txn, publicKey []byte, params *DeSoParams) error

+ func DBDeletePostEntryMappings(handle *badger.DB, postHash *BlockHash, params *DeSoParams) error

+ func DBDeletePostEntryMappingsWithTxn(txn *badger.Txn, postHash *BlockHash, params *DeSoParams) error

+ func DBDeleteProfileEntryMappings(handle *badger.DB, pkid *PKID, params *DeSoParams) error

+ func DBDeleteProfileEntryMappingsWithTxn(txn *badger.Txn, pkid *PKID, params *DeSoParams) error

+ func DBGetAcceptedNFTBidEntriesByPostHashSerialNumber(db *badger.DB, postHash *BlockHash, serialNumber uint64) *[]*NFTBidEntry

+ func DBGetAcceptedNFTBidEntriesByPostHashSerialNumberWithTxn(txn *badger.Txn, postHash *BlockHash, serialNumber uint64) *[]*NFTBidEntry

+ func DBGetAllPostsAndCommentsForPublicKeyOrderedByTimestamp(handle *badger.DB, publicKey []byte, fetchEntries bool, ...) (_tstamps []uint64, _postAndCommentHashes []*BlockHash, ...)

+ func DBGetAllPostsByTstamp(handle *badger.DB, fetchEntries bool) (_tstamps []uint64, _postHashes []*BlockHash, _postEntries []*PostEntry, ...)

+ func DBGetAllProfilesByCoinValue(handle *badger.DB, fetchEntries bool) (_lockedDeSoNanos []uint64, _profilePublicKeys []*PKID, ...)

+ func DBGetCommentPostHashesForParentStakeID(handle *badger.DB, stakeIDXXX []byte, fetchEntries bool) (_tstamps []uint64, _commentPostHashes []*BlockHash, ...)

+ func DBGetPaginatedKeysAndValuesForPrefix(db *badger.DB, startPrefix []byte, validForPrefix []byte, keyLen int, ...) (_keysFound [][]byte, _valsFound [][]byte, _err error)

+ func DBGetPaginatedKeysAndValuesForPrefixWithTxn(dbTxn *badger.Txn, startPrefix []byte, validForPrefix []byte, maxKeyLen int, ...) (_keysFound [][]byte, _valsFound [][]byte, _err error)

+ func DBGetPaginatedPostsOrderedByTime(db *badger.DB, startPostTimestampNanos uint64, startPostHash *BlockHash, ...) (_postHashes []*BlockHash, _tstampNanos []uint64, _postEntries []*PostEntry, ...)

+ func DBGetPublicKeyForPKID(db *badger.DB, pkidd *PKID) []byte

+ func DBGetPublicKeyForPKIDWithTxn(txn *badger.Txn, pkidd *PKID) []byte

+ func DBPutAcceptedNFTBidEntriesMapping(handle *badger.DB, nftKey NFTKey, nftBidEntries *[]*NFTBidEntry) error

+ func DBPutAcceptedNFTBidEntriesMappingWithTxn(txn *badger.Txn, nftKey NFTKey, nftBidEntries *[]*NFTBidEntry) error

+ func DBPutBalanceEntryMappings(handle *badger.DB, balanceEntry *BalanceEntry, isDAOCoin bool) error

+ func DBPutBalanceEntryMappingsWithTxn(txn *badger.Txn, balanceEntry *BalanceEntry, isDAOCoin bool) error

+ func DBPutDerivedKeyMapping(handle *badger.DB, ownerPublicKey PublicKey, derivedPublicKey PublicKey, ...) error

+ func DBPutDerivedKeyMappingWithTxn(txn *badger.Txn, ownerPublicKey PublicKey, derivedPublicKey PublicKey, ...) error

+ func DBPutMessageEntry(handle *badger.DB, messageKey MessageKey, messageEntry *MessageEntry) error

+ func DBPutMessageEntryWithTxn(txn *badger.Txn, messageKey MessageKey, messageEntry *MessageEntry) error

+ func DBPutMessagingGroupEntry(handle *badger.DB, ownerPublicKey *PublicKey, ...) error

+ func DBPutMessagingGroupEntryWithTxn(txn *badger.Txn, ownerPublicKey *PublicKey, ...) error

+ func DBPutMessagingGroupMember(handle *badger.DB, messagingGroupMember *MessagingGroupMember, ...) error

+ func DBPutMessagingGroupMemberWithTxn(txn *badger.Txn, messagingGroupMember *MessagingGroupMember, ...) error

+ func DBPutNFTBidEntryMappings(handle *badger.DB, nftEntry *NFTBidEntry) error

+ func DBPutNFTBidEntryMappingsWithTxn(txn *badger.Txn, nftBidEntry *NFTBidEntry) error

+ func DBPutNFTEntryMappings(handle *badger.DB, nftEntry *NFTEntry) error

+ func DBPutNFTEntryMappingsWithTxn(txn *badger.Txn, nftEntry *NFTEntry) error

+ func DBPutPKIDMappingsWithTxn(txn *badger.Txn, publicKey []byte, pkidEntry *PKIDEntry, params *DeSoParams) error

+ func DBPutPostEntryMappings(handle *badger.DB, postEntry *PostEntry, params *DeSoParams) error

+ func DBPutPostEntryMappingsWithTxn(txn *badger.Txn, postEntry *PostEntry, params *DeSoParams) error

+ func DBPutProfileEntryMappings(handle *badger.DB, profileEntry *ProfileEntry, pkid *PKID, params *DeSoParams) error

+ func DBPutProfileEntryMappingsWithTxn(txn *badger.Txn, profileEntry *ProfileEntry, pkid *PKID, params *DeSoParams) error

+ func DbBufForUtxoKey(utxoKey *UtxoKey) []byte

+ func DbBulkDeleteHeightHashToNodeInfo(nodes []*BlockNode, handle *badger.DB, bitcoinNodes bool) error

+ func DbCheckTxnExistence(handle *badger.DB, txID *BlockHash) bool

+ func DbDeleteAllMempoolTxns(handle *badger.DB) error

+ func DbDeleteAllMempoolTxnsWithTxn(txn *badger.Txn) error

+ func DbDeleteBitcoinBurnTxIDWithTxn(txn *badger.Txn, bitcoinBurnTxID *BlockHash) error

+ func DbDeleteDiamondMappings(handle *badger.DB, diamondEntry *DiamondEntry) error

+ func DbDeleteDiamondMappingsWithTxn(txn *badger.Txn, diamondEntry *DiamondEntry) error

+ func DbDeleteFollowMappings(handle *badger.DB, followerPKID *PKID, followedPKID *PKID) error

+ func DbDeleteFollowMappingsWithTxn(txn *badger.Txn, followerPKID *PKID, followedPKID *PKID) error

+ func DbDeleteForbiddenBlockSignaturePubKey(handle *badger.DB, publicKey []byte) error

+ func DbDeleteForbiddenBlockSignaturePubKeyWithTxn(txn *badger.Txn, publicKey []byte) error

+ func DbDeleteHeightHashToNodeInfoWithTxn(node *BlockNode, txn *badger.Txn, bitcoinNodes bool) error

+ func DbDeleteLikeMappings(handle *badger.DB, userPubKey []byte, likedPostHash BlockHash) error

+ func DbDeleteLikeMappingsWithTxn(txn *badger.Txn, userPubKey []byte, likedPostHash BlockHash) error

+ func DbDeleteMempoolTxn(handle *badger.DB, mempoolTx *MempoolTx) error

+ func DbDeleteMempoolTxnKey(handle *badger.DB, txnKey []byte) error

+ func DbDeleteMempoolTxnKeyWithTxn(txn *badger.Txn, txnKey []byte) error

+ func DbDeleteMempoolTxnWithTxn(txn *badger.Txn, mempoolTx *MempoolTx) error

+ func DbDeletePublicKeyToDeSoBalance(handle *badger.DB, publicKey []byte) error

+ func DbDeletePublicKeyToDeSoBalanceWithTxn(txn *badger.Txn, publicKey []byte) error

+ func DbDeleteRepostMappings(handle *badger.DB, userPubKey []byte, repostedPostHash BlockHash) error

+ func DbDeleteRepostMappingsWithTxn(txn *badger.Txn, userPubKey []byte, repostedPostHash BlockHash) error

+ func DbDeleteTxindexNextIndexForPublicKeyWithTxn(txn *badger.Txn, publicKey []byte) error

+ func DbDeleteTxindexPublicKeyToTxnMappingSingleWithTxn(dbTxn *badger.Txn, publicKey []byte, txID *BlockHash) error

+ func DbDeleteTxindexTransactionMappings(handle *badger.DB, txn *MsgDeSoTxn, params *DeSoParams) error

+ func DbDeleteTxindexTransactionMappingsWithTxn(dbTxn *badger.Txn, txn *MsgDeSoTxn, params *DeSoParams) error

+ func DbExistsBitcoinBurnTxID(db *badger.DB, bitcoinBurnTxID *BlockHash) bool

+ func DbExistsBitcoinBurnTxIDWithTxn(txn *badger.Txn, bitcoinBurnTxID *BlockHash) bool

+ func DbGetBlockRewardForPublicKeyBlockHash(db *badger.DB, publicKey []byte, blockHash *BlockHash) (_balance uint64, _err error)

+ func DbGetBlockRewardForPublicKeyBlockHashWithTxn(txn *badger.Txn, publicKey []byte, blockHash *BlockHash) (_balance uint64, _err error)

+ func DbGetDeSoBalanceNanosForPublicKey(db *badger.DB, publicKey []byte) (_balance uint64, _err error)

+ func DbGetDeSoBalanceNanosForPublicKeyWithTxn(txn *badger.Txn, publicKey []byte) (_balance uint64, _err error)

+ func DbGetFollowerToFollowedMapping(db *badger.DB, followerPKID *PKID, followedPKID *PKID) []byte

+ func DbGetFollowerToFollowedMappingWithTxn(txn *badger.Txn, followerPKID *PKID, followedPKID *PKID) []byte

+ func DbGetForbiddenBlockSignaturePubKey(db *badger.DB, publicKey []byte) []byte

+ func DbGetForbiddenBlockSignaturePubKeyWithTxn(txn *badger.Txn, publicKey []byte) []byte

+ func DbGetLikerPubKeyToLikedPostHashMapping(db *badger.DB, userPubKey []byte, likedPostHash BlockHash) []byte

+ func DbGetLikerPubKeyToLikedPostHashMappingWithTxn(txn *badger.Txn, userPubKey []byte, likedPostHash BlockHash) []byte

+ func DbGetLikerPubKeysLikingAPostHash(handle *badger.DB, likedPostHash BlockHash) (_pubKeys [][]byte, _err error)

+ func DbGetNanosPurchased(handle *badger.DB) uint64

+ func DbGetNanosPurchasedWithTxn(txn *badger.Txn) uint64

+ func DbGetPKIDsThatDiamondedYouMap(handle *badger.DB, yourPKID *PKID, fetchYouDiamonded bool) (_pkidToDiamondsMap map[PKID][]*DiamondEntry, _err error)

+ func DbGetPrefixForPublicKeyToDesoBalanceNanos() []byte

+ func DbGetPubKeysFollowingYou(handle *badger.DB, yourPubKey []byte) (_pubKeys [][]byte, _err error)

+ func DbGetPubKeysYouFollow(handle *badger.DB, yourPubKey []byte) (_pubKeys [][]byte, _err error)

+ func DbGetTxindexFullTransactionByTxID(txindexDBHandle *badger.DB, blockchainDBHandle *badger.DB, txID *BlockHash) (_txn *MsgDeSoTxn, _txnMeta *TransactionMetadata)

+ func DbGetTxindexNextIndexForPublicKey(handle *badger.DB, publicKey []byte) *uint64

+ func DbGetUSDCentsPerBitcoinExchangeRate(handle *badger.DB) uint64

+ func DbGetUSDCentsPerBitcoinExchangeRateWithTxn(txn *badger.Txn) uint64

+ func DbPrefixForCreatorDeSoLockedNanosCreatorPKID() []byte

+ func DbPutBitcoinBurnTxIDWithTxn(txn *badger.Txn, bitcoinBurnTxID *BlockHash) error

+ func DbPutDeSoBalanceForPublicKey(handle *badger.DB, publicKey []byte, balanceNanos uint64) error

+ func DbPutDeSoBalanceForPublicKeyWithTxn(txn *badger.Txn, publicKey []byte, balanceNanos uint64) error

+ func DbPutDiamondMappings(handle *badger.DB, diamondEntry *DiamondEntry) error

+ func DbPutDiamondMappingsWithTxn(txn *badger.Txn, diamondEntry *DiamondEntry) error

+ func DbPutFollowMappings(handle *badger.DB, followerPKID *PKID, followedPKID *PKID) error

+ func DbPutFollowMappingsWithTxn(txn *badger.Txn, followerPKID *PKID, followedPKID *PKID) error

+ func DbPutForbiddenBlockSignaturePubKey(handle *badger.DB, publicKey []byte) error

+ func DbPutForbiddenBlockSignaturePubKeyWithTxn(txn *badger.Txn, publicKey []byte) error

+ func DbPutGlobalParamsEntry(handle *badger.DB, globalParamsEntry GlobalParamsEntry) error

+ func DbPutGlobalParamsEntryWithTxn(txn *badger.Txn, globalParamsEntry GlobalParamsEntry) error

+ func DbPutLikeMappings(handle *badger.DB, userPubKey []byte, likedPostHash BlockHash) error

+ func DbPutLikeMappingsWithTxn(txn *badger.Txn, userPubKey []byte, likedPostHash BlockHash) error

+ func DbPutMempoolTxn(handle *badger.DB, mempoolTx *MempoolTx) error

+ func DbPutMempoolTxnWithTxn(txn *badger.Txn, mempoolTx *MempoolTx) error

+ func DbPutNanosPurchased(handle *badger.DB, nanosPurchased uint64) error

+ func DbPutNanosPurchasedWithTxn(txn *badger.Txn, nanosPurchased uint64) error

+ func DbPutRepostMappings(handle *badger.DB, userPubKey []byte, repostedPostHash BlockHash, ...) error

+ func DbPutRepostMappingsWithTxn(txn *badger.Txn, userPubKey []byte, repostedPostHash BlockHash, ...) error

+ func DbPutTxindexNextIndexForPublicKeyWithTxn(txn *badger.Txn, publicKey []byte, nextIndex uint64) error

+ func DbPutTxindexPublicKeyToTxnMappingSingleWithTxn(dbTxn *badger.Txn, publicKey []byte, txID *BlockHash) error

+ func DbPutTxindexTip(handle *badger.DB, tipHash *BlockHash) error

+ func DbPutTxindexTipWithTxn(dbTxn *badger.Txn, tipHash *BlockHash) error

+ func DbPutTxindexTransaction(handle *badger.DB, txID *BlockHash, txnMeta *TransactionMetadata) error

+ func DbPutTxindexTransactionMappings(handle *badger.DB, desoTxn *MsgDeSoTxn, params *DeSoParams, ...) error

+ func DbPutTxindexTransactionMappingsWithTxn(dbTx *badger.Txn, txn *MsgDeSoTxn, params *DeSoParams, ...) error

+ func DbPutTxindexTransactionWithTxn(txn *badger.Txn, txID *BlockHash, txnMeta *TransactionMetadata) error

+ func DbPutUSDCentsPerBitcoinExchangeRateWithTxn(txn *badger.Txn, usdCentsPerBitcoinExchangeRate uint64) error

+ func DbTxindexPublicKeyIndexToTxnKey(publicKey []byte, index uint32) []byte

+ func DbTxindexPublicKeyPrefix(publicKey []byte) []byte

+ func DbTxindexTxIDKey(txID *BlockHash) []byte

+ func DecodeByteArray(reader io.Reader) ([]byte, error)

+ func DecodeUint32(num []byte) uint32

+ func DecodeUint64(scoreBytes []byte) uint64

+ func DecryptBytesWithPrivateKey(bytesToDecrypt []byte, privKey *ecdsa.PrivateKey) ([]byte, error)

+ func DeletePubKeyUtxoKeyMappingWithTxn(txn *badger.Txn, publicKey []byte, utxoKey *UtxoKey) error

+ func DeleteUnmodifiedMappingsForUtxoWithTxn(txn *badger.Txn, utxoKey *UtxoKey) error

+ func DeleteUtxoEntryForKeyWithTxn(txn *badger.Txn, utxoKey *UtxoKey) error

+ func DeleteUtxoOperationsForBlockWithTxn(txn *badger.Txn, blockHash *BlockHash) error

+ func DeserializePubKeyToUint64Map(data []byte) (map[PublicKey]uint64, error)

+ func Diff(expected interface{}, actual interface{}) string

+ func Div(a *big.Float, b *big.Float) *big.Float

+ func EncodeByteArray(bytes []byte) []byte

+ func EncodeUint64(num uint64) []byte

+ func EncryptBytesWithPublicKey(bytesToEncrypt []byte, pubkey *ecdsa.PublicKey) ([]byte, error)

+ func EnumerateKeysForPrefix(db *badger.DB, dbPrefix []byte) (_keysFound [][]byte, _valsFound [][]byte)

+ func EqualGroupKeyName(a, b *GroupKeyName) bool

+ func EstimateBitcoinTxFee(numInputs int, numOutputs int, feeRateSatoshisPerKB uint64) uint64

+ func ExtractBitcoinBurnTransactionsFromBitcoinBlock(bitcoinBlock *wire.MsgBlock, bitcoinBurnAddress string, params *DeSoParams) []*wire.MsgTx

+ func ExtractBitcoinBurnTransactionsFromBitcoinBlockWithMerkleProofs(bitcoinBlock *wire.MsgBlock, burnAddress string, params *DeSoParams) (_txns []*wire.MsgTx, _merkleProofs [][]*merkletree.ProofPart, _err error)

+ func ExtractBitcoinPublicKeyFromBitcoinTransactionInputs(bitcoinTransaction *wire.MsgTx, btcdParams *chaincfg.Params) (_publicKey *btcec.PublicKey, _err error)

+ func FlushMempoolToDb(handle *badger.DB, allTxns []*MempoolTx) error

+ func FlushMempoolToDbWithTxn(txn *badger.Txn, allTxns []*MempoolTx) error

+ func GetBadgerDbPath(dataDir string) string

+ func GetBlockIndex(handle *badger.DB, bitcoinNodes bool) (map[BlockHash]*BlockNode, error)

+ func GetCreatorCoinNanosForDiamondLevelAtBlockHeight(coinsInCirculationNanos uint64, desoLockedNanos uint64, diamondLevel int64, ...) uint64

+ func GetDataDir(params *DeSoParams) string

+ func GetDeSoNanosDiamondLevelMapAtBlockHeight(blockHeight int64) map[int64]uint64

+ func GetDeSoNanosForDiamondLevelAtBlockHeight(diamondLevel int64, blockHeight int64) uint64

+ func GetReorgBlocks(tip *BlockNode, newNode *BlockNode) (_commonAncestor *BlockNode, _detachNodes []*BlockNode, ...)

+ func GetS256BasePointCompressed() []byte

+ func GetSatoshisPerUnitExchangeRate(startNanos uint64, usdCentsPerBitcoinExchangeRate uint64) uint64

+ func GetStartPriceSatoshisPerDeSo(usdCentsPerBitcoinExchangeRate uint64) uint64

+ func GetUtxoNumEntries(handle *badger.DB) uint64

+ func GetUtxoNumEntriesWithTxn(txn *badger.Txn) uint64

+ func GetUtxoOperationsForBlock(handle *badger.DB, blockHash *BlockHash) ([][]*UtxoOperation, error)

+ func GetUtxoOperationsForBlockWithTxn(txn *badger.Txn, blockHash *BlockHash) ([][]*UtxoOperation, error)

+ func HashToBigint(hash *BlockHash) *big.Int

+ func HeaderSizeBytes() int

+ func IPToNetAddr(ipStr string, addrMgr *addrmgr.AddrManager, params *DeSoParams) (*wire.NetAddress, error)

+ func InitDbWithDeSoGenesisBlock(params *DeSoParams, handle *badger.DB, eventManager *EventManager) error

+ func InitializeSecureMiddleware(allowedHosts []string, isDevelopment bool, contentSecurityPolicy string) *secure.Secure

+ func IntAdd(a *big.Int, b *big.Int) *big.Int

+ func IntDiv(a *big.Int, b *big.Int) *big.Int

+ func IntMul(a *big.Int, b *big.Int) *big.Int

+ func IntSub(a *big.Int, b *big.Int) *big.Int

+ func IntToBuf(xx int64) []byte

+ func IsBitcoinTestnet(params *DeSoParams) bool

+ func IsByteArrayValidPublicKey(bytes []byte) error

+ func IsControlMessage(msgType MsgType) bool

+ func IsQuotedRepost(postEntry *PostEntry) bool

+ func IsRuleError(err error) bool

+ func IsVanillaRepost(postEntry *PostEntry) bool

+ func LessThan(aa *BlockHash, bb *BlockHash) bool

+ func LogDBSummarySnapshot(db *badger.DB)

+ func LogSelect(query *orm.Query) error

+ func MakeDirIfNonExistent(filePath string) error

+ func MessagingKeyNameDecode(name *GroupKeyName) []byte

+ func MinInt(a, b int) int

+ func MinUint32(a, b uint32) uint32

+ func Mul(a *big.Float, b *big.Float) *big.Float

+ func MustBase58CheckDecode(input string) []byte

+ func NewFloat() *big.Float

+ func PKIDToPublicKey(pkid *PKID) []byte

+ func PPrintJSON(xx interface{})

+ func PkToString(pk []byte, params *DeSoParams) string

+ func PkToStringBoth(pk []byte) string

+ func PkToStringMainnet(pk []byte) string

+ func PkToStringTestnet(pk []byte) string

+ func PrivToString(priv []byte, params *DeSoParams) string

+ func PublicKeyBlockHashToBlockRewardKey(publicKey []byte, blockHash *BlockHash) []byte

+ func PutBestHash(bh *BlockHash, handle *badger.DB, chainType ChainType) error

+ func PutBestHashWithTxn(txn *badger.Txn, bh *BlockHash, chainType ChainType) error

+ func PutBlock(desoBlock *MsgDeSoBlock, handle *badger.DB) error

+ func PutBlockWithTxn(txn *badger.Txn, desoBlock *MsgDeSoBlock) error

+ func PutHeightHashToNodeInfo(node *BlockNode, handle *badger.DB, bitcoinNodes bool) error

+ func PutHeightHashToNodeInfoWithTxn(txn *badger.Txn, node *BlockNode, bitcoinNodes bool) error

+ func PutMappingsForUtxoWithTxn(txn *badger.Txn, utxoKey *UtxoKey, utxoEntry *UtxoEntry) error

+ func PutPubKeyUtxoKeyWithTxn(txn *badger.Txn, publicKey []byte, utxoKey *UtxoKey) error

+ func PutUtxoEntryForUtxoKeyWithTxn(txn *badger.Txn, utxoKey *UtxoKey, utxoEntry *UtxoEntry) error

+ func PutUtxoNumEntriesWithTxn(txn *badger.Txn, newNumEntries uint64) error

+ func PutUtxoOperationsForBlockWithTxn(txn *badger.Txn, blockHash *BlockHash, utxoOpsForBlock [][]*UtxoOperation) error

+ func PutUvarint(buf []byte, x uint64) int

+ func PutVarint(buf []byte, x int64) int

+ func RandInt32(max int32) int32

+ func RandInt64(max int64) int64

+ func RandomBytes(numBytes int32) []byte

+ func RandomBytesHex(numBytes int32) string

+ func ReadBoolByte(rr *bytes.Reader) bool

+ func ReadMessageVersion(txn *MsgDeSoTxn) (_version uint8, _err error)

+ func ReadUvarint(r io.Reader) (uint64, error)

+ func ReadVarString(rr io.Reader) ([]byte, error)

+ func ReadVarint(r io.Reader) (int64, error)

+ func SerializeBlockNode(blockNode *BlockNode) ([]byte, error)

+ func SerializePubKeyToUint64Map(mm map[PublicKey]uint64) ([]byte, error)

+ func SignTransactionWithDerivedKey(txnBytes []byte, privateKey *btcec.PrivateKey) ([]byte, []byte, error)

+ func StartDBSummarySnapshots(db *badger.DB)

+ func Sub(a *big.Float, b *big.Float) *big.Float

+ func UintToBuf(xx uint64) []byte

+ func Uvarint(buf []byte) (uint64, int)

+ func ValidateGroupPublicKeyAndName(messagingPublicKey, keyName []byte) error

+ func Varint(buf []byte) (int64, int)

+ func WriteMessage(ww io.Writer, msg DeSoMessage, networkType NetworkType) ([]byte, error)

+ type AcceptNFTBidMetadata struct

+ BidAmountNanos uint64

+ BidderInputs []*DeSoInput

+ BidderPKID *PKID

+ NFTPostHash *BlockHash

+ SerialNumber uint64

+ UnlockableText []byte

+ func (txnData *AcceptNFTBidMetadata) FromBytes(dataa []byte) error

+ func (txnData *AcceptNFTBidMetadata) GetTxnType() TxnType

+ func (txnData *AcceptNFTBidMetadata) New() DeSoTxnMetadata

+ func (txnData *AcceptNFTBidMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type AcceptNFTBidTxindexMetadata struct

+ BidAmountNanos uint64

+ NFTPostHashHex string

+ SerialNumber uint64

+ type AcceptNFTTransferMetadata struct

+ NFTPostHash *BlockHash

+ SerialNumber uint64

+ func (txnData *AcceptNFTTransferMetadata) FromBytes(dataa []byte) error

+ func (txnData *AcceptNFTTransferMetadata) GetTxnType() TxnType

+ func (txnData *AcceptNFTTransferMetadata) New() DeSoTxnMetadata

+ func (txnData *AcceptNFTTransferMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type AcceptNFTTransferTxindexMetadata struct

+ NFTPostHashHex string

+ SerialNumber uint64

+ type AffectedPublicKey struct

+ Metadata string

+ PublicKeyBase58Check string

+ type AuthorizeDerivedKeyMetadata struct

+ AccessSignature []byte

+ DerivedPublicKey []byte

+ ExpirationBlock uint64

+ OperationType AuthorizeDerivedKeyOperationType

+ func (txnData *AuthorizeDerivedKeyMetadata) FromBytes(data []byte) error

+ func (txnData *AuthorizeDerivedKeyMetadata) GetTxnType() TxnType

+ func (txnData *AuthorizeDerivedKeyMetadata) New() DeSoTxnMetadata

+ func (txnData *AuthorizeDerivedKeyMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type AuthorizeDerivedKeyOperationType uint8

+ const AuthorizeDerivedKeyOperationNotValid

+ const AuthorizeDerivedKeyOperationValid

+ type BalanceEntry struct

+ BalanceNanos uint256.Int

+ CreatorPKID *PKID

+ HODLerPKID *PKID

+ HasPurchased bool

+ func DBGetBalanceEntryForCreatorPKIDAndHODLerPubKeyWithTxn(txn *badger.Txn, creatorPKID *PKID, hodlerPKID *PKID, isDAOCoin bool) *BalanceEntry

+ func DBGetBalanceEntryForHODLerAndCreatorPKIDs(handle *badger.DB, hodlerPKID *PKID, creatorPKID *PKID, isDAOCoin bool) *BalanceEntry

+ func DBGetBalanceEntryForHODLerAndCreatorPKIDsWithTxn(txn *badger.Txn, hodlerPKID *PKID, creatorPKID *PKID, isDAOCoin bool) *BalanceEntry

+ func DbGetBalanceEntriesHodlingYou(db *badger.DB, pkid *PKID, filterOutZeroBalances bool, isDAOCoin bool) ([]*BalanceEntry, error)

+ func DbGetBalanceEntriesYouHold(db *badger.DB, pkid *PKID, filterOutZeroBalances bool, isDAOCoin bool) ([]*BalanceEntry, error)

+ func DbGetBalanceEntry(db *badger.DB, holder *PKID, creator *PKID, isDAOCoin bool) *BalanceEntry

+ func DbGetHolderPKIDCreatorPKIDToBalanceEntryWithTxn(txn *badger.Txn, holder *PKID, creator *PKID, isDAOCoin bool) *BalanceEntry

+ func GetSingleBalanceEntryFromPublicKeys(holder []byte, creator []byte, utxoView *UtxoView, isDAOCoin bool) (*BalanceEntry, error)

+ type BalanceEntryMapKey struct

+ CreatorPKID PKID

+ HODLerPKID PKID

+ func MakeBalanceEntryKey(hodlerPKID *PKID, creatorPKID *PKID) BalanceEntryMapKey

+ func (mm BalanceEntryMapKey) String() string

+ type BasicTransferMetadata struct

+ func (txnData *BasicTransferMetadata) FromBytes(data []byte) error

+ func (txnData *BasicTransferMetadata) GetTxnType() TxnType

+ func (txnData *BasicTransferMetadata) New() DeSoTxnMetadata

+ func (txnData *BasicTransferMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type BasicTransferTxindexMetadata struct

+ DiamondLevel int64

+ FeeNanos uint64

+ PostHashHex string

+ TotalInputNanos uint64

+ TotalOutputNanos uint64

+ UtxoOps []*UtxoOperation

+ UtxoOpsDump string

+ type BitcoinExchangeMetadata struct

+ BitcoinBlockHash *BlockHash

+ BitcoinMerkleProof []*merkletree.ProofPart

+ BitcoinMerkleRoot *BlockHash

+ BitcoinTransaction *wire.MsgTx

+ func (txnData *BitcoinExchangeMetadata) FromBytes(data []byte) error

+ func (txnData *BitcoinExchangeMetadata) GetTxnType() TxnType

+ func (txnData *BitcoinExchangeMetadata) New() DeSoTxnMetadata

+ func (txnData *BitcoinExchangeMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type BitcoinExchangeTxindexMetadata struct

+ BitcoinSpendAddress string

+ BitcoinTxnHash string

+ NanosCreated uint64

+ SatoshisBurned uint64

+ TotalNanosPurchasedAfter uint64

+ TotalNanosPurchasedBefore uint64

+ type BitcoinUtxo struct

+ AmountSatoshis int64

+ Index int64

+ TxID *chainhash.Hash

+ func BlockCypherExtractBitcoinUtxosFromResponse(apiData *BlockCypherAPIFullAddressResponse, addrString string, ...) ([]*BitcoinUtxo, error)

+ func BlockCypherUtxoSource(addrString string, params *DeSoParams) ([]*BitcoinUtxo, error)

+ func FrontendBlockCypherUtxoSource(apiData *BlockCypherAPIFullAddressResponse, addrString string, ...) ([]*BitcoinUtxo, error)

+ type BlockCypherAPIFullAddressResponse struct

+ Address string

+ ConfirmedBalance int64

+ Error string

+ FinalBalance int64

+ HasMore bool

+ Txns []*BlockCypherAPITxnResponse

+ UnconfirmedBalance int64

+ func GetBlockCypherAPIFullAddressResponse(addrString string, params *DeSoParams) (_apiData *BlockCypherAPIFullAddressResponse, _err error)

+ type BlockCypherAPIInputResponse struct

+ Addresses []string

+ Age int64

+ AmountSatoshis int64

+ Index int64

+ PrevTxIDHex string

+ ScriptHex string

+ ScriptType string

+ Sequence int64

+ type BlockCypherAPIOutputResponse struct

+ Addresses []string

+ AmountSatoshis int64

+ ScriptHex string

+ ScriptType string

+ SpentBy string

+ type BlockCypherAPITxnResponse struct

+ BlockHashHex string

+ BlockHeight int64

+ Confirmations int64

+ DoubleSpend bool

+ Inputs []*BlockCypherAPIInputResponse

+ LockTime int64

+ Outputs []*BlockCypherAPIOutputResponse

+ TxIDHex string

+ func GetBlockCypherTxnResponse(txnHash *chainhash.Hash, blockCypherAPIKey string, params *DeSoParams) (*BlockCypherAPITxnResponse, error)

+ type BlockEvent struct

+ Block *MsgDeSoBlock

+ UtxoOps [][]*UtxoOperation

+ UtxoView *UtxoView

+ type BlockEventFunc func(event *BlockEvent)

+ type BlockHash [HashSizeBytes]byte

+ func BigintToHash(bigint *big.Int) *BlockHash

+ func CalcNextDifficultyTarget(lastNode *BlockNode, version uint32, params *DeSoParams) (*BlockHash, error)

+ func ComputeTransactionHashes(txns []*MsgDeSoTxn) ([]*BlockHash, error)

+ func CopyBytesIntoBlockHash(data []byte) *BlockHash

+ func DbGetAllBitcoinBurnTxIDs(handle *badger.DB) (_bitcoinBurnTxIDs []*BlockHash)

+ func DbGetBestHash(handle *badger.DB, chainType ChainType) *BlockHash

+ func DbGetPostHashesYouLike(handle *badger.DB, yourPublicKey []byte) (_postHashes []*BlockHash, _err error)

+ func DbGetPostHashesYouRepost(handle *badger.DB, yourPublicKey []byte) (_postHashes []*BlockHash, _err error)

+ func DbGetTxindexTip(handle *badger.DB) *BlockHash

+ func DbGetTxindexTxnsForPublicKey(handle *badger.DB, publicKey []byte) []*BlockHash

+ func DbGetTxindexTxnsForPublicKeyWithTxn(dbTxn *badger.Txn, publicKey []byte) []*BlockHash

+ func ExpectedWorkForBlockHash(hash *BlockHash) *BlockHash

+ func FindLowestHash(blockHeaderr *MsgDeSoHeader, iterations uint64) (lowestHash *BlockHash, lowestNonce uint64, ee error)

+ func MustDecodeHexBlockHash(ss string) *BlockHash

+ func NewBlockHash(input []byte) *BlockHash

+ func ProofOfWorkHash(inputBytes []byte, version uint32) *BlockHash

+ func Sha256DoubleHash(input []byte) *BlockHash

+ func (bh *BlockHash) IsEqual(target *BlockHash) bool

+ func (bh *BlockHash) NewBlockHash() *BlockHash

+ func (bh *BlockHash) String() string

+ func (bh *BlockHash) ToBytes() []byte

+ type BlockNode struct

+ CumWork *big.Int

+ DifficultyTarget *BlockHash

+ Hash *BlockHash

+ Header *MsgDeSoHeader

+ Height uint32

+ Parent *BlockNode

+ Status BlockStatus

+ func DeserializeBlockNode(data []byte) (*BlockNode, error)

+ func GetBestChain(tipNode *BlockNode, blockIndex map[BlockHash]*BlockNode) ([]*BlockNode, error)

+ func GetHeightHashToNodeInfo(handle *badger.DB, height uint32, hash *BlockHash, bitcoinNodes bool) *BlockNode

+ func GetHeightHashToNodeInfoWithTxn(txn *badger.Txn, height uint32, hash *BlockHash, bitcoinNodes bool) *BlockNode

+ func NewBlockNode(parent *BlockNode, hash *BlockHash, height uint32, difficultyTarget *BlockHash, ...) *BlockNode

+ func (nn *BlockNode) Ancestor(height uint32) *BlockNode

+ func (nn *BlockNode) RelativeAncestor(distance uint32) *BlockNode

+ func (nn *BlockNode) String() string

+ type BlockProducerInfo struct

+ PublicKey []byte

+ Signature *btcec.Signature

+ func (bpi *BlockProducerInfo) Deserialize(data []byte) error

+ func (bpi *BlockProducerInfo) Serialize() []byte

+ func (bpi *BlockProducerInfo) String() string

+ type BlockRewardMetadataa struct

+ ExtraData []byte

+ func (txnData *BlockRewardMetadataa) FromBytes(dataa []byte) error

+ func (txnData *BlockRewardMetadataa) GetTxnType() TxnType

+ func (txnData *BlockRewardMetadataa) New() DeSoTxnMetadata

+ func (txnData *BlockRewardMetadataa) ToBytes(preSignature bool) ([]byte, error)

+ type BlockStatus uint32

+ func (blockStatus BlockStatus) String() string

+ type BlockTemplateStats struct

+ FailingTxnError string

+ FailingTxnHash string

+ FailingTxnMinutesSinceAdded float64

+ FailingTxnOriginalTimeAdded time.Time

+ TxnCount uint32

+ type Blockchain struct

+ ChainLock deadlock.RWMutex

+ func NewBlockchain(trustedBlockProducerPublicKeyStrs []string, ...) (*Blockchain, error)

+ func (bc *Blockchain) AddInputsAndChangeToTransaction(txArg *MsgDeSoTxn, minFeeRateNanosPerKB uint64, mempool *DeSoMempool) (_totalInputAdded uint64, _spendAmount uint64, _totalChangeAdded uint64, ...)

+ func (bc *Blockchain) AddInputsAndChangeToTransactionWithSubsidy(txArg *MsgDeSoTxn, minFeeRateNanosPerKB uint64, inputSubsidy uint64, ...) (_totalInputAdded uint64, _spendAmount uint64, _totalChangeAdded uint64, ...)

+ func (bc *Blockchain) BestChain() []*BlockNode

+ func (bc *Blockchain) BlockTip() *BlockNode

+ func (bc *Blockchain) ChainState() SyncState

+ func (bc *Blockchain) CopyBestChain() ([]*BlockNode, map[BlockHash]*BlockNode)

+ func (bc *Blockchain) CopyBestHeaderChain() ([]*BlockNode, map[BlockHash]*BlockNode)

+ func (bc *Blockchain) CopyBlockIndex() map[BlockHash]*BlockNode

+ func (bc *Blockchain) CreateAcceptNFTBidTxn(UpdaterPublicKey []byte, NFTPostHash *BlockHash, SerialNumber uint64, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateAcceptNFTTransferTxn(UpdaterPublicKey []byte, NFTPostHash *BlockHash, SerialNumber uint64, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateAuthorizeDerivedKeyTxn(ownerPublicKey []byte, derivedPublicKey []byte, expirationBlock uint64, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateBasicTransferTxnWithDiamonds(SenderPublicKey []byte, DiamondPostHash *BlockHash, DiamondLevel int64, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _spendAmount uint64, ...)

+ func (bc *Blockchain) CreateBurnNFTTxn(UpdaterPublicKey []byte, NFTPostHash *BlockHash, SerialNumber uint64, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateCreateNFTTxn(UpdaterPublicKey []byte, NFTPostHash *BlockHash, NumCopies uint64, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateCreatorCoinTransferTxn(UpdaterPublicKey []byte, ProfilePublicKey []byte, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateCreatorCoinTransferTxnWithDiamonds(SenderPublicKey []byte, ReceiverPublicKey []byte, DiamondPostHash *BlockHash, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateCreatorCoinTxn(UpdaterPublicKey []byte, ProfilePublicKey []byte, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateDAOCoinTransferTxn(UpdaterPublicKey []byte, metadata *DAOCoinTransferMetadata, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateDAOCoinTxn(UpdaterPublicKey []byte, metadata *DAOCoinMetadata, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateFollowTxn(senderPublicKey []byte, followedPublicKey []byte, isUnfollow bool, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateLikeTxn(userPublicKey []byte, likedPostHash BlockHash, isUnlike bool, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateMaxSpend(senderPkBytes []byte, recipientPkBytes []byte, minFeeRateNanosPerKB uint64, ...) (_txn *MsgDeSoTxn, _totalInputAdded uint64, _spendAmount uint64, _fee uint64, ...)

+ func (bc *Blockchain) CreateMessagingKeyTxn(senderPublicKey []byte, messagingPublicKey []byte, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateNFTBidTxn(UpdaterPublicKey []byte, NFTPostHash *BlockHash, SerialNumber uint64, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateNFTTransferTxn(SenderPublicKey []byte, ReceiverPublicKey []byte, NFTPostHash *BlockHash, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreatePrivateMessageTxn(senderPublicKey []byte, recipientPublicKey []byte, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateSubmitPostTxn(updaterPublicKey []byte, postHashToModify []byte, parentStakeID []byte, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateSwapIdentityTxn(UpdaterPublicKeyBytes []byte, FromPublicKeyBytes []byte, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateUpdateBitcoinUSDExchangeRateTxn(updaterPublicKey []byte, usdCentsPerbitcoin uint64, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateUpdateGlobalParamsTxn(updaterPublicKey []byte, usdCentsPerBitcoin int64, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateUpdateNFTTxn(UpdaterPublicKey []byte, NFTPostHash *BlockHash, SerialNumber uint64, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) CreateUpdateProfileTxn(UpdaterPublicKeyBytes []byte, OptionalProfilePublicKeyBytes []byte, ...) (_txn *MsgDeSoTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

+ func (bc *Blockchain) DB() *badger.DB

+ func (bc *Blockchain) EstimateDefaultFeeRateNanosPerKB(medianThreshold float64, minFeeRateNanosPerKB uint64) uint64

+ func (bc *Blockchain) GetBlock(blockHash *BlockHash) *MsgDeSoBlock

+ func (bc *Blockchain) GetBlockAtHeight(height uint32) *MsgDeSoBlock

+ func (bc *Blockchain) GetBlockNodesToFetch(numBlocks int, _maxHeight int, blocksToIgnore map[BlockHash]bool) []*BlockNode

+ func (bc *Blockchain) GetInputsToCoverAmount(spenderPublicKey []byte, utxoView *UtxoView, amountToCover uint64) (_inputs []*DeSoInput, _err error)

+ func (bc *Blockchain) GetSpendableUtxosForPublicKey(spendPublicKeyBytes []byte, mempool *DeSoMempool, referenceUtxoView *UtxoView) ([]*UtxoEntry, error)

+ func (bc *Blockchain) HasBlock(blockHash *BlockHash) bool

+ func (bc *Blockchain) HasHeader(headerHash *BlockHash) bool

+ func (bc *Blockchain) HeaderAtHeight(blockHeight uint32) *BlockNode

+ func (bc *Blockchain) HeaderLocatorWithNodeHash(blockHash *BlockHash) ([]*BlockHash, error)

+ func (bc *Blockchain) HeaderTip() *BlockNode

+ func (bc *Blockchain) LatestHeaderLocator() []*BlockHash

+ func (bc *Blockchain) LatestLocator(tip *BlockNode) []*BlockHash

+ func (bc *Blockchain) LocateBestBlockChainHeaders(locator []*BlockHash, stopHash *BlockHash) []*MsgDeSoHeader

+ func (bc *Blockchain) MarkBlockInvalid(node *BlockNode, errOccurred RuleError)

+ func (bc *Blockchain) ProcessBlock(desoBlock *MsgDeSoBlock, verifySignatures bool) (_isMainChain bool, _isOrphan bool, _err error)

+ func (bc *Blockchain) ProcessHeader(blockHeader *MsgDeSoHeader, headerHash *BlockHash) (_isMainChain bool, _isOrphan bool, _err error)

+ func (bc *Blockchain) ProcessOrphanBlock(desoBlock *MsgDeSoBlock, blockHash *BlockHash) error

+ func (bc *Blockchain) SetBestChain(bestChain []*BlockNode)

+ func (bc *Blockchain) SetBestChainMap(bestChain []*BlockNode, bestChainMap map[BlockHash]*BlockNode, ...)

+ func (bc *Blockchain) ValidateTransaction(txnMsg *MsgDeSoTxn, blockHeight uint32, verifySignatures bool, ...) error

+ type BlockchainInfoAPIResponse struct

+ DoubleSpend bool

+ type BlockonomicsRBFResponse struct

+ RBF int64

+ Status string

+ type BurnNFTMetadata struct

+ NFTPostHash *BlockHash

+ SerialNumber uint64

+ func (txnData *BurnNFTMetadata) FromBytes(dataa []byte) error

+ func (txnData *BurnNFTMetadata) GetTxnType() TxnType

+ func (txnData *BurnNFTMetadata) New() DeSoTxnMetadata

+ func (txnData *BurnNFTMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type BurnNFTTxindexMetadata struct

+ NFTPostHashHex string

+ SerialNumber uint64

+ type ChainType uint8

+ type CoinEntry struct

+ CoinWatermarkNanos uint64

+ CoinsInCirculationNanos uint256.Int

+ CreatorBasisPoints uint64

+ DeSoLockedNanos uint64

+ MintingDisabled bool

+ NumberOfHolders uint64

+ TransferRestrictionStatus TransferRestrictionStatus

+ type ConnectionManager struct

+ func NewConnectionManager(_params *DeSoParams, _addrMgr *addrmgr.AddrManager, _listeners []net.Listener, ...) *ConnectionManager

+ func (cmgr *ConnectionManager) ConnectPeer(conn net.Conn, persistentAddr *wire.NetAddress)

+ func (cmgr *ConnectionManager) GetAddrManager() *addrmgr.AddrManager

+ func (cmgr *ConnectionManager) GetAllPeers() []*Peer

+ func (cmgr *ConnectionManager) RandomPeer() *Peer

+ func (cmgr *ConnectionManager) RemovePeer(pp *Peer)

+ func (cmgr *ConnectionManager) Start()

+ func (cmgr *ConnectionManager) Stop()

+ type CreateNFTMetadata struct

+ HasUnlockable bool

+ IsForSale bool

+ MinBidAmountNanos uint64

+ NFTPostHash *BlockHash

+ NFTRoyaltyToCoinBasisPoints uint64

+ NFTRoyaltyToCreatorBasisPoints uint64

+ NumCopies uint64

+ func (txnData *CreateNFTMetadata) FromBytes(dataa []byte) error

+ func (txnData *CreateNFTMetadata) GetTxnType() TxnType

+ func (txnData *CreateNFTMetadata) New() DeSoTxnMetadata

+ func (txnData *CreateNFTMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type CreateNFTTxindexMetadata struct

+ AdditionalCoinRoyaltiesMap map[string]uint64

+ AdditionalDESORoyaltiesMap map[string]uint64

+ NFTPostHashHex string

+ type CreatorCoinMetadataa struct

+ CreatorCoinToSellNanos uint64

+ DeSoToAddNanos uint64

+ DeSoToSellNanos uint64

+ MinCreatorCoinExpectedNanos uint64

+ MinDeSoExpectedNanos uint64

+ OperationType CreatorCoinOperationType

+ ProfilePublicKey []byte

+ func (txnData *CreatorCoinMetadataa) FromBytes(dataa []byte) error

+ func (txnData *CreatorCoinMetadataa) GetTxnType() TxnType

+ func (txnData *CreatorCoinMetadataa) New() DeSoTxnMetadata

+ func (txnData *CreatorCoinMetadataa) ToBytes(preSignature bool) ([]byte, error)

+ type CreatorCoinOperationType uint8

+ const CreatorCoinOperationTypeAddDeSo

+ const CreatorCoinOperationTypeBuy

+ const CreatorCoinOperationTypeSell

+ type CreatorCoinTransferMetadataa struct

+ CreatorCoinToTransferNanos uint64

+ ProfilePublicKey []byte

+ ReceiverPublicKey []byte

+ func (txnData *CreatorCoinTransferMetadataa) FromBytes(dataa []byte) error

+ func (txnData *CreatorCoinTransferMetadataa) GetTxnType() TxnType

+ func (txnData *CreatorCoinTransferMetadataa) New() DeSoTxnMetadata

+ func (txnData *CreatorCoinTransferMetadataa) ToBytes(preSignature bool) ([]byte, error)

+ type CreatorCoinTransferTxindexMetadata struct

+ CreatorCoinToTransferNanos uint64

+ CreatorUsername string

+ DiamondLevel int64

+ PostHashHex string

+ type CreatorCoinTxindexMetadata struct

+ CreatorCoinToSellNanos uint64

+ DESOLockedNanosDiff int64

+ DeSoToAddNanos uint64

+ DeSoToSellNanos uint64

+ OperationType string

+ type DAOCoinMetadata struct

+ CoinsToBurnNanos uint256.Int

+ CoinsToMintNanos uint256.Int

+ OperationType DAOCoinOperationType

+ ProfilePublicKey []byte

+ func (txnData *DAOCoinMetadata) FromBytes(data []byte) error

+ func (txnData *DAOCoinMetadata) GetTxnType() TxnType

+ func (txnData *DAOCoinMetadata) New() DeSoTxnMetadata

+ func (txnData *DAOCoinMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type DAOCoinOperationType uint8

+ const DAOCoinOperationTypeBurn

+ const DAOCoinOperationTypeDisableMinting

+ const DAOCoinOperationTypeMint

+ const DAOCoinOperationTypeUpdateTransferRestrictionStatus

+ type DAOCoinTransferMetadata struct

+ DAOCoinToTransferNanos uint256.Int

+ ProfilePublicKey []byte

+ ReceiverPublicKey []byte

+ func (txnData *DAOCoinTransferMetadata) FromBytes(data []byte) error

+ func (txnData *DAOCoinTransferMetadata) GetTxnType() TxnType

+ func (txnData *DAOCoinTransferMetadata) New() DeSoTxnMetadata

+ func (txnData *DAOCoinTransferMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type DAOCoinTransferTxindexMetadata struct

+ CreatorUsername string

+ DAOCoinToTransferNanos uint256.Int

+ type DAOCoinTxindexMetadata struct

+ CoinsToBurnNanos uint256.Int

+ CoinsToMintNanos uint256.Int

+ CreatorUsername string

+ OperationType string

+ TransferRestrictionStatus string

+ type DeSoBlockProducer struct

+ func NewDeSoBlockProducer(minBlockUpdateIntervalSeconds uint64, maxBlockTemplatesToCache uint64, ...) (*DeSoBlockProducer, error)

+ func (bbp *DeSoBlockProducer) GetLatestBlockTemplateStats() *BlockTemplateStats

+ func (blockProducer *DeSoBlockProducer) GetHeadersAndExtraDatas(publicKeyBytes []byte, numHeaders int64, headerVersion uint32) (_blockID string, _headers [][]byte, _extraNonces []uint64, ...)

+ func (desoBlockProducer *DeSoBlockProducer) AddBlockTemplate(block *MsgDeSoBlock, diffTarget *BlockHash)

+ func (desoBlockProducer *DeSoBlockProducer) GetCopyOfRecentBlock(blockID string) (*MsgDeSoBlock, error)

+ func (desoBlockProducer *DeSoBlockProducer) GetRecentBlock(blockHash *BlockHash) *MsgDeSoBlock

+ func (desoBlockProducer *DeSoBlockProducer) SignBlock(blockFound *MsgDeSoBlock) error

+ func (desoBlockProducer *DeSoBlockProducer) Start()

+ func (desoBlockProducer *DeSoBlockProducer) Stop()

+ func (desoBlockProducer *DeSoBlockProducer) UpdateLatestBlockTemplate() error

+ type DeSoBodySchema struct

+ Body string

+ ImageURLs []string

+ VideoURLs []string

+ type DeSoInput UtxoKey

+ func NewDeSoInput() *DeSoInput

+ func (desoInput *DeSoInput) String() string

+ type DeSoMempool struct

+ func NewDeSoMempool(_bc *Blockchain, _rateLimitFeerateNanosPerKB uint64, ...) *DeSoMempool

+ func (mp *DeSoMempool) BlockUntilReadOnlyViewRegenerated()

+ func (mp *DeSoMempool) CheckSpend(op UtxoKey) *MsgDeSoTxn

+ func (mp *DeSoMempool) Count() int

+ func (mp *DeSoMempool) DumpTxnsToDB()

+ func (mp *DeSoMempool) FetchTransaction(txHash *BlockHash) *MempoolTx

+ func (mp *DeSoMempool) GetAugmentedUniversalView() (*UtxoView, error)

+ func (mp *DeSoMempool) GetAugmentedUtxoViewForPublicKey(pkBytes []byte, optionalTxn *MsgDeSoTxn) (*UtxoView, error)

+ func (mp *DeSoMempool) GetMempoolSummaryStats() (_summaryStatsMap map[string]*SummaryStats)

+ func (mp *DeSoMempool) GetTransaction(txId *BlockHash) (txn *MempoolTx)

+ func (mp *DeSoMempool) GetTransactionsOrderedByTimeAdded() (_poolTxns []*MempoolTx, _unconnectedTxns []*UnconnectedTx, _err error)

+ func (mp *DeSoMempool) InefficientRemoveTransaction(tx *MsgDeSoTxn)

+ func (mp *DeSoMempool) IsTransactionInPool(hash *BlockHash) bool

+ func (mp *DeSoMempool) LoadTxnsFromDB()

+ func (mp *DeSoMempool) MempoolTxs() []*MempoolTx

+ func (mp *DeSoMempool) OpenTempDBAndDumpTxns() error

+ func (mp *DeSoMempool) ProcessTransaction(tx *MsgDeSoTxn, allowUnconnectedTxn bool, rateLimit bool, peerID uint64, ...) ([]*MempoolTx, error)

+ func (mp *DeSoMempool) ProcessUnconnectedTransactions(acceptedTx *MsgDeSoTxn, rateLimit bool, verifySignatures bool) []*MempoolTx

+ func (mp *DeSoMempool) PublicKeyTxnMap(publicKey []byte) (txnMap map[BlockHash]*MempoolTx)

+ func (mp *DeSoMempool) RegenerateReadOnlyView() error

+ func (mp *DeSoMempool) StartMempoolDBDumper()

+ func (mp *DeSoMempool) StartReadOnlyUtxoViewRegenerator()

+ func (mp *DeSoMempool) Stop()

+ func (mp *DeSoMempool) TryAcceptTransaction(tx *MsgDeSoTxn, rateLimit bool, verifySignatures bool) ([]*BlockHash, *MempoolTx, error)

+ func (mp *DeSoMempool) TxHashes() []*BlockHash

+ func (mp *DeSoMempool) UpdateAfterConnectBlock(blk *MsgDeSoBlock) (_txnsAddedToMempool []*MempoolTx)

+ func (mp *DeSoMempool) UpdateAfterDisconnectBlock(blk *MsgDeSoBlock)

+ type DeSoMessage interface

+ FromBytes func(data []byte) error

+ GetMsgType func() MsgType

+ ToBytes func(preSignature bool) ([]byte, error)

+ func NewMessage(msgType MsgType) DeSoMessage

+ func ReadMessage(rr io.Reader, networkType NetworkType) (DeSoMessage, []byte, error)

+ type DeSoMessageMeta struct

+ DeSoMessage DeSoMessage

+ Inbound bool

+ type DeSoMiner struct

+ BlockProducer *DeSoBlockProducer

+ PublicKeys []*btcec.PublicKey

+ func NewDeSoMiner(_minerPublicKeys []string, _numThreads uint32, ...) (*DeSoMiner, error)

+ func (desoMiner *DeSoMiner) MineAndProcessSingleBlock(threadIndex uint32, mempoolToUpdate *DeSoMempool) (_block *MsgDeSoBlock, _err error)

+ func (desoMiner *DeSoMiner) Start()

+ func (desoMiner *DeSoMiner) Stop()

+ type DeSoNode struct

+ Name string

+ Owner string

+ URL string

+ type DeSoOutput struct

+ AmountNanos uint64

+ PublicKey []byte

+ func (desoOutput *DeSoOutput) String() string

+ type DeSoParams struct

+ Base58PrefixPrivateKey [3]byte

+ Base58PrefixPublicKey [3]byte

+ BitcoinBtcdParams *chaincfg.Params

+ BitcoinBurnAddress string

+ BitcoinDoubleSpendWaitSeconds float64

+ BitcoinExchangeFeeBasisPoints uint64

+ BitcoinStartBlockNode *BlockNode

+ BlockRewardMaturity time.Duration

+ CreatorCoinAutoSellThresholdNanos uint64

+ CreatorCoinReserveRatio *big.Float

+ CreatorCoinSlope *big.Float

+ CreatorCoinTradeFeeBasisPoints uint64

+ DNSSeedGenerators [][]string

+ DNSSeeds []string

+ DeSoNanosPurchasedAtGenesis uint64

+ DefaultJSONPort uint16

+ DefaultSocketPort uint16

+ DialTimeout time.Duration

+ ForkHeights ForkHeights

+ GenesisBlock *MsgDeSoBlock

+ GenesisBlockHashHex string

+ MaxBlockSizeBytes uint64

+ MaxCreatorBasisPoints uint64

+ MaxDifficultyRetargetFactor int64

+ MaxFetchBlocks uint32

+ MaxNFTRoyaltyBasisPoints uint64

+ MaxPostBodyLengthBytes uint64

+ MaxPostSubLengthBytes uint64

+ MaxPrivateMessageLengthBytes uint64

+ MaxProfilePicDimensions uint64

+ MaxProfilePicLengthBytes uint64

+ MaxStakeMultipleBasisPoints uint64

+ MaxTipAge time.Duration

+ MaxTstampOffsetSeconds uint64

+ MaxUserDescriptionLengthBytes uint64

+ MaxUsernameLengthBytes uint64

+ MinChainWorkHex string

+ MinDifficultyTargetHex string

+ MinProtocolVersion uint64

+ MinerMaxBlockSizeBytes uint64

+ MiningIterationsPerCycle uint64

+ NetworkType NetworkType

+ ParamUpdaterPublicKeys map[PkMapKey]bool

+ ProtocolVersion uint64

+ SeedBalances []*DeSoOutput

+ SeedTxns []string

+ StakeFeeBasisPoints uint64

+ TimeBetweenBlocks time.Duration

+ TimeBetweenDifficultyRetargets time.Duration

+ UserAgent string

+ V1DifficultyAdjustmentFactor int64

+ VersionNegotiationTimeout time.Duration

+ func (params *DeSoParams) EnableRegtest()

+ type DeSoTxnMetadata interface

+ FromBytes func(data []byte) error

+ GetTxnType func() TxnType

+ New func() DeSoTxnMetadata

+ ToBytes func(preSignature bool) ([]byte, error)

+ func NewTxnMetadata(txType TxnType) (DeSoTxnMetadata, error)

+ type DerivedKeyEntry struct

+ DerivedPublicKey PublicKey

+ ExpirationBlock uint64

+ OperationType AuthorizeDerivedKeyOperationType

+ OwnerPublicKey PublicKey

+ func DBGetAllOwnerToDerivedKeyMappings(handle *badger.DB, ownerPublicKey PublicKey) (_entries []*DerivedKeyEntry, _err error)

+ func DBGetOwnerToDerivedKeyMapping(db *badger.DB, ownerPublicKey PublicKey, derivedPublicKey PublicKey) *DerivedKeyEntry

+ func DBGetOwnerToDerivedKeyMappingWithTxn(txn *badger.Txn, ownerPublicKey PublicKey, derivedPublicKey PublicKey) *DerivedKeyEntry

+ type DerivedKeyMapKey struct

+ DerivedPublicKey PublicKey

+ OwnerPublicKey PublicKey

+ func MakeDerivedKeyMapKey(ownerPublicKey PublicKey, derivedPublicKey PublicKey) DerivedKeyMapKey

+ type DiamondEntry struct

+ DiamondLevel int64

+ DiamondPostHash *BlockHash

+ ReceiverPKID *PKID

+ SenderPKID *PKID

+ func DbGetDiamondEntriesForSenderToReceiver(handle *badger.DB, receiverPKID *PKID, senderPKID *PKID) (_diamondEntries []*DiamondEntry, _err error)

+ func DbGetDiamondMappings(db *badger.DB, diamondReceiverPKID *PKID, diamondSenderPKID *PKID, ...) *DiamondEntry

+ func DbGetDiamondMappingsWithTxn(txn *badger.Txn, diamondReceiverPKID *PKID, diamondSenderPKID *PKID, ...) *DiamondEntry

+ type DiamondKey struct

+ DiamondPostHash BlockHash

+ ReceiverPKID PKID

+ SenderPKID PKID

+ func MakeDiamondKey(senderPKID *PKID, receiverPKID *PKID, diamondPostHash *BlockHash) DiamondKey

+ func (mm *DiamondKey) String() string

+ type EventManager struct

+ func NewEventManager() *EventManager

+ func (em *EventManager) OnBlockAccepted(handler BlockEventFunc)

+ func (em *EventManager) OnBlockConnected(handler BlockEventFunc)

+ func (em *EventManager) OnBlockDisconnected(handler BlockEventFunc)

+ func (em *EventManager) OnTransactionConnected(handler TransactionEventFunc)

+ type ExpectedResponse struct

+ MessageType MsgType

+ TimeExpected time.Time

+ type FollowEntry struct

+ FollowedPKID *PKID

+ FollowerPKID *PKID

+ type FollowKey struct

+ FollowedPKID PKID

+ FollowerPKID PKID

+ func MakeFollowKey(followerPKID *PKID, followedPKID *PKID) FollowKey

+ type FollowMetadata struct

+ FollowedPublicKey []byte

+ IsUnfollow bool

+ func (txnData *FollowMetadata) FromBytes(data []byte) error

+ func (txnData *FollowMetadata) GetTxnType() TxnType

+ func (txnData *FollowMetadata) New() DeSoTxnMetadata

+ func (txnData *FollowMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type FollowTxindexMetadata struct

+ IsUnfollow bool

+ type ForbiddenPubKeyEntry struct

+ PubKey []byte

+ type ForkHeights struct

+ BrokenNFTBidsFixBlockHeight uint32

+ BuyCreatorCoinAfterDeletedBalanceEntryFixBlockHeight uint32

+ BuyNowAndNFTSplitsBlockHeight uint32

+ DAOCoinBlockHeight uint32

+ DeSoDiamondsBlockHeight uint32

+ DeSoFounderRewardBlockHeight uint32

+ DeSoV3MessagesBlockHeight uint32

+ DeflationBombBlockHeight uint64

+ NFTTransferOrBurnAndDerivedKeysBlockHeight uint32

+ ParamUpdaterProfileUpdateFixBlockHeight uint32

+ SalomonFixBlockHeight uint32

+ UpdateProfileFixBlockHeight uint32

+ type GetDataRequestInfo struct

+ PeerWhoSentInv *Peer

+ TimeRequested time.Time

+ type GlobalParamsEntry struct

+ CreateNFTFeeNanos uint64

+ CreateProfileFeeNanos uint64

+ MaxCopiesPerNFT uint64

+ MinimumNetworkFeeNanosPerKB uint64

+ USDCentsPerBitcoin uint64

+ func DbGetGlobalParamsEntry(handle *badger.DB) *GlobalParamsEntry

+ func DbGetGlobalParamsEntryWithTxn(txn *badger.Txn) *GlobalParamsEntry

+ type GroupKeyName [MaxMessagingKeyNameCharacters]byte

+ func BaseGroupKeyName() *GroupKeyName

+ func DefaultGroupKeyName() *GroupKeyName

+ func NewGroupKeyName(groupKeyName []byte) *GroupKeyName

+ func (name *GroupKeyName) ToBytes() []byte

+ type HelpConnectNFTSoldStruct struct

+ BidAmountNanos uint64

+ BidderInputs []*DeSoInput

+ BidderPKID *PKID

+ BlockHeight uint32

+ NFTPostHash *BlockHash

+ PrevNFTBidEntry *NFTBidEntry

+ SerialNumber uint64

+ TxHash *BlockHash

+ Txn *MsgDeSoTxn

+ UnlockableText []byte

+ VerifySignatures bool

+ type InvType uint32

+ const InvTypeBlock

+ const InvTypeTx

+ func (invtype InvType) String() string

+ type InvVect struct

+ Hash BlockHash

+ Type InvType

+ func (invVect *InvVect) String() string

+ type LikeEntry struct

+ LikedPostHash *BlockHash

+ LikerPubKey []byte

+ type LikeKey struct

+ LikedPostHash BlockHash

+ LikerPubKey PkMapKey

+ func MakeLikeKey(userPk []byte, LikedPostHash BlockHash) LikeKey

+ type LikeMetadata struct

+ IsUnlike bool

+ LikedPostHash *BlockHash

+ func (txnData *LikeMetadata) FromBytes(data []byte) error

+ func (txnData *LikeMetadata) GetTxnType() TxnType

+ func (txnData *LikeMetadata) New() DeSoTxnMetadata

+ func (txnData *LikeMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type LikeTxindexMetadata struct

+ IsUnlike bool

+ PostHashHex string

+ type MempoolTx struct

+ Added time.Time

+ Fee uint64

+ FeePerKB uint64

+ Hash *BlockHash

+ Height uint32

+ Tx *MsgDeSoTxn

+ TxMeta *TransactionMetadata

+ TxSizeBytes uint64

+ func (mempoolTx *MempoolTx) String() string

+ type MempoolTxFeeMinHeap []*MempoolTx

+ func (pq *MempoolTxFeeMinHeap) Pop() interface{}

+ func (pq *MempoolTxFeeMinHeap) Push(x interface{})

+ func (pq MempoolTxFeeMinHeap) Len() int

+ func (pq MempoolTxFeeMinHeap) Less(i, j int) bool

+ func (pq MempoolTxFeeMinHeap) Swap(i, j int)

+ type MessageEntry struct

+ EncryptedText []byte

+ RecipientMessagingGroupKeyName *GroupKeyName

+ RecipientMessagingPublicKey *PublicKey

+ RecipientPublicKey *PublicKey

+ SenderMessagingGroupKeyName *GroupKeyName

+ SenderMessagingPublicKey *PublicKey

+ SenderPublicKey *PublicKey

+ TstampNanos uint64

+ Version uint8

+ func DBGetLimitedMessageForMessagingKeys(handle *badger.DB, messagingKeys []*MessagingGroupEntry, limit uint64) (_privateMessages []*MessageEntry, _err error)

+ func DBGetMessageEntriesForPublicKey(handle *badger.DB, publicKey []byte) (_privateMessages []*MessageEntry, _err error)

+ func DBGetMessageEntry(db *badger.DB, publicKey []byte, tstampNanos uint64) *MessageEntry

+ func DBGetMessageEntryWithTxn(txn *badger.Txn, publicKey []byte, tstampNanos uint64) *MessageEntry

+ func (message *MessageEntry) Decode(data []byte) error

+ func (message *MessageEntry) Encode() []byte

+ type MessageKey struct

+ BlockHeight uint32

+ PublicKey PublicKey

+ TstampNanos uint64

+ func MakeMessageKey(pk []byte, tstampNanos uint64) MessageKey

+ func (mm *MessageKey) String() string

+ func (mm *MessageKey) StringKey(params *DeSoParams) string

+ type MessagingGroupEntry struct

+ GroupOwnerPublicKey *PublicKey

+ MessagingGroupKeyName *GroupKeyName

+ MessagingGroupMembers []*MessagingGroupMember

+ MessagingPublicKey *PublicKey

+ func DBGetAllMessagingGroupEntriesForMemberWithTxn(txn *badger.Txn, ownerPublicKey *PublicKey) ([]*MessagingGroupEntry, error)

+ func DBGetAllUserGroupEntiresWithTxn(txn *badger.Txn, ownerPublicKey []byte) ([]*MessagingGroupEntry, error)

+ func DBGetAllUserGroupEntries(handle *badger.DB, ownerPublicKey []byte) ([]*MessagingGroupEntry, error)

+ func DBGetMessagingGroupEntriesForOwnerWithTxn(txn *badger.Txn, ownerPublicKey *PublicKey) (_messagingKeyEntries []*MessagingGroupEntry, _err error)

+ func DBGetMessagingGroupEntry(db *badger.DB, messagingGroupKey *MessagingGroupKey) *MessagingGroupEntry

+ func DBGetMessagingGroupEntryWithTxn(txn *badger.Txn, messagingGroupKey *MessagingGroupKey) *MessagingGroupEntry

+ func DBGetMessagingGroupMemberWithTxn(txn *badger.Txn, messagingGroupMember *MessagingGroupMember, ...) *MessagingGroupEntry

+ func DBGetMessagingMember(db *badger.DB, messagingMember *MessagingGroupMember, ...) *MessagingGroupEntry

+ func (entry *MessagingGroupEntry) Decode(data []byte) error

+ func (entry *MessagingGroupEntry) Encode() []byte

+ func (entry *MessagingGroupEntry) String() string

+ type MessagingGroupKey struct

+ GroupKeyName GroupKeyName

+ OwnerPublicKey PublicKey

+ func NewMessagingGroupKey(ownerPublicKey *PublicKey, groupKeyName []byte) *MessagingGroupKey

+ func (key *MessagingGroupKey) String() string

+ type MessagingGroupMember struct

+ EncryptedKey []byte

+ GroupMemberKeyName *GroupKeyName

+ GroupMemberPublicKey *PublicKey

+ func (rec *MessagingGroupMember) Decode(rr io.Reader) error

+ func (rec *MessagingGroupMember) Encode() []byte

+ type MessagingGroupMetadata struct

+ GroupOwnerSignature []byte

+ MessagingGroupKeyName []byte

+ MessagingGroupMembers []*MessagingGroupMember

+ MessagingPublicKey []byte

+ func (txnData *MessagingGroupMetadata) FromBytes(data []byte) error

+ func (txnData *MessagingGroupMetadata) GetTxnType() TxnType

+ func (txnData *MessagingGroupMetadata) New() DeSoTxnMetadata

+ func (txnData *MessagingGroupMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type MiningSupplyIntervalStart struct

+ BlockRewardNanos uint64

+ StartBlockHeight uint32

+ type MsgDeSoAddr struct

+ AddrList []*SingleAddr

+ func (msg *MsgDeSoAddr) FromBytes(data []byte) error

+ func (msg *MsgDeSoAddr) GetMsgType() MsgType

+ func (msg *MsgDeSoAddr) String() string

+ func (msg *MsgDeSoAddr) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoBitcoinManagerUpdate struct

+ TransactionsFound []*MsgDeSoTxn

+ func (msg *MsgDeSoBitcoinManagerUpdate) FromBytes(data []byte) error

+ func (msg *MsgDeSoBitcoinManagerUpdate) GetMsgType() MsgType

+ func (msg *MsgDeSoBitcoinManagerUpdate) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoBlock struct

+ BlockProducerInfo *BlockProducerInfo

+ Header *MsgDeSoHeader

+ Txns []*MsgDeSoTxn

+ func GetBlock(blockHash *BlockHash, handle *badger.DB) (*MsgDeSoBlock, error)

+ func GetBlockWithTxn(txn *badger.Txn, blockHash *BlockHash) *MsgDeSoBlock

+ func (msg *MsgDeSoBlock) EncodeBlockCommmon(preSignature bool) ([]byte, error)

+ func (msg *MsgDeSoBlock) EncodeBlockVersion0(preSignature bool) ([]byte, error)

+ func (msg *MsgDeSoBlock) EncodeBlockVersion1(preSignature bool) ([]byte, error)

+ func (msg *MsgDeSoBlock) FromBytes(data []byte) error

+ func (msg *MsgDeSoBlock) GetMsgType() MsgType

+ func (msg *MsgDeSoBlock) Hash() (*BlockHash, error)

+ func (msg *MsgDeSoBlock) String() string

+ func (msg *MsgDeSoBlock) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoDonePeer struct

+ func (msg *MsgDeSoDonePeer) FromBytes(data []byte) error

+ func (msg *MsgDeSoDonePeer) GetMsgType() MsgType

+ func (msg *MsgDeSoDonePeer) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoGetAddr struct

+ func (msg *MsgDeSoGetAddr) FromBytes(data []byte) error

+ func (msg *MsgDeSoGetAddr) GetMsgType() MsgType

+ func (msg *MsgDeSoGetAddr) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoGetBlocks struct

+ HashList []*BlockHash

+ func (msg *MsgDeSoGetBlocks) FromBytes(data []byte) error

+ func (msg *MsgDeSoGetBlocks) GetMsgType() MsgType

+ func (msg *MsgDeSoGetBlocks) String() string

+ func (msg *MsgDeSoGetBlocks) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoGetHeaders struct

+ BlockLocator []*BlockHash

+ StopHash *BlockHash

+ func (msg *MsgDeSoGetHeaders) FromBytes(data []byte) error

+ func (msg *MsgDeSoGetHeaders) GetMsgType() MsgType

+ func (msg *MsgDeSoGetHeaders) String() string

+ func (msg *MsgDeSoGetHeaders) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoGetTransactions struct

+ HashList []*BlockHash

+ func (msg *MsgDeSoGetTransactions) FromBytes(data []byte) error

+ func (msg *MsgDeSoGetTransactions) GetMsgType() MsgType

+ func (msg *MsgDeSoGetTransactions) String() string

+ func (msg *MsgDeSoGetTransactions) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoHeader struct

+ ExtraNonce uint64

+ Height uint64

+ Nonce uint64

+ PrevBlockHash *BlockHash

+ TransactionMerkleRoot *BlockHash

+ TstampSecs uint64

+ Version uint32

+ func DecodeHeader(rr io.Reader) (*MsgDeSoHeader, error)

+ func DecodeHeaderVersion0(rr io.Reader) (*MsgDeSoHeader, error)

+ func DecodeHeaderVersion1(rr io.Reader) (*MsgDeSoHeader, error)

+ func (msg *MsgDeSoHeader) EncodeHeaderVersion0(preSignature bool) ([]byte, error)

+ func (msg *MsgDeSoHeader) EncodeHeaderVersion1(preSignature bool) ([]byte, error)

+ func (msg *MsgDeSoHeader) FromBytes(data []byte) error

+ func (msg *MsgDeSoHeader) GetMsgType() MsgType

+ func (msg *MsgDeSoHeader) Hash() (*BlockHash, error)

+ func (msg *MsgDeSoHeader) String() string

+ func (msg *MsgDeSoHeader) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoHeaderBundle struct

+ Headers []*MsgDeSoHeader

+ TipHash *BlockHash

+ TipHeight uint32

+ func (msg *MsgDeSoHeaderBundle) FromBytes(data []byte) error

+ func (msg *MsgDeSoHeaderBundle) GetMsgType() MsgType

+ func (msg *MsgDeSoHeaderBundle) String() string

+ func (msg *MsgDeSoHeaderBundle) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoInv struct

+ InvList []*InvVect

+ IsSyncResponse bool

+ func (msg *MsgDeSoInv) FromBytes(data []byte) error

+ func (msg *MsgDeSoInv) GetMsgType() MsgType

+ func (msg *MsgDeSoInv) String() string

+ func (msg *MsgDeSoInv) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoMempool struct

+ func (msg *MsgDeSoMempool) FromBytes(data []byte) error

+ func (msg *MsgDeSoMempool) GetMsgType() MsgType

+ func (msg *MsgDeSoMempool) String() string

+ func (msg *MsgDeSoMempool) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoNewPeer struct

+ func (msg *MsgDeSoNewPeer) FromBytes(data []byte) error

+ func (msg *MsgDeSoNewPeer) GetMsgType() MsgType

+ func (msg *MsgDeSoNewPeer) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoPing struct

+ Nonce uint64

+ func (msg *MsgDeSoPing) FromBytes(data []byte) error

+ func (msg *MsgDeSoPing) GetMsgType() MsgType

+ func (msg *MsgDeSoPing) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoPong struct

+ Nonce uint64

+ func (msg *MsgDeSoPong) FromBytes(data []byte) error

+ func (msg *MsgDeSoPong) GetMsgType() MsgType

+ func (msg *MsgDeSoPong) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoQuit struct

+ func (msg *MsgDeSoQuit) FromBytes(data []byte) error

+ func (msg *MsgDeSoQuit) GetMsgType() MsgType

+ func (msg *MsgDeSoQuit) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoTransactionBundle struct

+ Transactions []*MsgDeSoTxn

+ func (msg *MsgDeSoTransactionBundle) FromBytes(data []byte) error

+ func (msg *MsgDeSoTransactionBundle) GetMsgType() MsgType

+ func (msg *MsgDeSoTransactionBundle) String() string

+ func (msg *MsgDeSoTransactionBundle) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoTxn struct

+ ExtraData map[string][]byte

+ PublicKey []byte

+ Signature *btcec.Signature

+ TxInputs []*DeSoInput

+ TxOutputs []*DeSoOutput

+ TxnMeta DeSoTxnMetadata

+ TxnTypeJSON uint64

+ func DbGetAllMempoolTxnsSortedByTimeAdded(handle *badger.DB) (_mempoolTxns []*MsgDeSoTxn, _error error)

+ func DbGetMempoolTxn(db *badger.DB, mempoolTx *MempoolTx) *MsgDeSoTxn

+ func DbGetMempoolTxnWithTxn(txn *badger.Txn, mempoolTx *MempoolTx) *MsgDeSoTxn

+ func ExtractBitcoinExchangeTransactionsFromBitcoinBlock(bitcoinBlock *wire.MsgBlock, burnAddress string, params *DeSoParams) (_txns []*MsgDeSoTxn, _err error)

+ func (msg *MsgDeSoTxn) Copy() (*MsgDeSoTxn, error)

+ func (msg *MsgDeSoTxn) FromBytes(data []byte) error

+ func (msg *MsgDeSoTxn) GetMsgType() MsgType

+ func (msg *MsgDeSoTxn) Hash() *BlockHash

+ func (msg *MsgDeSoTxn) MarshalJSON() ([]byte, error)

+ func (msg *MsgDeSoTxn) Sign(privKey *btcec.PrivateKey) (*btcec.Signature, error)

+ func (msg *MsgDeSoTxn) String() string

+ func (msg *MsgDeSoTxn) ToBytes(preSignature bool) ([]byte, error)

+ func (msg *MsgDeSoTxn) UnmarshalJSON(data []byte) error

+ type MsgDeSoVerack struct

+ Nonce uint64

+ func (msg *MsgDeSoVerack) FromBytes(data []byte) error

+ func (msg *MsgDeSoVerack) GetMsgType() MsgType

+ func (msg *MsgDeSoVerack) ToBytes(preSignature bool) ([]byte, error)

+ type MsgDeSoVersion struct

+ MinFeeRateNanosPerKB uint64

+ Nonce uint64

+ Services ServiceFlag

+ StartBlockHeight uint32

+ TstampSecs int64

+ UserAgent string

+ Version uint64

+ func (msg *MsgDeSoVersion) FromBytes(data []byte) error

+ func (msg *MsgDeSoVersion) GetMsgType() MsgType

+ func (msg *MsgDeSoVersion) ToBytes(preSignature bool) ([]byte, error)

+ type MsgType uint64

+ const ControlMessagesStart

+ const MsgTypeAddr

+ const MsgTypeBitcoinManagerUpdate

+ const MsgTypeBlock

+ const MsgTypeBlockAccepted

+ const MsgTypeDonePeer

+ const MsgTypeGetAddr

+ const MsgTypeGetBlocks

+ const MsgTypeGetHeaders

+ const MsgTypeGetTransactions

+ const MsgTypeHeader

+ const MsgTypeHeaderBundle

+ const MsgTypeInv

+ const MsgTypeMempool

+ const MsgTypeNewPeer

+ const MsgTypePing

+ const MsgTypePong

+ const MsgTypeQuit

+ const MsgTypeTransactionBundle

+ const MsgTypeTxn

+ const MsgTypeUnset

+ const MsgTypeVerack

+ const MsgTypeVersion

+ func (msgType MsgType) String() string

+ type NFTBidEntry struct

+ AcceptedBlockHeight *uint32

+ BidAmountNanos uint64

+ BidderPKID *PKID

+ NFTPostHash *BlockHash

+ SerialNumber uint64

+ func DBGetNFTBidEntries(handle *badger.DB, nftPostHash *BlockHash, serialNumber uint64) (_nftBidEntries []*NFTBidEntry)

+ func DBGetNFTBidEntriesForPKID(handle *badger.DB, bidderPKID *PKID) (_nftBidEntries []*NFTBidEntry)

+ func DBGetNFTBidEntriesPaginated(handle *badger.DB, nftHash *BlockHash, serialNumber uint64, ...) (_bidEntries []*NFTBidEntry)

+ func DBGetNFTBidEntryForNFTBidKey(db *badger.DB, nftBidKey *NFTBidKey) *NFTBidEntry

+ func DBGetNFTBidEntryForNFTBidKeyWithTxn(txn *badger.Txn, nftBidKey *NFTBidKey) *NFTBidEntry

+ func (nftBidEntry *NFTBidEntry) Copy() *NFTBidEntry

+ type NFTBidKey struct

+ BidderPKID PKID

+ NFTPostHash BlockHash

+ SerialNumber uint64

+ func MakeNFTBidKey(bidderPKID *PKID, nftPostHash *BlockHash, serialNumber uint64) NFTBidKey

+ type NFTBidMetadata struct

+ BidAmountNanos uint64

+ NFTPostHash *BlockHash

+ SerialNumber uint64

+ func (txnData *NFTBidMetadata) FromBytes(dataa []byte) error

+ func (txnData *NFTBidMetadata) GetTxnType() TxnType

+ func (txnData *NFTBidMetadata) New() DeSoTxnMetadata

+ func (txnData *NFTBidMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type NFTBidTxindexMetadata struct

+ BidAmountNanos uint64

+ IsBuyNowBid bool

+ NFTPostHashHex string

+ OwnerPublicKeyBase58Check string

+ SerialNumber uint64

+ type NFTEntry struct

+ BuyNowPriceNanos uint64

+ IsBuyNow bool

+ IsForSale bool

+ IsPending bool

+ LastAcceptedBidAmountNanos uint64

+ LastOwnerPKID *PKID

+ MinBidAmountNanos uint64

+ NFTPostHash *BlockHash

+ OwnerPKID *PKID

+ SerialNumber uint64

+ UnlockableText []byte

+ func DBGetNFTEntriesForPKID(handle *badger.DB, ownerPKID *PKID) (_nftEntries []*NFTEntry)

+ func DBGetNFTEntriesForPostHash(handle *badger.DB, nftPostHash *BlockHash) (_nftEntries []*NFTEntry)

+ func DBGetNFTEntryByNFTOwnershipDetails(db *badger.DB, ownerPKID *PKID, isForSale bool, bidAmountNanos uint64, ...) *NFTEntry

+ func DBGetNFTEntryByNFTOwnershipDetailsWithTxn(txn *badger.Txn, ownerPKID *PKID, isForSale bool, bidAmountNanos uint64, ...) *NFTEntry

+ func DBGetNFTEntryByPostHashSerialNumber(db *badger.DB, postHash *BlockHash, serialNumber uint64) *NFTEntry

+ func DBGetNFTEntryByPostHashSerialNumberWithTxn(txn *badger.Txn, postHash *BlockHash, serialNumber uint64) *NFTEntry

+ type NFTKey struct

+ NFTPostHash BlockHash

+ SerialNumber uint64

+ func MakeNFTKey(nftPostHash *BlockHash, serialNumber uint64) NFTKey

+ type NFTRoyaltiesMetadata struct

+ AdditionalCoinRoyaltiesMap map[string]uint64

+ AdditionalDESORoyaltiesMap map[string]uint64

+ CreatorCoinRoyaltyNanos uint64

+ CreatorPublicKeyBase58Check string

+ CreatorRoyaltyNanos uint64

+ type NFTTransferMetadata struct

+ NFTPostHash *BlockHash

+ ReceiverPublicKey []byte

+ SerialNumber uint64

+ UnlockableText []byte

+ func (txnData *NFTTransferMetadata) FromBytes(dataa []byte) error

+ func (txnData *NFTTransferMetadata) GetTxnType() TxnType

+ func (txnData *NFTTransferMetadata) New() DeSoTxnMetadata

+ func (txnData *NFTTransferMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type NFTTransferTxindexMetadata struct

+ NFTPostHashHex string

+ SerialNumber uint64

+ type NetworkType uint64

+ const NetworkType_MAINNET

+ const NetworkType_TESTNET

+ const NetworkType_UNSET

+ func (nt NetworkType) String() string

+ type NotificationType uint8

+ const NotificationCoinDiamond

+ const NotificationCoinPurchase

+ const NotificationCoinTransfer

+ const NotificationDESODiamond

+ const NotificationFollow

+ const NotificationLike

+ const NotificationPostMention

+ const NotificationPostReply

+ const NotificationPostRepost

+ const NotificationSendDESO

+ const NotificationUnknown

+ type Notifier struct

+ func NewNotifier(coreChain *Blockchain, postgres *Postgres) *Notifier

+ func (notifier *Notifier) Start()

+ func (notifier *Notifier) Update() error

+ type OperationType uint

+ const OperationTypeAcceptNFTBid

+ const OperationTypeAcceptNFTTransfer

+ const OperationTypeAddUtxo

+ const OperationTypeAuthorizeDerivedKey

+ const OperationTypeBitcoinExchange

+ const OperationTypeBurnNFT

+ const OperationTypeCreateNFT

+ const OperationTypeCreatorCoin

+ const OperationTypeCreatorCoinTransfer

+ const OperationTypeDAOCoin

+ const OperationTypeDAOCoinTransfer

+ const OperationTypeDeSoDiamond

+ const OperationTypeDeletePost

+ const OperationTypeFollow

+ const OperationTypeLike

+ const OperationTypeMessagingKey

+ const OperationTypeNFTBid

+ const OperationTypeNFTTransfer

+ const OperationTypePrivateMessage

+ const OperationTypeSpendUtxo

+ const OperationTypeSubmitPost

+ const OperationTypeSwapIdentity

+ const OperationTypeUpdateBitcoinUSDExchangeRate

+ const OperationTypeUpdateGlobalParams

+ const OperationTypeUpdateNFT

+ const OperationTypeUpdateProfile

+ func (op OperationType) String() string

+ type OrphanBlock struct

+ Block *MsgDeSoBlock

+ Hash *BlockHash

+ type PGBalance struct

+ BalanceNanos uint64

+ PublicKey *PublicKey

+ type PGBlock struct

+ CumWork *BlockHash

+ DifficultyTarget *BlockHash

+ ExtraNonce uint64

+ Hash *BlockHash

+ Height uint64

+ Nonce uint64

+ Notified bool

+ ParentHash *BlockHash

+ Status BlockStatus

+ Timestamp uint64

+ TxMerkleRoot *BlockHash

+ Version uint32

+ type PGChain struct

+ Name string

+ TipHash *BlockHash

+ type PGCreatorCoinBalance struct

+ BalanceNanos uint64

+ CreatorPKID *PKID

+ HasPurchased bool

+ HolderPKID *PKID

+ func (balance *PGCreatorCoinBalance) NewBalanceEntry() *BalanceEntry

+ type PGDAOCoinBalance struct

+ BalanceNanos string

+ CreatorPKID *PKID

+ HasPurchased bool

+ HolderPKID *PKID

+ func (balance *PGDAOCoinBalance) NewBalanceEntry() *BalanceEntry

+ type PGDerivedKey struct

+ DerivedPublicKey PublicKey

+ ExpirationBlock uint64

+ OperationType AuthorizeDerivedKeyOperationType

+ OwnerPublicKey PublicKey

+ func (key *PGDerivedKey) NewDerivedKeyEntry() *DerivedKeyEntry

+ type PGDiamond struct

+ DiamondLevel uint8

+ DiamondPostHash *BlockHash

+ ReceiverPKID *PKID

+ SenderPKID *PKID

+ type PGFollow struct

+ FollowedPKID *PKID

+ FollowerPKID *PKID

+ func (follow *PGFollow) NewFollowEntry() *FollowEntry

+ type PGForbiddenKey struct

+ PublicKey *PublicKey

+ type PGGlobalParams struct

+ CreateNFTFeeNanos uint64

+ CreateProfileFeeNanos uint64

+ ID uint64

+ MaxCopiesPerNFT uint64

+ MinNetworkFeeNanosPerKB uint64

+ USDCentsPerBitcoin uint64

+ type PGLike struct

+ LikedPostHash *BlockHash

+ LikerPublicKey []byte

+ func (like *PGLike) NewLikeEntry() *LikeEntry

+ type PGMessage struct

+ EncryptedText []byte

+ MessageHash *BlockHash

+ RecipientPublicKey []byte

+ SenderPublicKey []byte

+ TimestampNanos uint64

+ type PGMessagingGroup struct

+ GroupOwnerPublicKey *PublicKey

+ MessagingGroupKeyName *GroupKeyName

+ MessagingGroupMembers []byte

+ MessagingPublicKey *PublicKey

+ type PGMetadataAcceptNFTBid struct

+ BidAmountNanos uint64

+ BidderInputs []*PGMetadataBidInput

+ BidderPKID *PKID

+ NFTPostHash *BlockHash

+ SerialNumber uint64

+ TransactionHash *BlockHash

+ UnlockableText []byte

+ type PGMetadataAcceptNFTTransfer struct

+ NFTPostHash *BlockHash

+ SerialNumber uint64

+ TransactionHash *BlockHash

+ type PGMetadataBidInput struct

+ InputHash *BlockHash

+ InputIndex uint32

+ TransactionHash *BlockHash

+ type PGMetadataBitcoinExchange struct

+ BitcoinBlockHash *BlockHash

+ BitcoinMerkleRoot *BlockHash

+ TransactionHash *BlockHash

+ type PGMetadataBlockReward struct

+ ExtraData []byte

+ TransactionHash *BlockHash

+ type PGMetadataBurnNFT struct

+ NFTPostHash *BlockHash

+ SerialNumber uint64

+ TransactionHash *BlockHash

+ type PGMetadataCreateNFT struct

+ CoinRoyaltyBasisPoints uint64

+ CreatorRoyaltyBasisPoints uint64

+ HasUnlockable bool

+ IsForSale bool

+ MinBidAmountNanos uint64

+ NFTPostHash *BlockHash

+ NumCopies uint64

+ TransactionHash *BlockHash

+ type PGMetadataCreatorCoin struct

+ CreatorCoinToSellNanos uint64

+ DeSoToAddNanos uint64

+ DeSoToSellNanos uint64

+ MinCreatorCoinExpectedNanos uint64

+ MinDeSoExpectedNanos uint64

+ OperationType CreatorCoinOperationType

+ ProfilePublicKey []byte

+ TransactionHash *BlockHash

+ type PGMetadataCreatorCoinTransfer struct

+ CreatorCoinToTransferNanos uint64

+ ProfilePublicKey []byte

+ ReceiverPublicKey []byte

+ TransactionHash *BlockHash

+ type PGMetadataDAOCoin struct

+ CoinsToBurnNanos string

+ CoinsToMintNanos string

+ OperationType DAOCoinOperationType

+ ProfilePublicKey []byte

+ TransactionHash *BlockHash

+ type PGMetadataDAOCoinTransfer struct

+ DAOCoinToTransferNanos string

+ ProfilePublicKey []byte

+ ReceiverPublicKey []byte

+ TransactionHash *BlockHash

+ type PGMetadataDerivedKey struct

+ AccessSignature []byte

+ DerivedPublicKey PublicKey

+ ExpirationBlock uint64

+ OperationType AuthorizeDerivedKeyOperationType

+ TransactionHash *BlockHash

+ type PGMetadataFollow struct

+ FollowedPublicKey []byte

+ IsUnfollow bool

+ TransactionHash *BlockHash

+ type PGMetadataLike struct

+ IsUnlike bool

+ LikedPostHash *BlockHash

+ TransactionHash *BlockHash

+ type PGMetadataNFTBid struct

+ BidAmountNanos uint64

+ NFTPostHash *BlockHash

+ SerialNumber uint64

+ TransactionHash *BlockHash

+ type PGMetadataNFTTransfer struct

+ NFTPostHash *BlockHash

+ ReceiverPublicKey []byte

+ SerialNumber uint64

+ TransactionHash *BlockHash

+ UnlockableText []byte

+ type PGMetadataPrivateMessage struct

+ EncryptedText []byte

+ RecipientPublicKey []byte

+ TimestampNanos uint64

+ TransactionHash *BlockHash

+ type PGMetadataSubmitPost struct

+ Body []byte

+ IsHidden bool

+ ParentStakeID *BlockHash

+ PostHashToModify *BlockHash

+ TimestampNanos uint64

+ TransactionHash *BlockHash

+ type PGMetadataSwapIdentity struct

+ FromPublicKey []byte

+ ToPublicKey []byte

+ TransactionHash *BlockHash

+ type PGMetadataUpdateExchangeRate struct

+ TransactionHash *BlockHash

+ USDCentsPerBitcoin uint64

+ type PGMetadataUpdateNFT struct

+ IsForSale bool

+ MinBidAmountNanos uint64

+ NFTPostHash *BlockHash

+ SerialNumber uint64

+ TransactionHash *BlockHash

+ type PGMetadataUpdateProfile struct

+ NewCreatorBasisPoints uint64

+ NewDescription []byte

+ NewProfilePic []byte

+ NewUsername []byte

+ ProfilePublicKey []byte

+ TransactionHash *BlockHash

+ type PGNFT struct

+ BuyNowPriceNanos uint64

+ ForSale bool

+ IsBuyNow bool

+ IsPending bool

+ LastAcceptedBidAmountNanos uint64

+ LastOwnerPKID *PKID

+ MinBidAmountNanos uint64

+ NFTPostHash *BlockHash

+ OwnerPKID *PKID

+ SerialNumber uint64

+ UnlockableText string

+ func (nft *PGNFT) NewNFTEntry() *NFTEntry

+ type PGNFTBid struct

+ Accepted bool

+ AcceptedBlockHeight *uint32

+ BidAmountNanos uint64

+ BidderPKID *PKID

+ NFTPostHash *BlockHash

+ SerialNumber uint64

+ func (bid *PGNFTBid) NewNFTBidEntry() *NFTBidEntry

+ type PGNotification struct

+ Amount uint64

+ FromUser []byte

+ Mined bool

+ OtherUser []byte

+ PostHash *BlockHash

+ Timestamp uint64

+ ToUser []byte

+ TransactionHash *BlockHash

+ Type NotificationType

+ type PGPost struct

+ AdditionalNFTRoyaltiesToCoinsBasisPoints map[string]uint64

+ AdditionalNFTRoyaltiesToCreatorsBasisPoints map[string]uint64

+ Body string

+ CoinRoyaltyBasisPoints uint64

+ CommentCount uint64

+ CreatorRoyaltyBasisPoints uint64

+ DiamondCount uint64

+ ExtraData map[string][]byte

+ Hidden bool

+ LikeCount uint64

+ NFT bool

+ NumNFTCopies uint64

+ NumNFTCopiesBurned uint64

+ NumNFTCopiesForSale uint64

+ ParentPostHash *BlockHash

+ Pinned bool

+ PostHash *BlockHash

+ PosterPublicKey []byte

+ QuoteRepostCount uint64

+ QuotedRepost bool

+ RepostCount uint64

+ RepostedPostHash *BlockHash

+ Timestamp uint64

+ Unlockable bool

+ func (post *PGPost) HasMedia() bool

+ func (post *PGPost) NewPostEntry() *PostEntry

+ type PGProfile struct

+ CoinWatermarkNanos uint64

+ CoinsInCirculationNanos uint64

+ CreatorBasisPoints uint64

+ DAOCoinCoinsInCirculationNanos string

+ DAOCoinMintingDisabled bool

+ DAOCoinNumberOfHolders uint64

+ DAOCoinTransferRestrictionStatus TransferRestrictionStatus

+ DeSoLockedNanos uint64

+ Description string

+ MintingDisabled bool

+ NumberOfHolders uint64

+ PKID *PKID

+ ProfilePic []byte

+ PublicKey *PublicKey

+ Username string

+ func (profile *PGProfile) Empty() bool

+ type PGRepost struct

+ RepostPostHash *BlockHash

+ RepostedPostHash *BlockHash

+ ReposterPublickey *PublicKey

+ type PGTransaction struct

+ BlockHash *BlockHash

+ ExtraData map[string][]byte

+ Hash *BlockHash

+ MetadataAcceptNFTBid *PGMetadataAcceptNFTBid

+ MetadataAcceptNFTTransfer *PGMetadataAcceptNFTTransfer

+ MetadataBitcoinExchange *PGMetadataBitcoinExchange

+ MetadataBlockReward *PGMetadataBlockReward

+ MetadataBurnNFT *PGMetadataBurnNFT

+ MetadataCreateNFT *PGMetadataCreateNFT

+ MetadataCreatorCoin *PGMetadataCreatorCoin

+ MetadataCreatorCoinTransfer *PGMetadataCreatorCoinTransfer

+ MetadataDAOCoin *PGMetadataDAOCoin

+ MetadataDAOCoinTransfer *PGMetadataDAOCoinTransfer

+ MetadataDerivedKey *PGMetadataDerivedKey

+ MetadataFollow *PGMetadataFollow

+ MetadataLike *PGMetadataLike

+ MetadataNFTBid *PGMetadataNFTBid

+ MetadataNFTTransfer *PGMetadataNFTTransfer

+ MetadataPrivateMessage *PGMetadataPrivateMessage

+ MetadataSubmitPost *PGMetadataSubmitPost

+ MetadataSwapIdentity *PGMetadataSwapIdentity

+ MetadataUpdateExchangeRate *PGMetadataUpdateExchangeRate

+ MetadataUpdateNFT *PGMetadataUpdateNFT

+ MetadataUpdateProfile *PGMetadataUpdateProfile

+ Outputs []*PGTransactionOutput

+ PublicKey []byte

+ R *BlockHash

+ S *BlockHash

+ Type TxnType

+ type PGTransactionOutput struct

+ AmountNanos uint64

+ Height uint32

+ InputHash *BlockHash

+ InputIndex uint32

+ OutputHash *BlockHash

+ OutputIndex uint32

+ OutputType UtxoType

+ PublicKey []byte

+ Spent bool

+ func (utxo *PGTransactionOutput) NewUtxoEntry() *UtxoEntry

+ type PKID [33]byte

+ func DBGetPKIDForUsername(db *badger.DB, username []byte) *PKID

+ func DBGetPKIDForUsernameWithTxn(txn *badger.Txn, username []byte) *PKID

+ func DbGetPKIDsFollowingYou(handle *badger.DB, yourPKID *PKID) (_pkids []*PKID, _err error)

+ func DbGetPKIDsYouFollow(handle *badger.DB, yourPKID *PKID) (_pkids []*PKID, _err error)

+ func NewPKID(pkidBytes []byte) *PKID

+ func PublicKeyToPKID(publicKey []byte) *PKID

+ func (pkid *PKID) NewPKID() *PKID

+ func (pkid *PKID) ToBytes() []byte

+ type PKIDEntry struct

+ PKID *PKID

+ PublicKey []byte

+ func DBGetPKIDEntryForPublicKey(db *badger.DB, publicKey []byte) *PKIDEntry

+ func DBGetPKIDEntryForPublicKeyWithTxn(txn *badger.Txn, publicKey []byte) *PKIDEntry

+ func (pkid *PKIDEntry) String() string

+ type Peer struct

+ ID uint64

+ LastPingMicros int64

+ LastPingNonce uint64

+ LastPingTime time.Time

+ MessageChan chan *ServerMessage

+ Params *DeSoParams

+ PeerInfoMtx deadlock.Mutex

+ PeerManuallyRemovedFromConnectionManager bool

+ StatsMtx deadlock.RWMutex

+ func NewPeer(_conn net.Conn, _isOutbound bool, _netAddr *wire.NetAddress, ...) *Peer

+ func (pp *Peer) AddDeSoMessage(desoMessage DeSoMessage, inbound bool)

+ func (pp *Peer) Address() string

+ func (pp *Peer) Connected() bool

+ func (pp *Peer) Disconnect()

+ func (pp *Peer) HandleGetBlocks(msg *MsgDeSoGetBlocks)

+ func (pp *Peer) HandleGetTransactionsMsg(getTxnMsg *MsgDeSoGetTransactions)

+ func (pp *Peer) HandleInv(msg *MsgDeSoInv)

+ func (pp *Peer) HandleTransactionBundleMessage(msg *MsgDeSoTransactionBundle)

+ func (pp *Peer) HelpHandleInv(msg *MsgDeSoInv)

+ func (pp *Peer) IP() string

+ func (pp *Peer) IsOutbound() bool

+ func (pp *Peer) IsSyncCandidate() bool

+ func (pp *Peer) MaybeDequeueDeSoMessage() *DeSoMessageMeta

+ func (pp *Peer) MinFeeRateNanosPerKB() uint64

+ func (pp *Peer) NegotiateVersion(versionNegotiationTimeout time.Duration) error

+ func (pp *Peer) NewVersionMessage(params *DeSoParams) *MsgDeSoVersion

+ func (pp *Peer) NumBlocksToSend() uint32

+ func (pp *Peer) Port() uint16

+ func (pp *Peer) QueueMessage(desoMessage DeSoMessage)

+ func (pp *Peer) ReadDeSoMessage() (DeSoMessage, error)

+ func (pp *Peer) Start()

+ func (pp *Peer) StartDeSoMessageProcessor()

+ func (pp *Peer) StartingBlockHeight() uint32

+ func (pp *Peer) String() string

+ func (pp *Peer) WriteDeSoMessage(msg DeSoMessage) error

+ type PkMapKey [btcec.PubKeyBytesLenCompressed]byte

+ func MakePkMapKey(pk []byte) PkMapKey

+ func (mm PkMapKey) String() string

+ type PostEntry struct

+ AdditionalNFTRoyaltiesToCoinsBasisPoints map[PKID]uint64

+ AdditionalNFTRoyaltiesToCreatorsBasisPoints map[PKID]uint64

+ Body []byte

+ CommentCount uint64

+ ConfirmationBlockHeight uint32

+ CreatorBasisPoints uint64

+ DiamondCount uint64

+ HasUnlockable bool

+ IsHidden bool

+ IsNFT bool

+ IsPinned bool

+ IsQuotedRepost bool

+ LikeCount uint64

+ NFTRoyaltyToCoinBasisPoints uint64

+ NFTRoyaltyToCreatorBasisPoints uint64

+ NumNFTCopies uint64

+ NumNFTCopiesBurned uint64

+ NumNFTCopiesForSale uint64

+ ParentStakeID []byte

+ PostExtraData map[string][]byte

+ PostHash *BlockHash

+ PosterPublicKey []byte

+ QuoteRepostCount uint64

+ RepostCount uint64

+ RepostedPostHash *BlockHash

+ StakeMultipleBasisPoints uint64

+ TimestampNanos uint64

+ func DBGetPostEntryByPostHash(db *badger.DB, postHash *BlockHash) *PostEntry

+ func DBGetPostEntryByPostHashWithTxn(txn *badger.Txn, postHash *BlockHash) *PostEntry

+ func (pe *PostEntry) HasMedia() bool

+ func (pe *PostEntry) IsDeleted() bool

+ type PostEntryReaderState struct

+ DiamondLevelBestowed int64

+ LikedByReader bool

+ RepostPostHashHex string

+ RepostedByReader bool

+ type Postgres struct

+ func NewPostgres(db *pg.DB) *Postgres

+ func (postgres *Postgres) FlushView(view *UtxoView) error

+ func (postgres *Postgres) GetAllDerivedKeysForOwner(ownerPublicKey *PublicKey) []*PGDerivedKey

+ func (postgres *Postgres) GetBalance(publicKey *PublicKey) uint64

+ func (postgres *Postgres) GetBlockIndex() (map[BlockHash]*BlockNode, error)

+ func (postgres *Postgres) GetBlockRewardsForPublicKey(publicKey *PublicKey, startHeight uint32, endHeight uint32) []*PGTransactionOutput

+ func (postgres *Postgres) GetChain(name string) *PGChain

+ func (postgres *Postgres) GetComments(parentPostHash *BlockHash) []*PGPost

+ func (postgres *Postgres) GetCreatorCoinBalance(holderPkid *PKID, creatorPkid *PKID) *PGCreatorCoinBalance

+ func (postgres *Postgres) GetCreatorCoinBalances(balances []*PGCreatorCoinBalance) []*PGCreatorCoinBalance

+ func (postgres *Postgres) GetCreatorCoinHolders(pkid *PKID) []*PGCreatorCoinBalance

+ func (postgres *Postgres) GetCreatorCoinHoldings(pkid *PKID) []*PGCreatorCoinBalance

+ func (postgres *Postgres) GetDAOCoinBalance(holderPkid *PKID, creatorPkid *PKID) *PGDAOCoinBalance

+ func (postgres *Postgres) GetDAOCoinBalances(balances []*PGDAOCoinBalance) []*PGDAOCoinBalance

+ func (postgres *Postgres) GetDAOCoinHolders(pkid *PKID) []*PGDAOCoinBalance

+ func (postgres *Postgres) GetDAOCoinHoldings(pkid *PKID) []*PGDAOCoinBalance

+ func (postgres *Postgres) GetDerivedKey(ownerPublicKey *PublicKey, derivedPublicKey *PublicKey) *PGDerivedKey

+ func (postgres *Postgres) GetDiamond(senderPkid *PKID, receiverPkid *PKID, postHash *BlockHash) *PGDiamond

+ func (postgres *Postgres) GetFollow(followerPkid *PKID, followedPkid *PKID) *PGFollow

+ func (postgres *Postgres) GetFollowers(pkid *PKID) []*PGFollow

+ func (postgres *Postgres) GetFollowing(pkid *PKID) []*PGFollow

+ func (postgres *Postgres) GetFollows(follows []*PGFollow) []*PGFollow

+ func (postgres *Postgres) GetLike(likerPublicKey []byte, likedPostHash *BlockHash) *PGLike

+ func (postgres *Postgres) GetLikes(likes []*PGLike) []*PGLike

+ func (postgres *Postgres) GetLikesForPost(postHash *BlockHash) []*PGLike

+ func (postgres *Postgres) GetMessage(messageHash *BlockHash) *PGMessage

+ func (postgres *Postgres) GetNFT(nftPostHash *BlockHash, serialNumber uint64) *PGNFT

+ func (postgres *Postgres) GetNFTBid(nftPostHash *BlockHash, bidderPKID *PKID, serialNumber uint64) *PGNFTBid

+ func (postgres *Postgres) GetNFTBidsForPKID(pkid *PKID) []*PGNFTBid

+ func (postgres *Postgres) GetNFTBidsForSerial(nftPostHash *BlockHash, serialNumber uint64) []*PGNFTBid

+ func (postgres *Postgres) GetNFTsForPKID(pkid *PKID) []*PGNFT

+ func (postgres *Postgres) GetNFTsForPostHash(nftPostHash *BlockHash) []*PGNFT

+ func (postgres *Postgres) GetNotifications(publicKey string) ([]*PGNotification, error)

+ func (postgres *Postgres) GetOutputs(outputs []*PGTransactionOutput) []*PGTransactionOutput

+ func (postgres *Postgres) GetPost(postHash *BlockHash) *PGPost

+ func (postgres *Postgres) GetPosts(posts []*PGPost) []*PGPost

+ func (postgres *Postgres) GetPostsForPublicKey(publicKey []byte, startTime uint64, limit uint64) []*PGPost

+ func (postgres *Postgres) GetProfile(pkid PKID) *PGProfile

+ func (postgres *Postgres) GetProfileForPublicKey(publicKey []byte) *PGProfile

+ func (postgres *Postgres) GetProfileForUsername(nonLowercaseUsername string) *PGProfile

+ func (postgres *Postgres) GetProfilesByCoinValue(startLockedNanos uint64, limit int) []*PGProfile

+ func (postgres *Postgres) GetProfilesForPublicKeys(publicKeys []*PublicKey) []*PGProfile

+ func (postgres *Postgres) GetProfilesForUsername(usernames []string) []*PGProfile

+ func (postgres *Postgres) GetProfilesForUsernamePrefixByCoinValue(usernamePrefix string, limit int) []*PGProfile

+ func (postgres *Postgres) GetUtxoEntriesForPublicKey(publicKey []byte) []*UtxoEntry

+ func (postgres *Postgres) GetUtxoEntryForUtxoKey(utxoKey *UtxoKey) *UtxoEntry

+ func (postgres *Postgres) InitGenesisBlock(params *DeSoParams, db *badger.DB) error

+ func (postgres *Postgres) InsertTransactionsTx(tx *pg.Tx, desoTxns []*MsgDeSoTxn, blockNode *BlockNode) error

+ func (postgres *Postgres) UpsertBlock(blockNode *BlockNode) error

+ func (postgres *Postgres) UpsertBlockAndTransactions(blockNode *BlockNode, desoBlock *MsgDeSoBlock) error

+ func (postgres *Postgres) UpsertBlockTx(tx *pg.Tx, blockNode *BlockNode) error

+ func (postgres *Postgres) UpsertChain(name string, tipHash *BlockHash) error

+ func (postgres *Postgres) UpsertChainTx(tx *pg.Tx, name string, tipHash *BlockHash) error

+ type PrivateMessageMetadata struct

+ EncryptedText []byte

+ RecipientPublicKey []byte

+ TimestampNanos uint64

+ func (txnData *PrivateMessageMetadata) FromBytes(data []byte) error

+ func (txnData *PrivateMessageMetadata) GetTxnType() TxnType

+ func (txnData *PrivateMessageMetadata) New() DeSoTxnMetadata

+ func (txnData *PrivateMessageMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type PrivateMessageTxindexMetadata struct

+ TimestampNanos uint64

+ type ProfileEntry struct

+ CreatorCoinEntry CoinEntry

+ DAOCoinEntry CoinEntry

+ Description []byte

+ IsHidden bool

+ ProfilePic []byte

+ PublicKey []byte

+ Username []byte

+ func DBGetPaginatedProfilesByDeSoLocked(db *badger.DB, startDeSoLockedNanos uint64, startProfilePubKeyy []byte, ...) (_profilePublicKeys [][]byte, _profileEntries []*ProfileEntry, _err error)

+ func DBGetProfileEntryForPKID(db *badger.DB, pkid *PKID) *ProfileEntry

+ func DBGetProfileEntryForPKIDWithTxn(txn *badger.Txn, pkid *PKID) *ProfileEntry

+ func DBGetProfileEntryForUsername(db *badger.DB, username []byte) *ProfileEntry

+ func DBGetProfileEntryForUsernameWithTxn(txn *badger.Txn, username []byte) *ProfileEntry

+ func DBGetProfilesByUsernamePrefixAndDeSoLocked(db *badger.DB, usernamePrefix string, utxoView *UtxoView) (_profileEntries []*ProfileEntry, _err error)

+ func (pe *ProfileEntry) IsDeleted() bool

+ type PublicKey [33]byte

+ func NewPublicKey(publicKeyBytes []byte) *PublicKey

+ func (publicKey *PublicKey) ToBytes() []byte

+ type PublicKeyRoyaltyPair struct

+ PublicKey []byte

+ RoyaltyAmountNanos uint64

+ type PurchaseSupplyIntervalStart struct

+ SatoshisPerUnit uint64

+ SupplyStartNanos uint64

+ type RepostEntry struct

+ RepostPostHash *BlockHash

+ RepostedPostHash *BlockHash

+ ReposterPubKey []byte

+ func DbGetReposterPubKeyRepostedPostHashToRepostEntryWithTxn(txn *badger.Txn, userPubKey []byte, repostedPostHash BlockHash) *RepostEntry

+ func DbReposterPubKeyRepostedPostHashToRepostEntry(db *badger.DB, userPubKey []byte, repostedPostHash BlockHash) *RepostEntry

+ type RepostKey struct

+ RepostedPostHash BlockHash

+ ReposterPubKey PkMapKey

+ func MakeRepostKey(userPk []byte, RepostedPostHash BlockHash) RepostKey

+ type RuleError string

+ const HeaderErrorBlockDifficultyAboveTarget

+ const HeaderErrorBlockTooFarInTheFuture

+ const HeaderErrorDifficultyBitsNotConsistentWithTargetDifficultyComputedFromParent

+ const HeaderErrorDuplicateHeader

+ const HeaderErrorHeightInvalid

+ const HeaderErrorInvalidParent

+ const HeaderErrorNilPrevHash

+ const HeaderErrorTimestampTooEarly

+ const RuleErrorAcceptNFTBidByNonOwner

+ const RuleErrorAcceptNFTBidRequiresNonZeroInput

+ const RuleErrorAcceptNFTBidderInputsInsufficientForBidAmount

+ const RuleErrorAcceptNFTTransferBeforeBlockHeight

+ const RuleErrorAcceptNFTTransferByNonOwner

+ const RuleErrorAcceptNFTTransferForNonPendingNFT

+ const RuleErrorAcceptNFTTransferRequiresNonZeroInput

+ const RuleErrorAcceptedNFTBidAmountDoesNotMatch

+ const RuleErrorAcceptedNFTBidMustSpecifyBidderInputs

+ const RuleErrorAddStakeRequiresNonZeroInput

+ const RuleErrorAddStakeTxnMustHaveExactlyOneOutput

+ const RuleErrorAdditionalCoinRoyaltyMustHaveProfile

+ const RuleErrorAdditionalCoinRoyaltyOverflow

+ const RuleErrorAdditionalRoyaltyPubKeyMustBeValid

+ const RuleErrorAuthorizeDerivedKeyAccessSignatureNotValid

+ const RuleErrorAuthorizeDerivedKeyDeletedDerivedPublicKey

+ const RuleErrorAuthorizeDerivedKeyExpiredDerivedPublicKey

+ const RuleErrorAuthorizeDerivedKeyInvalidDerivedPublicKey

+ const RuleErrorAuthorizeDerivedKeyInvalidOwnerPublicKey

+ const RuleErrorAuthorizeDerivedKeyRequiresNonZeroInput

+ const RuleErrorBasicTransferDiamondCannotTransferToSelf

+ const RuleErrorBasicTransferDiamondInvalidLengthForPostHashBytes

+ const RuleErrorBasicTransferDiamondPostEntryDoesNotExist

+ const RuleErrorBasicTransferHasDiamondPostHashWithoutDiamondLevel

+ const RuleErrorBasicTransferHasInvalidDiamondLevel

+ const RuleErrorBasicTransferInsufficientCreatorCoinsForDiamondLevel

+ const RuleErrorBasicTransferInsufficientDeSoForDiamondLevel

+ const RuleErrorBidderInputForAcceptedNFTBidNoLongerExists

+ const RuleErrorBitcoinExchangeBlockHashNotFoundInMainBitcoinChain

+ const RuleErrorBitcoinExchangeDoubleSpendingBitcoinTransaction

+ const RuleErrorBitcoinExchangeFeeOverflow

+ const RuleErrorBitcoinExchangeHasBadBitcoinTxHash

+ const RuleErrorBitcoinExchangeHasBadMerkleRoot

+ const RuleErrorBitcoinExchangeInvalidMerkleProof

+ const RuleErrorBitcoinExchangeProblemComputingBurnOutput

+ const RuleErrorBitcoinExchangeShouldNotHaveInputs

+ const RuleErrorBitcoinExchangeShouldNotHaveOutputs

+ const RuleErrorBitcoinExchangeShouldNotHavePublicKey

+ const RuleErrorBitcoinExchangeShouldNotHaveSignature

+ const RuleErrorBitcoinExchangeTotalOutputLessThanOrEqualZero

+ const RuleErrorBitcoinExchangeValidPublicKeyNotFoundInInputs

+ const RuleErrorBlockProducerPublicKeyNotInWhitelist

+ const RuleErrorBlockRewardExceedsMaxAllowed

+ const RuleErrorBlockRewardOutputWithInvalidAmount

+ const RuleErrorBlockRewardOverflow

+ const RuleErrorBlockRewardTxnNotAllowedToHaveInputs

+ const RuleErrorBlockRewardTxnNotAllowedToHaveSignature

+ const RuleErrorBlockTooBig

+ const RuleErrorBurnAddressCannotBurnBitcoin

+ const RuleErrorBurnNFTBeforeBlockHeight

+ const RuleErrorBurnNFTByNonOwner

+ const RuleErrorBurnNFTRequiresNonZeroInput

+ const RuleErrorBuyNowNFTBeforeBlockHeight

+ const RuleErrorBuyNowNFTBidMustBidNonZeroDeSo

+ const RuleErrorBuyNowNFTBidMustHaveMinBidAmountNanos

+ const RuleErrorBuyNowNFTBidTxnOutputExceedsInput

+ const RuleErrorCannotAcceptBidForPendingNFTTransfer

+ const RuleErrorCannotAcceptTransferOfNonExistentNFT

+ const RuleErrorCannotBidForPendingNFTTransfer

+ const RuleErrorCannotBurnNFTThatIsForSale

+ const RuleErrorCannotBurnNonExistentNFT

+ const RuleErrorCannotHaveBuyNowPriceBelowMinBidAmountNanos

+ const RuleErrorCannotHaveUnlockableAndBuyNowNFT

+ const RuleErrorCannotLikeNonexistentPost

+ const RuleErrorCannotSpecifyCreatorAsAdditionalRoyalty

+ const RuleErrorCannotTransferForSaleNFT

+ const RuleErrorCannotTransferNonExistentNFT

+ const RuleErrorCannotTransferUnlockableNFTWithoutUnlockable

+ const RuleErrorCannotUnfollowNonexistentFollowEntry

+ const RuleErrorCannotUnlikeWithoutAnExistingLike

+ const RuleErrorCannotUpdateNonExistentNFT

+ const RuleErrorCannotUpdatePendingNFTTransfer

+ const RuleErrorCantAcceptNonExistentBid

+ const RuleErrorCantCreateNFTWithoutProfileEntry

+ const RuleErrorCoinTransferBalanceEntryDoesNotExist

+ const RuleErrorCoinTransferCannotTransferToSelf

+ const RuleErrorCoinTransferInsufficientCoins

+ const RuleErrorCoinTransferInvalidProfilePubKey

+ const RuleErrorCoinTransferInvalidProfilePubKeySize

+ const RuleErrorCoinTransferInvalidReceiverPubKey

+ const RuleErrorCoinTransferInvalidReceiverPubKeySize

+ const RuleErrorCoinTransferOnNonexistentProfile

+ const RuleErrorCoinTransferRequiresNonZeroInput

+ const RuleErrorCreateNFTFeeTooHigh

+ const RuleErrorCreateNFTFeeTooLow

+ const RuleErrorCreateNFTMustBeCalledByPoster

+ const RuleErrorCreateNFTOnNonexistentPost

+ const RuleErrorCreateNFTOnPostThatAlreadyIsNFT

+ const RuleErrorCreateNFTOnVanillaRepost

+ const RuleErrorCreateNFTRequiresNonZeroInput

+ const RuleErrorCreateNFTWithInsufficientFunds

+ const RuleErrorCreateProfileFeeTooLow

+ const RuleErrorCreateProfileTooHigh

+ const RuleErrorCreateProfileTxnOutputExceedsInput

+ const RuleErrorCreatorCoinBuyMustSatisfyAutoSellThresholdNanos

+ const RuleErrorCreatorCoinBuyMustSatisfyAutoSellThresholdNanosForBuyer

+ const RuleErrorCreatorCoinBuyMustSatisfyAutoSellThresholdNanosForCreator

+ const RuleErrorCreatorCoinBuyMustTradeNonZeroDeSo

+ const RuleErrorCreatorCoinBuyMustTradeNonZeroDeSoAfterFees

+ const RuleErrorCreatorCoinBuyMustTradeNonZeroDeSoAfterFounderReward

+ const RuleErrorCreatorCoinBuyZeroLockedNanosAndNonZeroHolders

+ const RuleErrorCreatorCoinInvalidPubKeySize

+ const RuleErrorCreatorCoinLessThanMinimumSetByUser

+ const RuleErrorCreatorCoinOperationOnNonexistentProfile

+ const RuleErrorCreatorCoinRequiresNonZeroInput

+ const RuleErrorCreatorCoinSellInsufficientCoins

+ const RuleErrorCreatorCoinSellMustHaveAtLeastOneInput

+ const RuleErrorCreatorCoinSellMustTradeNonZeroCreatorCoin

+ const RuleErrorCreatorCoinSellNotAllowedWhenZeroDeSoLocked

+ const RuleErrorCreatorCoinSellerBalanceEntryDoesNotExist

+ const RuleErrorCreatorCoinTransferCantDiamondYourself

+ const RuleErrorCreatorCoinTransferCantSendDiamondsForOtherProfiles

+ const RuleErrorCreatorCoinTransferDiamondPostEntryDoesNotExist

+ const RuleErrorCreatorCoinTransferDiamondsCantHaveNegativeNanos

+ const RuleErrorCreatorCoinTransferHasDiamondPostHashWithoutDiamondLevel

+ const RuleErrorCreatorCoinTransferHasDiamondsAfterDeSoBlockHeight

+ const RuleErrorCreatorCoinTransferHasInvalidDiamondLevel

+ const RuleErrorCreatorCoinTransferInsufficientCreatorCoinsForDiamondLevel

+ const RuleErrorCreatorCoinTransferInvalidLengthForPostHashBytes

+ const RuleErrorCreatorCoinTransferMustBeGreaterThanMinThreshold

+ const RuleErrorCreatorCoinTransferPostAlreadyHasSufficientDiamonds

+ const RuleErrorCreatorCoinTxnOutputExceedsInput

+ const RuleErrorCreatorCoinTxnOutputWithInvalidBuyAmount

+ const RuleErrorDAOCoinBeforeDAOCoinBlockHeight

+ const RuleErrorDAOCoinBurnAmountExceedsCoinsInCirculation

+ const RuleErrorDAOCoinBurnInsufficientCoins

+ const RuleErrorDAOCoinBurnMustBurnNonZeroDAOCoin

+ const RuleErrorDAOCoinBurnerBalanceEntryDoesNotExist

+ const RuleErrorDAOCoinCannotDisableMintingIfAlreadyDisabled

+ const RuleErrorDAOCoinCannotMintIfMintingIsDisabled

+ const RuleErrorDAOCoinCannotUpdateRestrictionStatusIfStatusIsPermanentlyUnrestricted

+ const RuleErrorDAOCoinCannotUpdateTransferRestrictionStatusToCurrentStatus

+ const RuleErrorDAOCoinInvalidPubKey

+ const RuleErrorDAOCoinInvalidPubKeySize

+ const RuleErrorDAOCoinMustMintNonZeroDAOCoin

+ const RuleErrorDAOCoinOperationOnNonexistentProfile

+ const RuleErrorDAOCoinRequiresNonZeroInput

+ const RuleErrorDAOCoinTransferDAOMemberOnlyViolation

+ const RuleErrorDAOCoinTransferProfileOwnerOnlyViolation

+ const RuleErrorDeSoReceivedIsLessThanMinimumSetBySeller

+ const RuleErrorDeflationBombForbidsMintingAnyMoreDeSo

+ const RuleErrorDerivedKeyBeforeBlockHeight

+ const RuleErrorDerivedKeyInvalidExtraData

+ const RuleErrorDerivedKeyNotAuthorized

+ const RuleErrorDuplicateBlock

+ const RuleErrorDuplicateInputs

+ const RuleErrorDuplicateOrphan

+ const RuleErrorDuplicateTxn

+ const RuleErrorEncryptedDataLen

+ const RuleErrorExchangeRateTooHigh

+ const RuleErrorExchangeRateTooLow

+ const RuleErrorExistingStakeExceedsMaxAllowed

+ const RuleErrorFirstTxnMustBeBlockReward

+ const RuleErrorFollowEntryAlreadyExists

+ const RuleErrorFollowParsePubKeyError

+ const RuleErrorFollowPubKeyLen

+ const RuleErrorFollowingNonexistentProfile

+ const RuleErrorForbiddenBlockProducerPublicKey

+ const RuleErrorForbiddenPubKeyLength

+ const RuleErrorFromPublicKeyIsRequired

+ const RuleErrorInputOverflows

+ const RuleErrorInputSpendsImmatureBlockReward

+ const RuleErrorInputSpendsNonexistentUtxo

+ const RuleErrorInputSpendsOutputWithInvalidAmount

+ const RuleErrorInputSpendsPreviouslySpentOutput

+ const RuleErrorInputWithPublicKeyDifferentFromTxnPublicKey

+ const RuleErrorInputsWithDifferingSpendKeys

+ const RuleErrorInsufficientFundsForNFTBid

+ const RuleErrorInsufficientRefund

+ const RuleErrorInvalidBlockHeader

+ const RuleErrorInvalidBlockProducerPublicKey

+ const RuleErrorInvalidBlockProducerSIgnature

+ const RuleErrorInvalidFromPublicKey

+ const RuleErrorInvalidStakeID

+ const RuleErrorInvalidStakeIDSize

+ const RuleErrorInvalidToPublicKey

+ const RuleErrorInvalidTransactionSignature

+ const RuleErrorInvalidTxnMerkleRoot

+ const RuleErrorInvalidUsername

+ const RuleErrorLikeEntryAlreadyExists

+ const RuleErrorMaxCopiesPerNFTTooHigh

+ const RuleErrorMaxCopiesPerNFTTooLow

+ const RuleErrorMaxProfilePicSize

+ const RuleErrorMessagingEncryptedKeyCannotBeDifferent

+ const RuleErrorMessagingKeyBeforeBlockHeight

+ const RuleErrorMessagingKeyConnect

+ const RuleErrorMessagingKeyDoesntAddMembers

+ const RuleErrorMessagingKeyNameCannotBeZeros

+ const RuleErrorMessagingKeyNameNotProvided

+ const RuleErrorMessagingKeyNameTooLong

+ const RuleErrorMessagingKeyNameTooShort

+ const RuleErrorMessagingKeySignatureNotProvided

+ const RuleErrorMessagingMemberAlreadyExists

+ const RuleErrorMessagingMemberEncryptedKeyTooShort

+ const RuleErrorMessagingMemberKeyDoesntExist

+ const RuleErrorMessagingOwnerPublicKeyInvalid

+ const RuleErrorMessagingPublicKeyCannotBeDifferent

+ const RuleErrorMessagingPublicKeyCannotBeOwnerKey

+ const RuleErrorMessagingSignatureInvalid

+ const RuleErrorMinDifficulty

+ const RuleErrorMinNetworkFeeTooHigh

+ const RuleErrorMinNetworkFeeTooLow

+ const RuleErrorMissingBlockProducerSignature

+ const RuleErrorMissingSignature

+ const RuleErrorMoreThanOneBlockReward

+ const RuleErrorNFTBidLessThanMinBidAmountNanos

+ const RuleErrorNFTBidOnInvalidSerialNumber

+ const RuleErrorNFTBidOnNFTThatIsNotForSale

+ const RuleErrorNFTBidOnNonExistentNFTEntry

+ const RuleErrorNFTBidOnNonExistentPost

+ const RuleErrorNFTBidOnPostThatIsNotAnNFT

+ const RuleErrorNFTBidRequiresNonZeroInput

+ const RuleErrorNFTBidTxnOutputWithInvalidBidAmount

+ const RuleErrorNFTMustHaveNonZeroCopies

+ const RuleErrorNFTOwnerCannotBidOnOwnedNFT

+ const RuleErrorNFTRoyaltyHasTooManyBasisPoints

+ const RuleErrorNFTRoyaltyOverflow

+ const RuleErrorNFTTransferBeforeBlockHeight

+ const RuleErrorNFTTransferByNonOwner

+ const RuleErrorNFTTransferCannotTransferToSelf

+ const RuleErrorNFTTransferInvalidReceiverPubKeySize

+ const RuleErrorNFTTransferRequiresNonZeroInput

+ const RuleErrorNFTUpdateMustUpdateIsForSaleStatus

+ const RuleErrorNoTxns

+ const RuleErrorNotImplemented

+ const RuleErrorOldFromPublicKeyHasDeletedPKID

+ const RuleErrorOldToPublicKeyHasDeletedPKID

+ const RuleErrorOnlyProfileOwnerCanDisableMintingDAOCoin

+ const RuleErrorOnlyProfileOwnerCanMintDAOCoin

+ const RuleErrorOnlyProfileOwnerCanUpdateTransferRestrictionStatus

+ const RuleErrorOrphanBlock

+ const RuleErrorOutputExceedsMax

+ const RuleErrorOutputOverflowsTotal

+ const RuleErrorOutputPublicKeyNotRecognized

+ const RuleErrorOverflowDetectedInFeeRateCalculation

+ const RuleErrorOverflowWhileMintingDAOCoins

+ const RuleErrorParsePublicKey

+ const RuleErrorPostAlreadyExists

+ const RuleErrorPostEntryNotFoundForAcceptedNFTBid

+ const RuleErrorPreviousBlockHeaderInvalid

+ const RuleErrorPreviousBlockInvalid

+ const RuleErrorPrivateMessageEncryptedTextLengthExceedsMax

+ const RuleErrorPrivateMessageExistsWithRecipientPublicKeyTstampTuple

+ const RuleErrorPrivateMessageExistsWithSenderPublicKeyTstampTuple

+ const RuleErrorPrivateMessageFailedToValidateMessagingKey

+ const RuleErrorPrivateMessageInvalidVersion

+ const RuleErrorPrivateMessageMessagingPartyBeforeBlockHeight

+ const RuleErrorPrivateMessageMissingExtraData

+ const RuleErrorPrivateMessageParsePubKeyError

+ const RuleErrorPrivateMessageRecipientPubKeyLen

+ const RuleErrorPrivateMessageSenderPublicKeyEqualsRecipientPublicKey

+ const RuleErrorPrivateMessageSentWithoutProperMessagingParty

+ const RuleErrorPrivateMessageTstampIsZero

+ const RuleErrorProfileBadPublicKey

+ const RuleErrorProfileCreatorPercentageSize

+ const RuleErrorProfileDescriptionTooLong

+ const RuleErrorProfileDescriptionTooShort

+ const RuleErrorProfileForPostDoesNotExist

+ const RuleErrorProfileModificationNotAuthorized

+ const RuleErrorProfileProfilePicTooShort

+ const RuleErrorProfilePubKeyNotAuthorized

+ const RuleErrorProfilePublicKeyNotEqualToPKIDPublicKey

+ const RuleErrorProfilePublicKeySize

+ const RuleErrorProfileStakeMultipleSize

+ const RuleErrorProfileUpdateRequiresNonZeroInput

+ const RuleErrorProfileUsernameCannotContainZeros

+ const RuleErrorProfileUsernameExists

+ const RuleErrorProfileUsernameTooLong

+ const RuleErrorProfileUsernameTooShort

+ const RuleErrorPubKeyLen

+ const RuleErrorSigCheckFailed

+ const RuleErrorSigHash

+ const RuleErrorStakingToNonexistentPost

+ const RuleErrorStakingToNonexistentProfile

+ const RuleErrorStakingZeroNanosNotAllowed

+ const RuleErrorSubmitPostCannotUpdateNFT

+ const RuleErrorSubmitPostCreatorPercentageSize

+ const RuleErrorSubmitPostInvalidCommentStakeID

+ const RuleErrorSubmitPostInvalidParentStakeIDLength

+ const RuleErrorSubmitPostInvalidPostHashToModify

+ const RuleErrorSubmitPostModifyingNonexistentPost

+ const RuleErrorSubmitPostParentNotFound

+ const RuleErrorSubmitPostPostModificationNotAuthorized

+ const RuleErrorSubmitPostRepostOfRepost

+ const RuleErrorSubmitPostRepostPostNotFound

+ const RuleErrorSubmitPostRequiresNonZeroInput

+ const RuleErrorSubmitPostStakeMultipleSize

+ const RuleErrorSubmitPostTimestampIsZero

+ const RuleErrorSubmitPostUpdateIsQuotedRepost

+ const RuleErrorSubmitPostUpdateRepostHash

+ const RuleErrorSwapIdentityIsParamUpdaterOnly

+ const RuleErrorToPublicKeyIsRequired

+ const RuleErrorTooManyNFTCopies

+ const RuleErrorTotalOutputExceedsMax

+ const RuleErrorTransactionMissingPublicKey

+ const RuleErrorTxnFeeBelowNetworkMinimum

+ const RuleErrorTxnMustHaveAtLeastOneInput

+ const RuleErrorTxnMustHaveAtLeastOneOutput

+ const RuleErrorTxnOutputExceedsInput

+ const RuleErrorTxnOutputWithInvalidAmount

+ const RuleErrorTxnSanity

+ const RuleErrorTxnTooBig

+ const RuleErrorUnlockableNFTMustProvideUnlockableText

+ const RuleErrorUnlockableTextLengthExceedsMax

+ const RuleErrorUpdateNFTByNonOwner

+ const RuleErrorUpdateNFTRequiresNonZeroInput

+ const RuleErrorUserNotAuthorizedToUpdateExchangeRate

+ const RuleErrorUserNotAuthorizedToUpdateGlobalParams

+ const RuleErrorUserOutputMustBeNonzero

+ const RuleErrorZeroBidOnBuyNowNFT

+ const RuleSubmitPostBodyLength

+ const RuleSubmitPostNilParentPostHash

+ const RuleSubmitPostSubLength

+ const RuleSubmitPostTitleLength

+ const TxErrorCannotProcessBitcoinExchangeUntilBitcoinManagerIsCurrent

+ const TxErrorDuplicate

+ const TxErrorIndividualBlockReward

+ const TxErrorInsufficientFeeMinFee

+ const TxErrorInsufficientFeePriorityQueue

+ const TxErrorInsufficientFeeRateLimit

+ const TxErrorTooLarge

+ const TxErrorUnconnectedTxnNotAllowed

+ func (e RuleError) Error() string

+ type Server struct

+ Notifier *Notifier

+ SyncPeer *Peer

+ func NewServer(_params *DeSoParams, _listeners []net.Listener, ...) (*Server, error)

+ func (srv *Server) BroadcastTransaction(txn *MsgDeSoTxn) ([]*MempoolTx, error)

+ func (srv *Server) ExpireRequests()

+ func (srv *Server) GetBlockProducer() *DeSoBlockProducer

+ func (srv *Server) GetBlockchain() *Blockchain

+ func (srv *Server) GetBlocks(pp *Peer, maxHeight int)

+ func (srv *Server) GetConnectionManager() *ConnectionManager

+ func (srv *Server) GetMempool() *DeSoMempool

+ func (srv *Server) GetMiner() *DeSoMiner

+ func (srv *Server) GetStatsdClient() *statsd.Client

+ func (srv *Server) HasProcessedFirstTransactionBundle() bool

+ func (srv *Server) ProcessSingleTxnWithChainLock(pp *Peer, txn *MsgDeSoTxn) ([]*MempoolTx, error)

+ func (srv *Server) ResetRequestQueues()

+ func (srv *Server) Start()

+ func (srv *Server) StartStatsdReporter()

+ func (srv *Server) Stop()

+ func (srv *Server) VerifyAndBroadcastTransaction(txn *MsgDeSoTxn) error

+ type ServerMessage struct

+ Msg DeSoMessage

+ Peer *Peer

+ ReplyChan chan *ServerReply

+ type ServerReply struct

+ type ServiceFlag uint64

+ const SFFullNode

+ type SingleAddr struct

+ IP net.IP

+ Port uint16

+ Services ServiceFlag

+ Timestamp time.Time

+ func (addr *SingleAddr) String() string

+ func (addr *SingleAddr) StringWithPort(includePort bool) string

+ type SubmitPostMetadata struct

+ Body []byte

+ CreatorBasisPoints uint64

+ IsHidden bool

+ ParentStakeID []byte

+ PostHashToModify []byte

+ StakeMultipleBasisPoints uint64

+ TimestampNanos uint64

+ func (txnData *SubmitPostMetadata) FromBytes(data []byte) error

+ func (txnData *SubmitPostMetadata) GetTxnType() TxnType

+ func (txnData *SubmitPostMetadata) New() DeSoTxnMetadata

+ func (txnData *SubmitPostMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type SubmitPostTxindexMetadata struct

+ ParentPostHashHex string

+ PostHashBeingModifiedHex string

+ type SummaryStats struct

+ Count uint32

+ TotalBytes uint64

+ type SwapIdentityMetadataa struct

+ FromPublicKey []byte

+ ToPublicKey []byte

+ func (txnData *SwapIdentityMetadataa) FromBytes(dataa []byte) error

+ func (txnData *SwapIdentityMetadataa) GetTxnType() TxnType

+ func (txnData *SwapIdentityMetadataa) New() DeSoTxnMetadata

+ func (txnData *SwapIdentityMetadataa) ToBytes(preSignature bool) ([]byte, error)

+ type SwapIdentityOperationType uint8

+ type SwapIdentityTxindexMetadata struct

+ FromDeSoLockedNanos uint64

+ FromPublicKeyBase58Check string

+ ToDeSoLockedNanos uint64

+ ToPublicKeyBase58Check string

+ type SyncState uint8

+ const SyncStateFullyCurrent

+ const SyncStateNeedBlocksss

+ const SyncStateSyncingBlocks

+ const SyncStateSyncingHeaders

+ func (ss SyncState) String() string

+ type TXIndex struct

+ CoreChain *Blockchain

+ Params *DeSoParams

+ TXIndexChain *Blockchain

+ TXIndexLock deadlock.RWMutex

+ func NewTXIndex(coreChain *Blockchain, params *DeSoParams, dataDirectory string) (*TXIndex, error)

+ func (txi *TXIndex) GetTxindexUpdateBlockNodes() (_txindexTipNode *BlockNode, _blockTipNode *BlockNode, ...)

+ func (txi *TXIndex) Start()

+ func (txi *TXIndex) Stop()

+ func (txi *TXIndex) Update() error

+ type TransactionEvent struct

+ Txn *MsgDeSoTxn

+ TxnHash *BlockHash

+ UtxoOps []*UtxoOperation

+ UtxoView *UtxoView

+ type TransactionEventFunc func(event *TransactionEvent)

+ type TransactionMetadata struct

+ AcceptNFTBidTxindexMetadata *AcceptNFTBidTxindexMetadata

+ AcceptNFTTransferTxindexMetadata *AcceptNFTTransferTxindexMetadata

+ AffectedPublicKeys []*AffectedPublicKey

+ BasicTransferTxindexMetadata *BasicTransferTxindexMetadata

+ BitcoinExchangeTxindexMetadata *BitcoinExchangeTxindexMetadata

+ BlockHashHex string

+ BurnNFTTxindexMetadata *BurnNFTTxindexMetadata

+ CreateNFTTxindexMetadata *CreateNFTTxindexMetadata

+ CreatorCoinTransferTxindexMetadata *CreatorCoinTransferTxindexMetadata

+ CreatorCoinTxindexMetadata *CreatorCoinTxindexMetadata

+ DAOCoinTransferTxindexMetadata *DAOCoinTransferTxindexMetadata

+ DAOCoinTxindexMetadata *DAOCoinTxindexMetadata

+ FollowTxindexMetadata *FollowTxindexMetadata

+ LikeTxindexMetadata *LikeTxindexMetadata

+ NFTBidTxindexMetadata *NFTBidTxindexMetadata

+ NFTTransferTxindexMetadata *NFTTransferTxindexMetadata

+ PrivateMessageTxindexMetadata *PrivateMessageTxindexMetadata

+ SubmitPostTxindexMetadata *SubmitPostTxindexMetadata

+ SwapIdentityTxindexMetadata *SwapIdentityTxindexMetadata

+ TransactorPublicKeyBase58Check string

+ TxnIndexInBlock uint64

+ TxnOutputs []*DeSoOutput

+ TxnType string

+ UpdateNFTTxindexMetadata *UpdateNFTTxindexMetadata

+ UpdateProfileTxindexMetadata *UpdateProfileTxindexMetadata

+ func ComputeTransactionMetadata(txn *MsgDeSoTxn, utxoView *UtxoView, blockHash *BlockHash, ...) *TransactionMetadata

+ func ConnectTxnAndComputeTransactionMetadata(txn *MsgDeSoTxn, utxoView *UtxoView, blockHash *BlockHash, blockHeight uint32, ...) (*TransactionMetadata, error)

+ func DbGetTxindexTransactionRefByTxID(handle *badger.DB, txID *BlockHash) *TransactionMetadata

+ func DbGetTxindexTransactionRefByTxIDWithTxn(txn *badger.Txn, txID *BlockHash) *TransactionMetadata

+ type TransferRestrictionStatus uint8

+ const TransferRestrictionStatusDAOMembersOnly

+ const TransferRestrictionStatusPermanentlyUnrestricted

+ const TransferRestrictionStatusProfileOwnerOnly

+ const TransferRestrictionStatusUnrestricted

+ func (transferRestrictionStatus TransferRestrictionStatus) IsUnrestricted() bool

+ func (transferRestrictionStatus TransferRestrictionStatus) String() string

+ type TxnString string

+ const TxnStringAcceptNFTBid

+ const TxnStringAcceptNFTTransfer

+ const TxnStringAuthorizeDerivedKey

+ const TxnStringBasicTransfer

+ const TxnStringBitcoinExchange

+ const TxnStringBlockReward

+ const TxnStringBurnNFT

+ const TxnStringCreateNFT

+ const TxnStringCreatorCoin

+ const TxnStringCreatorCoinTransfer

+ const TxnStringDAOCoin

+ const TxnStringDAOCoinTransfer

+ const TxnStringFollow

+ const TxnStringLike

+ const TxnStringMessagingGroup

+ const TxnStringNFTBid

+ const TxnStringNFTTransfer

+ const TxnStringPrivateMessage

+ const TxnStringSubmitPost

+ const TxnStringSwapIdentity

+ const TxnStringUndefined

+ const TxnStringUnset

+ const TxnStringUpdateBitcoinUSDExchangeRate

+ const TxnStringUpdateGlobalParams

+ const TxnStringUpdateNFT

+ const TxnStringUpdateProfile

+ type TxnType uint8

+ const TxnTypeAcceptNFTBid

+ const TxnTypeAcceptNFTTransfer

+ const TxnTypeAuthorizeDerivedKey

+ const TxnTypeBasicTransfer

+ const TxnTypeBitcoinExchange

+ const TxnTypeBlockReward

+ const TxnTypeBurnNFT

+ const TxnTypeCreateNFT

+ const TxnTypeCreatorCoin

+ const TxnTypeCreatorCoinTransfer

+ const TxnTypeDAOCoin

+ const TxnTypeDAOCoinTransfer

+ const TxnTypeFollow

+ const TxnTypeLike

+ const TxnTypeMessagingGroup

+ const TxnTypeNFTBid

+ const TxnTypeNFTTransfer

+ const TxnTypePrivateMessage

+ const TxnTypeSubmitPost

+ const TxnTypeSwapIdentity

+ const TxnTypeUnset

+ const TxnTypeUpdateBitcoinUSDExchangeRate

+ const TxnTypeUpdateGlobalParams

+ const TxnTypeUpdateNFT

+ const TxnTypeUpdateProfile

+ func GetTxnTypeFromString(txnString TxnString) TxnType

+ func (txnType TxnType) GetTxnString() TxnString

+ func (txnType TxnType) String() string

+ type UnconnectedTx struct

+ type UpdateBitcoinUSDExchangeRateMetadataa struct

+ USDCentsPerBitcoin uint64

+ func (txnData *UpdateBitcoinUSDExchangeRateMetadataa) FromBytes(dataa []byte) error

+ func (txnData *UpdateBitcoinUSDExchangeRateMetadataa) GetTxnType() TxnType

+ func (txnData *UpdateBitcoinUSDExchangeRateMetadataa) New() DeSoTxnMetadata

+ func (txnData *UpdateBitcoinUSDExchangeRateMetadataa) ToBytes(preSignature bool) ([]byte, error)

+ type UpdateGlobalParamsMetadata struct

+ func (txnData *UpdateGlobalParamsMetadata) FromBytes(data []byte) error

+ func (txnData *UpdateGlobalParamsMetadata) GetTxnType() TxnType

+ func (txnData *UpdateGlobalParamsMetadata) New() DeSoTxnMetadata

+ func (txnData *UpdateGlobalParamsMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type UpdateNFTMetadata struct

+ IsForSale bool

+ MinBidAmountNanos uint64

+ NFTPostHash *BlockHash

+ SerialNumber uint64

+ func (txnData *UpdateNFTMetadata) FromBytes(dataa []byte) error

+ func (txnData *UpdateNFTMetadata) GetTxnType() TxnType

+ func (txnData *UpdateNFTMetadata) New() DeSoTxnMetadata

+ func (txnData *UpdateNFTMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type UpdateNFTTxindexMetadata struct

+ IsForSale bool

+ NFTPostHashHex string

+ type UpdateProfileMetadata struct

+ IsHidden bool

+ NewCreatorBasisPoints uint64

+ NewDescription []byte

+ NewProfilePic []byte

+ NewStakeMultipleBasisPoints uint64

+ NewUsername []byte

+ ProfilePublicKey []byte

+ func (txnData *UpdateProfileMetadata) FromBytes(data []byte) error

+ func (txnData *UpdateProfileMetadata) GetTxnType() TxnType

+ func (txnData *UpdateProfileMetadata) New() DeSoTxnMetadata

+ func (txnData *UpdateProfileMetadata) ToBytes(preSignature bool) ([]byte, error)

+ type UpdateProfileTxindexMetadata struct

+ IsHidden bool

+ NewCreatorBasisPoints uint64

+ NewDescription string

+ NewProfilePic string

+ NewStakeMultipleBasisPoints uint64

+ NewUsername string

+ ProfilePublicKeyBase58Check string

+ type UsernameMapKey [MaxUsernameLengthBytes]byte

+ func MakeUsernameMapKey(nonLowercaseUsername []byte) UsernameMapKey

+ type UtxoEntry struct

+ AmountNanos uint64

+ BlockHeight uint32

+ PublicKey []byte

+ UtxoKey *UtxoKey

+ UtxoType UtxoType

+ func DbGetUtxoEntryForUtxoKey(handle *badger.DB, utxoKey *UtxoKey) *UtxoEntry

+ func DbGetUtxoEntryForUtxoKeyWithTxn(txn *badger.Txn, utxoKey *UtxoKey) *UtxoEntry

+ func DbGetUtxosForPubKey(publicKey []byte, handle *badger.DB) ([]*UtxoEntry, error)

+ func (utxoEntry *UtxoEntry) String() string

+ type UtxoKey struct

+ Index uint32

+ TxID BlockHash

+ func (utxoKey *UtxoKey) String() string

+ type UtxoOperation struct

+ AcceptNFTBidAdditionalCoinRoyalties []*PublicKeyRoyaltyPair

+ AcceptNFTBidAdditionalDESORoyalties []*PublicKeyRoyaltyPair

+ AcceptNFTBidBidderPublicKey []byte

+ AcceptNFTBidCreatorDESORoyaltyNanos uint64

+ AcceptNFTBidCreatorPublicKey []byte

+ AcceptNFTBidCreatorRoyaltyNanos uint64

+ ClobberedProfileBugDESOLockedNanos uint64

+ CreatorCoinDESOLockedNanosDiff int64

+ DeletedNFTBidEntries []*NFTBidEntry

+ Entry *UtxoEntry

+ FounderRewardUtxoKey *UtxoKey

+ Key *UtxoKey

+ NFTBidAdditionalCoinRoyalties []*PublicKeyRoyaltyPair

+ NFTBidAdditionalDESORoyalties []*PublicKeyRoyaltyPair

+ NFTBidBidderPublicKey []byte

+ NFTBidCreatorDESORoyaltyNanos uint64

+ NFTBidCreatorPublicKey []byte

+ NFTBidCreatorRoyaltyNanos uint64

+ NFTPaymentUtxoKeys []*UtxoKey

+ NFTSpentUtxoEntries []*UtxoEntry

+ PrevAcceptedNFTBidEntries *[]*NFTBidEntry

+ PrevCoinEntry *CoinEntry

+ PrevCoinRoyaltyCoinEntries map[PKID]CoinEntry

+ PrevCreatorBalanceEntry *BalanceEntry

+ PrevDerivedKeyEntry *DerivedKeyEntry

+ PrevDiamondEntry *DiamondEntry

+ PrevForbiddenPubKeyEntry *ForbiddenPubKeyEntry

+ PrevGlobalParamsEntry *GlobalParamsEntry

+ PrevGrandparentPostEntry *PostEntry

+ PrevLikeCount uint64

+ PrevLikeEntry *LikeEntry

+ PrevMessagingKeyEntry *MessagingGroupEntry

+ PrevNFTBidEntry *NFTBidEntry

+ PrevNFTEntry *NFTEntry

+ PrevNanosPurchased uint64

+ PrevParentPostEntry *PostEntry

+ PrevPostEntry *PostEntry

+ PrevProfileEntry *ProfileEntry

+ PrevReceiverBalanceEntry *BalanceEntry

+ PrevRepostCount uint64

+ PrevRepostEntry *RepostEntry

+ PrevRepostedPostEntry *PostEntry

+ PrevSenderBalanceEntry *BalanceEntry

+ PrevTransactorBalanceEntry *BalanceEntry

+ PrevUSDCentsPerBitcoin uint64

+ SwapIdentityFromDESOLockedNanos uint64

+ SwapIdentityToDESOLockedNanos uint64

+ Type OperationType

+ type UtxoType uint8

+ const UtxoTypeBitcoinBurn

+ const UtxoTypeBlockReward

+ const UtxoTypeCreatorCoinFounderReward

+ const UtxoTypeCreatorCoinSale

+ const UtxoTypeNFTAdditionalDESORoyalty

+ const UtxoTypeNFTBidderChange

+ const UtxoTypeNFTCreatorRoyalty

+ const UtxoTypeNFTSeller

+ const UtxoTypeOutput

+ const UtxoTypeStakeReward

+ func (mm UtxoType) String() string

+ type UtxoView struct

+ BitcoinBurnTxIDs map[BlockHash]bool

+ DerivedKeyToDerivedEntry map[DerivedKeyMapKey]*DerivedKeyEntry

+ DiamondKeyToDiamondEntry map[DiamondKey]*DiamondEntry

+ FollowKeyToFollowEntry map[FollowKey]*FollowEntry

+ ForbiddenPubKeyToForbiddenPubKeyEntry map[PkMapKey]*ForbiddenPubKeyEntry

+ GlobalParamsEntry *GlobalParamsEntry

+ HODLerPKIDCreatorPKIDToBalanceEntry map[BalanceEntryMapKey]*BalanceEntry

+ HODLerPKIDCreatorPKIDToDAOCoinBalanceEntry map[BalanceEntryMapKey]*BalanceEntry

+ Handle *badger.DB

+ LikeKeyToLikeEntry map[LikeKey]*LikeEntry

+ MessageKeyToMessageEntry map[MessageKey]*MessageEntry

+ MessageMap map[BlockHash]*PGMessage

+ MessagingGroupKeyToMessagingGroupEntry map[MessagingGroupKey]*MessagingGroupEntry

+ NFTBidKeyToNFTBidEntry map[NFTBidKey]*NFTBidEntry

+ NFTKeyToAcceptedNFTBidHistory map[NFTKey]*[]*NFTBidEntry

+ NFTKeyToNFTEntry map[NFTKey]*NFTEntry

+ NanosPurchased uint64

+ NumUtxoEntries uint64

+ PKIDToPublicKey map[PKID]*PKIDEntry

+ Params *DeSoParams

+ PostHashToPostEntry map[BlockHash]*PostEntry

+ Postgres *Postgres

+ ProfilePKIDToProfileEntry map[PKID]*ProfileEntry

+ ProfileUsernameToProfileEntry map[UsernameMapKey]*ProfileEntry

+ PublicKeyToDeSoBalanceNanos map[PublicKey]uint64

+ PublicKeyToPKIDEntry map[PkMapKey]*PKIDEntry

+ RepostKeyToRepostEntry map[RepostKey]*RepostEntry

+ TipHash *BlockHash

+ USDCentsPerBitcoin uint64

+ UtxoKeyToUtxoEntry map[UtxoKey]*UtxoEntry

+ func NewUtxoView(_handle *badger.DB, _params *DeSoParams, _postgres *Postgres) (*UtxoView, error)

+ func (bav *UtxoView) ConnectBlock(desoBlock *MsgDeSoBlock, txHashes []*BlockHash, verifySignatures bool, ...) ([][]*UtxoOperation, error)

+ func (bav *UtxoView) ConnectTransaction(txn *MsgDeSoTxn, txHash *BlockHash, txnSizeBytes int64, blockHeight uint32, ...) (_utxoOps []*UtxoOperation, _totalInput uint64, _totalOutput uint64, ...)

+ func (bav *UtxoView) CopyUtxoView() (*UtxoView, error)

+ func (bav *UtxoView) DisconnectBlock(desoBlock *MsgDeSoBlock, txHashes []*BlockHash, utxoOps [][]*UtxoOperation) error

+ func (bav *UtxoView) DisconnectTransaction(currentTxn *MsgDeSoTxn, txnHash *BlockHash, utxoOpsForTxn []*UtxoOperation, ...) error

+ func (bav *UtxoView) FlushToDb() error

+ func (bav *UtxoView) FlushToDbWithTxn(txn *badger.Txn) error

+ func (bav *UtxoView) GetAcceptNFTBidHistoryForNFTKey(nftKey *NFTKey) *[]*NFTBidEntry

+ func (bav *UtxoView) GetAllDerivedKeyMappingsForOwner(ownerPublicKey []byte) (map[PublicKey]*DerivedKeyEntry, error)

+ func (bav *UtxoView) GetAllNFTBidEntries(nftPostHash *BlockHash, serialNumber uint64) []*NFTBidEntry

+ func (bav *UtxoView) GetAllPosts() (_corePosts []*PostEntry, _commentsByPostHash map[BlockHash][]*PostEntry, ...)

+ func (bav *UtxoView) GetAllProfiles(readerPK []byte) (_profiles map[PkMapKey]*ProfileEntry, ...)

+ func (bav *UtxoView) GetBalanceEntry(holderPkid *PKID, creatorPkid *PKID, isDAOCoin bool) *BalanceEntry

+ func (bav *UtxoView) GetBalanceEntryForHODLerPubKeyAndCreatorPubKey(hodlerPubKey []byte, creatorPubKey []byte, isDAOCoin bool) (_balanceEntry *BalanceEntry, _hodlerPKID *PKID, _creatorPKID *PKID)

+ func (bav *UtxoView) GetBalanceEntryHolders(pkid *PKID, isDAOCoin bool) []*BalanceEntry

+ func (bav *UtxoView) GetBalanceEntryHoldings(pkid *PKID, isDAOCoin bool) []*BalanceEntry

+ func (bav *UtxoView) GetCommentEntriesForParentStakeID(parentStakeID []byte) ([]*PostEntry, error)

+ func (bav *UtxoView) GetCreatorCoinBalanceEntryForHODLerPubKeyAndCreatorPubKey(hodlerPubKey []byte, creatorPubKey []byte) (_balanceEntry *BalanceEntry, _hodlerPKID *PKID, _creatorPKID *PKID)

+ func (bav *UtxoView) GetCurrentUSDCentsPerBitcoin() uint64

+ func (bav *UtxoView) GetDAOCoinBalanceEntryForHODLerPubKeyAndCreatorPubKey(hodlerPubKey []byte, creatorPubKey []byte) (_balanceEntry *BalanceEntry, _hodlerPKID *PKID, _creatorPKID *PKID)

+ func (bav *UtxoView) GetDAOCoinHolders(pkid *PKID, fetchProfiles bool) ([]*BalanceEntry, []*ProfileEntry, error)

+ func (bav *UtxoView) GetDAOCoinHoldings(pkid *PKID, fetchProfiles bool) ([]*BalanceEntry, []*ProfileEntry, error)

+ func (bav *UtxoView) GetDBHighAndLowBidEntriesForNFT(nftHash *BlockHash, serialNumber uint64) (_highBidEntry *NFTBidEntry, _lowBidEntry *NFTBidEntry)

+ func (bav *UtxoView) GetDBHighAndLowBidsForNFT(nftHash *BlockHash, serialNumber uint64) (_highBid uint64, _lowBid uint64)

+ func (bav *UtxoView) GetDeSoBalanceNanosForPublicKey(publicKeyArg []byte) (uint64, error)

+ func (bav *UtxoView) GetDiamondEntriesForSenderToReceiver(receiverPublicKey []byte, senderPublicKey []byte) (_diamondEntries []*DiamondEntry, _err error)

+ func (bav *UtxoView) GetDiamondEntryForDiamondKey(diamondKey *DiamondKey) *DiamondEntry

+ func (bav *UtxoView) GetDiamondEntryMapForPublicKey(publicKey []byte, fetchYouDiamonded bool) (_pkidToDiamondsMap map[PKID][]*DiamondEntry, _err error)

+ func (bav *UtxoView) GetDiamondSendersForPostHash(postHash *BlockHash) (_pkidToDiamondLevel map[PKID]int64, _err error)

+ func (bav *UtxoView) GetFollowEntriesForPublicKey(publicKey []byte, getEntriesFollowingPublicKey bool) (_followEntries []*FollowEntry, _err error)

+ func (bav *UtxoView) GetFollowEntryForFollowerPublicKeyCreatorPublicKey(followerPublicKey []byte, creatorPublicKey []byte) *FollowEntry

+ func (bav *UtxoView) GetHODLerPKIDCreatorPKIDToBalanceEntryMap(isDAOCoin bool) map[BalanceEntryMapKey]*BalanceEntry

+ func (bav *UtxoView) GetHighAndLowBidsForNFTCollection(nftHash *BlockHash) (_highBid uint64, _lowBid uint64)

+ func (bav *UtxoView) GetHighAndLowBidsForNFTSerialNumber(nftHash *BlockHash, serialNumber uint64) (_highBid uint64, _lowBid uint64)

+ func (bav *UtxoView) GetHolders(pkid *PKID, fetchProfiles bool, isDAOCoin bool) ([]*BalanceEntry, []*ProfileEntry, error)

+ func (bav *UtxoView) GetHoldings(pkid *PKID, fetchProfiles bool, isDAOCoin bool) ([]*BalanceEntry, []*ProfileEntry, error)

+ func (bav *UtxoView) GetLikedByReader(readerPK []byte, postHash *BlockHash) bool

+ func (bav *UtxoView) GetLikesForPostHash(postHash *BlockHash) (_likerPubKeys [][]byte, _err error)

+ func (bav *UtxoView) GetLimitedMessagesForUser(ownerPublicKey []byte, limit uint64) (_messageEntries []*MessageEntry, _messagingGroupEntries []*MessagingGroupEntry, ...)

+ func (bav *UtxoView) GetMessagesForUser(publicKey []byte) (_messageEntries []*MessageEntry, _messagingKeyEntries []*MessagingGroupEntry, ...)

+ func (bav *UtxoView) GetMessagingGroupEntriesForUser(ownerPublicKey []byte) (_messagingGroupEntries []*MessagingGroupEntry, _err error)

+ func (bav *UtxoView) GetMessagingGroupKeyToMessagingGroupEntryMapping(messagingGroupKey *MessagingGroupKey) *MessagingGroupEntry

+ func (bav *UtxoView) GetNFTBidEntriesForPKID(bidderPKID *PKID) (_nftBidEntries []*NFTBidEntry)

+ func (bav *UtxoView) GetNFTBidEntryForNFTBidKey(nftBidKey *NFTBidKey) *NFTBidEntry

+ func (bav *UtxoView) GetNFTEntriesForPKID(ownerPKID *PKID) []*NFTEntry

+ func (bav *UtxoView) GetNFTEntriesForPostHash(nftPostHash *BlockHash) []*NFTEntry

+ func (bav *UtxoView) GetNFTEntryForNFTKey(nftKey *NFTKey) *NFTEntry

+ func (bav *UtxoView) GetPKIDForPublicKey(publicKeyArg []byte) *PKIDEntry

+ func (bav *UtxoView) GetParentPostEntriesForPostEntry(postEntry *PostEntry, maxDepth uint32, rootFirst bool) (_parentPostEntries []*PostEntry, _truncatedTree bool)

+ func (bav *UtxoView) GetPostEntryForPostHash(postHash *BlockHash) *PostEntry

+ func (bav *UtxoView) GetPostEntryReaderState(readerPK []byte, postEntry *PostEntry) *PostEntryReaderState

+ func (bav *UtxoView) GetPostsPaginatedForPublicKeyOrderedByTimestamp(publicKey []byte, startPostHash *BlockHash, limit uint64, mediaRequired bool, ...) (_posts []*PostEntry, _err error)

+ func (bav *UtxoView) GetProfileEntryForPKID(pkid *PKID) *ProfileEntry

+ func (bav *UtxoView) GetProfileEntryForPublicKey(publicKey []byte) *ProfileEntry

+ func (bav *UtxoView) GetProfileEntryForUsername(nonLowercaseUsername []byte) *ProfileEntry

+ func (bav *UtxoView) GetProfilesByCoinValue(startLockedNanos uint64, limit int) []*ProfileEntry

+ func (bav *UtxoView) GetProfilesForUsernamePrefixByCoinValue(usernamePrefix string) []*ProfileEntry

+ func (bav *UtxoView) GetPublicKeyForPKID(pkidArg *PKID) []byte

+ func (bav *UtxoView) GetQuoteRepostsForPostHash(postHash *BlockHash) (_quoteReposterPubKeys [][]byte, ...)

+ func (bav *UtxoView) GetRepostPostEntryStateForReader(readerPK []byte, postHash *BlockHash) (string, bool)

+ func (bav *UtxoView) GetRepostsForPostHash(postHash *BlockHash) (_reposterPubKeys [][]byte, _err error)

+ func (bav *UtxoView) GetSpendableDeSoBalanceNanosForPublicKey(pkBytes []byte, tipHeight uint32) (_spendableBalance uint64, _err error)

+ func (bav *UtxoView) GetUnspentUtxoEntrysForPublicKey(pkBytes []byte) ([]*UtxoEntry, error)

+ func (bav *UtxoView) GetUtxoEntryForUtxoKey(utxoKeyArg *UtxoKey) *UtxoEntry

+ func (bav *UtxoView) HelpConnectCoinTransfer(txn *MsgDeSoTxn, txHash *BlockHash, blockHeight uint32, verifySignatures bool, ...) (_totalInput uint64, _totalOutput uint64, _utxoOps []*UtxoOperation, _err error)

+ func (bav *UtxoView) HelpConnectCreatorCoinBuy(txn *MsgDeSoTxn, txHash *BlockHash, blockHeight uint32, verifySignatures bool) (_totalInput uint64, _totalOutput uint64, _creatorCoinReturnedNanos uint64, ...)

+ func (bav *UtxoView) HelpConnectCreatorCoinSell(txn *MsgDeSoTxn, txHash *BlockHash, blockHeight uint32, verifySignatures bool) (_totalInput uint64, _totalOutput uint64, _desoReturnedNanos uint64, ...)

+ func (bav *UtxoView) HelpConnectDAOCoinBurn(txn *MsgDeSoTxn, txHash *BlockHash, blockHeight uint32, verifySignatures bool) (_totalInput uint64, _totalOutput uint64, _utxoOps []*UtxoOperation, _err error)

+ func (bav *UtxoView) HelpConnectDAOCoinDisableMinting(txn *MsgDeSoTxn, txHash *BlockHash, blockHeight uint32, verifySignatures bool) (_totalInput uint64, _totalOutput uint64, _utxoOps []*UtxoOperation, _err error)

+ func (bav *UtxoView) HelpConnectDAOCoinInitialization(txn *MsgDeSoTxn, txHash *BlockHash, blockHeight uint32, verifySignatures bool) (_totalInput uint64, _totalOutput uint64, _utxoOps []*UtxoOperation, ...)

+ func (bav *UtxoView) HelpConnectDAOCoinMint(txn *MsgDeSoTxn, txHash *BlockHash, blockHeight uint32, verifySignatures bool) (_totalInput uint64, _totalOutput uint64, _utxoOps []*UtxoOperation, _err error)

+ func (bav *UtxoView) HelpConnectUpdateTransferRestrictionStatus(txn *MsgDeSoTxn, txHash *BlockHash, blockHeight uint32, verifySignatures bool) (_totalInput uint64, _totalOutput uint64, _utxoOps []*UtxoOperation, _err error)

+ func (bav *UtxoView) IsValidDAOCoinTransfer(creatorProfileEntry *ProfileEntry, senderPublicKey []byte, ...) error

+ func (bav *UtxoView) Preload(desoBlock *MsgDeSoBlock) error

+ func (bav *UtxoView) ValidateDiamondsAndGetNumCreatorCoinNanos(senderPublicKey []byte, receiverPublicKey []byte, diamondPostHash *BlockHash, ...) (_numCreatorCoinNanos uint64, _netNewDiamonds int64, _err error)

+ func (bav *UtxoView) ValidateDiamondsAndGetNumDeSoNanos(senderPublicKey []byte, receiverPublicKey []byte, diamondPostHash *BlockHash, ...) (_numDeSoNanos uint64, _netNewDiamonds int64, _err error)

+ func (bav *UtxoView) ValidateKeyAndNameWithUtxo(ownerPublicKey, messagingPublicKey, keyName []byte) error

Other modules containing this package

github.com/deso-smart/deso-core/v3

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