share

Documentation

Overview

TODO(@Wondertan): Instead of doing sampling over the coordinates do a random walk over NMT trees.

Index

• Constants
• Variables
• func RandFullServiceWithSquare(t *testing.T, n int) (Service, *Root)
• func RandLightServiceWithSquare(t *testing.T, n int) (Service, *Root)
• type Availability
  • func NewFullAvailability(get format.NodeGetter) Availability
  • func NewLightAvailability(get format.NodeGetter) Availability
• type DAGNet
  • func NewDAGNet(ctx context.Context, t *testing.T) *DAGNet
  • func (dn *DAGNet) CleanDAG() format.DAGService
  • func (dn *DAGNet) CleanService() Service
  • func (dn *DAGNet) ConnectAll()
  • func (dn *DAGNet) RandDAG(n int) (format.DAGService, *Root)
  • func (dn *DAGNet) RandFullService(n int) (Service, *Root)
  • func (dn *DAGNet) RandLightService(n int) (Service, *Root)
• type Root
  • func RandFillDAG(t *testing.T, n int, dag format.DAGService) *Root
• type Sample
  • func SampleSquare(squareWidth int, num int) ([]Sample, error)
• type Service
  • func NewService(dag format.DAGService, avail Availability) Service
• type Share
  • func RandShares(t *testing.T, n int) []Share

Constants

const AvailabilityTimeout = 10 * time.Minute

AvailabilityTimeout specifies timeout for DA validation during which data have to be found on the network, otherwise ErrNotAvailable is fired. TODO: https://github.com/celestiaorg/celestia-node/issues/10

Variables

var DefaultSampleAmount = 16

DefaultSampleAmount sets the default amount of samples to be sampled from the network by lightAvailability.

var ErrNotAvailable = errors.New("da: data not available")

ErrNotAvailable is returned whenever DA sampling fails.

Functions

func RandFullServiceWithSquare

func RandFullServiceWithSquare(t *testing.T, n int) (Service, *Root)

RandFullServiceWithSquare provides a share.Service filled with 'n' NMT trees of 'n' random shares, essentially storing a whole square.

func RandLightServiceWithSquare

func RandLightServiceWithSquare(t *testing.T, n int) (Service, *Root)

RandLightServiceWithSquare provides a share.Service filled with 'n' NMT trees of 'n' random shares, essentially storing a whole square.

Types

type Availability

type Availability interface {
	// SharesAvailable subjectively validates if Shares committed to the given Root are available on the Network.
	SharesAvailable(context.Context, *Root) error
}

Availability defines interface for validation of Shares' availability.

func NewFullAvailability

func NewFullAvailability(get format.NodeGetter) Availability

NewFullAvailability creates a new full Availability.

func NewLightAvailability

func NewLightAvailability(get format.NodeGetter) Availability

NewLightAvailability creates a new light Availability.

type DAGNet

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

func NewDAGNet

func NewDAGNet(ctx context.Context, t *testing.T) *DAGNet

func (*DAGNet) CleanDAG

func (dn *DAGNet) CleanDAG() format.DAGService

func (*DAGNet) CleanService

func (dn *DAGNet) CleanService() Service

func (*DAGNet) ConnectAll

func (dn *DAGNet) ConnectAll()

func (*DAGNet) RandDAG

func (dn *DAGNet) RandDAG(n int) (format.DAGService, *Root)

func (*DAGNet) RandFullService

func (dn *DAGNet) RandFullService(n int) (Service, *Root)

func (*DAGNet) RandLightService

func (dn *DAGNet) RandLightService(n int) (Service, *Root)

type Root

type Root = da.DataAvailabilityHeader

Root represents root commitment to multiple Shares. In practice, it is a commitment to all the Data in a square.

func RandFillDAG

func RandFillDAG(t *testing.T, n int, dag format.DAGService) *Root

type Sample

type Sample struct {
	Row, Col int
}

Sample is a point in 2D space over square.

func SampleSquare

func SampleSquare(squareWidth int, num int) ([]Sample, error)

SampleSquare randomly picks *num* unique points from the given *width* square and returns them as samples.

type Service

type Service interface {
	Availability

	// GetShare loads a Share committed to the given DataAvailabilityHeader by its Row and Column coordinates in the
	// erasure coded data square or block.
	GetShare(ctx context.Context, root *Root, row, col int) (Share, error)

	// GetShares loads all the Shares committed to the given DataAvailabilityHeader as a 2D array/slice.
	// It also optimistically executes erasure coding recovery.
	GetShares(context.Context, *Root) ([][]Share, error)

	// GetSharesByNamespace loads all the Shares of the given namespace.ID committed to the given
	// DataAvailabilityHeader as a 1D array/slice.
	GetSharesByNamespace(context.Context, *Root, namespace.ID) ([]Share, error)

	// Start starts the Service.
	Start(context.Context) error

	// Stop stops the Service.
	Stop(context.Context) error
}

Service provides a simple interface to access any data square or block share on the network.

All Get methods follow the following flow:

• Check local storage for the requested Share.
• If exists
• Load from disk
• Return
• If not
• Find provider on the network
• Fetch the Share from the provider
• Store the Share
• Return

func NewService

func NewService(dag format.DAGService, avail Availability) Service

NewService creates new basic share.Service.

type Share

type Share = namespace.PrefixedData8

TODO(@Wondertan): We prefix real data of shares with namespaces to be able to recover them during erasure coding

recovery. However, that is storage and bandwidth overhead(8 bytes per each share) which we can avoid by getting
namespaces from CIDs stored in IPLD NMT Nodes, instead of encoding namespaces in erasure coding.

TODO(@Wondertan): Ideally, Shares structure should be defined in a separate store with

rsmt2d/nmt/celestia-core/celestia-node importing it. rsmt2d and nmt are already dependent on the notion of "share",
so why shouldn't we have a separated and global type for it to avoid the type mess with defining own share type in
each package.

Share is a fixed-size data chunk associated with a namespace ID, whose data will be erasure-coded and committed to in Namespace Merkle trees.

func RandShares

func RandShares(t *testing.T, n int) []Share

RandShares provides 'n' randomized shares prefixed with random namespaces.