badger

func (*BadgerLogger) Debugf ¶

func (b *BadgerLogger) Debugf(msg string, args ...any)

func (*BadgerLogger) Errorf ¶

func (b *BadgerLogger) Errorf(msg string, args ...any)

func (*BadgerLogger) Infof ¶

func (b *BadgerLogger) Infof(msg string, args ...any)

func (*BadgerLogger) Warningf ¶

func (b *BadgerLogger) Warningf(msg string, args ...any)

func (*BlobStoreBadger) Backup ¶ added in v0.69.0

func (d *BlobStoreBadger) Backup(ctx context.Context, w io.Writer) error

Backup streams a full, MVCC-consistent backup of the store to w. It does not block concurrent readers or writers.

Badger's own Backup has no context parameter and, once started, runs to completion regardless of ctx — checking ctx.Err() only here, before calling it, would let a cancellation request (see bark's CancelOperation) sit unnoticed for the entire duration of a large backup. Wrapping w in a contextWriter closes that gap: Badger calls Write repeatedly as it streams entries out, and each call re-checks ctx, so cancellation takes effect within a chunk or two rather than only between operations.

func (*BlobStoreBadger) Close ¶

func (d *BlobStoreBadger) Close() error

Close gets the database handle from our BlobStore and closes it

func (*BlobStoreBadger) DB ¶

func (d *BlobStoreBadger) DB() *badger.DB

DB returns the database handle

func (*BlobStoreBadger) Delete ¶ added in v0.19.0

func (d *BlobStoreBadger) Delete(txn types.Txn, key []byte) error

Delete removes a key from badger within a transaction

func (*BlobStoreBadger) DeleteBlock ¶ added in v0.20.0

func (d *BlobStoreBadger) DeleteBlock(
	txn types.Txn,
	slot uint64,
	hash []byte,
	id uint64,
) error

DeleteBlock removes a block and its associated data

func (*BlobStoreBadger) DeleteTx ¶ added in v0.22.0

func (d *BlobStoreBadger) DeleteTx(
	txn types.Txn,
	txHash []byte,
) error

DeleteTx removes a transaction's offset data

func (*BlobStoreBadger) DeleteUtxo ¶ added in v0.20.0

func (d *BlobStoreBadger) DeleteUtxo(
	txn types.Txn,
	txId []byte,
	outputIdx uint32,
) error

DeleteUtxo removes a UTxO's data

func (*BlobStoreBadger) DiskSize ¶ added in v0.29.0

func (d *BlobStoreBadger) DiskSize() (int64, error)

DiskSize returns the on-disk size of the Badger database in bytes (LSM tree size + value log size).

func (*BlobStoreBadger) Get ¶ added in v0.19.0

func (d *BlobStoreBadger) Get(
	txn types.Txn,
	key []byte,
) ([]byte, error)

Get retrieves a value from badger within a transaction

func (*BlobStoreBadger) GetBlock ¶ added in v0.20.0

func (d *BlobStoreBadger) GetBlock(
	txn types.Txn,
	slot uint64,
	hash []byte,
) ([]byte, types.BlockMetadata, error)

GetBlock retrieves a block's CBOR data and metadata

func (*BlobStoreBadger) GetBlockURL ¶ added in v0.22.0

func (d *BlobStoreBadger) GetBlockURL(
	ctx context.Context,
	txn types.Txn,
	point ocommon.Point,
) (types.SignedURL, types.BlockMetadata, error)

func (*BlobStoreBadger) GetCommitTimestamp ¶

func (b *BlobStoreBadger) GetCommitTimestamp() (int64, error)

func (*BlobStoreBadger) GetTx ¶ added in v0.22.0

func (d *BlobStoreBadger) GetTx(
	txn types.Txn,
	txHash []byte,
) ([]byte, error)

GetTx retrieves a transaction's offset data

func (*BlobStoreBadger) GetUtxo ¶ added in v0.20.0

func (d *BlobStoreBadger) GetUtxo(
	txn types.Txn,
	txId []byte,
	outputIdx uint32,
) ([]byte, error)

GetUtxo retrieves a UTxO's CBOR data

func (*BlobStoreBadger) NewIterator ¶ added in v0.19.0

func (d *BlobStoreBadger) NewIterator(
	txn types.Txn,
	opts types.BlobIteratorOptions,
) (iter types.BlobIterator)

NewIterator creates an iterator for badger within a transaction.

Important: items returned by the iterator's `Item()` must only be accessed while the transaction used to create the iterator is still active. Implementations may validate transaction state at access time (for example `ValueCopy` may fail if the transaction has been committed or rolled back). Typical usage iterates and accesses item values within the same transaction scope.

func (*BlobStoreBadger) NewTransaction ¶

