Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

altda

package

Go to main page

Versions in this module

v1

v1.9.4

Oct 8, 2024

v1.9.3

Sep 25, 2024

Changes in this version

+ var DaServiceFlagName = altDAFlags("da-service")

+ var GetTimeoutFlagName = altDAFlags("get-timeout")

+ var MaxConcurrentRequestsFlagName = altDAFlags("max-concurrent-da-requests")

+ var PutTimeoutFlagName = altDAFlags("put-timeout")

type CLIConfig

+ GetTimeout time.Duration

+ MaxConcurrentRequests uint64

+ PutTimeout time.Duration

type DAServer

+ func (b *DAServer) HttpEndpoint() string

+ type FakeDAServer struct

+ func NewFakeDAServer(host string, port int, log log.Logger) *FakeDAServer

+ func (s *FakeDAServer) HandleGet(w http.ResponseWriter, r *http.Request)

+ func (s *FakeDAServer) HandlePut(w http.ResponseWriter, r *http.Request)

+ func (s *FakeDAServer) SetGetRequestLatency(latency time.Duration)

+ func (s *FakeDAServer) SetPutRequestLatency(latency time.Duration)

+ func (s *FakeDAServer) Start() error

+ type MemStore struct

+ func NewMemStore() *MemStore

+ func (s *MemStore) Get(ctx context.Context, key []byte) ([]byte, error)

+ func (s *MemStore) Put(ctx context.Context, key []byte, value []byte) error

v1.9.2

Sep 5, 2024

v1.9.1

Aug 28, 2024

Changes in this version

+ const GenericCommitmentString

+ const GenericCommitmentType

+ const Keccak256CommitmentType

+ const KeccakCommitmentString

+ const MaxInputSize

+ const TxDataVersion1

+ var ChallengeStatusEventABI = "ChallengeStatusChanged(uint256,bytes,uint8)"

+ var ChallengeStatusEventABIHash = crypto.Keccak256Hash([]byte(ChallengeStatusEventABI))

+ var ChallengeStatusEventName = "ChallengeStatusChanged"

+ var DaServerAddressFlagName = altDAFlags("da-server")

+ var DaServiceFlag = altDAFlags("da-service")

+ var Disabled = &AltDADisabled

+ var EnabledFlagName = altDAFlags("enabled")

+ var ErrCommitmentMismatch = errors.New("commitment mismatch")

+ var ErrExpiredChallenge = errors.New("challenge expired")

+ var ErrInvalidChallenge = errors.New("invalid challenge")

+ var ErrInvalidCommitment = errors.New("invalid commitment")

+ var ErrInvalidInput = errors.New("invalid input")

+ var ErrMissingPastWindow = errors.New("data missing past window")

+ var ErrNotEnabled = errors.New("altDA not enabled")

+ var ErrNotFound = errors.New("not found")

+ var ErrPendingChallenge = errors.New("not found, pending challenge")

+ var ErrReorgRequired = errors.New("reorg required")

+ var VerifyOnReadFlagName = altDAFlags("verify-on-read")

+ func CLIFlags(envPrefix string, category string) []cli.Flag

+ func DecodeChallengeStatusEvent(log *types.Log) (*bindings.DataAvailabilityChallengeChallengeStatusChanged, error)

+ func DecodeResolvedInput(data []byte) ([]byte, error)

+ type AltDADisabled struct

+ func (d *AltDADisabled) AdvanceL1Origin(ctx context.Context, l1 L1Fetcher, blockId eth.BlockID) error

+ func (d *AltDADisabled) Finalize(ref eth.L1BlockRef)

+ func (d *AltDADisabled) GetInput(ctx context.Context, l1 L1Fetcher, commitment CommitmentData, ...) (eth.Data, error)

+ func (d *AltDADisabled) OnFinalizedHeadSignal(f HeadSignalFn)

+ func (d *AltDADisabled) Reset(ctx context.Context, base eth.L1BlockRef, baseCfg eth.SystemConfig) error

+ type CLIConfig struct

+ DAServerURL string

+ Enabled bool

+ GenericDA bool

