fix: op-avail architechture restucturing

op-avail/avail/avail.go

@@ -0,0 +1,90 @@
+package avail
+
+import (
+	"fmt"
+
+	gsrpc "github.com/centrifuge/go-substrate-rpc-client/v4"
+
+	"github.com/ethereum/go-ethereum/log"
+
+	config "github.com/ethereum-optimism/optimism/op-avail/internal/config"
+	service "github.com/ethereum-optimism/optimism/op-avail/internal/services"
+	types "github.com/ethereum-optimism/optimism/op-avail/internal/types"
+)
+
+// AvailMessageHeaderFlag indicates that this data is a Blob Pointer
+// which will be used to retrieve data from Avail
+const AvailMessageHeaderFlag byte = 0x0a
+
+func IsAvailMessageHeaderByte(header byte) bool {
+	return (AvailMessageHeaderFlag & header) > 0
+}
+
+type AvailDA struct {
+	cfg config.DAConfig
+	api *gsrpc.SubstrateAPI
+}
+
+func NewAvailDA(path string) (*AvailDA, error) {
+
+	// Load config
+	var cfg config.DAConfig
+	err := cfg.GetConfig(path)
+	if err != nil {
+		log.Error("Unable to create config variable for op-avail")
+		panic(fmt.Sprintf("cannot get config:%v", err))
+	}
+
+	//Creating new substrate api
+	api, err := gsrpc.NewSubstrateAPI(cfg.ApiURL)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Info("Connected to Avail ✅")
+	return &AvailDA{
+		cfg: cfg,
+		api: api,
+	}, nil
+}
+
+func (a *AvailDA) SubmitTxDataAndGetRef(TxData []byte) ([]byte, error) {
+	log.Info("Working on batch submission for avail")
+
+	//Checking for the size of TxData
+	if len(TxData) >= 512000 {
+		return []byte{}, fmt.Errorf("size of TxData is more than 512KB, it is higher than a single data submit transaction supports on avail")
+	}
+
+	// Submitting data to Avail
+	avail_Blk_Ref, err := service.SubmitDataAndWatch(a.api, a.cfg, TxData)
+	if err != nil {
+		return []byte{}, fmt.Errorf("cannot submit data:%v", err)
+	}
+
+	log.Info("Avail Block Reference:", "Ref", avail_Blk_Ref)
+
+	ref_bytes_Data, err := avail_Blk_Ref.MarshalToBinary()
+	if err != nil {
+		return []byte{}, fmt.Errorf("cannot get the binary form of avail block reference:%v", err)
+	}
+
+	return ref_bytes_Data, nil
+}
+
+func (a *AvailDA) GetTxDataByDARef(RefData []byte) ([]byte, error) {
+	//Getting Avail block reference from callData
+	avail_blk_ref := types.AvailBlockRef{}
+	err := avail_blk_ref.UnmarshalFromBinary(RefData)
+	if err != nil {
+		return []byte{}, fmt.Errorf("failed to unmarshal the ethereum trxn data to avail block refrence, error:%v", err)
+	}
+	log.Info("Avail Block Reference:", "Ref", avail_blk_ref)
+
+	txData, err := service.GetBlockExtrinsicData(a.api, a.cfg, avail_blk_ref)
+	if err != nil {
+		return []byte{}, fmt.Errorf("failed to get block extrinsic data, error:%v", err)
+	}
+
+	return txData, nil
+}

op-avail/internal/config/config.go

@@ -6,13 +6,13 @@ import (
 	"os"
 )
 
