lib

package

Go to main page

Versions in this module

v1

v1.1.6

Sep 13, 2021

Changes in this version

+ const DerivedPublicKey

+ var NFTTransferOrBurnAndDerivedKeysBlockHeight = uint32(60743)

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

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

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

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

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

+ 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() BitCloutTxnMetadata

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

+ type AuthorizeDerivedKeyOperationType uint8

+ const AuthorizeDerivedKeyOperationNotValid

+ const AuthorizeDerivedKeyOperationValid

type Blockchain

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

+ 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 OperationType

+ const OperationTypeAuthorizeDerivedKey

+ type PGDerivedKey struct

+ DerivedPublicKey PublicKey

+ ExpirationBlock uint64

+ OperationType AuthorizeDerivedKeyOperationType

+ OwnerPublicKey PublicKey

+ func (key *PGDerivedKey) NewDerivedKeyEntry() *DerivedKeyEntry

+ type PGMetadataDerivedKey struct

+ AccessSignature []byte

+ DerivedPublicKey PublicKey

+ ExpirationBlock uint64

+ OperationType AuthorizeDerivedKeyOperationType

+ TransactionHash *BlockHash

type PGTransaction

+ MetadataDerivedKey *PGMetadataDerivedKey

type Postgres

+ func (postgres *Postgres) GetAllDerivedKeysForOwner(ownerPublicKey *PublicKey) []*PGDerivedKey

+ func (postgres *Postgres) GetDerivedKey(ownerPublicKey *PublicKey, derivedPublicKey *PublicKey) *PGDerivedKey

type RuleError

+ const RuleErrorAuthorizeDerivedKeyAccessSignatureNotValid

+ const RuleErrorAuthorizeDerivedKeyDeletedDerivedPublicKey

+ const RuleErrorAuthorizeDerivedKeyExpiredDerivedPublicKey

+ const RuleErrorAuthorizeDerivedKeyInvalidDerivedPublicKey

+ const RuleErrorAuthorizeDerivedKeyInvalidOwnerPublicKey

+ const RuleErrorAuthorizeDerivedKeyRequiresNonZeroInput

+ const RuleErrorDerivedKeyBeforeBlockHeight

+ const RuleErrorDerivedKeyInvalidExtraData

+ const RuleErrorDerivedKeyNotAuthorized

type TxnType

+ const TxnTypeAuthorizeDerivedKey

type UtxoOperation

+ PrevDerivedKeyEntry *DerivedKeyEntry

type UtxoView

+ DerivedKeyToDerivedEntry map[DerivedKeyMapKey]*DerivedKeyEntry

+ func (bav *UtxoView) GetAllDerivedKeyMappingsForOwner(ownerPublicKey []byte) (map[PublicKey]*DerivedKeyEntry, error)

v1.1.5

Sep 10, 2021

Changes in this version

+ const MAIN_CHAIN

+ var NFTTransferOrBurnBlockHeight = uint32(60743)

+ func BoolToByte(val bool) byte

+ func LogSelect(query *orm.Query) error

+ func ReadBoolByte(rr *bytes.Reader) bool

+ type AcceptNFTTransferMetadata struct

+ NFTPostHash *BlockHash

+ SerialNumber uint64

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

+ func (txnData *AcceptNFTTransferMetadata) GetTxnType() TxnType

+ func (txnData *AcceptNFTTransferMetadata) New() BitCloutTxnMetadata

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

type BalanceEntry

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

type BasicTransferTxindexMetadata

+ DiamondLevel int64

+ PostHashHex string

type BlockHash

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

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

type Blockchain

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

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

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

+ type BurnNFTMetadata struct

+ NFTPostHash *BlockHash

+ SerialNumber uint64

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

+ func (txnData *BurnNFTMetadata) GetTxnType() TxnType

+ func (txnData *BurnNFTMetadata) New() BitCloutTxnMetadata

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

type NFTEntry

+ IsPending bool

+ 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() BitCloutTxnMetadata

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

+ type NotificationType uint8

+ const NotificationCloutDiamond

+ const NotificationCoinDiamond

+ const NotificationCoinPurchase

+ const NotificationCoinTransfer

+ const NotificationFollow

+ const NotificationLike

+ const NotificationPostMention

+ const NotificationPostReclout

+ const NotificationPostReply

+ const NotificationSendClout

+ const NotificationUnknown

+ type Notifier struct

+ func NewNotifier(coreChain *Blockchain, postgres *Postgres) *Notifier

+ func (notifier *Notifier) Start()

+ func (notifier *Notifier) Update() error

type OperationType

+ const OperationTypeAcceptNFTTransfer

+ const OperationTypeBurnNFT

+ const OperationTypeNFTTransfer

+ 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 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 PGMetadataAcceptNFTBid struct

+ BidAmountNanos uint64

+ BidderInputs []*PGMetadataBidInput

+ BidderPKID *PKID

+ NFTPostHash *BlockHash

+ SerialNumber uint64

+ TransactionHash *BlockHash

+ UnlockableText []byte

+ 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 PGMetadataCreateNFT struct

+ CoinRoyaltyBasisPoints uint64

+ CreatorRoyaltyBasisPoints uint64

+ HasUnlockable bool

+ IsForSale bool

+ MinBidAmountNanos uint64

+ NFTPostHash *BlockHash

+ NumCopies uint64

+ TransactionHash *BlockHash

+ type PGMetadataCreatorCoin struct

+ BitCloutToAddNanos uint64

+ BitCloutToSellNanos uint64

+ CreatorCoinToSellNanos uint64

+ MinBitCloutExpectedNanos uint64

+ MinCreatorCoinExpectedNanos uint64

+ OperationType CreatorCoinOperationType

+ ProfilePublicKey []byte

+ TransactionHash *BlockHash

+ type PGMetadataCreatorCoinTransfer struct

+ CreatorCoinToTransferNanos uint64

+ ProfilePublicKey []byte

+ ReceiverPublicKey []byte

+ 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 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

+ ForSale 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

+ 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

+ Body string

+ CoinRoyaltyBasisPoints uint64

+ CommentCount uint64

+ CreatorRoyaltyBasisPoints uint64

+ DiamondCount uint64

+ ExtraData map[string][]byte

+ Hidden bool

+ LikeCount uint64

+ NFT bool

+ NumNFTCopies uint64

+ ParentPostHash *BlockHash

+ Pinned bool

+ PostHash *BlockHash

+ PosterPublicKey []byte

+ QuoteRecloutCount uint64

+ QuotedReclout bool

+ RecloutCount uint64

+ RecloutedPostHash *BlockHash

+ Timestamp uint64

+ Unlockable bool

+ func (post *PGPost) HasMedia() bool

+ func (post *PGPost) NewPostEntry() *PostEntry

+ type PGProfile struct

+ BitCloutLockedNanos uint64

+ CoinWatermarkNanos uint64

+ CoinsInCirculationNanos uint64

+ CreatorBasisPoints uint64

+ Description string

+ NumberOfHolders uint64

+ PKID *PKID

+ ProfilePic []byte

+ PublicKey *PublicKey

+ Username string

+ func (profile *PGProfile) Empty() bool

+ type PGReclout struct

+ RecloutPostHash *BlockHash

+ RecloutedPostHash *BlockHash

+ ReclouterPublickey *PublicKey

+ type PGTransaction struct

+ BlockHash *BlockHash

+ ExtraData map[string][]byte

+ Hash *BlockHash

+ MetadataAcceptNFTBid *PGMetadataAcceptNFTBid

+ MetadataBitcoinExchange *PGMetadataBitcoinExchange

+ MetadataBlockReward *PGMetadataBlockReward

+ MetadataCreateNFT *PGMetadataCreateNFT

+ MetadataCreatorCoin *PGMetadataCreatorCoin

+ MetadataCreatorCoinTransfer *PGMetadataCreatorCoinTransfer

+ MetadataFollow *PGMetadataFollow

+ MetadataLike *PGMetadataLike

+ MetadataNFTBid *PGMetadataNFTBid

+ 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

+ func NewPKID(pkidBytes []byte) *PKID

+ func (pkid *PKID) NewPKID() *PKID

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

type PKIDEntry

+ func (pkid *PKIDEntry) String() string

type PostEntry

+ NumNFTCopiesBurned uint64

+ type Postgres struct

+ func NewPostgres(db *pg.DB) *Postgres

+ func (postgres *Postgres) FlushView(view *UtxoView) error

+ 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) 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) GetHolders(pkid *PKID) []*PGCreatorCoinBalance

+ func (postgres *Postgres) GetHoldings(pkid *PKID) []*PGCreatorCoinBalance

+ 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 *BitCloutParams, db *badger.DB) error

+ func (postgres *Postgres) InsertTransactionsTx(tx *pg.Tx, bitCloutTxns []*MsgBitCloutTxn, blockNode *BlockNode) error

+ func (postgres *Postgres) UpsertBlock(blockNode *BlockNode) error

+ func (postgres *Postgres) UpsertBlockAndTransactions(blockNode *BlockNode, bitcloutBlock *MsgBitCloutBlock) 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 PublicKey [33]byte

+ func NewPublicKey(publicKeyBytes []byte) *PublicKey

+ func (publicKey *PublicKey) ToBytes() []byte

type RuleError

+ const RuleErrorAcceptNFTTranserBeforeBlockHeight

+ const RuleErrorAcceptNFTTransferByNonOwner

+ const RuleErrorAcceptNFTTransferForNonPendingNFT

+ const RuleErrorAcceptNFTTransferRequiresNonZeroInput

+ const RuleErrorBurnNFTBeforeBlockHeight

+ const RuleErrorBurnNFTByNonOwner

+ const RuleErrorBurnNFTRequiresNonZeroInput

+ const RuleErrorCannotAcceptBidForPendingNFTTransfer

+ const RuleErrorCannotAcceptTransferOfNonExistentNFT

+ const RuleErrorCannotBidForPendingNFTTransfer

+ const RuleErrorCannotBurnNFTThatIsForSale

+ const RuleErrorCannotBurnNonExistentNFT

+ const RuleErrorCannotTransferForSaleNFT

+ const RuleErrorCannotTransferNonExistentNFT

+ const RuleErrorCannotTransferUnlockableNFTWithoutUnlockable

+ const RuleErrorCannotUpdatePendingNFTTransfer

+ const RuleErrorNFTTranserBeforeBlockHeight

+ const RuleErrorNFTTransferByNonOwner

+ const RuleErrorNFTTransferCannotTransferToSelf

+ const RuleErrorNFTTransferInvalidReceiverPubKeySize

+ const RuleErrorNFTTransferRequiresNonZeroInput

type Server

+ Notifier *Notifier

type TxnType

+ const TxnTypeAcceptNFTTransfer

+ const TxnTypeBurnNFT