+ VerifyOnRead bool

+ func ReadCLIConfig(c *cli.Context) CLIConfig

+ func (c CLIConfig) Check() error

+ func (c CLIConfig) NewDAClient() *DAClient

+ type Challenge struct

+ type ChallengeStatus uint8

+ const ChallengeActive

+ const ChallengeExpired

+ const ChallengeResolved

+ const ChallengeUninitialized

+ type Commitment struct

+ type CommitmentData interface

+ CommitmentType func() CommitmentType

+ Encode func() []byte

+ String func() string

+ TxData func() []byte

+ Verify func(input []byte) error

+ func DecodeCommitmentData(input []byte) (CommitmentData, error)

+ func NewCommitmentData(t CommitmentType, input []byte) CommitmentData

+ type CommitmentType byte

+ func CommitmentTypeFromString(s string) (CommitmentType, error)

+ type Config struct

+ ChallengeWindow uint64

+ CommitmentType CommitmentType

+ DAChallengeContractAddress common.Address

+ ResolveWindow uint64

+ type DA struct

+ func NewAltDA(log log.Logger, cli CLIConfig, cfg Config, metrics Metricer) *DA

+ func NewAltDAWithState(log log.Logger, cfg Config, storage DAStorage, metrics Metricer, state *State) *DA

+ func NewAltDAWithStorage(log log.Logger, cfg Config, storage DAStorage, metrics Metricer) *DA

+ func (d *DA) AdvanceChallengeOrigin(ctx context.Context, l1 L1Fetcher, block eth.BlockID) error

+ func (d *DA) AdvanceCommitmentOrigin(ctx context.Context, l1 L1Fetcher, block eth.BlockID) error

+ func (d *DA) AdvanceL1Origin(ctx context.Context, l1 L1Fetcher, block eth.BlockID) error

+ func (d *DA) Finalize(l1Finalized eth.L1BlockRef)

+ func (d *DA) GetInput(ctx context.Context, l1 L1Fetcher, comm CommitmentData, blockId eth.L1BlockRef) (eth.Data, error)

+ func (d *DA) LookAhead(ctx context.Context, l1 L1Fetcher) error

+ func (d *DA) OnFinalizedHeadSignal(f HeadSignalFn)

+ func (d *DA) Reset(ctx context.Context, base eth.L1BlockRef, baseCfg eth.SystemConfig) error

+ type DAClient struct

+ func NewDAClient(url string, verify bool, pc bool) *DAClient

+ func (c *DAClient) GetInput(ctx context.Context, comm CommitmentData) ([]byte, error)

+ func (c *DAClient) SetInput(ctx context.Context, img []byte) (CommitmentData, error)

+ type DAErrFaker struct

+ Client *MockDAClient

+ func (f *DAErrFaker) ActGetPreImageFail()

+ func (f *DAErrFaker) ActSetPreImageFail()

+ func (f *DAErrFaker) GetInput(ctx context.Context, key CommitmentData) ([]byte, error)

+ func (f *DAErrFaker) SetInput(ctx context.Context, data []byte) (CommitmentData, error)

+ type DAServer struct

+ func NewDAServer(host string, port int, store KVStore, log log.Logger, useGenericComm bool) *DAServer

+ func (b *DAServer) Endpoint() string

+ func (b *DAServer) Stop() error

+ func (d *DAServer) HandleGet(w http.ResponseWriter, r *http.Request)

+ func (d *DAServer) HandlePut(w http.ResponseWriter, r *http.Request)

+ func (d *DAServer) Start() error

+ type DAStorage interface

+ GetInput func(ctx context.Context, key CommitmentData) ([]byte, error)

+ SetInput func(ctx context.Context, img []byte) (CommitmentData, error)

+ type GenericCommitment []byte

+ func DecodeGenericCommitment(commitment []byte) (GenericCommitment, error)

+ func NewGenericCommitment(input []byte) GenericCommitment

+ func (c GenericCommitment) CommitmentType() CommitmentType

+ func (c GenericCommitment) Encode() []byte

+ func (c GenericCommitment) String() string