func (d *BlobStoreBadger) NewTransaction(update bool) types.Txn

NewTransaction creates a new badger transaction

func (*BlobStoreBadger) Restore ¶ added in v0.69.0

func (d *BlobStoreBadger) Restore(
	ctx context.Context,
	r io.Reader,
) (err error)

Restore replaces the store's contents by loading a backup stream produced by Backup. It must only be called against a freshly opened, empty store -- enforced below, unlike relying on callers to honor the contract unchecked. See Backup's doc comment for why r is wrapped the same way w is there: Badger's Load has no context parameter of its own.

Some malformed inputs make Badger's Load return a clean error (e.g. a proto-unmarshal failure), but others make it panic outright (observed with arbitrary garbage bytes: a corrupted length header produces a negative/oversized slice length inside Load, panicking on the allocation) — a real, previously-unhandled crash risk for a live node restoring an untrusted or corrupted snapshot. The recover below covers that, but not every failure mode: Load's length prefix is an unvalidated raw uint64 that it trusts unconditionally before allocating a buffer of that size, and a single-allocation failure large enough can produce a fatal, unrecoverable runtime OOM rather than a regular panic recover can catch — no defer can stop that from taking the whole process down. validateLoadRecordSizes below makes a cheap, allocation-bounded pass over the same record framing Load uses first, so an oversized declared length is rejected as a normal error before Load ever sees it, rather than only after it's already been trusted for the allocation.

func (*BlobStoreBadger) Set ¶ added in v0.19.0

func (d *BlobStoreBadger) Set(txn types.Txn, key, val []byte) error

Set stores a key-value pair in badger within a transaction

func (*BlobStoreBadger) SetBlock ¶ added in v0.20.0

func (d *BlobStoreBadger) SetBlock(
	txn types.Txn,
	slot uint64,
	hash []byte,
	cborData []byte,
	id uint64,
	blockType uint,
	height uint64,
	prevHash []byte,
) error

SetBlock stores a block with its metadata and index

func (*BlobStoreBadger) SetCommitTimestamp ¶

func (b *BlobStoreBadger) SetCommitTimestamp(
	timestamp int64,
	txn types.Txn,
) error

func (*BlobStoreBadger) SetLogger ¶ added in v0.24.0

func (d *BlobStoreBadger) SetLogger(logger *slog.Logger)

func (*BlobStoreBadger) SetTx ¶ added in v0.22.0

func (d *BlobStoreBadger) SetTx(
	txn types.Txn,
	txHash []byte,
	offsetData []byte,
) error

SetTx stores a transaction's offset data

func (*BlobStoreBadger) SetUtxo ¶ added in v0.20.0

func (d *BlobStoreBadger) SetUtxo(
	txn types.Txn,
	txId []byte,
	outputIdx uint32,
	cborData []byte,
) error

SetUtxo stores a UTxO's CBOR data

func (*BlobStoreBadger) Start ¶ added in v0.18.0

func (d *BlobStoreBadger) Start() error

Start implements the plugin.Plugin interface. When the database was created with WithDeferOpen, Start opens Badger using the logger that was injected via SetLogger after construction.

func (*BlobStoreBadger) Stop ¶ added in v0.18.0

func (d *BlobStoreBadger) Stop() error

Stop implements the plugin.Plugin interface

func (*BlobStoreBadger) Sync ¶ added in v0.69.0

func (d *BlobStoreBadger) Sync() error

Sync flushes committed writes to disk. Badger is opened with its default SyncWrites=false, so a committed transaction lives in the active memtable's WAL and the value log without an fsync; with a 128MiB default memtable and only a few MiB of blocks per hour at chain tip, an unclean shutdown can discard hours of committed blocks. badger.DB.Sync syncs both the memtable WAL and the value log, which is what makes those commits recoverable on reopen. It is a no-op for in-memory and read-only stores.

func (*BlobStoreBadger) TombstoneBlock ¶ added in v0.39.1

func (d *BlobStoreBadger) TombstoneBlock(
	txn types.Txn,
	slot uint64,
	hash []byte,
) error

TombstoneBlock overwrites a block's CBOR with an expired-history marker. GetBlock reads the bp value, sees the marker, and returns types.ErrHistoryExpired so an archive proxy can intercept it.

What stays:

• bi<id>: required by BlockByIndex (the chain iterator translates id→key here; no equivalent index exists in metadata).

• bh<hash>: BlockByHash resolves only through this index and treats a missing entry as a hard miss (ErrBlockNotFound), so the entry must survive tombstoning to keep the block reachable by hash.

• bp_metadata: kept so bark can populate models.Block.ID (and the other small metadata fields) when surfacing a CBOR fetched from the archive. Without this the chain iterator's BlockByIndex path gets ID=0 and immediately returns ErrIteratorChainTip.