+ const TxnTypeNFTTransfer

type UtxoView

+ MessageMap map[BlockHash]*PGMessage

+ Postgres *Postgres

+ func (bav *UtxoView) GetHolders(pkid *PKID, fetchProfiles bool) ([]*BalanceEntry, []*ProfileEntry, error)

+ func (bav *UtxoView) GetHoldings(pkid *PKID, fetchProfiles bool) ([]*BalanceEntry, []*ProfileEntry, error)

+ func (bav *UtxoView) GetProfilesByCoinValue(startLockedNanos uint64, limit int) []*ProfileEntry

+ func (bav *UtxoView) GetProfilesForUsernamePrefixByCoinValue(usernamePrefix string) []*ProfileEntry

+ func (bav *UtxoView) Preload(bitcloutBlock *MsgBitCloutBlock) error

v1.1.4

Aug 18, 2021

Changes in this version

+ var BitCloutDiamondsBlockHeight = uint32(52112)

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

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

type Blockchain

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

type OperationType

+ const OperationTypeBitCloutDiamond

type RuleError

+ const RuleErrorBasicTransferDiamondCannotTransferToSelf

+ const RuleErrorBasicTransferDiamondInvalidLengthForPostHashBytes

+ const RuleErrorBasicTransferDiamondPostEntryDoesNotExist

+ const RuleErrorBasicTransferHasDiamondPostHashWithoutDiamondLevel

+ const RuleErrorBasicTransferHasInvalidDiamondLevel

+ const RuleErrorBasicTransferInsufficientBitCloutForDiamondLevel

+ const RuleErrorBasicTransferInsufficientCreatorCoinsForDiamondLevel

+ const RuleErrorCreatorCoinTransferHasDiamondsAfterBitCloutBlockHeight

type UtxoView

+ func (bav *UtxoView) ValidateDiamondsAndGetNumBitCloutNanos(senderPublicKey []byte, receiverPublicKey []byte, diamondPostHash *BlockHash, ...) (_numBitCloutNanos uint64, _netNewDiamonds int64, _err error)

v1.1.3

Jul 29, 2021

Changes in this version

type BasicTransferTxindexMetadata

+ UtxoOps []*UtxoOperation

v1.1.2

Jul 28, 2021

Changes in this version

+ var BrokenNFTBidsFixBlockHeight = uint32(46917)

v1.1.1

Jul 27, 2021

v1.1.0

Jul 27, 2021

Changes in this version

+ const CreateNFTFeeNanosKey

+ const CreateProfileFeeNanosKey

+ const ForbiddenBlockSignaturePubKeyKey

+ const MaxCopiesPerNFTKey

+ const MaxCreateNFTFeeNanos

+ const MaxMaxCopiesPerNFT

+ const MinCreateNFTFeeNanos

+ const MinMaxCopiesPerNFT

+ const MinNetworkFeeNanosPerKBKey

+ const USDCentsPerBitcoinKey

+ var UpdateProfileFixBlockHeight = uint32(46165)

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

+ func DBDeleteAcceptedNFTBidMappings(handle *badger.DB, postHash *BlockHash, serialNumber uint64) 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 DBGetAcceptedNFTBidEntriesByPostHashSerialNumber(db *badger.DB, postHash *BlockHash, serialNumber uint64) *[]*NFTBidEntry

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

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

+ func DBPutAcceptedNFTBidEntriesMappingWithTxn(txn *badger.Txn, nftKey NFTKey, nftBidEntries *[]*NFTBidEntry) 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 DbDeletePublicKeyToBitcloutBalance(handle *badger.DB, publicKey []byte) error

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

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

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

+ 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 DbPutBitcloutBalanceForPublicKey(handle *badger.DB, publicKey []byte, balanceNanos uint64) error

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

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

+ type AcceptNFTBidMetadata struct

+ BidAmountNanos uint64

+ BidderInputs []*BitCloutInput

+ BidderPKID *PKID

+ NFTPostHash *BlockHash

+ SerialNumber uint64

+ UnlockableText []byte

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

+ func (txnData *AcceptNFTBidMetadata) GetTxnType() TxnType

+ func (txnData *AcceptNFTBidMetadata) New() BitCloutTxnMetadata

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

+ type AcceptNFTBidTxindexMetadata struct

+ BidAmountNanos uint64

+ NFTPostHashHex string

+ SerialNumber uint64

type BitCloutParams

+ MaxNFTRoyaltyBasisPoints uint64

type Blockchain

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

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

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

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

+ 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() BitCloutTxnMetadata

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

type GlobalParamsEntry

+ CreateNFTFeeNanos uint64

+ MaxCopiesPerNFT uint64

+ type NFTBidEntry struct

+ 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

+ 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() BitCloutTxnMetadata

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

+ type NFTBidTxindexMetadata struct

+ BidAmountNanos uint64

+ NFTPostHashHex string

+ SerialNumber uint64

+ type NFTEntry struct

+ IsForSale 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 OperationType

+ const OperationTypeAcceptNFTBid

+ const OperationTypeCreateNFT

+ const OperationTypeNFTBid

+ const OperationTypeUpdateNFT

type PostEntry

+ HasUnlockable bool

+ IsNFT bool

+ NFTRoyaltyToCoinBasisPoints uint64

+ NFTRoyaltyToCreatorBasisPoints uint64

+ NumNFTCopies uint64

+ NumNFTCopiesForSale uint64

type RuleError

+ const RuleErrorAcceptNFTBidByNonOwner

+ const RuleErrorAcceptNFTBidRequiresNonZeroInput

+ const RuleErrorAcceptNFTBidderInputsInsufficientForBidAmount

+ const RuleErrorAcceptedNFTBidAmountDoesNotMatch

+ const RuleErrorAcceptedNFTBidMustSpecifyBidderInputs

+ const RuleErrorBidderInputForAcceptedNFTBidNoLongerExists

+ const RuleErrorCannotUpdateNonExistentNFT

+ const RuleErrorCantAcceptNonExistentBid

+ const RuleErrorCantCreateNFTWithoutProfileEntry

+ const RuleErrorCreateNFTFeeTooHigh

+ const RuleErrorCreateNFTFeeTooLow

+ const RuleErrorCreateNFTMustBeCalledByPoster

+ const RuleErrorCreateNFTOnNonexistentPost

+ const RuleErrorCreateNFTOnPostThatAlreadyIsNFT

+ const RuleErrorCreateNFTOnVanillaReclout

+ const RuleErrorCreateNFTRequiresNonZeroInput

+ const RuleErrorCreateNFTWithInsufficientFunds

+ const RuleErrorInsufficientFundsForNFTBid

+ const RuleErrorMaxCopiesPerNFTTooHigh

+ const RuleErrorMaxCopiesPerNFTTooLow

+ const RuleErrorNFTBidLessThanMinBidAmountNanos

+ const RuleErrorNFTBidOnInvalidSerialNumber

+ const RuleErrorNFTBidOnNFTThatIsNotForSale

+ const RuleErrorNFTBidOnNonExistentNFTEntry

+ const RuleErrorNFTBidOnNonExistentPost

+ const RuleErrorNFTBidOnPostThatIsNotAnNFT

+ const RuleErrorNFTBidRequiresNonZeroInput

+ const RuleErrorNFTMustHaveNonZeroCopies

+ const RuleErrorNFTOwnerCannotBidOnOwnedNFT

+ const RuleErrorNFTRoyaltyHasTooManyBasisPoints

+ const RuleErrorNFTRoyaltyOverflow

+ const RuleErrorNFTUpdateMustUpdateIsForSaleStatus

+ const RuleErrorPostEntryNotFoundForAcceptedNFTBid

+ const RuleErrorProfilePubKeyNotAuthorized

+ const RuleErrorSubmitPostCannotUpdateNFT

+ const RuleErrorTooManyNFTCopies

+ const RuleErrorUnlockableNFTMustProvideUnlockableText

+ const RuleErrorUnlockableTextLengthExceedsMax

+ const RuleErrorUpdateNFTByNonOwner

+ const RuleErrorUpdateNFTRequiresNonZeroInput

type TransactionMetadata

+ AcceptNFTBidTxindexMetadata *AcceptNFTBidTxindexMetadata

+ NFTBidTxindexMetadata *NFTBidTxindexMetadata

type TxnType

+ const TxnTypeAcceptNFTBid

+ const TxnTypeCreateNFT

+ const TxnTypeNFTBid

+ const TxnTypeUpdateNFT

+ 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() BitCloutTxnMetadata

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

type UtxoOperation

+ DeletedNFTBidEntries []*NFTBidEntry

+ NFTPaymentUtxoKeys []*UtxoKey

+ NFTSpentUtxoEntries []*UtxoEntry

+ PrevAcceptedNFTBidEntries *[]*NFTBidEntry

+ PrevNFTBidEntry *NFTBidEntry

+ PrevNFTEntry *NFTEntry

type UtxoType

+ const UtxoTypeNFTBidderChange

+ const UtxoTypeNFTCreatorRoyalty

+ const UtxoTypeNFTSeller

type UtxoView

+ NFTBidKeyToNFTBidEntry map[NFTBidKey]*NFTBidEntry

+ NFTKeyToAcceptedNFTBidHistory map[NFTKey]*[]*NFTBidEntry

+ NFTKeyToNFTEntry map[NFTKey]*NFTEntry

+ PublicKeyToBitcloutBalanceNanos map[PkMapKey]uint64

+ func (bav *UtxoView) GetAcceptNFTBidHistoryForNFTKey(nftKey *NFTKey) *[]*NFTBidEntry

+ func (bav *UtxoView) GetAllNFTBidEntries(nftPostHash *BlockHash, serialNumber uint64) []*NFTBidEntry

+ func (bav *UtxoView) GetBitcloutBalanceNanosForPublicKey(publicKey []byte) (_balance uint64, _err 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) GetHighAndLowBidsForNFTCollection(nftHash *BlockHash) (_highBid uint64, _lowBid uint64)

+ func (bav *UtxoView) GetHighAndLowBidsForNFTSerialNumber(nftHash *BlockHash, serialNumber uint64) (_highBid uint64, _lowBid uint64)

+ 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) GetSpendableBitcloutBalanceNanosForPublicKey(pkBytes []byte, tipHeight uint32) (_spendableBalance uint64, _err error)

v1.0.7

Jul 20, 2021

Changes in this version

type BitCloutParams

+ func (params *BitCloutParams) EnableRegtest()

type MessageEntry

+ Version uint8

type UtxoView

+ func (bav *UtxoView) GetBalanceEntryForHODLerPubKeyAndCreatorPubKey(hodlerPubKey []byte, creatorPubKey []byte) (_balanceEntry *BalanceEntry, _hodlerPKID *PKID, _creatorPKID *PKID)