-type Config struct {
+type DAConfig struct {
 	Seed   string `json:"seed"`
 	ApiURL string `json:"api_url"`
 	AppID  int    `json:"app_id"`
 }
 
-func (c *Config) GetConfig(configFileName string) error {
+func (c *DAConfig) GetConfig(configFileName string) error {
 
 	jsonFile, err := os.Open(configFileName)
 	if err != nil {

op-avail/internal/services/getBlockExtrinsicData.go

@@ -14,28 +14,13 @@ import (
 )
 
 // GetBlock: To fetch the extrinsic Data from block's extrinsic by hash
-func GetBlockExtrinsicData(avail_blk_ref types.AvailBlockRef, l log.Logger) ([]byte, error) {
-
-	// Load config
-	var config config.Config
-	err := config.GetConfig("../op-avail/config.json")
-	if err != nil {
-		l.Error("Unable to create config variable for op-avail")
-		panic(fmt.Sprintf("cannot get config:%v", err))
-	}
+func GetBlockExtrinsicData(api *gsrpc.SubstrateAPI, config config.DAConfig, avail_blk_ref types.AvailBlockRef) ([]byte, error) {
 
 	//Intitializing variables
-	ApiURL := config.ApiURL
 	Hash := avail_blk_ref.BlockHash
 	Address := avail_blk_ref.Sender
 	Nonce := avail_blk_ref.Nonce
 
-	//Creating new substrate api
-	api, err := gsrpc.NewSubstrateAPI(ApiURL)
-	if err != nil {
-		return []byte{}, fmt.Errorf("cannot create api:%w", err)
-	}
-
 	// Converting this string type into gsrpc_types.hash type
 	blk_hash, err := gsrpc_types.NewHashFromHexString(Hash)
 	if err != nil {
@@ -53,7 +38,7 @@ func GetBlockExtrinsicData(avail_blk_ref types.AvailBlockRef, l log.Logger) ([]b
 		//Extracting sender address for extrinsic
 		ext_Addr, err := subkey.SS58Address(ext.Signature.Signer.AsID.ToBytes(), 42)
 		if err != nil {
-			l.Error("unable to get sender address from extrinsic", "err", err)
+			log.Error("unable to get sender address from extrinsic", "err", err)
 		}
 		if ext_Addr == Address && ext.Signature.Nonce.Int64() == Nonce {
 			args := ext.Method.Args

op-avail/internal/services/submitDataAndWatch.go

@@ -15,27 +15,17 @@ import (
 )
 
 // submitData creates a transaction and makes a Avail data submission
-func SubmitDataAndWatch(data []byte, l log.Logger) (types.AvailBlockRef, error) {
+func SubmitDataAndWatch(api *gsrpc.SubstrateAPI, config config.DAConfig, data []byte) (types.AvailBlockRef, error) {
 
-	//Load variables
-	var config config.Config
-	err := config.GetConfig("../op-avail/config.json")
-	if err != nil {
-		l.Error("Unable to create config variable for op-avail")
-		panic(fmt.Sprintf("cannot get config:%v", err))
-	}
-
-	//Intitializing variables
-	ApiURL := config.ApiURL
 	Seed := config.Seed
 	AppID := config.AppID
 
-	//Creating new substrate api
-	api, err := gsrpc.NewSubstrateAPI(ApiURL)
-	if err != nil {
-		fmt.Printf("cannot create api: error:%v", err)
-		return types.AvailBlockRef{}, err
-	}
+	// //Creating new substrate api
+	// api, err := gsrpc.NewSubstrateAPI(ApiURL)
+	// if err != nil {
+	// 	fmt.Printf("cannot create api: error:%v", err)
+	// 	return types.AvailBlockRef{}, err
+	// }
 
 	meta, err := api.RPC.State.GetMetadataLatest()
 	if err != nil {
@@ -116,7 +106,7 @@ func SubmitDataAndWatch(data []byte, l log.Logger) (types.AvailBlockRef, error)
 		return types.AvailBlockRef{}, err
 	}
 
-	l.Info("Tx batch is submitted to Avail", "length", len(data), "address", keyringPair.Address, "appID", appID)
+	log.Info("Tx batch is submitted to Avail", "length", len(data), "address", keyringPair.Address, "appID", appID)
 
 	defer sub.Unsubscribe()
 	timeout := time.After(100 * time.Second)

op-batcher/batcher/config.go

@@ -7,6 +7,7 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/urfave/cli/v2"
 
+	"github.com/ethereum-optimism/optimism/op-avail/avail"
 	"github.com/ethereum-optimism/optimism/op-batcher/compressor"
 	"github.com/ethereum-optimism/optimism/op-batcher/flags"
 	"github.com/ethereum-optimism/optimism/op-batcher/metrics"
@@ -25,7 +26,9 @@ type Config struct {
 	L1Client   *ethclient.Client
 	L2Client   *ethclient.Client
 	RollupNode *sources.RollupClient
-	TxManager  txmgr.TxManager
+	AvailDA    *avail.AvailDA
+
+	TxManager txmgr.TxManager
 
 	NetworkTimeout         time.Duration
 	PollInterval           time.Duration
@@ -59,6 +62,9 @@ type CLIConfig struct {
 	// RollupRpc is the HTTP provider URL for the L2 rollup node.
 	RollupRpc string
 
+	// AvailConfig provides the path of config file for setting up avail da
+	AvailConfig string
+
 	// MaxChannelDuration is the maximum duration (in #L1-blocks) to keep a
 	// channel open. This allows to more eagerly send batcher transactions
 	// during times of low L2 transaction volume. Note that the effective
@@ -123,6 +129,7 @@ func NewConfig(ctx *cli.Context) CLIConfig {
 		RollupRpc:       ctx.String(flags.RollupRpcFlag.Name),
 		SubSafetyMargin: ctx.Uint64(flags.SubSafetyMarginFlag.Name),
 		PollInterval:    ctx.Duration(flags.PollIntervalFlag.Name),
+		AvailConfig:     ctx.String(flags.AvailDAConfigFlag.Name),
 
 		/* Optional Flags */
 		MaxPendingTransactions: ctx.Uint64(flags.MaxPendingTransactionsFlag.Name),

op-batcher/batcher/driver.go

@@ -72,6 +72,11 @@ func NewBatchSubmitterFromCLIConfig(cfg CLIConfig, l log.Logger, m metrics.Metri
 		return nil, fmt.Errorf("querying rollup config: %w", err)
 	}
 
+	availDA, err := avail.NewAvailDA(cfg.AvailConfig)
+	if err != nil {
+		return nil, fmt.Errorf("Unable to intialize Avail DA, err:%w", err)
+	}
+
 	txManager, err := txmgr.NewSimpleTxManager("batcher", l, m, cfg.TxMgrConfig)
 	if err != nil {
 		return nil, err
@@ -81,6 +86,7 @@ func NewBatchSubmitterFromCLIConfig(cfg CLIConfig, l log.Logger, m metrics.Metri
 		L1Client:               l1Client,
 		L2Client:               l2Client,
 		RollupNode:             rollupClient,
+		AvailDA:                availDA,
 		PollInterval:           cfg.PollInterval,
 		MaxPendingTransactions: cfg.MaxPendingTransactions,
 		NetworkTimeout:         cfg.TxMgrConfig.NetworkTimeout,
@@ -398,7 +404,7 @@ func (l *BatchSubmitter) sendTransaction(txdata txData, queue *txmgr.Queue[txDat
 
 	if l.Rollup.DAEnabled {
 		// Submit transaction data on Data and get reference to submit on ethereum layer
-		refData, err := avail.SubmitTxDataAndGetRef(data, l.log)
+		refData, err := l.AvailDA.SubmitTxDataAndGetRef(data)
 		if err != nil {
 			l.log.Error("failed to submit txData on avail", "err", err)
 			return

op-batcher/flags/flags.go

@@ -39,6 +39,11 @@ var (
 		Usage:   "HTTP provider URL for Rollup node",
 		EnvVars: prefixEnvVars("ROLLUP_RPC"),
 	}
+	AvailDAConfigFlag = &cli.StringFlag{
+		Name:    "avail-da.config",
+		Usage:   "Config for setting up Avail DA",
+		EnvVars: prefixEnvVars("AVAIL_DA_CONFIG"),
+	}
 	// Optional flags
 	SubSafetyMarginFlag = &cli.Uint64Flag{
 		Name: "sub-safety-margin",
@@ -85,6 +90,7 @@ var requiredFlags = []cli.Flag{
 	L1EthRpcFlag,
 	L2EthRpcFlag,
 	RollupRpcFlag,
+	AvailDAConfigFlag,
 }
 
 var optionalFlags = []cli.Flag{

op-e2e/actions/l2_sequencer.go

@@ -39,8 +39,8 @@ type L2Sequencer struct {
 	mockL1OriginSelector *MockL1OriginSelector
 }
 
-func NewL2Sequencer(t Testing, log log.Logger, l1 derive.L1Fetcher, eng L2API, cfg *rollup.Config, seqConfDepth uint64) *L2Sequencer {
-	ver := NewL2Verifier(t, log, l1, eng, cfg)
+func NewL2Sequencer(t Testing, log log.Logger, l1 derive.L1Fetcher, availDAFetcher derive.AvailDAFetcher, eng L2API, cfg *rollup.Config, seqConfDepth uint64) *L2Sequencer {
+	ver := NewL2Verifier(t, log, l1, availDAFetcher, eng, cfg)
 	attrBuilder := derive.NewFetchingAttributesBuilder(cfg, l1, eng)
 	seqConfDepthL1 := driver.NewConfDepth(seqConfDepth, ver.l1State.L1Head, l1)
 	l1OriginSelector := &MockL1OriginSelector{

op-e2e/actions/l2_verifier.go

@@ -55,9 +55,9 @@ type L2API interface {
 	GetProof(ctx context.Context, address common.Address, storage []common.Hash, blockTag string) (*eth.AccountResult, error)
 }
 
-func NewL2Verifier(t Testing, log log.Logger, l1 derive.L1Fetcher, eng L2API, cfg *rollup.Config) *L2Verifier {
+func NewL2Verifier(t Testing, log log.Logger, l1 derive.L1Fetcher, availDAFetcher derive.AvailDAFetcher, eng L2API, cfg *rollup.Config) *L2Verifier {
 	metrics := &testutils.TestDerivationMetrics{}
-	pipeline := derive.NewDerivationPipeline(log, cfg, l1, eng, metrics)
+	pipeline := derive.NewDerivationPipeline(log, cfg, l1, availDAFetcher, eng, metrics)
 	pipeline.Reset()
 
 	rollupNode := &L2Verifier{

op-node/flags/flags.go

@@ -39,6 +39,11 @@ var (
 		Usage:   "Rollup chain parameters",
 		EnvVars: prefixEnvVars("ROLLUP_CONFIG"),
 	}
+	AvailDAConfig = &cli.StringFlag{
+		Name:    "avail-da.config",
+		Usage:   "Config for setting up Avail DA",
+		EnvVars: prefixEnvVars("AVAIL_DA_CONFIG"),
+	}
 	Network = &cli.StringFlag{
 		Name:    "network",
 		Usage:   fmt.Sprintf("Predefined network selection. Available networks: %s", strings.Join(chaincfg.AvailableNetworks(), ", ")),
@@ -219,6 +224,7 @@ var (
 var requiredFlags = []cli.Flag{
 	L1NodeAddr,
 	L2EngineAddr,
+	AvailDAConfig,
 }
 
 var optionalFlags = []cli.Flag{

op-node/node/config.go

@@ -23,6 +23,8 @@ type Config struct {
 
 	Rollup rollup.Config
 
+	AvailDAConfig string
+
 	// P2PSigner will be used for signing off on published content
 	// if the node is sequencing and if the p2p stack is enabled
 	P2PSigner p2p.SignerSetup