+ func (c GenericCommitment) TxData() []byte

+ func (c GenericCommitment) Verify(input []byte) error

+ type HeadSignalFn func(eth.L1BlockRef)

+ type KVStore interface

+ Get func(ctx context.Context, key []byte) ([]byte, error)

+ Put func(ctx context.Context, key []byte, value []byte) error

+ type Keccak256Commitment []byte

+ func DecodeKeccak256(commitment []byte) (Keccak256Commitment, error)

+ func NewKeccak256Commitment(input []byte) Keccak256Commitment

+ func (c Keccak256Commitment) CommitmentType() CommitmentType

+ func (c Keccak256Commitment) Encode() []byte

+ func (c Keccak256Commitment) String() string

+ func (c Keccak256Commitment) TxData() []byte

+ func (c Keccak256Commitment) Verify(input []byte) error

+ type L1Fetcher interface

+ FetchReceipts func(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, types.Receipts, error)

+ InfoAndTxsByHash func(ctx context.Context, hash common.Hash) (eth.BlockInfo, types.Transactions, error)

+ L1BlockRefByNumber func(context.Context, uint64) (eth.L1BlockRef, error)

+ type Metricer interface

+ RecordActiveChallenge func(commBlock uint64, startBlock uint64, hash []byte)

+ RecordChallengesHead func(name string, num uint64)

+ RecordExpiredChallenge func(hash []byte)

+ RecordResolvedChallenge func(hash []byte)

+ RecordStorageError func()

+ type Metrics struct

+ ChallengesHead *prometheus.GaugeVec

+ ChallengesStatus *prometheus.GaugeVec

+ StorageErrors *metrics.Event

+ func MakeMetrics(ns string, factory metrics.Factory) *Metrics

+ func (m *Metrics) RecordActiveChallenge(commBlock uint64, startBlock uint64, hash []byte)

+ func (m *Metrics) RecordChallenge(status string)

+ func (m *Metrics) RecordChallengesHead(name string, num uint64)

+ func (m *Metrics) RecordExpiredChallenge(hash []byte)

+ func (m *Metrics) RecordResolvedChallenge(hash []byte)

+ func (m *Metrics) RecordStorageError()

+ type MockDAClient struct

+ CommitmentType CommitmentType

+ func NewMockDAClient(log log.Logger) *MockDAClient

+ func (c *MockDAClient) DeleteData(key []byte) error

+ func (c *MockDAClient) GetInput(ctx context.Context, key CommitmentData) ([]byte, error)

+ func (c *MockDAClient) SetInput(ctx context.Context, data []byte) (CommitmentData, error)

+ type NoopMetrics struct

+ func (m *NoopMetrics) RecordActiveChallenge(commBlock uint64, startBlock uint64, hash []byte)

+ func (m *NoopMetrics) RecordChallengesHead(name string, num uint64)

+ func (m *NoopMetrics) RecordExpiredChallenge(hash []byte)

+ func (m *NoopMetrics) RecordResolvedChallenge(hash []byte)

+ func (m *NoopMetrics) RecordStorageError()

+ type State struct

+ func NewState(log log.Logger, m Metricer, cfg Config) *State

+ func (s *State) ClearCommitments()

+ func (s *State) CreateChallenge(comm CommitmentData, inclusionBlock eth.BlockID, commBlockNumber uint64)

+ func (s *State) ExpireChallenges(origin eth.BlockID)

+ func (s *State) ExpireCommitments(origin eth.BlockID) error

+ func (s *State) GetChallenge(comm CommitmentData, commBlockNumber uint64) (*Challenge, bool)

+ func (s *State) GetChallengeStatus(comm CommitmentData, commBlockNumber uint64) ChallengeStatus

+ func (s *State) NoCommitments() bool

+ func (s *State) Prune(origin eth.BlockID)

+ func (s *State) Reset()

+ func (s *State) ResolveChallenge(comm CommitmentData, inclusionBlock eth.BlockID, commBlockNumber uint64, ...) error

+ func (s *State) TrackCommitment(comm CommitmentData, inclusionBlock eth.L1BlockRef)