+ func (bav *UtxoView) GetFollowEntryForFollowerPublicKeyCreatorPublicKey(followerPublicKey []byte, creatorPublicKey []byte) *FollowEntry

v1.0.6

Jun 28, 2021

Changes in this version

+ var BuyCreatorCoinAfterDeletedBalanceEntryFixBlockHeight = uint32(39713)

+ var ParamUpdaterProfileUpdateFixBlockHeight = uint32(39713)

v1.0.4

Jun 24, 2021

Changes in this version

type Server

+ func (srv *Server) StartStatsdReporter()

v1.0.3

Jun 16, 2021

Changes in this version

+ const IsQuotedRecloutKey

type PostEntry

+ QuoteRecloutCount uint64

+ func (pe *PostEntry) HasMedia() bool

type TransactionMetadata

+ TxnOutputs []*BitCloutOutput

type UtxoView

+ func (bav *UtxoView) GetDiamondSendersForPostHash(postHash *BlockHash) (_pkidToDiamondLevel map[PKID]int64, _err error)

+ func (bav *UtxoView) GetLikedByReader(readerPK []byte, postHash *BlockHash) bool

+ func (bav *UtxoView) GetLikesForPostHash(postHash *BlockHash) (_likerPubKeys [][]byte, _err error)

+ func (bav *UtxoView) GetQuoteRecloutsForPostHash(postHash *BlockHash) (_quoteReclouterPubKeys [][]byte, ...)

+ func (bav *UtxoView) GetRecloutPostEntryStateForReader(readerPK []byte, postHash *BlockHash) (string, bool)

+ func (bav *UtxoView) GetRecloutsForPostHash(postHash *BlockHash) (_reclouterPubKeys [][]byte, _err error)

v1.0.2

Jun 7, 2021

Changes in this version

+ const BlocksPerDay

+ var DeflationBombBlockRewardAdjustmentBlockHeight = uint32(32060)

type Server

+ func (srv *Server) GetStatsdClient() *statsd.Client

+ func (srv *Server) StartMempoolStatsReporter()

+ type TXIndex struct

+ BitcoinManager *BitcoinManager

+ CoreChain *Blockchain

+ Params *BitCloutParams

+ TXIndexChain *Blockchain

+ TXIndexLock deadlock.RWMutex

+ func NewTXIndex(coreChain *Blockchain, bitcoinManager *BitcoinManager, params *BitCloutParams, ...) (*TXIndex, error)

+ func (txi *TXIndex) GetTxindexUpdateBlockNodes() (_txindexTipNode *BlockNode, _blockTipNode *BlockNode, ...)

+ func (txi *TXIndex) Start()

+ func (txi *TXIndex) Stop()

+ func (txi *TXIndex) Update() error

v1.0.1

May 21, 2021

v1.0.0

May 18, 2021

Changes in this version

+ const AddrRelayIntervalSeconds

+ const BlocksPerYear

+ const ChainTypeBitCloutBlock

+ const ChainTypeBitcoinHeader

+ const ConfigDirAppName

+ const ConfigDirVendorName

+ const CreateProfileFeeNanos

+ const CurrentHeaderVersion

+ const DiamondLevelKey

+ const DiamondPostHashKey

+ const FloatPrecision

+ const ForbiddenBlockSignaturePubKey

+ const HashSizeBytes

+ const HeaderVersion0

+ const HeaderVersion1

+ const IsQuotedReclout

+ const MaxAddrsPerAddrMsg

+ const MaxBitCloutInputSizeBytes

+ const MaxBitCloutOutputSizeBytes

+ const MaxBlockIndexNodes

+ const MaxBlocksInFlight

+ const MaxCreateProfileFeeNanos

+ const MaxMessagePayload

+ 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 MinCreateProfileFeeNanos

+ const MinNanosToCreate

+ const MinNetworkFeeNanosPerKB

+ const MinNetworkFeeNanosPerKBValue

+ const MinUSDCentsPerBitcoin

+ const NanosPerUnit

+ const OutputSizeBytes

+ const RebroadcastNodeAddrIntervalMinutes

+ const RecloutedPostHash

+ const SECURE_MIDDLEWARE_RESTRICTIVE_CONTENT_SECURITY_POLICY

+ const SatoshisPerBitcoin

+ const SecondsIn3Days

+ const SecondsIn4Days

+ const StartBitCloutPriceUSDCents

+ const StatusBitcoinHeaderValidateFailed

+ const StatusBitcoinHeaderValidated

+ const StatusBlockProcessed

+ const StatusBlockStored

+ const StatusBlockValidateFailed

+ const StatusBlockValidated

+ const StatusHeaderValidateFailed

+ const StatusHeaderValidated

+ const StatusNone

+ const TrancheSizeNanos

+ const USDCentsPerBitcoin

+ const Uint32Dec

+ const Uint64Dec

+ const UnconnectedTxnExpirationInterval

+ const UseridLengthBytes

+ var ArchitectPubKeyBase58Check = "BC1YLg3oh6Boj8e2boCo1vQCYHLk1rjsHF6jthBdvSw79bixQvKK6Qa"

+ var BitCloutFounderRewardBlockHeight = uint32(21869)

+ var BitCloutMainnetParams = BitCloutParams

+ var BitCloutTestnetParams = BitCloutParams

+ var BitcoinGetHeadersTimeout = 3 * time.Second

+ var BitcoinHeaderUpdateInterval = 5 * time.Second

+ var BurnPubKeyBase58Check = "BC1YLjWBf2qnDJmi8HZzzCPeXqy4dCKq95oqqzerAyW8MUTbuXTb1QT"

+ var ForgivenBitcoinTransactions = map[string]bool

+ var ForgivenProfileUsernameClaims = map[BlockHash]string

+ var GenesisBlock = MsgBitCloutBlock

+ var GenesisBlockHash = mustDecodeHexBlockHash(GenesisBlockHashHex)

+ var GenesisBlockHashHex = "5567c45b7b83b604f9ff5cb5e88dfc9ad7d5a1dd5818dd19e6d02466f47cbd62"

+ var InitialGlobalParamsEntry = GlobalParamsEntry

+ var InitialUSDCentsPerBitcoinExchangeRate = uint64(3000000)

+ var IsBlacklisted = []byte

+ var IsGraylisted = []byte

+ var IsReserved = map[string]bool

+ var LowFeeTxLimitBytesPerTenMinutes = 150000

+ var MaxBitcoinHeadersPerMsg = uint32(2000)

+ var MaxBlockRewardDataSizeBytes = 250

+ var MaxHeadersPerMsg = uint32(2000)

+ var MiningSupplyIntervals = []*MiningSupplyIntervalStart

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

+ var NotQuotedRecloutVal = []byte

+ var NukedBitcoinTransactions = map[string]bool

+ var ParamUpdaterPublicKeys = map[PkMapKey]bool

+ var PostExtraDataConsensusKeys = [2]string

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

+ var QuotedRecloutVal = []byte

+ var ReadOnlyUtxoViewRegenerationIntervalSeconds = float64(1.0)

+ var ReadOnlyUtxoViewRegenerationIntervalTxns = int64(1000)

+ var SalomonFixBlockHeight = uint32(15270)

+ var SeedBalances = []*BitCloutOutput

+ var SeedTxns = []string

+ var TestSeedBalances = []*BitCloutOutput

+ 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 *BitCloutParams) 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 BitcoinTxnToString(txn *wire.MsgTx) string

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

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

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

+ func BlockHashToBlockKey(blockHash *BlockHash) []byte

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

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

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

+ func CalcBlockRewardNanos(blockHeight uint32) uint64

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

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

+ func CalculateCreatorCoinToMint(bitcloutToSellNanos uint64, coinsInCirculationNanos uint64, ...) uint64

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

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

+ func CheckTransactionSanity(txn *MsgBitCloutTxn) error

+ func ComputeKeysFromSeed(seedBytes []byte, index uint32, params *BitCloutParams) (_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 []*MsgBitCloutTxn) (_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 DBDeleteCreatorCoinBalanceEntryMappings(handle *badger.DB, hodlerPKID *PKID, creatorPKID *PKID, params *BitCloutParams) error

+ func DBDeleteCreatorCoinBalanceEntryMappingsWithTxn(txn *badger.Txn, hodlerPKID *PKID, creatorPKID *PKID, params *BitCloutParams) error

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

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

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

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

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

+ 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) (_lockedBitCloutNanos []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 DBPutCreatorCoinBalanceEntryMappings(handle *badger.DB, balanceEntry *BalanceEntry, params *BitCloutParams) error

+ func DBPutCreatorCoinBalanceEntryMappingsWithTxn(txn *badger.Txn, balanceEntry *BalanceEntry, params *BitCloutParams) error

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

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

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

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

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

+ func DbBufForUtxoKey(utxoKey *UtxoKey) []byte

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

+ 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, diamondReceiverPKID *PKID, diamondGiverPKID *PKID, ...) error

+ func DbDeleteDiamondMappingsWithTxn(txn *badger.Txn, diamondReceiverPKID *PKID, diamondSenderPKID *PKID, ...) 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 DbDeleteMessageEntryMappings(handle *badger.DB, publicKey []byte, tstampNanos uint64) error

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

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

+ func DbDeleteRecloutMappingsWithTxn(txn *badger.Txn, userPubKey []byte, recloutedPostHash 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 *MsgBitCloutTxn, params *BitCloutParams) error

+ func DbDeleteTxindexTransactionMappingsWithTxn(dbTxn *badger.Txn, txn *MsgBitCloutTxn, params *BitCloutParams) error

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

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

+ func DbGetBalanceEntriesHodlingYou(pkid *PKIDEntry, fetchProfiles bool, filterOutZeroBalances bool, ...) (_entriesHodlingYou []*BalanceEntry, _profilesHodlingYou []*ProfileEntry, ...)

+ func DbGetBalanceEntriesYouHodl(pkid *PKIDEntry, fetchProfiles bool, filterOutZeroBalances bool, ...) (_entriesYouHodl []*BalanceEntry, _profilesYouHodl []*ProfileEntry, _err error)

+ func DbGetCreatorCoinBalanceEntriesForPubKey(pkid *PKIDEntry, fetchProfiles bool, filterOutZeroBalances bool, ...) (_entriesYouHodl []*BalanceEntry, _entriesThatHodlYou []*BalanceEntry, ...)

+ 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 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 *MsgBitCloutTxn, _txnMeta *TransactionMetadata)

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

+ func DbGetUSDCentsPerBitcoinExchangeRate(handle *badger.DB) uint64

+ func DbGetUSDCentsPerBitcoinExchangeRateWithTxn(txn *badger.Txn) uint64

+ func DbPutBitcoinBurnTxIDWithTxn(txn *badger.Txn, bitcoinBurnTxID *BlockHash) 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 DbPutMessageEntry(handle *badger.DB, messageEntry *MessageEntry) error

+ func DbPutMessageEntryWithTxn(txn *badger.Txn, messageEntry *MessageEntry) error

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

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

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

+ func DbPutRecloutMappingsWithTxn(txn *badger.Txn, userPubKey []byte, recloutedPostHash 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, bitcloutTxn *MsgBitCloutTxn, params *BitCloutParams, ...) error

+ func DbPutTxindexTransactionMappingsWithTxn(dbTx *badger.Txn, txn *MsgBitCloutTxn, params *BitCloutParams, ...) 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 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 Diff(expected interface{}, actual interface{}) string

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

+ 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 EstimateBitcoinTxFee(numInputs int, numOutputs int, feeRateSatoshisPerKB uint64) uint64

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

+ func ExtractBitcoinBurnTransactionsFromBitcoinBlockWithMerkleProofs(bitcoinBlock *wire.MsgBlock, burnAddress string, params *BitCloutParams) (_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 GetBitCloutNanosDiamondLevelMapAtBlockHeight(blockHeight int64) map[int64]uint64

+ func GetBitCloutNanosForDiamondLevelAtBlockHeight(diamondLevel int64, blockHeight int64) uint64

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

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

+ func GetDataDir(params *BitCloutParams) string

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

+ func GetSatoshisPerUnitExchangeRate(startNanos uint64, usdCentsPerBitcoinExchangeRate uint64) uint64

+ func GetStartPriceSatoshisPerBitClout(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 HashToStakeID(hash *BlockHash) []byte

+ func HeaderSizeBytes() int

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

+ func InitDbWithBitCloutGenesisBlock(params *BitCloutParams, handle *badger.DB) 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 *BitCloutParams) bool

+ func IsControlMessage(msgType MsgType) bool

+ func IsForgivenBitcoinTransaction(txn *MsgBitCloutTxn) bool

+ func IsNukedBitcoinTransaction(txn *MsgBitCloutTxn) bool

+ func IsRestrictedPubKey(userGraylistState []byte, userBlacklistState []byte, moderationType string) bool

+ func IsRuleError(err error) bool

+ func IsUnminedBitcoinExchange(txnMeta *BitcoinExchangeMetadata) bool

+ func IsVanillaReclout(postEntry *PostEntry) bool

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

+ func LogDBSummarySnapshot(db *badger.DB)

+ func MakeDirIfNonExistent(filePath string) error

+ 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 *BitCloutParams) string

+ func PkToStringBoth(pk []byte) string

+ func PkToStringMainnet(pk []byte) string

+ func PkToStringTestnet(pk []byte) string

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

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

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

+ func PutBlock(bitcloutBlock *MsgBitCloutBlock, handle *badger.DB) error

+ func PutBlockWithTxn(txn *badger.Txn, bitcloutBlock *MsgBitCloutBlock) 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 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 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 Varint(buf []byte) (int64, int)

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

+ type AffectedPublicKey struct

+ Metadata string

+ PublicKeyBase58Check string

+ type BalanceEntry struct

+ BalanceNanos uint64

+ CreatorPKID *PKID

+ HODLerPKID *PKID

+ HasPurchased bool

+ func DBGetCreatorCoinBalanceEntryForCreatorPKIDAndHODLerPubKeyWithTxn(txn *badger.Txn, creatorPKID *PKID, hodlerPKID *PKID) *BalanceEntry

+ func DBGetCreatorCoinBalanceEntryForHODLerAndCreatorPKIDs(handle *badger.DB, hodlerPKID *PKID, creatorPKID *PKID) *BalanceEntry

+ func DBGetCreatorCoinBalanceEntryForHODLerAndCreatorPKIDsWithTxn(txn *badger.Txn, hodlerPKID *PKID, creatorPKID *PKID) *BalanceEntry

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

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

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

+ type BalanceEntryMapKey struct

+ CreatorPKID PKID

+ HODLerPKID PKID

+ func MakeCreatorCoinBalanceKey(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() BitCloutTxnMetadata

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

+ type BasicTransferTxindexMetadata struct

+ FeeNanos uint64

+ TotalInputNanos uint64

+ TotalOutputNanos uint64

+ UtxoOpsDump string

+ type BitCloutBlockProducer struct

+ func NewBitCloutBlockProducer(_minBlockUpdateIntervalSeconds uint64, _maxBlockTemplatesToCache uint64, ...) (*BitCloutBlockProducer, error)

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

+ func (bitcloutBlockProducer *BitCloutBlockProducer) AddBlockTemplate(block *MsgBitCloutBlock, diffTarget *BlockHash)

+ func (bitcloutBlockProducer *BitCloutBlockProducer) GetCopyOfRecentBlock(blockID string) (*MsgBitCloutBlock, error)

+ func (bitcloutBlockProducer *BitCloutBlockProducer) GetRecentBlock(blockHash *BlockHash) *MsgBitCloutBlock

+ func (bitcloutBlockProducer *BitCloutBlockProducer) SignBlock(blockFound *MsgBitCloutBlock) error

+ func (bitcloutBlockProducer *BitCloutBlockProducer) Start()

+ func (bitcloutBlockProducer *BitCloutBlockProducer) Stop()

+ func (bitcloutBlockProducer *BitCloutBlockProducer) UpdateLatestBlockTemplate() error

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

+ type BitCloutBodySchema struct

+ Body string

+ ImageURLs []string

+ type BitCloutInput UtxoKey

+ func NewBitCloutInput() *BitCloutInput

+ func (bitcloutInput *BitCloutInput) String() string

+ type BitCloutMempool struct

+ func NewBitCloutMempool(_bc *Blockchain, _rateLimitFeerateNanosPerKB uint64, ...) *BitCloutMempool

+ func (mp *BitCloutMempool) BlockUntilReadOnlyViewRegenerated()

+ func (mp *BitCloutMempool) CheckSpend(op UtxoKey) *MsgBitCloutTxn

+ func (mp *BitCloutMempool) Count() int

+ func (mp *BitCloutMempool) DumpTxnsToDB()

+ func (mp *BitCloutMempool) EvictUnminedBitcoinTransactions(bitcoinTxnHashes []string, dryRun bool) (int64, map[string]int64, []string, []string)

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

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

+ func (mp *BitCloutMempool) GetAugmentedUtxoViewForPublicKey(pkBytes []byte, optionalTxn *MsgBitCloutTxn) (*UtxoView, error)

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

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

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

+ func (mp *BitCloutMempool) InefficientRemoveTransaction(tx *MsgBitCloutTxn)

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

+ func (mp *BitCloutMempool) LoadTxnsFromDB()

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

+ func (mp *BitCloutMempool) OpenTempDBAndDumpTxns() error

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

+ func (mp *BitCloutMempool) ProcessUnconnectedTransactions(acceptedTx *MsgBitCloutTxn, rateLimit bool, verifySignatures bool) []*MempoolTx

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

+ func (mp *BitCloutMempool) RegenerateReadOnlyView() error

+ func (mp *BitCloutMempool) StartMempoolDBDumper()

+ func (mp *BitCloutMempool) StartMempoolStatsReporter()

+ func (mp *BitCloutMempool) StartReadOnlyUtxoViewRegenerator()

+ func (mp *BitCloutMempool) Stop()

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

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

+ func (mp *BitCloutMempool) UpdateAfterConnectBlock(blk *MsgBitCloutBlock) (_txnsAddedToMempool []*MempoolTx)

+ func (mp *BitCloutMempool) UpdateAfterDisconnectBlock(blk *MsgBitCloutBlock)

+ type BitCloutMessage interface

+ FromBytes func(data []byte) error

+ GetMsgType func() MsgType

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

+ func NewMessage(msgType MsgType) BitCloutMessage

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

+ type BitCloutMessageMeta struct

+ BitCloutMessage BitCloutMessage

+ Inbound bool

+ type BitCloutMiner struct

+ BlockProducer *BitCloutBlockProducer

+ PublicKeys []*btcec.PublicKey

+ func NewBitCloutMiner(_minerPublicKeys []string, _numThreads uint32, ...) (*BitCloutMiner, error)

+ func (bitcloutMiner *BitCloutMiner) MineAndProcessSingleBlock(threadIndex uint32, mempoolToUpdate *BitCloutMempool) (_block *MsgBitCloutBlock, _err error)

+ func (bitcloutMiner *BitCloutMiner) Start()

+ func (bitcloutMiner *BitCloutMiner) Stop()

+ type BitCloutOutput struct

+ AmountNanos uint64

+ PublicKey []byte

+ func (bitcloutOutput *BitCloutOutput) String() string

+ type BitCloutParams struct

+ Base58PrefixPrivateKey [3]byte

+ Base58PrefixPublicKey [3]byte

+ BitCloutNanosPurchasedAtGenesis uint64

+ BitcoinBlocksPerRetarget uint32

+ BitcoinBtcdParams *chaincfg.Params

+ BitcoinBurnAddress string

+ BitcoinDNSSeeds []string

+ BitcoinDefaultPort string

+ BitcoinDoubleSpendWaitSeconds float64

+ BitcoinExchangeFeeBasisPoints uint64

+ BitcoinMaxRetargetTimespanSecs uint32

+ BitcoinMaxTipAge time.Duration

+ BitcoinMaxTstampOffsetSeconds uint64

+ BitcoinMinBurnWorkBlockss int64

+ BitcoinMinChainWorkHex string

+ BitcoinMinDiffReductionTime time.Duration

+ BitcoinMinRetargetTimespanSecs uint32

+ BitcoinPowLimitBits uint32

+ BitcoinProtocolVersion uint32

+ BitcoinStartBlockNode *BlockNode

+ BitcoinTargetTimespanSecs uint32

+ BitcoinTimeBetweenBlocks time.Duration

+ BlockRewardMaturity time.Duration

+ CreatorCoinAutoSellThresholdNanos uint64

+ CreatorCoinReserveRatio *big.Float

+ CreatorCoinSlope *big.Float

+ CreatorCoinTradeFeeBasisPoints uint64

+ DNSSeedGenerators [][]string

+ DNSSeeds []string

+ DefaultJSONPort uint16

+ DefaultSocketPort uint16

+ DeflationBombBlockHeight uint64

+ DialTimeout time.Duration

+ GenesisBlock *MsgBitCloutBlock

+ GenesisBlockHashHex string

+ MaxBlockSizeBytes uint64

+ MaxCreatorBasisPoints uint64

+ MaxDifficultyRetargetFactor int64

+ MaxFetchBlocks uint32

+ 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

+ MinerBitcoinMinBurnWorkBlockss int64

+ MinerMaxBlockSizeBytes uint64

+ MiningIterationsPerCycle uint64

+ NetworkType NetworkType

+ ParamUpdaterPublicKeys map[PkMapKey]bool

+ ProtocolVersion uint64

+ SeedBalances []*BitCloutOutput

+ SeedTxns []string

+ StakeFeeBasisPoints uint64

+ TimeBetweenBlocks time.Duration

+ TimeBetweenDifficultyRetargets time.Duration

+ UserAgent string

+ V1DifficultyAdjustmentFactor int64

+ VersionNegotiationTimeout time.Duration

+ type BitCloutTxnMetadata interface

+ FromBytes func(data []byte) error

+ GetTxnType func() TxnType

+ New func() BitCloutTxnMetadata

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

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

+ 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() BitCloutTxnMetadata

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

+ type BitcoinExchangeTxindexMetadata struct

+ BitcoinSpendAddress string

+ BitcoinTxnHash string

+ NanosCreated uint64

+ SatoshisBurned uint64

+ TotalNanosPurchasedAfter uint64

+ TotalNanosPurchasedBefore uint64

+ type BitcoinManager struct

+ BitcoinHeaderIndexLock deadlock.RWMutex

+ ExpectedResponsesLock deadlock.RWMutex

+ SwitchPeerChan chan *SwitchPeerMsg

+ func NewBitcoinManager(_db *badger.DB, _params *BitCloutParams, ...) (*BitcoinManager, error)

+ func (bm *BitcoinManager) AddSeeds()

+ func (bm *BitcoinManager) BroadcastTxn(txn *wire.MsgTx)

+ func (bm *BitcoinManager) BroadcastTxnAndCheckAdded(txn *wire.MsgTx, timeoutSecs int) (_err error)

+ func (bm *BitcoinManager) BroadcastTxnAndCheckAddedRedundant(txn *wire.MsgTx, timeoutSecs int, numNodesToPing int) (_err error)

+ func (bm *BitcoinManager) FullyValidateHeaderAtIndex(index int) (_finished bool, _err error)

+ func (bm *BitcoinManager) FullyValidateHeaders() error

+ func (bm *BitcoinManager) GetAddrManager() *addrmgr.AddrManager

+ func (bm *BitcoinManager) GetBitcoinBlockNode(hash *BlockHash) *BlockNode

+ func (bm *BitcoinManager) GetBitcoinBurnWorkBlocks(blockHeight uint32) int64

+ func (bm *BitcoinManager) HandleBitcoinHeaders(conn net.Conn, msg *wire.MsgHeaders) error

+ func (bm *BitcoinManager) HeaderAtHeight(blockHeight uint32) *BlockNode

+ func (bm *BitcoinManager) HeaderForHash(hash *BlockHash) *BlockNode

+ func (bm *BitcoinManager) HeaderTip() *BlockNode

+ func (bm *BitcoinManager) IsCurrent(considerCumWork bool) bool

+ func (bm *BitcoinManager) MaybeRequestBitcoinBlock(conn net.Conn, hash chainhash.Hash)

+ func (bm *BitcoinManager) ProcessBitcoinBlock(bitcoinBlock *wire.MsgBlock)

+ func (bm *BitcoinManager) ProcessBitcoinHeaderFull(bitcoinHeader *wire.BlockHeader, params *BitCloutParams) (_isMainChain bool, _isOrphan bool, _err error)

+ func (bm *BitcoinManager) ProcessBitcoinHeaderQuick(bitcoinHeader *wire.BlockHeader, params *BitCloutParams) (_isMainChain bool, _isOrphan bool, _err error)

+ func (bm *BitcoinManager) RequestBitcoinBlock(blockHash chainhash.Hash)

+ func (bm *BitcoinManager) RequestBitcoinTxn(txHash chainhash.Hash)

+ func (bm *BitcoinManager) ResetBitcoinHeaderIndex() error

+ func (bm *BitcoinManager) SendGetHeaders(conn net.Conn)

+ func (bm *BitcoinManager) SetHeaderIndexAndBestChainListMap(bestChain []*BlockNode, headerIndex map[BlockHash]*BlockNode)

+ func (bm *BitcoinManager) Start()

+ func (bm *BitcoinManager) SyncConn() net.Conn

+ type BitcoinUtxo struct

+ AmountSatoshis int64

+ Index int64

+ TxID *chainhash.Hash

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

+ func BlockCypherUtxoSource(addrString string, params *BitCloutParams) ([]*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 *BitCloutParams) (_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

+ type BlockHash [HashSizeBytes]byte

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

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

+ func ComputeTransactionHashes(txns []*MsgBitCloutTxn) ([]*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 DbGetPostHashesYouReclout(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 *MsgBitCloutHeader, iterations uint64) (lowestHash *BlockHash, lowestNonce uint64, ee error)

+ func MustDecodeHexBlockHash(ss string) *BlockHash

+ func NewBlockHash(hexBytes string) *BlockHash

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

+ func Sha256DoubleHash(input []byte) *BlockHash

+ func StakeIDToHash(stakeID []byte) *BlockHash

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

+ func (bh *BlockHash) String() string

+ type BlockNode struct

+ CumWork *big.Int

+ DifficultyTarget *BlockHash

+ Hash *BlockHash

+ Header *MsgBitCloutHeader

+ 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() BitCloutTxnMetadata

+ 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 *MsgBitCloutTxn, minFeeRateNanosPerKB uint64, mempool *BitCloutMempool) (_totalInputAdded uint64, _spendAmount uint64, _totalChangeAdded uint64, ...)

+ func (bc *Blockchain) AddInputsAndChangeToTransactionWithSubsidy(txArg *MsgBitCloutTxn, 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) CreateCreatorCoinTransferTxn(UpdaterPublicKey []byte, ProfilePublicKey []byte, ...) (_txn *MsgBitCloutTxn, _totalInput uint64, _changeAmount uint64, _fees uint64, ...)

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

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

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

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

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

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

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

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

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

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

+ func (bc *Blockchain) CreateUpdateProfileTxn(UpdaterPublicKeyBytes []byte, OptionalProfilePublicKeyBytes []byte, ...) (_txn *MsgBitCloutTxn, _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) *MsgBitCloutBlock

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

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

+ func (bc *Blockchain) GetSpendableUtxosForPublicKey(spendPublicKeyBytes []byte, mempool *BitCloutMempool, ...) ([]*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) []*MsgBitCloutHeader

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

+ func (bc *Blockchain) ProcessBlock(bitcloutBlock *MsgBitCloutBlock, verifySignatures bool) (_isMainChain bool, _isOrphan bool, _err error)

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

+ func (bc *Blockchain) ProcessOrphanBlock(bitcloutBlock *MsgBitCloutBlock, blockHash *BlockHash) error

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

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

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

+ type BlockonomicsRBFResponse struct

+ RBF int64

+ Status string

+ type BroadcastTxn struct

+ TimeAdded time.Time

+ Txn *wire.MsgTx

+ WasBroadcast bool

+ type ChainType uint8

+ type CoinEntry struct

+ BitCloutLockedNanos uint64

+ CoinWatermarkNanos uint64

+ CoinsInCirculationNanos uint64

+ CreatorBasisPoints uint64

+ NumberOfHolders uint64

+ type ConnectionManager struct

+ func NewConnectionManager(_params *BitCloutParams, _addrMgr *addrmgr.AddrManager, ...) *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 CreatorCoinMetadataa struct

+ BitCloutToAddNanos uint64

+ BitCloutToSellNanos uint64

+ CreatorCoinToSellNanos uint64

+ MinBitCloutExpectedNanos uint64

+ MinCreatorCoinExpectedNanos uint64

+ OperationType CreatorCoinOperationType

+ ProfilePublicKey []byte

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

+ func (txnData *CreatorCoinMetadataa) GetTxnType() TxnType

+ func (txnData *CreatorCoinMetadataa) New() BitCloutTxnMetadata

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

+ type CreatorCoinOperationType uint8

+ const CreatorCoinOperationTypeAddBitClout

+ 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() BitCloutTxnMetadata

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

+ type CreatorCoinTransferTxindexMetadata struct

+ CreatorCoinToTransferNanos uint64

+ CreatorUsername string

+ DiamondLevel int64

+ PostHashHex string

+ type CreatorCoinTxindexMetadata struct

+ BitCloutToAddNanos uint64

+ BitCloutToSellNanos uint64

+ CreatorCoinToSellNanos uint64

+ OperationType string

+ 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 ExpectedBitcoinResponse struct

+ Command string

+ TimeExpected time.Time

+ 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() BitCloutTxnMetadata

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

+ type FollowTxindexMetadata struct

+ IsUnfollow bool

+ type ForbiddenPubKeyEntry struct

+ PubKey []byte

+ type GetDataRequestInfo struct

+ PeerWhoSentInv *Peer

+ TimeRequested time.Time

+ type GlobalParamsEntry struct

+ CreateProfileFeeNanos uint64

+ MinimumNetworkFeeNanosPerKB uint64

+ USDCentsPerBitcoin uint64

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

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

+ 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() BitCloutTxnMetadata

+ 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 *MsgBitCloutTxn

+ 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

+ RecipientPublicKey []byte

+ SenderPublicKey []byte

+ TstampNanos uint64

+ func DbGetLimitedMessageEntriesForPublicKey(handle *badger.DB, publicKey []byte) (_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

+ type MessageKey struct

+ BlockHeight uint32

+ PublicKey PkMapKey

+ TstampNanos uint64

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

+ func (mm *MessageKey) String() string

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

+ type MiningSupplyIntervalStart struct

+ BlockRewardNanos uint64

+ StartBlockHeight uint32

+ type MsgBitCloutAddr struct

+ AddrList []*SingleAddr

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

+ func (msg *MsgBitCloutAddr) GetMsgType() MsgType

+ func (msg *MsgBitCloutAddr) String() string

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

+ type MsgBitCloutBitcoinManagerUpdate struct

+ TransactionsFound []*MsgBitCloutTxn

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

+ func (msg *MsgBitCloutBitcoinManagerUpdate) GetMsgType() MsgType

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

+ type MsgBitCloutBlock struct

+ BlockProducerInfo *BlockProducerInfo

+ Header *MsgBitCloutHeader

+ Txns []*MsgBitCloutTxn

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

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

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

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

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

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

+ func (msg *MsgBitCloutBlock) GetMsgType() MsgType

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

+ func (msg *MsgBitCloutBlock) String() string

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

+ type MsgBitCloutBlockAccepted struct

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

+ func (msg *MsgBitCloutBlockAccepted) GetMsgType() MsgType

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

+ type MsgBitCloutDonePeer struct

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

+ func (msg *MsgBitCloutDonePeer) GetMsgType() MsgType

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

+ type MsgBitCloutGetAddr struct

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

+ func (msg *MsgBitCloutGetAddr) GetMsgType() MsgType

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

+ type MsgBitCloutGetBlocks struct

+ HashList []*BlockHash

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

+ func (msg *MsgBitCloutGetBlocks) GetMsgType() MsgType

+ func (msg *MsgBitCloutGetBlocks) String() string

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

+ type MsgBitCloutGetHeaders struct

+ BlockLocator []*BlockHash

+ StopHash *BlockHash

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

+ func (msg *MsgBitCloutGetHeaders) GetMsgType() MsgType

+ func (msg *MsgBitCloutGetHeaders) String() string

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

+ type MsgBitCloutGetTransactions struct

+ HashList []*BlockHash

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

+ func (msg *MsgBitCloutGetTransactions) GetMsgType() MsgType

+ func (msg *MsgBitCloutGetTransactions) String() string

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

+ type MsgBitCloutHeader struct

+ ExtraNonce uint64

+ Height uint64

+ Nonce uint64

+ PrevBlockHash *BlockHash

+ TransactionMerkleRoot *BlockHash

+ TstampSecs uint64

+ Version uint32

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

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

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

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

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

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

+ func (msg *MsgBitCloutHeader) GetMsgType() MsgType

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

+ func (msg *MsgBitCloutHeader) String() string

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

+ type MsgBitCloutHeaderBundle struct

+ Headers []*MsgBitCloutHeader

+ TipHash *BlockHash

+ TipHeight uint32

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

+ func (msg *MsgBitCloutHeaderBundle) GetMsgType() MsgType

+ func (msg *MsgBitCloutHeaderBundle) String() string

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

+ type MsgBitCloutInv struct

+ InvList []*InvVect

+ IsSyncResponse bool

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

+ func (msg *MsgBitCloutInv) GetMsgType() MsgType

+ func (msg *MsgBitCloutInv) String() string

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

+ type MsgBitCloutMempool struct

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

+ func (msg *MsgBitCloutMempool) GetMsgType() MsgType

+ func (msg *MsgBitCloutMempool) String() string

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

+ type MsgBitCloutNewPeer struct

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

+ func (msg *MsgBitCloutNewPeer) GetMsgType() MsgType

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

+ type MsgBitCloutPing struct

+ Nonce uint64

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

+ func (msg *MsgBitCloutPing) GetMsgType() MsgType

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

+ type MsgBitCloutPong struct

+ Nonce uint64

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

+ func (msg *MsgBitCloutPong) GetMsgType() MsgType

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

+ type MsgBitCloutQuit struct

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

+ func (msg *MsgBitCloutQuit) GetMsgType() MsgType

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

+ type MsgBitCloutTransactionBundle struct

+ Transactions []*MsgBitCloutTxn

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

+ func (msg *MsgBitCloutTransactionBundle) GetMsgType() MsgType

+ func (msg *MsgBitCloutTransactionBundle) String() string

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

+ type MsgBitCloutTxn struct

+ ExtraData map[string][]byte

+ PublicKey []byte

+ Signature *btcec.Signature

+ TxInputs []*BitCloutInput

+ TxOutputs []*BitCloutOutput

+ TxnMeta BitCloutTxnMetadata

+ TxnTypeJSON uint64

+ func DbGetAllMempoolTxnsSortedByTimeAdded(handle *badger.DB) (_mempoolTxns []*MsgBitCloutTxn, _error error)

+ func DbGetMempoolTxn(db *badger.DB, mempoolTx *MempoolTx) *MsgBitCloutTxn

+ func DbGetMempoolTxnWithTxn(txn *badger.Txn, mempoolTx *MempoolTx) *MsgBitCloutTxn

+ func ExtractBitcoinExchangeTransactionsFromBitcoinBlock(bitcoinBlock *wire.MsgBlock, burnAddress string, params *BitCloutParams) (_txns []*MsgBitCloutTxn, _err error)

+ func (msg *MsgBitCloutTxn) Copy() (*MsgBitCloutTxn, error)

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

+ func (msg *MsgBitCloutTxn) GetMsgType() MsgType

+ func (msg *MsgBitCloutTxn) Hash() *BlockHash

+ func (msg *MsgBitCloutTxn) MarshalJSON() ([]byte, error)

+ func (msg *MsgBitCloutTxn) Sign(privKey *btcec.PrivateKey) (*btcec.Signature, error)

+ func (msg *MsgBitCloutTxn) String() string

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

+ func (msg *MsgBitCloutTxn) UnmarshalJSON(data []byte) error

+ type MsgBitCloutVerack struct

+ Nonce uint64

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

+ func (msg *MsgBitCloutVerack) GetMsgType() MsgType

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

+ type MsgBitCloutVersion struct

+ MinFeeRateNanosPerKB uint64

+ Nonce uint64

+ Services ServiceFlag

+ StartBlockHeight uint32

+ TstampSecs int64

+ UserAgent string

+ Version uint64

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

+ func (msg *MsgBitCloutVersion) GetMsgType() MsgType

+ func (msg *MsgBitCloutVersion) 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 MsgWithError struct

+ type NetworkType uint64

+ const NetworkType_MAINNET

+ const NetworkType_TESTNET

+ const NetworkType_UNSET

+ func (nt NetworkType) String() string

+ type OperationType uint

+ const OperationTypeAddUtxo

+ const OperationTypeBitcoinExchange

+ const OperationTypeCreatorCoin

+ const OperationTypeCreatorCoinTransfer

+ const OperationTypeDeletePost

+ const OperationTypeFollow

+ const OperationTypeLike

+ const OperationTypePrivateMessage

+ const OperationTypeSpendUtxo

+ const OperationTypeSubmitPost

+ const OperationTypeSwapIdentity

+ const OperationTypeUpdateBitcoinUSDExchangeRate

+ const OperationTypeUpdateGlobalParams

+ const OperationTypeUpdateProfile

+ func (op OperationType) String() string

+ type OrphanBlock struct

+ Block *MsgBitCloutBlock

+ Hash *BlockHash

+ 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 PublicKeyToPKID(publicKey []byte) *PKID

+ type PKIDEntry struct

+ PKID *PKID

+ PublicKey []byte

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

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

+ type Peer struct

+ ID uint64

+ LastPingMicros int64

+ LastPingNonce uint64

+ LastPingTime time.Time

+ MessageChan chan *ServerMessage

+ Params *BitCloutParams

+ PeerInfoMtx deadlock.Mutex

+ PeerManuallyRemovedFromConnectionManager bool

+ StatsMtx deadlock.RWMutex

+ func NewPeer(_conn net.Conn, _isOutbound bool, _netAddr *wire.NetAddress, ...) *Peer

+ func (pp *Peer) AddBitCloutMessage(bitcloutMessage BitCloutMessage, inbound bool)

+ func (pp *Peer) Address() string

+ func (pp *Peer) Connected() bool

+ func (pp *Peer) Disconnect()

+ func (pp *Peer) HandleGetBlocks(msg *MsgBitCloutGetBlocks)

+ func (pp *Peer) HandleGetTransactionsMsg(getTxnMsg *MsgBitCloutGetTransactions)

+ func (pp *Peer) HandleInv(msg *MsgBitCloutInv)

+ func (pp *Peer) HandleTransactionBundleMessage(msg *MsgBitCloutTransactionBundle)

+ func (pp *Peer) HelpHandleInv(msg *MsgBitCloutInv)

+ func (pp *Peer) IP() string

+ func (pp *Peer) IsOutbound() bool

+ func (pp *Peer) IsSyncCandidate() bool

+ func (pp *Peer) MaybeDequeueBitCloutMessage() *BitCloutMessageMeta

+ func (pp *Peer) MinFeeRateNanosPerKB() uint64

+ func (pp *Peer) NegotiateVersion(versionNegotiationTimeout time.Duration) error

+ func (pp *Peer) NewVersionMessage(params *BitCloutParams) *MsgBitCloutVersion

+ func (pp *Peer) NumBlocksToSend() uint32

+ func (pp *Peer) Port() uint16

+ func (pp *Peer) QueueMessage(bitcloutMessage BitCloutMessage)

+ func (pp *Peer) ReadBitCloutMessage() (BitCloutMessage, error)

+ func (pp *Peer) Start()

+ func (pp *Peer) StartBitCloutMessageProcessor()

+ func (pp *Peer) StartingBlockHeight() uint32

+ func (pp *Peer) String() string

+ func (pp *Peer) WriteBitCloutMessage(msg BitCloutMessage) error

+ type PkMapKey [btcec.PubKeyBytesLenCompressed]byte

+ func MakePkMapKey(pk []byte) PkMapKey

+ func (mm PkMapKey) String() string

+ type PostEntry struct

+ Body []byte

+ CommentCount uint64

+ ConfirmationBlockHeight uint32

+ CreatorBasisPoints uint64

+ DiamondCount uint64

+ IsHidden bool

+ IsPinned bool

+ IsQuotedReclout bool

+ LikeCount uint64

+ ParentStakeID []byte

+ PostExtraData map[string][]byte

+ PostHash *BlockHash

+ PosterPublicKey []byte

+ RecloutCount uint64

+ RecloutedPostHash *BlockHash

+ StakeEntry *StakeEntry

+ StakeMultipleBasisPoints uint64

+ TimestampNanos uint64

+ func DBGetPostEntryByPostHash(db *badger.DB, postHash *BlockHash) *PostEntry

+ func DBGetPostEntryByPostHashWithTxn(txn *badger.Txn, postHash *BlockHash) *PostEntry

+ func (pe *PostEntry) IsDeleted() bool

+ type PostEntryReaderState struct

+ DiamondLevelBestowed int64

+ LikedByReader bool

+ RecloutPostHashHex string

+ RecloutedByReader bool

+ 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() BitCloutTxnMetadata

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

+ type PrivateMessageTxindexMetadata struct

+ TimestampNanos uint64

+ type ProfileEntry struct

+ Description []byte

+ IsHidden bool

+ ProfilePic []byte

+ PublicKey []byte

+ StakeEntry *StakeEntry

+ StakeMultipleBasisPoints uint64

+ Username []byte

+ func DBGetPaginatedProfilesByBitCloutLocked(db *badger.DB, startBitCloutLockedNanos 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 DBGetProfilesByUsernamePrefixAndBitCloutLocked(db *badger.DB, usernamePrefix string, utxoView *UtxoView) (_profileEntries []*ProfileEntry, _err error)

+ func (pe *ProfileEntry) IsDeleted() bool

+ type PurchaseSupplyIntervalStart struct

+ SatoshisPerUnit uint64

+ SupplyStartNanos uint64

+ type RecloutEntry struct

+ RecloutPostHash *BlockHash

+ RecloutedPostHash *BlockHash

+ ReclouterPubKey []byte

+ func DbGetReclouterPubKeyRecloutedPostHashToRecloutEntryWithTxn(txn *badger.Txn, userPubKey []byte, recloutedPostHash BlockHash) *RecloutEntry

+ func DbReclouterPubKeyRecloutedPostHashToRecloutEntry(db *badger.DB, userPubKey []byte, recloutedPostHash BlockHash) *RecloutEntry

+ type RecloutKey struct

+ RecloutedPostHash BlockHash

+ ReclouterPubKey PkMapKey

+ func MakeRecloutKey(userPk []byte, RecloutedPostHash BlockHash) RecloutKey

+ type RuleError string

+ const HeaderErrorBlockDifficultyAboveTarget

+ const HeaderErrorBlockTooFarInTheFuture

+ const HeaderErrorDifficultyBitsNotConsistentWithTargetDifficultyComputedFromParent

+ const HeaderErrorDuplicateHeader

+ const HeaderErrorHeightInvalid

+ const HeaderErrorInvalidParent

+ const HeaderErrorNilPrevHash

+ const HeaderErrorTimestampTooEarly

+ const RuleErrorAddStakeRequiresNonZeroInput

+ const RuleErrorAddStakeTxnMustHaveExactlyOneOutput

+ const RuleErrorBitCloutReceivedIsLessThanMinimumSetBySeller

+ 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 RuleErrorCannotLikeNonexistentPost

+ const RuleErrorCannotUnfollowNonexistentFollowEntry

+ const RuleErrorCannotUnlikeWithoutAnExistingLike

+ const RuleErrorCreateProfileFeeTooLow

+ const RuleErrorCreateProfileTooHigh

+ const RuleErrorCreateProfileTxnOutputExceedsInput

+ const RuleErrorCreatorCoinBuyMustSatisfyAutoSellThresholdNanos

+ const RuleErrorCreatorCoinBuyMustSatisfyAutoSellThresholdNanosForBuyer

+ const RuleErrorCreatorCoinBuyMustSatisfyAutoSellThresholdNanosForCreator

+ const RuleErrorCreatorCoinBuyMustTradeNonZeroBitClout

+ const RuleErrorCreatorCoinBuyMustTradeNonZeroBitCloutAfterFees

+ const RuleErrorCreatorCoinBuyMustTradeNonZeroBitCloutAfterFounderReward

+ const RuleErrorCreatorCoinBuyZeroLockedNanosAndNonZeroHolders

+ const RuleErrorCreatorCoinInvalidPubKeySize

+ const RuleErrorCreatorCoinLessThanMinimumSetByUser

+ const RuleErrorCreatorCoinOperationOnNonexistentProfile

+ const RuleErrorCreatorCoinRequiresNonZeroInput

+ const RuleErrorCreatorCoinSellInsufficientCoins

+ const RuleErrorCreatorCoinSellMustHaveAtLeastOneInput

+ const RuleErrorCreatorCoinSellMustTradeNonZeroCreatorCoin

+ const RuleErrorCreatorCoinSellNotAllowedWhenZeroBitCloutLocked

+ const RuleErrorCreatorCoinSellerBalanceEntryDoesNotExist

+ const RuleErrorCreatorCoinTransferBalanceEntryDoesNotExist

+ const RuleErrorCreatorCoinTransferCannotTransferToSelf

+ const RuleErrorCreatorCoinTransferCantDiamondYourself

+ const RuleErrorCreatorCoinTransferCantSendDiamondsForOtherProfiles

+ const RuleErrorCreatorCoinTransferDiamondPostEntryDoesNotExist

+ const RuleErrorCreatorCoinTransferDiamondsCantHaveNegativeNanos

+ const RuleErrorCreatorCoinTransferHasDiamondPostHashWithoutDiamondLevel

+ const RuleErrorCreatorCoinTransferHasInvalidDiamondLevel

+ const RuleErrorCreatorCoinTransferInsufficientCoins

+ const RuleErrorCreatorCoinTransferInsufficientCreatorCoinsForDiamondLevel

+ const RuleErrorCreatorCoinTransferInvalidLengthForPostHashBytes

+ const RuleErrorCreatorCoinTransferInvalidProfilePubKeySize

+ const RuleErrorCreatorCoinTransferInvalidReceiverPubKeySize

+ const RuleErrorCreatorCoinTransferMustBeGreaterThanMinThreshold

+ const RuleErrorCreatorCoinTransferOnNonexistentProfile

+ const RuleErrorCreatorCoinTransferPostAlreadyHasSufficientDiamonds

+ const RuleErrorCreatorCoinTransferRequiresNonZeroInput

+ const RuleErrorCreatorCoinTxnOutputExceedsInput

+ const RuleErrorCreatorCoinTxnOutputWithInvalidBuyAmount

+ const RuleErrorDeflationBombForbidsMintingAnyMoreBitClout

+ 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 RuleErrorInsufficientRefund

+ const RuleErrorInvalidBlockHeader

+ const RuleErrorInvalidBlockProducerPublicKey

+ const RuleErrorInvalidBlockProducerSIgnature

+ const RuleErrorInvalidFromPublicKey

+ const RuleErrorInvalidStakeID

+ const RuleErrorInvalidStakeIDSize

+ const RuleErrorInvalidToPublicKey

+ const RuleErrorInvalidTransactionSignature

+ const RuleErrorInvalidTxnMerkleRoot

+ const RuleErrorInvalidUsername

+ const RuleErrorLikeEntryAlreadyExists

+ const RuleErrorMaxProfilePicSize

+ const RuleErrorMinDifficulty

+ const RuleErrorMinNetworkFeeTooHigh

+ const RuleErrorMinNetworkFeeTooLow

+ const RuleErrorMissingBlockProducerSignature

+ const RuleErrorMissingSignature

+ const RuleErrorMoreThanOneBlockReward

+ const RuleErrorNoTxns

+ const RuleErrorNotImplemented

+ const RuleErrorOldFromPublicKeyHasDeletedPKID

+ const RuleErrorOldToPublicKeyHasDeletedPKID

+ const RuleErrorOrphanBlock

+ const RuleErrorOutputExceedsMax

+ const RuleErrorOutputOverflowsTotal

+ const RuleErrorOutputPublicKeyNotRecognized

+ const RuleErrorOverflowDetectedInFeeRateCalculation

+ const RuleErrorParsePublicKey

+ const RuleErrorPostAlreadyExists

+ const RuleErrorPreviousBlockHeaderInvalid

+ const RuleErrorPreviousBlockInvalid

+ const RuleErrorPrivateMessageEncryptedTextLengthExceedsMax

+ const RuleErrorPrivateMessageExistsWithRecipientPublicKeyTstampTuple

+ const RuleErrorPrivateMessageExistsWithSenderPublicKeyTstampTuple

+ const RuleErrorPrivateMessageParsePubKeyError

+ const RuleErrorPrivateMessageRecipientPubKeyLen

+ const RuleErrorPrivateMessageSenderPublicKeyEqualsRecipientPublicKey

+ const RuleErrorPrivateMessageTstampIsZero

+ const RuleErrorProfileBadPublicKey

+ const RuleErrorProfileCreatorPercentageSize

+ const RuleErrorProfileDescriptionTooLong

+ const RuleErrorProfileDescriptionTooShort

+ const RuleErrorProfileForPostDoesNotExist

+ const RuleErrorProfileModificationNotAuthorized

+ const RuleErrorProfileProfilePicTooShort

+ 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 RuleErrorSubmitPostCreatorPercentageSize

+ const RuleErrorSubmitPostInvalidCommentStakeID

+ const RuleErrorSubmitPostInvalidParentStakeIDLength

+ const RuleErrorSubmitPostInvalidPostHashToModify

+ const RuleErrorSubmitPostModifyingNonexistentPost

+ const RuleErrorSubmitPostParentNotFound

+ const RuleErrorSubmitPostPostModificationNotAuthorized

+ const RuleErrorSubmitPostRecloutOfReclout

+ const RuleErrorSubmitPostRecloutPostNotFound

+ const RuleErrorSubmitPostRequiresNonZeroInput

+ const RuleErrorSubmitPostStakeMultipleSize

+ const RuleErrorSubmitPostTimestampIsZero

+ const RuleErrorSubmitPostUpdateIsQuotedReclout

+ const RuleErrorSubmitPostUpdateRecloutHash

+ const RuleErrorSwapIdentityIsParamUpdaterOnly

+ const RuleErrorToPublicKeyIsRequired

+ const RuleErrorTotalOutputExceedsMax

+ const RuleErrorTransactionMissingPublicKey

+ const RuleErrorTxnFeeBelowNetworkMinimum

+ const RuleErrorTxnMustHaveAtLeastOneInput

+ const RuleErrorTxnMustHaveAtLeastOneOutput

+ const RuleErrorTxnOutputExceedsInput

+ const RuleErrorTxnOutputWithInvalidAmount

+ const RuleErrorTxnSanity

+ const RuleErrorTxnTooBig

+ const RuleErrorUserNotAuthorizedToUpdateExchangeRate

+ const RuleErrorUserNotAuthorizedToUpdateGlobalParams

+ const RuleErrorUserOutputMustBeNonzero

+ const RuleSubmitPostBodyLength

+ const RuleSubmitPostNilParentPostHash

+ const RuleSubmitPostSubLength

+ const RuleSubmitPostTitleLength

+ const TxErrorCannotProcessBitcoinExchangeUntilBitcoinManagerIsCurrent

+ const TxErrorDoubleSpend

+ const TxErrorDuplicate

+ const TxErrorDuplicateBitcoinExchangeTxn

+ const TxErrorIndividualBlockReward

+ const TxErrorInsufficientFeeMinFee

+ const TxErrorInsufficientFeePriorityQueue

+ const TxErrorInsufficientFeeRateLimit

+ const TxErrorTooLarge

+ const TxErrorUnconnectedTxnNotAllowed

+ func (e RuleError) Error() string

+ type Server struct

+ SyncPeer *Peer

+ func NewServer(_params *BitCloutParams, _listeners []net.Listener, ...) (*Server, error)

+ func (srv *Server) BroadcastTransaction(txn *MsgBitCloutTxn) ([]*MempoolTx, error)

+ func (srv *Server) ExpireRequests()

+ func (srv *Server) GetBitcoinManager() *BitcoinManager

+ func (srv *Server) GetBlockProducer() *BitCloutBlockProducer

+ func (srv *Server) GetBlockchain() *Blockchain

+ func (srv *Server) GetBlocks(pp *Peer, maxHeight int)

+ func (srv *Server) GetConnectionManager() *ConnectionManager

+ func (srv *Server) GetMempool() *BitCloutMempool

+ func (srv *Server) GetMiner() *BitCloutMiner

+ func (srv *Server) HasProcessedFirstTransactionBundle() bool

+ func (srv *Server) ProcessSingleTxnWithChainLock(pp *Peer, txn *MsgBitCloutTxn) ([]*MempoolTx, error)

+ func (srv *Server) ResetRequestQueues()

+ func (srv *Server) Start()

+ func (srv *Server) Stop()

+ func (srv *Server) VerifyAndBroadcastTransaction(txn *MsgBitCloutTxn) error

+ type ServerMessage struct

+ Msg BitCloutMessage

+ 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 SingleStake struct

+ BlockHeight uint64

+ InitialCreatorPercentageBasisPoints uint64

+ InitialStakeMultipleBasisPoints uint64

+ InitialStakeNanos uint64

+ PublicKey []byte

+ RemainingStakeOwedNanos uint64

+ type StakeEntry struct

+ StakeList []*SingleStake

+ TotalPostStake uint64

+ func NewStakeEntry() *StakeEntry

+ func StakeEntryCopy(stakeEntry *StakeEntry) *StakeEntry

+ type StakeEntryStats struct

+ TotalCreatorEarningsNanos uint64

+ TotalFeesBurnedNanos uint64

+ TotalPostStakeNanos uint64

+ TotalStakeNanos uint64

+ TotalStakeOwedNanos uint64

+ func GetStakeEntryStats(stakeEntry *StakeEntry, params *BitCloutParams) *StakeEntryStats

+ type StakeIDType uint8

+ const StakeIDTypePost

+ const StakeIDTypeProfile

+ func (ss StakeIDType) String() 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() BitCloutTxnMetadata

+ 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() BitCloutTxnMetadata

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

+ type SwapIdentityOperationType uint8

+ type SwapIdentityTxindexMetadata struct

+ FromPublicKeyBase58Check string

+ ToPublicKeyBase58Check string

+ type SwitchPeerMsg struct

+ NewAddr string

+ ReplyChan chan error

+ type SyncState uint8

+ const SyncStateFullyCurrent

+ const SyncStateNeedBlocksss

+ const SyncStateSyncingBlocks

+ const SyncStateSyncingHeaders

+ func (ss SyncState) String() string

+ type TransactionMetadata struct

+ AffectedPublicKeys []*AffectedPublicKey

+ BasicTransferTxindexMetadata *BasicTransferTxindexMetadata

+ BitcoinExchangeTxindexMetadata *BitcoinExchangeTxindexMetadata

+ BlockHashHex string

+ CreatorCoinTransferTxindexMetadata *CreatorCoinTransferTxindexMetadata

+ CreatorCoinTxindexMetadata *CreatorCoinTxindexMetadata

+ FollowTxindexMetadata *FollowTxindexMetadata

+ LikeTxindexMetadata *LikeTxindexMetadata

+ PrivateMessageTxindexMetadata *PrivateMessageTxindexMetadata

+ SubmitPostTxindexMetadata *SubmitPostTxindexMetadata

+ SwapIdentityTxindexMetadata *SwapIdentityTxindexMetadata

+ TransactorPublicKeyBase58Check string

+ TxnIndexInBlock uint64

+ TxnType string

+ UpdateProfileTxindexMetadata *UpdateProfileTxindexMetadata

+ func ComputeTransactionMetadata(txn *MsgBitCloutTxn, utxoView *UtxoView, blockHash *BlockHash, ...) (*TransactionMetadata, error)

+ func ConnectTxnAndComputeTransactionMetadata(txn *MsgBitCloutTxn, utxoView *UtxoView, blockHash *BlockHash, ...) (*TransactionMetadata, error)

+ func DbGetTxindexTransactionRefByTxID(handle *badger.DB, txID *BlockHash) *TransactionMetadata

+ func DbGetTxindexTransactionRefByTxIDWithTxn(txn *badger.Txn, txID *BlockHash) *TransactionMetadata

+ type TxnType uint64

+ const TxnTypeBasicTransfer

+ const TxnTypeBitcoinExchange

+ const TxnTypeBlockReward

+ const TxnTypeCreatorCoin

+ const TxnTypeCreatorCoinTransfer

+ const TxnTypeFollow

+ const TxnTypeLike

+ const TxnTypePrivateMessage

+ const TxnTypeSubmitPost

+ const TxnTypeSwapIdentity

+ const TxnTypeUnset

+ const TxnTypeUpdateBitcoinUSDExchangeRate

+ const TxnTypeUpdateGlobalParams

+ const TxnTypeUpdateProfile

+ 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() BitCloutTxnMetadata

+ 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() BitCloutTxnMetadata

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

+ 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() BitCloutTxnMetadata

+ 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

+ Entry *UtxoEntry

+ FounderRewardUtxoKey *UtxoKey

+ Key *UtxoKey

+ PrevCoinEntry *CoinEntry

+ PrevCreatorBalanceEntry *BalanceEntry

+ PrevDiamondEntry *DiamondEntry

+ PrevForbiddenPubKeyEntry *ForbiddenPubKeyEntry

+ PrevGlobalParamsEntry *GlobalParamsEntry

+ PrevGrandparentPostEntry *PostEntry

+ PrevLikeCount uint64

+ PrevLikeEntry *LikeEntry

+ PrevNanosPurchased uint64

+ PrevParentPostEntry *PostEntry

+ PrevPostEntry *PostEntry

+ PrevProfileEntry *ProfileEntry

+ PrevReceiverBalanceEntry *BalanceEntry

+ PrevRecloutCount uint64

+ PrevRecloutEntry *RecloutEntry

+ PrevRecloutedPostEntry *PostEntry

+ PrevSenderBalanceEntry *BalanceEntry

+ PrevTransactorBalanceEntry *BalanceEntry

+ PrevUSDCentsPerBitcoin uint64

+ Type OperationType

+ type UtxoType uint8

+ const UtxoTypeBitcoinBurn

+ const UtxoTypeBlockReward

+ const UtxoTypeCreatorCoinFounderReward

+ const UtxoTypeCreatorCoinSale

+ const UtxoTypeOutput

+ const UtxoTypeStakeReward

+ func (mm UtxoType) String() string

+ type UtxoView struct

+ BitcoinBurnTxIDs map[BlockHash]bool

+ BitcoinManager *BitcoinManager

+ DiamondKeyToDiamondEntry map[DiamondKey]*DiamondEntry

+ FollowKeyToFollowEntry map[FollowKey]*FollowEntry

+ ForbiddenPubKeyToForbiddenPubKeyEntry map[PkMapKey]*ForbiddenPubKeyEntry

+ GlobalParamsEntry *GlobalParamsEntry

+ HODLerPKIDCreatorPKIDToBalanceEntry map[BalanceEntryMapKey]*BalanceEntry

+ Handle *badger.DB

+ LikeKeyToLikeEntry map[LikeKey]*LikeEntry

+ MessageKeyToMessageEntry map[MessageKey]*MessageEntry

+ NanosPurchased uint64

+ NumUtxoEntries uint64

+ PKIDToPublicKey map[PKID]*PKIDEntry

+ Params *BitCloutParams

+ PostHashToPostEntry map[BlockHash]*PostEntry

+ ProfilePKIDToProfileEntry map[PKID]*ProfileEntry

+ ProfileUsernameToProfileEntry map[UsernameMapKey]*ProfileEntry

+ PublicKeyToPKIDEntry map[PkMapKey]*PKIDEntry

+ RecloutKeyToRecloutEntry map[RecloutKey]*RecloutEntry

+ TipHash *BlockHash

+ USDCentsPerBitcoin uint64

+ UtxoKeyToUtxoEntry map[UtxoKey]*UtxoEntry

+ func NewUtxoView(_handle *badger.DB, _params *BitCloutParams, _bitcoinManager *BitcoinManager) (*UtxoView, error)

+ func (bav *UtxoView) ConnectBlock(bitcloutBlock *MsgBitCloutBlock, txHashes []*BlockHash, verifySignatures bool) ([][]*UtxoOperation, error)

+ func (bav *UtxoView) ConnectTransaction(txn *MsgBitCloutTxn, txHash *BlockHash, txnSizeBytes int64, blockHeight uint32, ...) (_utxoOps []*UtxoOperation, _totalInput uint64, _totalOutput uint64, ...)

+ func (bav *UtxoView) CopyUtxoView() (*UtxoView, error)

+ func (bav *UtxoView) DisconnectBlock(bitcloutBlock *MsgBitCloutBlock, txHashes []*BlockHash, ...) error

+ func (bav *UtxoView) DisconnectTransaction(currentTxn *MsgBitCloutTxn, txnHash *BlockHash, utxoOpsForTxn []*UtxoOperation, ...) error

+ func (bav *UtxoView) FlushToDb() error

+ func (bav *UtxoView) FlushToDbWithTxn(txn *badger.Txn) error

+ func (bav *UtxoView) GetAllPosts() (_corePosts []*PostEntry, _commentsByPostHash map[BlockHash][]*PostEntry, ...)

+ func (bav *UtxoView) GetAllProfiles(readerPK []byte) (_profiles map[PkMapKey]*ProfileEntry, ...)

+ func (bav *UtxoView) GetCommentEntriesForParentStakeID(parentStakeID []byte) (_commentEntries []*PostEntry, _err error)

+ func (bav *UtxoView) GetCurrentUSDCentsPerBitcoin() uint64

+ 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) GetFollowEntriesForPublicKey(publicKey []byte, getEntriesFollowingPublicKey bool) (_followEntries []*FollowEntry, _err error)

+ func (bav *UtxoView) GetLimitedMessagesForUser(publicKey []byte) (_messageEntries []*MessageEntry, _err error)

+ func (bav *UtxoView) GetMessagesForUser(publicKey []byte) (_messageEntries []*MessageEntry, _err error)

+ func (bav *UtxoView) GetPKIDForPublicKey(publicKey []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) (_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) GetPublicKeyForPKID(pkid *PKID) []byte

+ func (bav *UtxoView) GetUnspentUtxoEntrysForPublicKey(pkBytes []byte) ([]*UtxoEntry, error)

+ func (bav *UtxoView) GetUtxoEntryForUtxoKey(utxoKey *UtxoKey) *UtxoEntry

+ func (bav *UtxoView) HelpConnectCreatorCoinBuy(txn *MsgBitCloutTxn, txHash *BlockHash, blockHeight uint32, ...) (_totalInput uint64, _totalOutput uint64, _creatorCoinReturnedNanos uint64, ...)

+ func (bav *UtxoView) HelpConnectCreatorCoinSell(txn *MsgBitCloutTxn, txHash *BlockHash, blockHeight uint32, ...) (_totalInput uint64, _totalOutput uint64, _bitCloutReturnedNanos uint64, ...)

+ func (bav *UtxoView) ValidateDiamondsAndGetNumCreatorCoinNanos(senderPublicKey []byte, receiverPublicKey []byte, diamondPostHash *BlockHash, ...) (_numCreatorCoinNanos uint64, _netNewDiamonds int64, _err error)

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