From 53275759d1814a975cdcce218116c2f08149988c Mon Sep 17 00:00:00 2001
From: omritoptix <omritoptix@gmail.com>
Date: Thu, 15 Jun 2023 11:54:59 +0200
Subject: [PATCH 01/12] Added avail client.

---
 da/avail/avail.go               | 388 +++++++++++++
 da/avail/avail_test.go          | 183 ++++++
 da/da.go                        |   1 +
 da/errors.go                    |  12 +
 go.mod                          |  11 +-
 go.sum                          |  18 +-
 mocks/da/avail/SubstrateApiI.go | 985 ++++++++++++++++++++++++++++++++
 node/node.go                    |   2 +-
 testutil/mocks.go               |  17 +
 9 files changed, 1612 insertions(+), 5 deletions(-)
 create mode 100644 da/avail/avail.go
 create mode 100644 da/avail/avail_test.go
 create mode 100644 da/errors.go
 create mode 100644 mocks/da/avail/SubstrateApiI.go

diff --git a/da/avail/avail.go b/da/avail/avail.go
new file mode 100644
index 000000000..887a18633
--- /dev/null
+++ b/da/avail/avail.go
@@ -0,0 +1,388 @@
+package avail
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/avast/retry-go"
+	"github.com/dymensionxyz/dymint/log"
+	"github.com/gogo/protobuf/proto"
+
+	"github.com/dymensionxyz/dymint/types"
+
+	gsrpc "github.com/centrifuge/go-substrate-rpc-client/v4"
+	"github.com/centrifuge/go-substrate-rpc-client/v4/rpc/author"
+	"github.com/centrifuge/go-substrate-rpc-client/v4/rpc/chain"
+	"github.com/centrifuge/go-substrate-rpc-client/v4/rpc/state"
+	"github.com/centrifuge/go-substrate-rpc-client/v4/signature"
+	availtypes "github.com/centrifuge/go-substrate-rpc-client/v4/types"
+	"github.com/dymensionxyz/dymint/da"
+	"github.com/dymensionxyz/dymint/store"
+	pb "github.com/dymensionxyz/dymint/types/pb/dymint"
+	"github.com/tendermint/tendermint/libs/pubsub"
+)
+
+const (
+	keyringNetworkID          uint8 = 42
+	defaultTxInculsionTimeout       = 100 * time.Second
+	defaultBatchRetryDelay          = 10 * time.Second
+	defaultBatchRetryAttempts       = 10
+	DataCallSection                 = "DataAvailability"
+	DataCallMethod                  = "submit_data"
+	DataCallSectionIndex            = 29
+	DataCallMethodIndex             = 1
+)
+
+type SubstrateApiI interface {
+	chain.Chain
+	state.State
+	author.Author
+}
+
+type SubstrateApi struct {
+	chain.Chain
+	state.State
+	author.Author
+}
+
+type Config struct {
+	Seed   string `json:"seed"`
+	ApiURL string `json:"api_url"`
+	AppID  int64  `json:"app_id"`
+	Tip    uint64 `json:"tip"`
+}
+
+type DataAvailabilityLayerClient struct {
+	client             SubstrateApiI
+	pubsubServer       *pubsub.Server
+	config             Config
+	logger             log.Logger
+	ctx                context.Context
+	cancel             context.CancelFunc
+	txInclusionTimeout time.Duration
+	batchRetryDelay    time.Duration
+	batchRetryAttempts uint
+}
+
+var _ da.DataAvailabilityLayerClient = &DataAvailabilityLayerClient{}
+var _ da.BatchRetriever = &DataAvailabilityLayerClient{}
+
+//WithClient is an option which sets the client.
+func WithClient(client SubstrateApiI) da.Option {
+	return func(dalc da.DataAvailabilityLayerClient) {
+		dalc.(*DataAvailabilityLayerClient).client = client
+	}
+}
+
+//WithTxInclusionTimeout is an option which sets the timeout for waiting for transaction inclusion.
+func WithTxInclusionTimeout(timeout time.Duration) da.Option {
+	return func(dalc da.DataAvailabilityLayerClient) {
+		dalc.(*DataAvailabilityLayerClient).txInclusionTimeout = timeout
+	}
+}
+
+//WithBatchRetryDelay is an option which sets the delay between batch retries.
+func WithBatchRetryDelay(delay time.Duration) da.Option {
+	return func(dalc da.DataAvailabilityLayerClient) {
+		dalc.(*DataAvailabilityLayerClient).batchRetryDelay = delay
+	}
+}
+
+//WithBatchRetryAttempts is an option which sets the number of batch retries.
+func WithBatchRetryAttempts(attempts uint) da.Option {
+	return func(dalc da.DataAvailabilityLayerClient) {
+		dalc.(*DataAvailabilityLayerClient).batchRetryAttempts = attempts
+	}
+}
+
+// Init initializes DataAvailabilityLayerClient instance.
+func (c *DataAvailabilityLayerClient) Init(config []byte, pubsubServer *pubsub.Server, kvStore store.KVStore, logger log.Logger, options ...da.Option) error {
+	c.logger = logger
+
+	if len(config) > 0 {
+		err := json.Unmarshal(config, &c.config)
+		if err != nil {
+			return err
+		}
+	}
+
+	// Set defaults
+	c.pubsubServer = pubsubServer
+	c.txInclusionTimeout = defaultTxInculsionTimeout
+	c.batchRetryDelay = defaultBatchRetryDelay
+	c.batchRetryAttempts = defaultBatchRetryAttempts
+
+	// Apply options
+	for _, apply := range options {
+		apply(c)
+	}
+
+	// If client wasn't set, create a new one
+	if c.client == nil {
+		substrateApiClient, err := gsrpc.NewSubstrateAPI(c.config.ApiURL)
+		if err != nil {
+			return err
+		}
+		c.client = SubstrateApi{
+			Chain:  substrateApiClient.RPC.Chain,
+			State:  substrateApiClient.RPC.State,
+			Author: substrateApiClient.RPC.Author,
+		}
+	}
+
+	c.ctx, c.cancel = context.WithCancel(context.Background())
+
+	return nil
+}
+
+// Start starts DataAvailabilityLayerClient instance.
+func (c *DataAvailabilityLayerClient) Start() error {
+	return nil
+}
+
+// Stop stops DataAvailabilityLayerClient instance.
+func (c *DataAvailabilityLayerClient) Stop() error {
+	c.cancel()
+	return nil
+}
+
+// GetClientType returns client type.
+func (c *DataAvailabilityLayerClient) GetClientType() da.Client {
+	return da.Avail
+}
+
+// RetrieveBatch retrieves batch from DataAvailabilityLayerClient instance.
+func (c *DataAvailabilityLayerClient) RetrieveBatches(dataLayerHeight uint64) da.ResultRetrieveBatch {
+	blockHash, err := c.client.GetBlockHash(dataLayerHeight)
+	if err != nil {
+		return da.ResultRetrieveBatch{
+			BaseResult: da.BaseResult{
+				Code:    da.StatusError,
+				Message: err.Error(),
+			},
+		}
+	}
+	block, err := c.client.GetBlock(blockHash)
+	if err != nil {
+		return da.ResultRetrieveBatch{
+			BaseResult: da.BaseResult{
+				Code:    da.StatusError,
+				Message: err.Error(),
+			},
+		}
+
+	}
+	// Convert the data returned to batches
+	var batches []*types.Batch
+	for _, ext := range block.Block.Extrinsics {
+		// these values below are specific indexes only for data submission, differs with each extrinsic
+		if ext.Signature.AppID.Int64() == c.config.AppID &&
+			ext.Method.CallIndex.SectionIndex == DataCallSectionIndex &&
+			ext.Method.CallIndex.MethodIndex == DataCallMethodIndex {
+			data := ext.Method.Args
+			for len(data) > 0 {
+				var pbBatch pb.Batch
+				// Attempt to unmarshal the data.
+				err := proto.Unmarshal(data, &pbBatch)
+				if err != nil {
+					c.logger.Error("failed to unmarshal batch", "daHeight", dataLayerHeight, "error", err)
+					continue
+				}
+				// Convert the proto batch to a batch
+				batch := &types.Batch{}
+				err = batch.FromProto(&pbBatch)
+				if err != nil {
+					c.logger.Error("failed to convert batch", "daHeight", dataLayerHeight, "error", err)
+					continue
+				}
+				// Add the batch to the list
+				batches = append(batches, batch)
+				// Remove the bytes we just decoded.
+				data = data[proto.Size(&pbBatch):]
+
+			}
+		}
+	}
+
+	return da.ResultRetrieveBatch{
+		BaseResult: da.BaseResult{
+			Code:     da.StatusSuccess,
+			DAHeight: dataLayerHeight,
+		},
+		Batches: batches,
+	}
+}
+
+// SubmitBatch submits batch to DataAvailabilityLayerClient instance.
+func (c *DataAvailabilityLayerClient) SubmitBatch(batch *types.Batch) da.ResultSubmitBatch {
+	blob, err := batch.MarshalBinary()
+	if err != nil {
+		return da.ResultSubmitBatch{
+			BaseResult: da.BaseResult{
+				Code:    da.StatusError,
+				Message: err.Error(),
+			},
+		}
+	}
+
+	c.logger.Debug("Submitting to da blob with size", "size", len(blob))
+	return c.submitBatchLoop(blob)
+
+}
+
+// submitBatchLoop tries submitting the batch. In case we get a configuration error we would like to stop trying,
+// otherwise, for network error we keep trying indefinitely.
+func (c *DataAvailabilityLayerClient) submitBatchLoop(dataBlob []byte) da.ResultSubmitBatch {
+	for {
+		select {
+		case <-c.ctx.Done():
+			return da.ResultSubmitBatch{
+				BaseResult: da.BaseResult{
+					Code:    da.StatusError,
+					Message: "context done",
+				},
+			}
+		default:
+			var daBlockHeight uint64
+			err := retry.Do(func() error {
+				var err error
+				daBlockHeight, err = c.broadcastTx(dataBlob)
+				if err != nil {
+					c.logger.Error("Error broadcasting transaction", "error", err)
+					return err
+				}
+				return nil
+			}, retry.Context(c.ctx), retry.LastErrorOnly(true), retry.Delay(c.batchRetryDelay),
+				retry.DelayType(retry.FixedDelay), retry.Attempts(c.batchRetryAttempts))
+			if err != nil {
+				if err == da.ErrTxBroadcastConfigError {
+					return da.ResultSubmitBatch{
+						BaseResult: da.BaseResult{
+							Code:    da.StatusError,
+							Message: err.Error(),
+						},
+					}
+				} else {
+					c.logger.Error("Error broadcasting transaction. Trying again..", "error", err)
+					continue
+				}
+			} else {
+				return da.ResultSubmitBatch{
+					BaseResult: da.BaseResult{
+						Code:     da.StatusSuccess,
+						Message:  "success",
+						DAHeight: daBlockHeight,
+					},
+				}
+			}
+
+		}
+	}
+
+}
+
+// broadcastTx broadcasts the transaction to the network and in case of success
+// returns the block height the batch was included in.
+func (c *DataAvailabilityLayerClient) broadcastTx(tx []byte) (uint64, error) {
+	meta, err := c.client.GetMetadataLatest()
+	if err != nil {
+		return 0, fmt.Errorf("%w: %s", da.ErrTxBroadcastNetworkError, err)
+	}
+	newCall, err := availtypes.NewCall(meta, DataCallSection+"."+DataCallMethod, availtypes.NewBytes(tx))
+	if err != nil {
+		return 0, fmt.Errorf("%w: %s", da.ErrTxBroadcastConfigError, err)
+	}
+	// Create the extrinsic
+	ext := availtypes.NewExtrinsic(newCall)
+	genesisHash, err := c.client.GetBlockHash(0)
+	if err != nil {
+		return 0, fmt.Errorf("%w: %s", da.ErrTxBroadcastNetworkError, err)
+	}
+	rv, err := c.client.GetRuntimeVersionLatest()
+	if err != nil {
+		return 0, fmt.Errorf("%w: %s", da.ErrTxBroadcastNetworkError, err)
+	}
+	keyringPair, err := signature.KeyringPairFromSecret(c.config.Seed, keyringNetworkID)
+	if err != nil {
+		return 0, fmt.Errorf("%w: %s", da.ErrTxBroadcastConfigError, err)
+	}
+	// Get the account info for the nonce
+	key, err := availtypes.CreateStorageKey(meta, "System", "Account", keyringPair.PublicKey)
+	if err != nil {
+		return 0, fmt.Errorf("%w: %s", da.ErrTxBroadcastConfigError, err)
+	}
+
+	var accountInfo availtypes.AccountInfo
+	ok, err := c.client.GetStorageLatest(key, &accountInfo)
+	if err != nil || !ok {
+		return 0, fmt.Errorf("%w: %s", da.ErrTxBroadcastNetworkError, err)
+	}
+
+	nonce := uint32(accountInfo.Nonce)
+	options := availtypes.SignatureOptions{
+		BlockHash:          genesisHash,
+		Era:                availtypes.ExtrinsicEra{IsMortalEra: false},
+		GenesisHash:        genesisHash,
+		Nonce:              availtypes.NewUCompactFromUInt(uint64(nonce)),
+		SpecVersion:        rv.SpecVersion,
+		Tip:                availtypes.NewUCompactFromUInt(c.config.Tip),
+		TransactionVersion: rv.TransactionVersion,
+		AppID:              availtypes.NewUCompactFromUInt(uint64(c.config.AppID)),
+	}
+
+	// Sign the transaction using Alice's default account
+	err = ext.Sign(keyringPair, options)
+	if err != nil {
+		return 0, fmt.Errorf("%w: %s", da.ErrTxBroadcastConfigError, err)
+	}
+
+	// Send the extrinsic
+	sub, err := c.client.SubmitAndWatchExtrinsic(ext)
+	if err != nil {
+		return 0, fmt.Errorf("%w: %s", da.ErrTxBroadcastNetworkError, err)
+	}
+
+	c.logger.Info("Submitted data to avail. Waiting for inclusion event")
+
+	defer sub.Unsubscribe()
+	timeout := time.After(c.txInclusionTimeout * time.Second)
+	for {
+		select {
+		case status := <-sub.Chan():
+			if status.IsInBlock {
+				c.logger.Info("Txn inside block %v\n", status.AsInBlock.Hex())
+			} else if status.IsFinalized {
+				c.logger.Info("Txn inside finalized block\n")
+				hash := status.AsFinalized
+				blockHeight, err := c.getHeightFromHash(hash)
+				if err != nil {
+					return 0, fmt.Errorf("%w: %s", da.ErrTxBroadcastNetworkError, err)
+				}
+				return blockHeight, nil
+			}
+		case <-timeout:
+			return 0, fmt.Errorf("%w: %s", da.ErrTxBroadcastTimeout, err)
+		}
+	}
+}
+
+// CheckBatchAvailability checks batch availability in DataAvailabilityLayerClient instance.
+func (c *DataAvailabilityLayerClient) CheckBatchAvailability(dataLayerHeight uint64) da.ResultCheckBatch {
+	return da.ResultCheckBatch{
+		BaseResult: da.BaseResult{
+			Code:    da.StatusError,
+			Message: "not implemented",
+		},
+	}
+}
+
+// getHeightFromHash returns the block height from the block hash
+func (c *DataAvailabilityLayerClient) getHeightFromHash(hash availtypes.Hash) (uint64, error) {
+	block, err := c.client.GetBlock(hash)
+	if err != nil {
+		return 0, fmt.Errorf("cannot get block by hash:%w", err)
+	}
+	return uint64(block.Block.Header.Number), nil
+}
diff --git a/da/avail/avail_test.go b/da/avail/avail_test.go
new file mode 100644
index 000000000..1b737bc1c
--- /dev/null
+++ b/da/avail/avail_test.go
@@ -0,0 +1,183 @@
+package avail_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	availtypes "github.com/centrifuge/go-substrate-rpc-client/v4/types"
+	"github.com/dymensionxyz/dymint/da"
+	"github.com/dymensionxyz/dymint/da/avail"
+	"github.com/dymensionxyz/dymint/log/test"
+	mocks "github.com/dymensionxyz/dymint/mocks/da/avail"
+	"github.com/dymensionxyz/dymint/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+	"github.com/tendermint/tendermint/libs/pubsub"
+)
+
+const (
+	seed = "copper mother insect grunt blue cute tell side welcome domain border oxygen"
+)
+
+//FIXME(omritoptix): This test is currently not working as I couldn't find a way to mock the SubmitAndWatchExtrinsic function.
+// func TestSubmitBatch(t *testing.T) {
+// 	assert := assert.New(t)
+// 	require := require.New(t)
+// 	configBytes, err := json.Marshal(avail.Config{
+// 		Seed: seed,
+// 	})
+// 	require.NoError(err)
+// 	// Create mock clients
+// 	mockSubstrateApiClient := mocks.NewSubstrateApiI(t)
+// 	// Configure DALC options
+// 	options := []da.Option{
+// 		avail.WithClient(mockSubstrateApiClient),
+// 		avail.WithBatchRetryAttempts(1),
+// 		avail.WithBatchRetryDelay(1 * time.Second),
+// 		avail.WithTxInclusionTimeout(1 * time.Second),
+// 	}
+// 	// Subscribe to the health status event
+// 	pubsubServer := pubsub.NewServer()
+// 	pubsubServer.Start()
+// 	// HealthSubscription, err := pubsubServer.Subscribe(context.Background(), "testSubmitBatch", da.EventQueryDAHealthStatus)
+// 	assert.NoError(err)
+// 	// Start the DALC
+// 	dalc := avail.DataAvailabilityLayerClient{}
+// 	err = dalc.Init(configBytes, pubsubServer, nil, test.NewLogger(t), options...)
+// 	require.NoError(err)
+// 	err = dalc.Start()
+// 	require.NoError(err)
+// 	// Set the mock functions
+// 	metadata := availtypes.NewMetadataV14()
+// 	metadata.AsMetadataV14 = availtypes.MetadataV14{
+// 		Pallets: []availtypes.PalletMetadataV14{
+// 			{
+// 				Name:     "DataAvailability",
+// 				HasCalls: true,
+// 			},
+// 			{
+// 				Name:       "System",
+// 				HasStorage: true,
+// 				Storage: availtypes.StorageMetadataV14{
+// 					Prefix: "System",
+// 					Items: []availtypes.StorageEntryMetadataV14{
+// 						{
+// 							Name: "Account",
+// 							Type: availtypes.StorageEntryTypeV14{
+// 								IsPlainType: true,
+// 								IsMap:       true,
+// 								AsMap: availtypes.MapTypeV14{
+// 									Hashers: []availtypes.StorageHasherV10{
+// 										{
+// 											IsIdentity: true,
+// 										},
+// 									},
+// 								},
+// 							},
+// 						},
+// 					},
+// 				},
+// 			},
+// 		},
+// 		EfficientLookup: map[int64]*availtypes.Si1Type{
+// 			0: {
+// 				Def: availtypes.Si1TypeDef{
+// 					Variant: availtypes.Si1TypeDefVariant{
+// 						Variants: []availtypes.Si1Variant{
+// 							{
+// 								Name: "submit_data",
+// 							},
+// 						},
+// 					},
+// 				},
+// 			},
+// 		},
+// 	}
+
+// 	mockSubstrateApiClient.On("GetMetadataLatest").Return(metadata, nil)
+// 	mockSubstrateApiClient.On("GetBlockHash", mock.Anything).Return(availtypes.NewHash([]byte("123")), nil)
+// 	mockSubstrateApiClient.On("GetRuntimeVersionLatest").Return(availtypes.NewRuntimeVersion(), nil)
+// 	mockSubstrateApiClient.On("GetStorageLatest", mock.Anything, mock.Anything).Return(true, nil)
+// 	mockSubstrateApiClient.On("SubmitAndWatchExtrinsic", mock.Anything).Return(nil, nil)
+// batch := &types.Batch{
+// 	StartHeight: 0,
+// 	EndHeight:   1,
+// }
+// res := dalc.SubmitBatch(batch)
+// assert.Equal(res.Code, da.StatusSuccess)
+
+// }
+
+// TestRetriveBatches tests the RetrieveBatches function manages
+// to decode the batches from the block extrinsics and only returns
+// the batches relevant for our app id and method index.
+func TestRetriveBatches(t *testing.T) {
+	assert := assert.New(t)
+	require := require.New(t)
+	const appId = 123
+	// Setup the config
+	configBytes, err := json.Marshal(avail.Config{
+		Seed:  seed,
+		AppID: int64(appId),
+	})
+	require.NoError(err)
+	// Create mock client
+	mockSubstrateApiClient := mocks.NewSubstrateApiI(t)
+	// Configure DALC options
+	options := []da.Option{
+		avail.WithClient(mockSubstrateApiClient),
+	}
+	pubsubServer := pubsub.NewServer()
+	pubsubServer.Start()
+	assert.NoError(err)
+	// Start the DALC
+	dalc := avail.DataAvailabilityLayerClient{}
+	err = dalc.Init(configBytes, pubsubServer, nil, test.NewLogger(t), options...)
+	require.NoError(err)
+	err = dalc.Start()
+	require.NoError(err)
+	// Set the mock functions
+	mockSubstrateApiClient.On("GetBlockHash", mock.Anything).Return(availtypes.NewHash([]byte("123")), nil)
+	// Build batches for the block extrinsics
+	batch1 := types.Batch{StartHeight: 0, EndHeight: 1}
+	batch2 := types.Batch{StartHeight: 2, EndHeight: 3}
+	batch1bytes, err := batch1.MarshalBinary()
+	require.NoError(err)
+	batch2bytes, err := batch2.MarshalBinary()
+	require.NoError(err)
+	// Build the signed block
+	signedBlock := &availtypes.SignedBlock{
+		Block: availtypes.Block{
+			Extrinsics: []availtypes.Extrinsic{
+				{
+					Method: availtypes.Call{
+						Args: availtypes.Args(batch1bytes),
+						CallIndex: availtypes.CallIndex{
+							MethodIndex:  avail.DataCallMethodIndex,
+							SectionIndex: avail.DataCallSectionIndex,
+						},
+					},
+					Signature: availtypes.ExtrinsicSignatureV4{
+						AppID: availtypes.NewUCompactFromUInt(uint64(appId)),
+					},
+				},
+				{
+					Method: availtypes.Call{
+						Args: availtypes.Args(batch2bytes),
+						CallIndex: availtypes.CallIndex{
+							MethodIndex:  avail.DataCallMethodIndex,
+							SectionIndex: avail.DataCallMethodIndex,
+						},
+					},
+				},
+			},
+		},
+	}
+	mockSubstrateApiClient.On("GetBlock", mock.Anything).Return(signedBlock, nil)
+	// Retrieve the batches and make sure we only get the batches relevant for our app id
+	batchResult := dalc.RetrieveBatches(1)
+	assert.Equal(1, len(batchResult.Batches))
+	assert.Equal(batch1.StartHeight, batchResult.Batches[0].StartHeight)
+
+}
diff --git a/da/da.go b/da/da.go
index f446d8210..2af675c27 100644
--- a/da/da.go
+++ b/da/da.go
@@ -28,6 +28,7 @@ type Client string
 const (
 	Mock     Client = "mock"
 	Celestia Client = "celestia"
+	Avail    Client = "avail"
 )
 
 // Option is a function that sets a parameter on the da layer.
diff --git a/da/errors.go b/da/errors.go
new file mode 100644
index 000000000..28633212d
--- /dev/null
+++ b/da/errors.go
@@ -0,0 +1,12 @@
+package da
+
+import "errors"
+
+var (
+	// ErrFailedTxBuild is returned when transaction build fails.
+	ErrTxBroadcastConfigError = errors.New("Failed building tx")
+	// ErrFailedTxBroadcast is returned when transaction broadcast fails.
+	ErrTxBroadcastNetworkError = errors.New("Failed broadcasting tx")
+	// ErrTxBroadcastTimeout is returned when transaction broadcast times out.
+	ErrTxBroadcastTimeout = errors.New("Broadcast timeout error")
+)
diff --git a/go.mod b/go.mod
index 45169205c..31042fb5e 100644
--- a/go.mod
+++ b/go.mod
@@ -6,6 +6,7 @@ require (
 	code.cloudfoundry.org/go-diodes v0.0.0-20220725190411-383eb6634c40
 	github.com/avast/retry-go v3.0.0+incompatible
 	github.com/celestiaorg/go-cnc v0.2.0
+	github.com/centrifuge/go-substrate-rpc-client/v4 v4.0.12
 	github.com/dgraph-io/badger/v3 v3.2103.3
 	github.com/dymensionxyz/cosmosclient v0.3.0-beta.0.20230514120937-449e9becd080
 	github.com/dymensionxyz/dymension v0.2.0-beta.0.20230607115558-745644a96ea6
@@ -50,19 +51,26 @@ require (
 	github.com/cosmos/cosmos-proto v1.0.0-beta.2 // indirect
 	github.com/cosmos/gogoproto v1.4.3 // indirect
 	github.com/creachadair/taskgroup v0.3.2 // indirect
+	github.com/deckarep/golang-set v1.8.0 // indirect
+	github.com/decred/base58 v1.0.4 // indirect
+	github.com/decred/dcrd/crypto/blake256 v1.0.0 // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 // indirect
 	github.com/ethereum/go-ethereum v1.10.26 // indirect
 	github.com/evmos/ethermint v0.20.0 // indirect
 	github.com/ghodss/yaml v1.0.0 // indirect
+	github.com/go-stack/stack v1.8.1 // indirect
 	github.com/lib/pq v1.10.7 // indirect
 	github.com/minio/highwayhash v1.0.2 // indirect
+	github.com/pierrec/xxHash v0.1.5 // indirect
 	github.com/satori/go.uuid v1.2.0 // indirect
 	github.com/sirupsen/logrus v1.9.0 // indirect
 	github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c // indirect
 	github.com/tidwall/btree v1.5.0 // indirect
 	github.com/tyler-smith/go-bip39 v1.1.0 // indirect
+	github.com/vedhavyas/go-subkey v1.0.3 // indirect
 	github.com/zondax/ledger-go v0.14.1 // indirect
 	golang.org/x/exp v0.0.0-20230310171629-522b1b587ee0 // indirect
+	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect
 	sigs.k8s.io/yaml v1.3.0 // indirect
 )
 
@@ -178,7 +186,7 @@ require (
 	github.com/miekg/dns v1.1.48 // indirect
 	github.com/mikioh/tcpinfo v0.0.0-20190314235526-30a79bb1804b // indirect
 	github.com/mikioh/tcpopt v0.0.0-20190314235656-172688c1accc // indirect
-	github.com/mimoo/StrobeGo v0.0.0-20210601165009-122bf33a46e0 // indirect
+	github.com/mimoo/StrobeGo v0.0.0-20220103164710-9a04d6ca976b // indirect
 	github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 // indirect
 	github.com/minio/sha256-simd v1.0.0 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
@@ -257,6 +265,7 @@ require (
 
 replace (
 	github.com/celestiaorg/go-cnc => github.com/dymensionxyz/go-cnc v0.2.2
+	github.com/centrifuge/go-substrate-rpc-client/v4 => github.com/availproject/go-substrate-rpc-client/v4 v4.0.12-avail-1.4.0-rc1-5e286e3
 	github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.2-alpha.regen.4
 	github.com/gorilla/rpc => github.com/dymensionxyz/rpc v1.3.1
 	github.com/tendermint/tendermint => github.com/cometbft/cometbft v0.34.28
diff --git a/go.sum b/go.sum
index 8035577e6..5803a844e 100644
--- a/go.sum
+++ b/go.sum
@@ -100,6 +100,8 @@ github.com/armon/go-metrics v0.4.1 h1:hR91U9KYmb6bLBYLQjyM+3j+rcd/UhE+G78SFnF8gJ
 github.com/armon/go-metrics v0.4.1/go.mod h1:E6amYzXo6aW1tqzoZGT755KkbgrJsSdpwZ+3JqfkOG4=
 github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
 github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6lCRdSC2Tm3DSWRPvIPr6xNKyeHdqDQSQT+A=
+github.com/availproject/go-substrate-rpc-client/v4 v4.0.12-avail-1.4.0-rc1-5e286e3 h1:9bPK0/Vd+uOQul3vEBSemRXO+rwqi+UXDAvFzNUlG8A=
+github.com/availproject/go-substrate-rpc-client/v4 v4.0.12-avail-1.4.0-rc1-5e286e3/go.mod h1:5g1oM4Zu3BOaLpsKQ+O8PAv2kNuq+kPcA1VzFbsSqxE=
 github.com/avast/retry-go v3.0.0+incompatible h1:4SOWQ7Qs+oroOTQOYnAHqelpCO0biHSxpiH9JdtuBj0=
 github.com/avast/retry-go v3.0.0+incompatible/go.mod h1:XtSnn+n/sHqQIpZ10K1qAevBhOOCWBLXXy3hyiqqBrY=
 github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU=
@@ -231,7 +233,11 @@ github.com/davidlazar/go-crypto v0.0.0-20170701192655-dcfb0a7ac018/go.mod h1:rQY
 github.com/davidlazar/go-crypto v0.0.0-20200604182044-b73af7476f6c h1:pFUpOrbxDR6AkioZ1ySsx5yxlDQZ8stG2b88gTPxgJU=
 github.com/davidlazar/go-crypto v0.0.0-20200604182044-b73af7476f6c/go.mod h1:6UhI8N9EjYm1c2odKpFpAYeR8dsBeM7PtzQhRgxRr9U=
 github.com/deckarep/golang-set v1.8.0 h1:sk9/l/KqpunDwP7pSjUg0keiOOLEnOBHzykLrsPppp4=
+github.com/deckarep/golang-set v1.8.0/go.mod h1:5nI87KwE7wgsBU1F4GKAw2Qod7p5kyS383rP6+o6qqo=
+github.com/decred/base58 v1.0.4 h1:QJC6B0E0rXOPA8U/kw2rP+qiRJsUaE2Er+pYb3siUeA=
+github.com/decred/base58 v1.0.4/go.mod h1:jJswKPEdvpFpvf7dsDvFZyLT22xZ9lWqEByX38oGd9E=
 github.com/decred/dcrd/crypto/blake256 v1.0.0 h1:/8DMNYp9SGi5f0w7uCm6d6M4OU2rGFK09Y2A4Xv7EE0=
+github.com/decred/dcrd/crypto/blake256 v1.0.0/go.mod h1:sQl2p6Y26YV+ZOcSTP6thNdn47hh8kt6rqSlvmrXFAc=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 h1:HbphB4TFFXpv7MNrT52FGrrgVXF1owhMVTHFZIlnvd4=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0/go.mod h1:DZGJHZMqrU4JJqFAWUS2UO1+lbSKsdiOoYi9Zzey7Fc=
 github.com/decred/dcrd/lru v1.0.0/go.mod h1:mxKOwFd7lFjN2GZYsiz/ecgqR6kkYAl+0pz0tEMk218=
@@ -342,8 +348,9 @@ github.com/go-resty/resty/v2 v2.7.0 h1:me+K9p3uhSmXtrBZ4k9jcEAfJmuC8IivWHwaLZwPr
 github.com/go-resty/resty/v2 v2.7.0/go.mod h1:9PWDzw47qPphMRFfhsyk0NnSgvluHcljSMVIq3w7q0I=
 github.com/go-sourcemap/sourcemap v2.1.3+incompatible h1:W1iEw64niKVGogNgBN3ePyLFfuisuzeidWPMPWmECqU=
 github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
-github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw=
+github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0 h1:p104kn46Q8WdvHunIJ9dAyjPVtrBPhSr3KT2yUst43I=
 github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg7847qk6SyHyPtNmDHnmrv/HOrqktSC+C9fM+CJOE=
 github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 h1:ZpnhV/YsD2/4cESfV5+Hoeu/iUR3ruzNvZ+yQfO03a0=
@@ -870,8 +877,8 @@ github.com/mikioh/tcpinfo v0.0.0-20190314235526-30a79bb1804b/go.mod h1:lxPUiZwKo
 github.com/mikioh/tcpopt v0.0.0-20190314235656-172688c1accc h1:PTfri+PuQmWDqERdnNMiD9ZejrlswWrCpBEZgWOiTrc=
 github.com/mikioh/tcpopt v0.0.0-20190314235656-172688c1accc/go.mod h1:cGKTAVKx4SxOuR/czcZ/E2RSJ3sfHs8FpHhQ5CWMf9s=
 github.com/mimoo/StrobeGo v0.0.0-20181016162300-f8f6d4d2b643/go.mod h1:43+3pMjjKimDBf5Kr4ZFNGbLql1zKkbImw+fZbw3geM=
-github.com/mimoo/StrobeGo v0.0.0-20210601165009-122bf33a46e0 h1:QRUSJEgZn2Snx0EmT/QLXibWjSUDjKWvXIT19NBVp94=
-github.com/mimoo/StrobeGo v0.0.0-20210601165009-122bf33a46e0/go.mod h1:43+3pMjjKimDBf5Kr4ZFNGbLql1zKkbImw+fZbw3geM=
+github.com/mimoo/StrobeGo v0.0.0-20220103164710-9a04d6ca976b h1:QrHweqAtyJ9EwCaGHBu1fghwxIPiopAHV06JlXrMHjk=
+github.com/mimoo/StrobeGo v0.0.0-20220103164710-9a04d6ca976b/go.mod h1:xxLb2ip6sSUts3g1irPVHyk/DGslwQsNOo9I7smJfNU=
 github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 h1:lYpkrQH5ajf0OXOcUbGjvZxxijuBwbbmlSxLiuofa+g=
 github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ=
 github.com/minio/highwayhash v1.0.2 h1:Aak5U0nElisjDCfPSG79Tgzkn2gl66NxOMspRrKnA/g=
@@ -1035,6 +1042,8 @@ github.com/petermattis/goid v0.0.0-20230317030725-371a4b8eda08/go.mod h1:pxMtw7c
 github.com/philhofer/fwd v1.1.1/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU=
 github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc=
 github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
+github.com/pierrec/xxHash v0.1.5 h1:n/jBpwTHiER4xYvK3/CdPVnLDPchj8eTJFFLUb4QHBo=
+github.com/pierrec/xxHash v0.1.5/go.mod h1:w2waW5Zoa/Wc4Yqe0wgrIYAGKqRMf7czn2HNKXmuL+I=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@@ -1238,6 +1247,8 @@ github.com/ulikunitz/xz v0.5.8 h1:ERv8V6GKqVi23rgu5cj9pVfVzJbOqAY2Ntl88O6c2nQ=
 github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
 github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
 github.com/urfave/cli v1.22.2/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
+github.com/vedhavyas/go-subkey v1.0.3 h1:iKR33BB/akKmcR2PMlXPBeeODjWLM90EL98OrOGs8CA=
+github.com/vedhavyas/go-subkey v1.0.3/go.mod h1:CloUaFQSSTdWnINfBRFjVMkWXZANW+nd8+TI5jYcl6Y=
 github.com/viant/assertly v0.4.8/go.mod h1:aGifi++jvCrUaklKEKT0BU95igDNaqkvz+49uaYMPRU=
 github.com/viant/toolbox v0.24.0/go.mod h1:OxMCG57V0PXuIP2HNQrtJf2CjqdmbrOx5EkMILuUhzM=
 github.com/wangjia184/sortedset v0.0.0-20160527075905-f5d03557ba30/go.mod h1:YkocrP2K2tcw938x9gCOmT5G5eCD6jsTz0SZuyAqwIE=
@@ -1799,6 +1810,7 @@ gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
 gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
 gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce h1:+JknDZhAj8YMt7GC73Ei8pv4MzjDUNPHgQWJdtMAaDU=
+gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce/go.mod h1:5AcXVHNjg+BDxry382+8OKon8SEWiKktQR07RKPsv1c=
 gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
 gopkg.in/src-d/go-cli.v0 v0.0.0-20181105080154-d492247bbc0d/go.mod h1:z+K8VcOYVYcSwSjGebuDL6176A1XskgbtNl64NSg+n8=
 gopkg.in/src-d/go-log.v1 v1.0.1/go.mod h1:GN34hKP0g305ysm2/hctJ0Y8nWP3zxXXJ8GFabTyABE=
diff --git a/mocks/da/avail/SubstrateApiI.go b/mocks/da/avail/SubstrateApiI.go
new file mode 100644
index 000000000..ee98d165e
--- /dev/null
+++ b/mocks/da/avail/SubstrateApiI.go
@@ -0,0 +1,985 @@
+// Code generated by mockery v2.15.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	author "github.com/centrifuge/go-substrate-rpc-client/v4/rpc/author"
+
+	chain "github.com/centrifuge/go-substrate-rpc-client/v4/rpc/chain"
+
+	mock "github.com/stretchr/testify/mock"
+
+	state "github.com/centrifuge/go-substrate-rpc-client/v4/rpc/state"
+
+	types "github.com/centrifuge/go-substrate-rpc-client/v4/types"
+)
+
+// SubstrateApiI is an autogenerated mock type for the SubstrateApiI type
+type SubstrateApiI struct {
+	mock.Mock
+}
+
+// GetBlock provides a mock function with given fields: blockHash
+func (_m *SubstrateApiI) GetBlock(blockHash types.Hash) (*types.SignedBlock, error) {
+	ret := _m.Called(blockHash)
+
+	var r0 *types.SignedBlock
+	if rf, ok := ret.Get(0).(func(types.Hash) *types.SignedBlock); ok {
+		r0 = rf(blockHash)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.SignedBlock)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.Hash) error); ok {
+		r1 = rf(blockHash)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetBlockHash provides a mock function with given fields: blockNumber
+func (_m *SubstrateApiI) GetBlockHash(blockNumber uint64) (types.Hash, error) {
+	ret := _m.Called(blockNumber)
+
+	var r0 types.Hash
+	if rf, ok := ret.Get(0).(func(uint64) types.Hash); ok {
+		r0 = rf(blockNumber)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(types.Hash)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(uint64) error); ok {
+		r1 = rf(blockNumber)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetBlockHashLatest provides a mock function with given fields:
+func (_m *SubstrateApiI) GetBlockHashLatest() (types.Hash, error) {
+	ret := _m.Called()
+
+	var r0 types.Hash
+	if rf, ok := ret.Get(0).(func() types.Hash); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(types.Hash)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetBlockLatest provides a mock function with given fields:
+func (_m *SubstrateApiI) GetBlockLatest() (*types.SignedBlock, error) {
+	ret := _m.Called()
+
+	var r0 *types.SignedBlock
+	if rf, ok := ret.Get(0).(func() *types.SignedBlock); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.SignedBlock)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChildKeys provides a mock function with given fields: childStorageKey, prefix, blockHash
+func (_m *SubstrateApiI) GetChildKeys(childStorageKey types.StorageKey, prefix types.StorageKey, blockHash types.Hash) ([]types.StorageKey, error) {
+	ret := _m.Called(childStorageKey, prefix, blockHash)
+
+	var r0 []types.StorageKey
+	if rf, ok := ret.Get(0).(func(types.StorageKey, types.StorageKey, types.Hash) []types.StorageKey); ok {
+		r0 = rf(childStorageKey, prefix, blockHash)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]types.StorageKey)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, types.StorageKey, types.Hash) error); ok {
+		r1 = rf(childStorageKey, prefix, blockHash)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChildKeysLatest provides a mock function with given fields: childStorageKey, prefix
+func (_m *SubstrateApiI) GetChildKeysLatest(childStorageKey types.StorageKey, prefix types.StorageKey) ([]types.StorageKey, error) {
+	ret := _m.Called(childStorageKey, prefix)
+
+	var r0 []types.StorageKey
+	if rf, ok := ret.Get(0).(func(types.StorageKey, types.StorageKey) []types.StorageKey); ok {
+		r0 = rf(childStorageKey, prefix)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]types.StorageKey)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, types.StorageKey) error); ok {
+		r1 = rf(childStorageKey, prefix)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChildStorage provides a mock function with given fields: childStorageKey, key, target, blockHash
+func (_m *SubstrateApiI) GetChildStorage(childStorageKey types.StorageKey, key types.StorageKey, target interface{}, blockHash types.Hash) (bool, error) {
+	ret := _m.Called(childStorageKey, key, target, blockHash)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(types.StorageKey, types.StorageKey, interface{}, types.Hash) bool); ok {
+		r0 = rf(childStorageKey, key, target, blockHash)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, types.StorageKey, interface{}, types.Hash) error); ok {
+		r1 = rf(childStorageKey, key, target, blockHash)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChildStorageHash provides a mock function with given fields: childStorageKey, key, blockHash
+func (_m *SubstrateApiI) GetChildStorageHash(childStorageKey types.StorageKey, key types.StorageKey, blockHash types.Hash) (types.Hash, error) {
+	ret := _m.Called(childStorageKey, key, blockHash)
+
+	var r0 types.Hash
+	if rf, ok := ret.Get(0).(func(types.StorageKey, types.StorageKey, types.Hash) types.Hash); ok {
+		r0 = rf(childStorageKey, key, blockHash)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(types.Hash)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, types.StorageKey, types.Hash) error); ok {
+		r1 = rf(childStorageKey, key, blockHash)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChildStorageHashLatest provides a mock function with given fields: childStorageKey, key
+func (_m *SubstrateApiI) GetChildStorageHashLatest(childStorageKey types.StorageKey, key types.StorageKey) (types.Hash, error) {
+	ret := _m.Called(childStorageKey, key)
+
+	var r0 types.Hash
+	if rf, ok := ret.Get(0).(func(types.StorageKey, types.StorageKey) types.Hash); ok {
+		r0 = rf(childStorageKey, key)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(types.Hash)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, types.StorageKey) error); ok {
+		r1 = rf(childStorageKey, key)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChildStorageLatest provides a mock function with given fields: childStorageKey, key, target
+func (_m *SubstrateApiI) GetChildStorageLatest(childStorageKey types.StorageKey, key types.StorageKey, target interface{}) (bool, error) {
+	ret := _m.Called(childStorageKey, key, target)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(types.StorageKey, types.StorageKey, interface{}) bool); ok {
+		r0 = rf(childStorageKey, key, target)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, types.StorageKey, interface{}) error); ok {
+		r1 = rf(childStorageKey, key, target)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChildStorageRaw provides a mock function with given fields: childStorageKey, key, blockHash
+func (_m *SubstrateApiI) GetChildStorageRaw(childStorageKey types.StorageKey, key types.StorageKey, blockHash types.Hash) (*types.StorageDataRaw, error) {
+	ret := _m.Called(childStorageKey, key, blockHash)
+
+	var r0 *types.StorageDataRaw
+	if rf, ok := ret.Get(0).(func(types.StorageKey, types.StorageKey, types.Hash) *types.StorageDataRaw); ok {
+		r0 = rf(childStorageKey, key, blockHash)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.StorageDataRaw)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, types.StorageKey, types.Hash) error); ok {
+		r1 = rf(childStorageKey, key, blockHash)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChildStorageRawLatest provides a mock function with given fields: childStorageKey, key
+func (_m *SubstrateApiI) GetChildStorageRawLatest(childStorageKey types.StorageKey, key types.StorageKey) (*types.StorageDataRaw, error) {
+	ret := _m.Called(childStorageKey, key)
+
+	var r0 *types.StorageDataRaw
+	if rf, ok := ret.Get(0).(func(types.StorageKey, types.StorageKey) *types.StorageDataRaw); ok {
+		r0 = rf(childStorageKey, key)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.StorageDataRaw)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, types.StorageKey) error); ok {
+		r1 = rf(childStorageKey, key)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChildStorageSize provides a mock function with given fields: childStorageKey, key, blockHash
+func (_m *SubstrateApiI) GetChildStorageSize(childStorageKey types.StorageKey, key types.StorageKey, blockHash types.Hash) (types.U64, error) {
+	ret := _m.Called(childStorageKey, key, blockHash)
+
+	var r0 types.U64
+	if rf, ok := ret.Get(0).(func(types.StorageKey, types.StorageKey, types.Hash) types.U64); ok {
+		r0 = rf(childStorageKey, key, blockHash)
+	} else {
+		r0 = ret.Get(0).(types.U64)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, types.StorageKey, types.Hash) error); ok {
+		r1 = rf(childStorageKey, key, blockHash)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetChildStorageSizeLatest provides a mock function with given fields: childStorageKey, key
+func (_m *SubstrateApiI) GetChildStorageSizeLatest(childStorageKey types.StorageKey, key types.StorageKey) (types.U64, error) {
+	ret := _m.Called(childStorageKey, key)
+
+	var r0 types.U64
+	if rf, ok := ret.Get(0).(func(types.StorageKey, types.StorageKey) types.U64); ok {
+		r0 = rf(childStorageKey, key)
+	} else {
+		r0 = ret.Get(0).(types.U64)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, types.StorageKey) error); ok {
+		r1 = rf(childStorageKey, key)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetFinalizedHead provides a mock function with given fields:
+func (_m *SubstrateApiI) GetFinalizedHead() (types.Hash, error) {
+	ret := _m.Called()
+
+	var r0 types.Hash
+	if rf, ok := ret.Get(0).(func() types.Hash); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(types.Hash)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetHeader provides a mock function with given fields: blockHash
+func (_m *SubstrateApiI) GetHeader(blockHash types.Hash) (*types.Header, error) {
+	ret := _m.Called(blockHash)
+
+	var r0 *types.Header
+	if rf, ok := ret.Get(0).(func(types.Hash) *types.Header); ok {
+		r0 = rf(blockHash)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.Header)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.Hash) error); ok {
+		r1 = rf(blockHash)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetHeaderLatest provides a mock function with given fields:
+func (_m *SubstrateApiI) GetHeaderLatest() (*types.Header, error) {
+	ret := _m.Called()
+
+	var r0 *types.Header
+	if rf, ok := ret.Get(0).(func() *types.Header); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.Header)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetKeys provides a mock function with given fields: prefix, blockHash
+func (_m *SubstrateApiI) GetKeys(prefix types.StorageKey, blockHash types.Hash) ([]types.StorageKey, error) {
+	ret := _m.Called(prefix, blockHash)
+
+	var r0 []types.StorageKey
+	if rf, ok := ret.Get(0).(func(types.StorageKey, types.Hash) []types.StorageKey); ok {
+		r0 = rf(prefix, blockHash)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]types.StorageKey)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, types.Hash) error); ok {
+		r1 = rf(prefix, blockHash)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetKeysLatest provides a mock function with given fields: prefix
+func (_m *SubstrateApiI) GetKeysLatest(prefix types.StorageKey) ([]types.StorageKey, error) {
+	ret := _m.Called(prefix)
+
+	var r0 []types.StorageKey
+	if rf, ok := ret.Get(0).(func(types.StorageKey) []types.StorageKey); ok {
+		r0 = rf(prefix)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]types.StorageKey)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey) error); ok {
+		r1 = rf(prefix)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetMetadata provides a mock function with given fields: blockHash
+func (_m *SubstrateApiI) GetMetadata(blockHash types.Hash) (*types.Metadata, error) {
+	ret := _m.Called(blockHash)
+
+	var r0 *types.Metadata
+	if rf, ok := ret.Get(0).(func(types.Hash) *types.Metadata); ok {
+		r0 = rf(blockHash)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.Metadata)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.Hash) error); ok {
+		r1 = rf(blockHash)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetMetadataLatest provides a mock function with given fields:
+func (_m *SubstrateApiI) GetMetadataLatest() (*types.Metadata, error) {
+	ret := _m.Called()
+
+	var r0 *types.Metadata
+	if rf, ok := ret.Get(0).(func() *types.Metadata); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.Metadata)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRuntimeVersion provides a mock function with given fields: blockHash
+func (_m *SubstrateApiI) GetRuntimeVersion(blockHash types.Hash) (*types.RuntimeVersion, error) {
+	ret := _m.Called(blockHash)
+
+	var r0 *types.RuntimeVersion
+	if rf, ok := ret.Get(0).(func(types.Hash) *types.RuntimeVersion); ok {
+		r0 = rf(blockHash)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.RuntimeVersion)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.Hash) error); ok {
+		r1 = rf(blockHash)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetRuntimeVersionLatest provides a mock function with given fields:
+func (_m *SubstrateApiI) GetRuntimeVersionLatest() (*types.RuntimeVersion, error) {
+	ret := _m.Called()
+
+	var r0 *types.RuntimeVersion
+	if rf, ok := ret.Get(0).(func() *types.RuntimeVersion); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.RuntimeVersion)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetStorage provides a mock function with given fields: key, target, blockHash
+func (_m *SubstrateApiI) GetStorage(key types.StorageKey, target interface{}, blockHash types.Hash) (bool, error) {
+	ret := _m.Called(key, target, blockHash)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(types.StorageKey, interface{}, types.Hash) bool); ok {
+		r0 = rf(key, target, blockHash)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, interface{}, types.Hash) error); ok {
+		r1 = rf(key, target, blockHash)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetStorageHash provides a mock function with given fields: key, blockHash
+func (_m *SubstrateApiI) GetStorageHash(key types.StorageKey, blockHash types.Hash) (types.Hash, error) {
+	ret := _m.Called(key, blockHash)
+
+	var r0 types.Hash
+	if rf, ok := ret.Get(0).(func(types.StorageKey, types.Hash) types.Hash); ok {
+		r0 = rf(key, blockHash)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(types.Hash)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, types.Hash) error); ok {
+		r1 = rf(key, blockHash)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetStorageHashLatest provides a mock function with given fields: key
+func (_m *SubstrateApiI) GetStorageHashLatest(key types.StorageKey) (types.Hash, error) {
+	ret := _m.Called(key)
+
+	var r0 types.Hash
+	if rf, ok := ret.Get(0).(func(types.StorageKey) types.Hash); ok {
+		r0 = rf(key)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(types.Hash)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey) error); ok {
+		r1 = rf(key)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetStorageLatest provides a mock function with given fields: key, target
+func (_m *SubstrateApiI) GetStorageLatest(key types.StorageKey, target interface{}) (bool, error) {
+	ret := _m.Called(key, target)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(types.StorageKey, interface{}) bool); ok {
+		r0 = rf(key, target)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, interface{}) error); ok {
+		r1 = rf(key, target)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetStorageRaw provides a mock function with given fields: key, blockHash
+func (_m *SubstrateApiI) GetStorageRaw(key types.StorageKey, blockHash types.Hash) (*types.StorageDataRaw, error) {
+	ret := _m.Called(key, blockHash)
+
+	var r0 *types.StorageDataRaw
+	if rf, ok := ret.Get(0).(func(types.StorageKey, types.Hash) *types.StorageDataRaw); ok {
+		r0 = rf(key, blockHash)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.StorageDataRaw)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, types.Hash) error); ok {
+		r1 = rf(key, blockHash)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetStorageRawLatest provides a mock function with given fields: key
+func (_m *SubstrateApiI) GetStorageRawLatest(key types.StorageKey) (*types.StorageDataRaw, error) {
+	ret := _m.Called(key)
+
+	var r0 *types.StorageDataRaw
+	if rf, ok := ret.Get(0).(func(types.StorageKey) *types.StorageDataRaw); ok {
+		r0 = rf(key)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.StorageDataRaw)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey) error); ok {
+		r1 = rf(key)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetStorageSize provides a mock function with given fields: key, blockHash
+func (_m *SubstrateApiI) GetStorageSize(key types.StorageKey, blockHash types.Hash) (types.U64, error) {
+	ret := _m.Called(key, blockHash)
+
+	var r0 types.U64
+	if rf, ok := ret.Get(0).(func(types.StorageKey, types.Hash) types.U64); ok {
+		r0 = rf(key, blockHash)
+	} else {
+		r0 = ret.Get(0).(types.U64)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey, types.Hash) error); ok {
+		r1 = rf(key, blockHash)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// GetStorageSizeLatest provides a mock function with given fields: key
+func (_m *SubstrateApiI) GetStorageSizeLatest(key types.StorageKey) (types.U64, error) {
+	ret := _m.Called(key)
+
+	var r0 types.U64
+	if rf, ok := ret.Get(0).(func(types.StorageKey) types.U64); ok {
+		r0 = rf(key)
+	} else {
+		r0 = ret.Get(0).(types.U64)
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.StorageKey) error); ok {
+		r1 = rf(key)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// PendingExtrinsics provides a mock function with given fields:
+func (_m *SubstrateApiI) PendingExtrinsics() ([]types.Extrinsic, error) {
+	ret := _m.Called()
+
+	var r0 []types.Extrinsic
+	if rf, ok := ret.Get(0).(func() []types.Extrinsic); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]types.Extrinsic)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// QueryStorage provides a mock function with given fields: keys, startBlock, block
+func (_m *SubstrateApiI) QueryStorage(keys []types.StorageKey, startBlock types.Hash, block types.Hash) ([]types.StorageChangeSet, error) {
+	ret := _m.Called(keys, startBlock, block)
+
+	var r0 []types.StorageChangeSet
+	if rf, ok := ret.Get(0).(func([]types.StorageKey, types.Hash, types.Hash) []types.StorageChangeSet); ok {
+		r0 = rf(keys, startBlock, block)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]types.StorageChangeSet)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func([]types.StorageKey, types.Hash, types.Hash) error); ok {
+		r1 = rf(keys, startBlock, block)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// QueryStorageAt provides a mock function with given fields: keys, block
+func (_m *SubstrateApiI) QueryStorageAt(keys []types.StorageKey, block types.Hash) ([]types.StorageChangeSet, error) {
+	ret := _m.Called(keys, block)
+
+	var r0 []types.StorageChangeSet
+	if rf, ok := ret.Get(0).(func([]types.StorageKey, types.Hash) []types.StorageChangeSet); ok {
+		r0 = rf(keys, block)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]types.StorageChangeSet)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func([]types.StorageKey, types.Hash) error); ok {
+		r1 = rf(keys, block)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// QueryStorageAtLatest provides a mock function with given fields: keys
+func (_m *SubstrateApiI) QueryStorageAtLatest(keys []types.StorageKey) ([]types.StorageChangeSet, error) {
+	ret := _m.Called(keys)
+
+	var r0 []types.StorageChangeSet
+	if rf, ok := ret.Get(0).(func([]types.StorageKey) []types.StorageChangeSet); ok {
+		r0 = rf(keys)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]types.StorageChangeSet)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func([]types.StorageKey) error); ok {
+		r1 = rf(keys)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// QueryStorageLatest provides a mock function with given fields: keys, startBlock
+func (_m *SubstrateApiI) QueryStorageLatest(keys []types.StorageKey, startBlock types.Hash) ([]types.StorageChangeSet, error) {
+	ret := _m.Called(keys, startBlock)
+
+	var r0 []types.StorageChangeSet
+	if rf, ok := ret.Get(0).(func([]types.StorageKey, types.Hash) []types.StorageChangeSet); ok {
+		r0 = rf(keys, startBlock)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]types.StorageChangeSet)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func([]types.StorageKey, types.Hash) error); ok {
+		r1 = rf(keys, startBlock)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SubmitAndWatchExtrinsic provides a mock function with given fields: xt
+func (_m *SubstrateApiI) SubmitAndWatchExtrinsic(xt types.Extrinsic) (*author.ExtrinsicStatusSubscription, error) {
+	ret := _m.Called(xt)
+
+	var r0 *author.ExtrinsicStatusSubscription
+	if rf, ok := ret.Get(0).(func(types.Extrinsic) *author.ExtrinsicStatusSubscription); ok {
+		r0 = rf(xt)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*author.ExtrinsicStatusSubscription)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.Extrinsic) error); ok {
+		r1 = rf(xt)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SubmitExtrinsic provides a mock function with given fields: xt
+func (_m *SubstrateApiI) SubmitExtrinsic(xt types.Extrinsic) (types.Hash, error) {
+	ret := _m.Called(xt)
+
+	var r0 types.Hash
+	if rf, ok := ret.Get(0).(func(types.Extrinsic) types.Hash); ok {
+		r0 = rf(xt)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(types.Hash)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(types.Extrinsic) error); ok {
+		r1 = rf(xt)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SubscribeFinalizedHeads provides a mock function with given fields:
+func (_m *SubstrateApiI) SubscribeFinalizedHeads() (*chain.FinalizedHeadsSubscription, error) {
+	ret := _m.Called()
+
+	var r0 *chain.FinalizedHeadsSubscription
+	if rf, ok := ret.Get(0).(func() *chain.FinalizedHeadsSubscription); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*chain.FinalizedHeadsSubscription)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SubscribeNewHeads provides a mock function with given fields:
+func (_m *SubstrateApiI) SubscribeNewHeads() (*chain.NewHeadsSubscription, error) {
+	ret := _m.Called()
+
+	var r0 *chain.NewHeadsSubscription
+	if rf, ok := ret.Get(0).(func() *chain.NewHeadsSubscription); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*chain.NewHeadsSubscription)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SubscribeRuntimeVersion provides a mock function with given fields:
+func (_m *SubstrateApiI) SubscribeRuntimeVersion() (*state.RuntimeVersionSubscription, error) {
+	ret := _m.Called()
+
+	var r0 *state.RuntimeVersionSubscription
+	if rf, ok := ret.Get(0).(func() *state.RuntimeVersionSubscription); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*state.RuntimeVersionSubscription)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// SubscribeStorageRaw provides a mock function with given fields: keys
+func (_m *SubstrateApiI) SubscribeStorageRaw(keys []types.StorageKey) (*state.StorageSubscription, error) {
+	ret := _m.Called(keys)
+
+	var r0 *state.StorageSubscription
+	if rf, ok := ret.Get(0).(func([]types.StorageKey) *state.StorageSubscription); ok {
+		r0 = rf(keys)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*state.StorageSubscription)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func([]types.StorageKey) error); ok {
+		r1 = rf(keys)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+type mockConstructorTestingTNewSubstrateApiI interface {
+	mock.TestingT
+	Cleanup(func())
+}
+
+// NewSubstrateApiI creates a new instance of SubstrateApiI. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewSubstrateApiI(t mockConstructorTestingTNewSubstrateApiI) *SubstrateApiI {
+	mock := &SubstrateApiI{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
diff --git a/node/node.go b/node/node.go
index e156fd009..f15d0a305 100644
--- a/node/node.go
+++ b/node/node.go
@@ -146,7 +146,7 @@ func NewNode(ctx context.Context, conf config.NodeConfig, p2pKey crypto.PrivKey,
 	if dalc == nil {
 		return nil, fmt.Errorf("couldn't get data availability client named '%s'", conf.DALayer)
 	}
-	err := dalc.Init([]byte(conf.DAConfig), pubsubServer, dalcKV, logger.With("module", "da_client"))
+	err := dalc.Init([]byte(conf.DAConfig), pubsubServer, dalcKV, logger.With("module", string(dalc.GetClientType())))
 	if err != nil {
 		return nil, fmt.Errorf("data availability layer client initialization error: %w", err)
 	}
diff --git a/testutil/mocks.go b/testutil/mocks.go
index c38814526..36f462cbb 100644
--- a/testutil/mocks.go
+++ b/testutil/mocks.go
@@ -154,3 +154,20 @@ type DALayerClientRetrieveBatchesError struct {
 func (m *DALayerClientRetrieveBatchesError) RetrieveBatches(_ uint64) da.ResultRetrieveBatch {
 	return da.ResultRetrieveBatch{BaseResult: da.BaseResult{Code: da.StatusError, Message: batchNotFoundErrorMessage}}
 }
+
+//SubscribeMock is a mock to provide a subscription like behavior for testing
+type SubscribeMock struct {
+	messageCh chan interface{}
+}
+
+func NewSubscribeMock(messageCh chan interface{}) *SubscribeMock {
+	return &SubscribeMock{messageCh: make(chan interface{})}
+}
+
+func (s *SubscribeMock) Chan() <-chan interface{} {
+	return s.messageCh
+}
+
+func (s *SubscribeMock) Unsubscribe() {
+	close(s.messageCh)
+}

From 390e3bbebed6a81c535786717753de27b2c47b51 Mon Sep 17 00:00:00 2001
From: omritoptix <omritoptix@gmail.com>
Date: Thu, 15 Jun 2023 15:16:09 +0200
Subject: [PATCH 02/12] Removed redundant DaStartHeight flag.

---
 block/manager_test.go | 3 +--
 config/config.go      | 7 +------
 da/avail/avail.go     | 8 ++++----
 testutil/mocks.go     | 2 +-
 4 files changed, 7 insertions(+), 13 deletions(-)

diff --git a/block/manager_test.go b/block/manager_test.go
index 7e7ee4399..dd94ddaa4 100644
--- a/block/manager_test.go
+++ b/block/manager_test.go
@@ -161,7 +161,7 @@ func TestProduceOnlyAfterSynced(t *testing.T) {
 	require.Greater(t, manager.store.Height(), lastStoreHeight)
 	assert.Equal(t, batch.EndHeight, manager.store.Height())
 	// Wait until manager is done
-	time.Sleep(time.Second * 1)
+	time.Sleep(time.Second * 4)
 
 	t.Log("Validate blocks are produced")
 	ctx, cancel = context.WithTimeout(context.Background(), time.Second*3)
@@ -584,7 +584,6 @@ func getManagerConfig() config.BlockManagerConfig {
 		BlockTime:          100 * time.Millisecond,
 		BlockBatchSize:     defaultBatchSize,
 		BatchSubmitMaxTime: 30 * time.Minute,
-		DAStartHeight:      0,
 		NamespaceID:        "0102030405060708",
 	}
 }
diff --git a/config/config.go b/config/config.go
index 15a6d1efc..d2f3d6744 100644
--- a/config/config.go
+++ b/config/config.go
@@ -15,7 +15,6 @@ const (
 	flagBlockTime           = "dymint.block_time"
 	flagEmptyBlocksMaxTime  = "dymint.empty_blocks_max_time"
 	flagBatchSubmitMaxTime  = "dymint.batch_submit_max_time"
-	flagDAStartHeight       = "dymint.da_start_height"
 	flagNamespaceID         = "dymint.namespace_id"
 	flagBlockBatchSize      = "dymint.block_batch_size"
 	flagBlockBatchSizeBytes = "dymint.block_batch_size_bytes"
@@ -61,9 +60,7 @@ type BlockManagerConfig struct {
 	EmptyBlocksMaxTime time.Duration `mapstructure:"empty_blocks_max_time"`
 	// BatchSubmitMaxTime defines how long should block manager wait for before submitting batch
 	BatchSubmitMaxTime time.Duration `mapstructure:"batch_submit_max_time"`
-	// DAStartHeight allows skipping first DAStartHeight-1 blocks when querying for blocks.
-	DAStartHeight uint64 `mapstructure:"da_start_height"`
-	NamespaceID   string `mapstructure:"namespace_id"`
+	NamespaceID        string        `mapstructure:"namespace_id"`
 	// The size of the batch in blocks. Every batch we'll write to the DA and the settlement layer.
 	BlockBatchSize uint64 `mapstructure:"block_batch_size"`
 	// The size of the batch in Bytes. Every batch we'll write to the DA and the settlement layer.
@@ -78,7 +75,6 @@ func (nc *NodeConfig) GetViperConfig(v *viper.Viper) error {
 	nc.DALayer = v.GetString(flagDALayer)
 	nc.DAConfig = v.GetString(flagDAConfig)
 	nc.SettlementLayer = v.GetString(flagSettlementLayer)
-	nc.DAStartHeight = v.GetUint64(flagDAStartHeight)
 	nc.BlockTime = v.GetDuration(flagBlockTime)
 	nc.EmptyBlocksMaxTime = v.GetDuration(flagEmptyBlocksMaxTime)
 	nc.BatchSubmitMaxTime = v.GetDuration(flagBatchSubmitMaxTime)
@@ -109,7 +105,6 @@ func AddFlags(cmd *cobra.Command) {
 	cmd.Flags().Duration(flagBlockTime, def.BlockTime, "block time (for aggregator mode)")
 	cmd.Flags().Duration(flagEmptyBlocksMaxTime, def.EmptyBlocksMaxTime, "max time for empty blocks (for aggregator mode)")
 	cmd.Flags().Duration(flagBatchSubmitMaxTime, def.BatchSubmitMaxTime, "max time for batch submit (for aggregator mode)")
-	cmd.Flags().Uint64(flagDAStartHeight, def.DAStartHeight, "starting DA block height (for syncing)")
 	cmd.Flags().String(flagNamespaceID, def.NamespaceID, "namespace identifies (8 bytes in hex)")
 	cmd.Flags().Uint64(flagBlockBatchSize, def.BlockBatchSize, "block batch size")
 	cmd.Flags().Uint64(flagBlockBatchSizeBytes, def.BlockBatchSizeBytes, "block batch size in bytes")
diff --git a/da/avail/avail.go b/da/avail/avail.go
index 887a18633..e415f497d 100644
--- a/da/avail/avail.go
+++ b/da/avail/avail.go
@@ -69,28 +69,28 @@ type DataAvailabilityLayerClient struct {
 var _ da.DataAvailabilityLayerClient = &DataAvailabilityLayerClient{}
 var _ da.BatchRetriever = &DataAvailabilityLayerClient{}
 
-//WithClient is an option which sets the client.
+// WithClient is an option which sets the client.
 func WithClient(client SubstrateApiI) da.Option {
 	return func(dalc da.DataAvailabilityLayerClient) {
 		dalc.(*DataAvailabilityLayerClient).client = client
 	}
 }
 
-//WithTxInclusionTimeout is an option which sets the timeout for waiting for transaction inclusion.
+// WithTxInclusionTimeout is an option which sets the timeout for waiting for transaction inclusion.
 func WithTxInclusionTimeout(timeout time.Duration) da.Option {
 	return func(dalc da.DataAvailabilityLayerClient) {
 		dalc.(*DataAvailabilityLayerClient).txInclusionTimeout = timeout
 	}
 }
 
-//WithBatchRetryDelay is an option which sets the delay between batch retries.
+// WithBatchRetryDelay is an option which sets the delay between batch retries.
 func WithBatchRetryDelay(delay time.Duration) da.Option {
 	return func(dalc da.DataAvailabilityLayerClient) {
 		dalc.(*DataAvailabilityLayerClient).batchRetryDelay = delay
 	}
 }
 
-//WithBatchRetryAttempts is an option which sets the number of batch retries.
+// WithBatchRetryAttempts is an option which sets the number of batch retries.
 func WithBatchRetryAttempts(attempts uint) da.Option {
 	return func(dalc da.DataAvailabilityLayerClient) {
 		dalc.(*DataAvailabilityLayerClient).batchRetryAttempts = attempts
diff --git a/testutil/mocks.go b/testutil/mocks.go
index 36f462cbb..a9fbc89a4 100644
--- a/testutil/mocks.go
+++ b/testutil/mocks.go
@@ -155,7 +155,7 @@ func (m *DALayerClientRetrieveBatchesError) RetrieveBatches(_ uint64) da.ResultR
 	return da.ResultRetrieveBatch{BaseResult: da.BaseResult{Code: da.StatusError, Message: batchNotFoundErrorMessage}}
 }
 
-//SubscribeMock is a mock to provide a subscription like behavior for testing
+// SubscribeMock is a mock to provide a subscription like behavior for testing
 type SubscribeMock struct {
 	messageCh chan interface{}
 }

From 926ded5d071e413625b915bd1351f3b64f62b203 Mon Sep 17 00:00:00 2001
From: omritoptix <omritoptix@gmail.com>
Date: Thu, 15 Jun 2023 15:25:11 +0200
Subject: [PATCH 03/12] Renamed blockBatchSizeBytes to blockBatchMaxSizeBytes
 as batch can be smaller.

---
 block/manager.go      |  8 ++++----
 block/manager_test.go |  6 +++---
 config/config.go      | 25 +++++++++++++------------
 config/defaults.go    | 12 ++++++------
 4 files changed, 26 insertions(+), 25 deletions(-)

diff --git a/block/manager.go b/block/manager.go
index 1631c1d12..18762058b 100644
--- a/block/manager.go
+++ b/block/manager.go
@@ -115,9 +115,9 @@ func NewManager(
 	}
 
 	// TODO((#119): Probably should be validated and manage default on config init.
-	if conf.BlockBatchSizeBytes == 0 {
-		logger.Info("WARNING: using default DA batch size bytes limit", "BlockBatchSizeBytes", config.DefaultNodeConfig.BlockBatchSizeBytes)
-		conf.BlockBatchSizeBytes = config.DefaultNodeConfig.BlockBatchSizeBytes
+	if conf.BlockBatchMaxSizeBytes == 0 {
+		logger.Info("WARNING: using default DA batch size bytes limit", "BlockBatchSizeBytes", config.DefaultNodeConfig.BlockBatchMaxSizeBytes)
+		conf.BlockBatchMaxSizeBytes = config.DefaultNodeConfig.BlockBatchMaxSizeBytes
 	}
 	if conf.BatchSubmitMaxTime == 0 {
 		logger.Info("WARNING: using default DA batch submit max time", "BatchSubmitMaxTime", config.DefaultNodeConfig.BatchSubmitMaxTime)
@@ -798,7 +798,7 @@ func (m *Manager) createNextDABatch(startHeight uint64, endHeight uint64) (*type
 
 		//Check if the batch size is too big
 		totalSize := batch.ToProto().Size()
-		if totalSize > int(m.conf.BlockBatchSizeBytes) {
+		if totalSize > int(m.conf.BlockBatchMaxSizeBytes) {
 			// Nil out the last block and commit
 			batch.Blocks[len(batch.Blocks)-1] = nil
 			batch.Commits[len(batch.Commits)-1] = nil
diff --git a/block/manager_test.go b/block/manager_test.go
index dd94ddaa4..44250a92c 100644
--- a/block/manager_test.go
+++ b/block/manager_test.go
@@ -413,7 +413,7 @@ func TestCreateNextDABatchWithBytesLimit(t *testing.T) {
 	// Init manager
 	managerConfig := getManagerConfig()
 	managerConfig.BlockBatchSize = 1000
-	managerConfig.BlockBatchSizeBytes = batchLimitBytes //enough for 2 block, not enough for 10 blocks
+	managerConfig.BlockBatchMaxSizeBytes = batchLimitBytes //enough for 2 block, not enough for 10 blocks
 	manager, err := getManager(managerConfig, nil, nil, 1, 1, 0, proxyApp, nil)
 	require.NoError(err)
 
@@ -451,7 +451,7 @@ func TestCreateNextDABatchWithBytesLimit(t *testing.T) {
 			assert.NoError(err)
 
 			assert.Equal(batch.StartHeight, startHeight)
-			assert.LessOrEqual(batch.ToProto().Size(), int(managerConfig.BlockBatchSizeBytes))
+			assert.LessOrEqual(batch.ToProto().Size(), int(managerConfig.BlockBatchMaxSizeBytes))
 
 			if !tc.expectedToBeTruncated {
 				assert.Equal(batch.EndHeight, endHeight)
@@ -461,7 +461,7 @@ func TestCreateNextDABatchWithBytesLimit(t *testing.T) {
 
 				//validate next added block to batch would have been actually too big
 				//First relax the byte limit so we could proudce larger batch
-				manager.conf.BlockBatchSizeBytes = 10 * manager.conf.BlockBatchSizeBytes
+				manager.conf.BlockBatchMaxSizeBytes = 10 * manager.conf.BlockBatchMaxSizeBytes
 				newBatch, err := manager.createNextDABatch(startHeight, batch.EndHeight+1)
 				assert.Greater(newBatch.ToProto().Size(), batchLimitBytes)
 
diff --git a/config/config.go b/config/config.go
index d2f3d6744..f7dffd321 100644
--- a/config/config.go
+++ b/config/config.go
@@ -9,15 +9,16 @@ import (
 )
 
 const (
-	flagAggregator          = "dymint.aggregator"
-	flagDALayer             = "dymint.da_layer"
-	flagDAConfig            = "dymint.da_config"
-	flagBlockTime           = "dymint.block_time"
-	flagEmptyBlocksMaxTime  = "dymint.empty_blocks_max_time"
-	flagBatchSubmitMaxTime  = "dymint.batch_submit_max_time"
-	flagNamespaceID         = "dymint.namespace_id"
-	flagBlockBatchSize      = "dymint.block_batch_size"
-	flagBlockBatchSizeBytes = "dymint.block_batch_size_bytes"
+	flagAggregator         = "dymint.aggregator"
+	flagDALayer            = "dymint.da_layer"
+	flagDAConfig           = "dymint.da_config"
+	flagBlockTime          = "dymint.block_time"
+	flagEmptyBlocksMaxTime = "dymint.empty_blocks_max_time"
+	flagBatchSubmitMaxTime = "dymint.batch_submit_max_time"
+	// TODO(omritoptix): Namespace ID should be part of the DA config
+	flagNamespaceID            = "dymint.namespace_id"
+	flagBlockBatchSize         = "dymint.block_batch_size"
+	flagBlockBatchMaxSizeBytes = "dymint.block_batch_max_size_bytes"
 )
 
 const (
@@ -64,7 +65,7 @@ type BlockManagerConfig struct {
 	// The size of the batch in blocks. Every batch we'll write to the DA and the settlement layer.
 	BlockBatchSize uint64 `mapstructure:"block_batch_size"`
 	// The size of the batch in Bytes. Every batch we'll write to the DA and the settlement layer.
-	BlockBatchSizeBytes uint64 `mapstructure:"block_batch_size_bytes"`
+	BlockBatchMaxSizeBytes uint64 `mapstructure:"block_batch_size_bytes"`
 }
 
 // GetViperConfig reads configuration parameters from Viper instance.
@@ -79,7 +80,7 @@ func (nc *NodeConfig) GetViperConfig(v *viper.Viper) error {
 	nc.EmptyBlocksMaxTime = v.GetDuration(flagEmptyBlocksMaxTime)
 	nc.BatchSubmitMaxTime = v.GetDuration(flagBatchSubmitMaxTime)
 	nc.BlockBatchSize = v.GetUint64(flagBlockBatchSize)
-	nc.BlockBatchSizeBytes = v.GetUint64(flagBlockBatchSizeBytes)
+	nc.BlockBatchMaxSizeBytes = v.GetUint64(flagBlockBatchMaxSizeBytes)
 	nc.NamespaceID = v.GetString(flagNamespaceID)
 
 	nc.SettlementConfig.NodeAddress = v.GetString(flagSLNodeAddress)
@@ -107,7 +108,7 @@ func AddFlags(cmd *cobra.Command) {
 	cmd.Flags().Duration(flagBatchSubmitMaxTime, def.BatchSubmitMaxTime, "max time for batch submit (for aggregator mode)")
 	cmd.Flags().String(flagNamespaceID, def.NamespaceID, "namespace identifies (8 bytes in hex)")
 	cmd.Flags().Uint64(flagBlockBatchSize, def.BlockBatchSize, "block batch size")
-	cmd.Flags().Uint64(flagBlockBatchSizeBytes, def.BlockBatchSizeBytes, "block batch size in bytes")
+	cmd.Flags().Uint64(flagBlockBatchMaxSizeBytes, def.BlockBatchMaxSizeBytes, "block batch max size in bytes")
 
 	cmd.Flags().String(flagSettlementLayer, def.SettlementLayer, "Settlement Layer Client name")
 	cmd.Flags().String(flagSLNodeAddress, def.SettlementConfig.NodeAddress, "Settlement Layer RPC node address")
diff --git a/config/defaults.go b/config/defaults.go
index 0e0701e26..bae592e20 100644
--- a/config/defaults.go
+++ b/config/defaults.go
@@ -18,12 +18,12 @@ var DefaultNodeConfig = NodeConfig{
 		Seeds:         ""},
 	Aggregator: true,
 	BlockManagerConfig: BlockManagerConfig{
-		BlockTime:           200 * time.Millisecond,
-		EmptyBlocksMaxTime:  60 * time.Second,
-		BatchSubmitMaxTime:  600 * time.Second,
-		NamespaceID:         "000000000000ffff",
-		BlockBatchSize:      500,
-		BlockBatchSizeBytes: 1500000},
+		BlockTime:              200 * time.Millisecond,
+		EmptyBlocksMaxTime:     60 * time.Second,
+		BatchSubmitMaxTime:     600 * time.Second,
+		NamespaceID:            "000000000000ffff",
+		BlockBatchSize:         500,
+		BlockBatchMaxSizeBytes: 1500000},
 	DALayer:         "mock",
 	SettlementLayer: "mock",
 }

From ad3c47d4ef6a3f0dfe33973dbe23d5025a0e284e Mon Sep 17 00:00:00 2001
From: omritoptix <omritoptix@gmail.com>
Date: Thu, 15 Jun 2023 15:30:01 +0200
Subject: [PATCH 04/12] Updated golangci-lint pre-commit hook.

---
 contrib/githooks/pre-commit-config.yaml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/contrib/githooks/pre-commit-config.yaml b/contrib/githooks/pre-commit-config.yaml
index d24bcd424..899855ddc 100644
--- a/contrib/githooks/pre-commit-config.yaml
+++ b/contrib/githooks/pre-commit-config.yaml
@@ -92,8 +92,10 @@ repos:
     # - https://github.com/golangci/golangci-lint
     #
     # -   id: golangci-lint
-    -   id: golangci-lint-mod
-    -   id: golangci-lint-repo-mod
+-   repo: https://github.com/golangci/golangci-lint
+    rev: v1.53.3
+    hooks:
+    -   id: golangci-lint
     #
     # # Invoking Custom Go Tools
     # # - Configured *entirely* through the `args` attribute, ie:

From c7d4bfd458a48d86d6884cec2a9fe1fc2b947c89 Mon Sep 17 00:00:00 2001
From: omritoptix <omritoptix@gmail.com>
Date: Thu, 15 Jun 2023 18:07:58 +0200
Subject: [PATCH 05/12] Added avail client to registry.

---
 block/manager.go             |  2 +-
 da/avail/avail.go            |  2 +-
 da/da_test.go                | 12 ++++++++++++
 da/registry/registry.go      |  2 ++
 da/registry/registry_test.go |  2 +-
 5 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/block/manager.go b/block/manager.go
index 18762058b..991b38026 100644
--- a/block/manager.go
+++ b/block/manager.go
@@ -331,7 +331,7 @@ func (m *Manager) ProduceBlockLoop(ctx context.Context) {
 			return
 		//Empty blocks timeout
 		case <-tickerEmptyBlocksMaxTimeCh:
-			m.logger.Error("No transactions for %s seconds, producing empty block", m.conf.EmptyBlocksMaxTime.Seconds())
+			m.logger.Error(fmt.Sprintf("No transactions for %.2f seconds, producing empty block", m.conf.EmptyBlocksMaxTime.Seconds()))
 			produceEmptyBlock = true
 		//Produce block
 		case <-ticker.C:
diff --git a/da/avail/avail.go b/da/avail/avail.go
index e415f497d..aeb267bb0 100644
--- a/da/avail/avail.go
+++ b/da/avail/avail.go
@@ -352,7 +352,7 @@ func (c *DataAvailabilityLayerClient) broadcastTx(tx []byte) (uint64, error) {
 		select {
 		case status := <-sub.Chan():
 			if status.IsInBlock {
-				c.logger.Info("Txn inside block %v\n", status.AsInBlock.Hex())
+				c.logger.Info(fmt.Sprintf("Txn included inside a block with hash %v\n, waiting for finalization..", status.AsInBlock.Hex()))
 			} else if status.IsFinalized {
 				c.logger.Info("Txn inside finalized block\n")
 				hash := status.AsFinalized
diff --git a/da/da_test.go b/da/da_test.go
index b9e99a20b..076f71098 100644
--- a/da/da_test.go
+++ b/da/da_test.go
@@ -32,6 +32,10 @@ func TestLifecycle(t *testing.T) {
 	defer srv.GracefulStop()
 
 	for _, dalc := range registry.RegisteredClients() {
+		//TODO(omritoptix): Possibly add support for avail here.
+		if dalc == "avail" {
+			t.Skip("TODO")
+		}
 		t.Run(dalc, func(t *testing.T) {
 			doTestLifecycle(t, registry.GetClient(dalc))
 		})
@@ -60,6 +64,10 @@ func TestDALC(t *testing.T) {
 	defer httpServer.Stop()
 
 	for _, dalc := range registry.RegisteredClients() {
+		//TODO(omritoptix): Possibly add support for avail here.
+		if dalc == "avail" {
+			t.Skip("TODO")
+		}
 		t.Run(dalc, func(t *testing.T) {
 			doTestDALC(t, registry.GetClient(dalc))
 		})
@@ -145,6 +153,10 @@ func TestRetrieve(t *testing.T) {
 
 	for _, client := range registry.RegisteredClients() {
 		t.Run(client, func(t *testing.T) {
+			//TODO(omritoptix): Possibly add support for avail here.
+			if client == "avail" {
+				t.Skip("TODO")
+			}
 			dalc := registry.GetClient(client)
 			_, ok := dalc.(da.BatchRetriever)
 			if ok {
diff --git a/da/registry/registry.go b/da/registry/registry.go
index ca8bd75fe..0cc0dd67f 100644
--- a/da/registry/registry.go
+++ b/da/registry/registry.go
@@ -2,6 +2,7 @@ package registry
 
 import (
 	"github.com/dymensionxyz/dymint/da"
+	"github.com/dymensionxyz/dymint/da/avail"
 	"github.com/dymensionxyz/dymint/da/celestia"
 	"github.com/dymensionxyz/dymint/da/grpc"
 	"github.com/dymensionxyz/dymint/da/mock"
@@ -12,6 +13,7 @@ var clients = map[string]func() da.DataAvailabilityLayerClient{
 	"mock":     func() da.DataAvailabilityLayerClient { return &mock.DataAvailabilityLayerClient{} },
 	"grpc":     func() da.DataAvailabilityLayerClient { return &grpc.DataAvailabilityLayerClient{} },
 	"celestia": func() da.DataAvailabilityLayerClient { return &celestia.DataAvailabilityLayerClient{} },
+	"avail":    func() da.DataAvailabilityLayerClient { return &avail.DataAvailabilityLayerClient{} },
 }
 
 // GetClient returns client identified by name.
diff --git a/da/registry/registry_test.go b/da/registry/registry_test.go
index 0eb8d00cf..bd9a5975d 100644
--- a/da/registry/registry_test.go
+++ b/da/registry/registry_test.go
@@ -9,7 +9,7 @@ import (
 func TestRegistery(t *testing.T) {
 	assert := assert.New(t)
 
-	expected := []string{"mock", "grpc", "celestia"}
+	expected := []string{"mock", "grpc", "celestia", "avail"}
 	actual := RegisteredClients()
 
 	assert.ElementsMatch(expected, actual)

From 25685b3f30bcab02a4d31c9ec955fad65fd7e83b Mon Sep 17 00:00:00 2001
From: omritoptix <omritoptix@gmail.com>
Date: Thu, 15 Jun 2023 18:38:41 +0200
Subject: [PATCH 06/12] Updated avail log messages.

---
 da/avail/avail.go | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/da/avail/avail.go b/da/avail/avail.go
index aeb267bb0..5e2f71af1 100644
--- a/da/avail/avail.go
+++ b/da/avail/avail.go
@@ -227,7 +227,7 @@ func (c *DataAvailabilityLayerClient) SubmitBatch(batch *types.Batch) da.ResultS
 		}
 	}
 
-	c.logger.Debug("Submitting to da blob with size", "size", len(blob))
+	c.logger.Debug("Submitting to da batch with size", "size", len(blob))
 	return c.submitBatchLoop(blob)
 
 }
@@ -250,7 +250,7 @@ func (c *DataAvailabilityLayerClient) submitBatchLoop(dataBlob []byte) da.Result
 				var err error
 				daBlockHeight, err = c.broadcastTx(dataBlob)
 				if err != nil {
-					c.logger.Error("Error broadcasting transaction", "error", err)
+					c.logger.Error("Error broadcasting batch", "error", err)
 					return err
 				}
 				return nil
@@ -265,7 +265,7 @@ func (c *DataAvailabilityLayerClient) submitBatchLoop(dataBlob []byte) da.Result
 						},
 					}
 				} else {
-					c.logger.Error("Error broadcasting transaction. Trying again..", "error", err)
+					c.logger.Error("Error broadcasting batch. Trying again..", "error", err)
 					continue
 				}
 			} else {
@@ -344,7 +344,7 @@ func (c *DataAvailabilityLayerClient) broadcastTx(tx []byte) (uint64, error) {
 		return 0, fmt.Errorf("%w: %s", da.ErrTxBroadcastNetworkError, err)
 	}
 
-	c.logger.Info("Submitted data to avail. Waiting for inclusion event")
+	c.logger.Info("Submitted batch to avail. Waiting for inclusion event")
 
 	defer sub.Unsubscribe()
 	timeout := time.After(c.txInclusionTimeout * time.Second)
@@ -352,9 +352,9 @@ func (c *DataAvailabilityLayerClient) broadcastTx(tx []byte) (uint64, error) {
 		select {
 		case status := <-sub.Chan():
 			if status.IsInBlock {
-				c.logger.Info(fmt.Sprintf("Txn included inside a block with hash %v\n, waiting for finalization..", status.AsInBlock.Hex()))
+				c.logger.Info(fmt.Sprintf("Batch included inside a block with hash %v\n, waiting for finalization.", status.AsInBlock.Hex()))
 			} else if status.IsFinalized {
-				c.logger.Info("Txn inside finalized block\n")
+				c.logger.Info("Batch successfully sent")
 				hash := status.AsFinalized
 				blockHeight, err := c.getHeightFromHash(hash)
 				if err != nil {

From 77a22103aeb08cbc98c67a0badc8265fe66e2186 Mon Sep 17 00:00:00 2001
From: omritoptix <omritoptix@gmail.com>
Date: Thu, 15 Jun 2023 19:08:06 +0200
Subject: [PATCH 07/12] Moved util functionality from celestia to a util.go
 file.

---
 da/celestia/celestia.go | 26 +++++---------------------
 da/utils.go             | 23 +++++++++++++++++++++++
 2 files changed, 28 insertions(+), 21 deletions(-)
 create mode 100644 da/utils.go

diff --git a/da/celestia/celestia.go b/da/celestia/celestia.go
index 2a90e2f7f..4af7f40d2 100644
--- a/da/celestia/celestia.go
+++ b/da/celestia/celestia.go
@@ -176,7 +176,7 @@ func (c *DataAvailabilityLayerClient) SubmitBatch(batch *types.Batch) da.ResultS
 				if txResponse.Code != 0 {
 					c.logger.Debug("Failed to submit DA batch. Emitting health event and trying again", "txResponse", txResponse, "error", err)
 					// Publish an health event. Only if we failed to emit the event we return an error.
-					res, err := c.submitBatchHealthEventHelper(false, errors.New(txResponse.RawLog))
+					res, err := da.SubmitBatchHealthEventHelper(c.pubsubServer, c.ctx, false, errors.New(txResponse.RawLog))
 					if err != nil {
 						return res
 					}
@@ -187,7 +187,7 @@ func (c *DataAvailabilityLayerClient) SubmitBatch(batch *types.Batch) da.ResultS
 					c.logger.Debug("Failed to receive DA batch inclusion result. Waiting for inclusion", "txResponse", txResponse, "error", err)
 					inclusionHeight, err := c.waitForTXInclusion(txResponse.TxHash)
 					if err == nil {
-						res, err := c.submitBatchHealthEventHelper(true, nil)
+						res, err := da.SubmitBatchHealthEventHelper(c.pubsubServer, c.ctx, true, nil)
 						if err != nil {
 							return res
 						} else {
@@ -201,7 +201,7 @@ func (c *DataAvailabilityLayerClient) SubmitBatch(batch *types.Batch) da.ResultS
 						}
 					} else {
 						c.logger.Debug("Failed to receive DA batch inclusion result. Emitting health event and trying again", "error", err)
-						res, err := c.submitBatchHealthEventHelper(false, err)
+						res, err := da.SubmitBatchHealthEventHelper(c.pubsubServer, c.ctx, false, err)
 						if err != nil {
 							return res
 						}
@@ -209,7 +209,7 @@ func (c *DataAvailabilityLayerClient) SubmitBatch(batch *types.Batch) da.ResultS
 
 				} else {
 					c.logger.Debug("Successfully submitted DA batch", "txResponse", txResponse)
-					res, err := c.submitBatchHealthEventHelper(true, nil)
+					res, err := da.SubmitBatchHealthEventHelper(c.pubsubServer, c.ctx, true, nil)
 					if err != nil {
 						return res
 					}
@@ -222,7 +222,7 @@ func (c *DataAvailabilityLayerClient) SubmitBatch(batch *types.Batch) da.ResultS
 					}
 				}
 			} else {
-				res, err := c.submitBatchHealthEventHelper(false, errors.New("DA txResponse is nil"))
+				res, err := da.SubmitBatchHealthEventHelper(c.pubsubServer, c.ctx, false, errors.New("DA txResponse is nil"))
 				if err != nil {
 					return res
 				}
@@ -326,19 +326,3 @@ func (c *DataAvailabilityLayerClient) waitForTXInclusion(txHash string) (uint64,
 	}
 	return inclusionHeight, nil
 }
-
-func (c *DataAvailabilityLayerClient) submitBatchHealthEventHelper(healthy bool, err error) (da.ResultSubmitBatch, error) {
-	err = c.pubsubServer.PublishWithEvents(c.ctx, da.EventDataDAHealthStatus{Healthy: healthy, Error: err},
-		map[string][]string{da.EventTypeKey: {da.EventDAHealthStatus}})
-	if err != nil {
-		return da.ResultSubmitBatch{
-			BaseResult: da.BaseResult{
-				Code:    da.StatusError,
-				Message: err.Error(),
-			},
-		}, err
-	} else {
-		return da.ResultSubmitBatch{}, nil
-	}
-
-}
diff --git a/da/utils.go b/da/utils.go
new file mode 100644
index 000000000..84040bfe1
--- /dev/null
+++ b/da/utils.go
@@ -0,0 +1,23 @@
+package da
+
+import (
+	"context"
+
+	"github.com/tendermint/tendermint/libs/pubsub"
+)
+
+func SubmitBatchHealthEventHelper(pubsubServer *pubsub.Server, ctx context.Context, healthy bool, err error) (ResultSubmitBatch, error) {
+	err = pubsubServer.PublishWithEvents(ctx, EventDataDAHealthStatus{Healthy: healthy, Error: err},
+		map[string][]string{EventTypeKey: {EventDAHealthStatus}})
+	if err != nil {
+		return ResultSubmitBatch{
+			BaseResult: BaseResult{
+				Code:    StatusError,
+				Message: err.Error(),
+			},
+		}, err
+	} else {
+		return ResultSubmitBatch{}, nil
+	}
+
+}

From 988f132be3a3a57fd806b6ef8799734631e583a9 Mon Sep 17 00:00:00 2001
From: omritoptix <omritoptix@gmail.com>
Date: Thu, 15 Jun 2023 19:15:39 +0200
Subject: [PATCH 08/12] Added health event emission to avail client.

---
 da/avail/avail.go | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/da/avail/avail.go b/da/avail/avail.go
index 5e2f71af1..84960fdef 100644
--- a/da/avail/avail.go
+++ b/da/avail/avail.go
@@ -265,10 +265,19 @@ func (c *DataAvailabilityLayerClient) submitBatchLoop(dataBlob []byte) da.Result
 						},
 					}
 				} else {
-					c.logger.Error("Error broadcasting batch. Trying again..", "error", err)
+					c.logger.Error("Error broadcasting batch. Emitting DA unhealthy event and Trying again.", "error", err)
+					res, err := da.SubmitBatchHealthEventHelper(c.pubsubServer, c.ctx, false, err)
+					if err != nil {
+						return res
+					}
 					continue
 				}
 			} else {
+				c.logger.Debug("Successfully submitted DA batch")
+				res, err := da.SubmitBatchHealthEventHelper(c.pubsubServer, c.ctx, true, nil)
+				if err != nil {
+					return res
+				}
 				return da.ResultSubmitBatch{
 					BaseResult: da.BaseResult{
 						Code:     da.StatusSuccess,
@@ -352,9 +361,9 @@ func (c *DataAvailabilityLayerClient) broadcastTx(tx []byte) (uint64, error) {
 		select {
 		case status := <-sub.Chan():
 			if status.IsInBlock {
-				c.logger.Info(fmt.Sprintf("Batch included inside a block with hash %v\n, waiting for finalization.", status.AsInBlock.Hex()))
+				c.logger.Debug(fmt.Sprintf("Batch included inside a block with hash %v\n, waiting for finalization.", status.AsInBlock.Hex()))
 			} else if status.IsFinalized {
-				c.logger.Info("Batch successfully sent")
+				c.logger.Debug("Batch finalized inside block")
 				hash := status.AsFinalized
 				blockHeight, err := c.getHeightFromHash(hash)
 				if err != nil {
@@ -380,6 +389,7 @@ func (c *DataAvailabilityLayerClient) CheckBatchAvailability(dataLayerHeight uin
 
 // getHeightFromHash returns the block height from the block hash
 func (c *DataAvailabilityLayerClient) getHeightFromHash(hash availtypes.Hash) (uint64, error) {
+	c.logger.Debug("Getting block height from hash", "hash", hash)
 	block, err := c.client.GetBlock(hash)
 	if err != nil {
 		return 0, fmt.Errorf("cannot get block by hash:%w", err)

From 8244200312326f0f5ac833e7098717b5b4279bba Mon Sep 17 00:00:00 2001
From: Michael Tsitrin <michael@dymension.xyz>
Date: Mon, 19 Jun 2023 16:43:12 +0300
Subject: [PATCH 09/12] added avail example config

---
 config/toml.go | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/config/toml.go b/config/toml.go
index 6edd39669..115a74c32 100644
--- a/config/toml.go
+++ b/config/toml.go
@@ -79,13 +79,15 @@ batch_submit_max_time = "{{ .BlockManagerConfig.BatchSubmitMaxTime }}"
 ### da config ###
 da_layer = "{{ .DALayer }}" # mock, celestia
 namespace_id = "{{ .BlockManagerConfig.NamespaceID }}"
+da_config = "{{ .DAConfig }}"
 
 # max size of batch in bytes that can be accepted by DA
 block_batch_max_size_bytes = {{ .BlockManagerConfig.BlockBatchMaxSizeBytes }}
 
-#celestia config
+#celestia config example:
 # da_config = "{\"base_url\": \"http://127.0.0.1:26659\", \"timeout\": 60000000000, \"fee\":20000, \"gas_limit\": 20000000, \"namespace_id\":\"000000000000ffff\"}"
-da_config = "{{ .DAConfig }}"
+# Avail config example:
+# da_config = “{\“seed\“: \“MNEMONIC\“, \“api_url\“: \“wss://kate.avail.tools/ws\“, \“app_id\“: 0, \“tip\“:10}“,
 
 ### settlement config ###
 settlement_layer = "{{ .SettlementLayer }}" # mock, dymension

From 325e9d156860b0f06a75f7f46d10339d8789c18c Mon Sep 17 00:00:00 2001
From: Michael Tsitrin <michael@dymension.xyz>
Date: Mon, 19 Jun 2023 17:39:42 +0300
Subject: [PATCH 10/12] fixed wrong quotes used in example

---
 config/toml.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config/toml.go b/config/toml.go
index 115a74c32..8f4f55038 100644
--- a/config/toml.go
+++ b/config/toml.go
@@ -87,7 +87,7 @@ block_batch_max_size_bytes = {{ .BlockManagerConfig.BlockBatchMaxSizeBytes }}
 #celestia config example:
 # da_config = "{\"base_url\": \"http://127.0.0.1:26659\", \"timeout\": 60000000000, \"fee\":20000, \"gas_limit\": 20000000, \"namespace_id\":\"000000000000ffff\"}"
 # Avail config example:
-# da_config = “{\“seed\“: \“MNEMONIC\“, \“api_url\“: \“wss://kate.avail.tools/ws\“, \“app_id\“: 0, \“tip\“:10}“,
+# da_config = "{\"seed\": \"MNEMONIC\", \"api_url\": \"wss://kate.avail.tools/ws\", \"app_id\": 0, \"tip\":10}",
 
 ### settlement config ###
 settlement_layer = "{{ .SettlementLayer }}" # mock, dymension

From 32482443159fb45bcab5bf98fb10e91f02b15e7e Mon Sep 17 00:00:00 2001
From: Michael Tsitrin <michael@dymension.xyz>
Date: Wed, 21 Jun 2023 16:34:09 +0300
Subject: [PATCH 11/12] updated cosmosclient version

---
 go.mod | 12 +++---------
 go.sum | 58 +++++++---------------------------------------------------
 2 files changed, 10 insertions(+), 60 deletions(-)

diff --git a/go.mod b/go.mod
index 189ea4756..75108a415 100644
--- a/go.mod
+++ b/go.mod
@@ -8,7 +8,7 @@ require (
 	github.com/celestiaorg/go-cnc v0.2.0
 	github.com/centrifuge/go-substrate-rpc-client/v4 v4.0.12
 	github.com/dgraph-io/badger/v3 v3.2103.3
-	github.com/dymensionxyz/cosmosclient v0.3.0-beta.0.20230514120937-449e9becd080
+	github.com/dymensionxyz/cosmosclient v0.3.0-beta.0.20230621132116-77eb2ae5ab92
 	github.com/dymensionxyz/dymension v0.2.0-beta.0.20230607115558-745644a96ea6
 	github.com/go-kit/kit v0.12.0
 	github.com/gofrs/uuid v4.3.0+incompatible
@@ -44,13 +44,9 @@ require (
 	github.com/StackExchange/wmi v1.2.1 // indirect
 	github.com/Workiva/go-datastructures v1.0.53 // indirect
 	github.com/blang/semver v3.5.1+incompatible // indirect
-	github.com/btcsuite/btcd v0.22.2 // indirect
 	github.com/btcsuite/btcd/btcec/v2 v2.3.2 // indirect
-	github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 // indirect
-	github.com/btcsuite/btcutil v1.0.3-0.20201208143702-a53e38424cce // indirect
 	github.com/cometbft/cometbft-db v0.7.0 // indirect
 	github.com/cosmos/cosmos-proto v1.0.0-beta.2 // indirect
-	github.com/cosmos/gogoproto v1.4.3 // indirect
 	github.com/creachadair/taskgroup v0.3.2 // indirect
 	github.com/deckarep/golang-set v1.8.0 // indirect
 	github.com/decred/base58 v1.0.4 // indirect
@@ -58,8 +54,8 @@ require (
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 // indirect
 	github.com/emirpasic/gods v1.18.1 // indirect
 	github.com/ethereum/go-ethereum v1.10.26 // indirect
-	github.com/evmos/ethermint v0.20.0 // indirect
 	github.com/ghodss/yaml v1.0.0 // indirect
+	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/go-stack/stack v1.8.1 // indirect
 	github.com/golang/mock v1.6.0 // indirect
 	github.com/google/pprof v0.0.0-20221203041831-ce31453925ec // indirect
@@ -70,18 +66,16 @@ require (
 	github.com/minio/highwayhash v1.0.2 // indirect
 	github.com/onsi/ginkgo/v2 v2.5.1 // indirect
 	github.com/pierrec/xxHash v0.1.5 // indirect
-	github.com/prometheus/tsdb v0.10.0 // indirect
 	github.com/quic-go/qpack v0.4.0 // indirect
 	github.com/quic-go/qtls-go1-19 v0.2.1 // indirect
 	github.com/quic-go/qtls-go1-20 v0.1.1 // indirect
 	github.com/quic-go/quic-go v0.33.0 // indirect
 	github.com/quic-go/webtransport-go v0.5.1 // indirect
-	github.com/rjeczalik/notify v0.9.2 // indirect
 	github.com/satori/go.uuid v1.2.0 // indirect
 	github.com/sirupsen/logrus v1.9.0 // indirect
 	github.com/tecbot/gorocksdb v0.0.0-20191217155057-f0fad39f321c // indirect
 	github.com/tidwall/btree v1.5.0 // indirect
-	github.com/tyler-smith/go-bip39 v1.1.0 // indirect
+	github.com/tklauser/go-sysconf v0.3.10 // indirect
 	github.com/vedhavyas/go-subkey v1.0.3 // indirect
 	github.com/zondax/ledger-go v0.14.1 // indirect
 	go.uber.org/dig v1.15.0 // indirect
diff --git a/go.sum b/go.sum
index cf97c47dc..a2244beed 100644
--- a/go.sum
+++ b/go.sum
@@ -72,12 +72,10 @@ github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDOSA=
 github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8=
-github.com/VictoriaMetrics/fastcache v1.6.0 h1:C/3Oi3EiBCqufydp1neRZkqcwmEiuRT9c3fqvvgKm5o=
 github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE=
 github.com/Workiva/go-datastructures v1.0.53 h1:J6Y/52yX10Xc5JjXmGtWoSSxs3mZnGSaq37xZZh7Yig=
 github.com/Workiva/go-datastructures v1.0.53/go.mod h1:1yZL+zfsztete+ePzZz/Zb1/t5BnDuE2Ya2MMGhzP6A=
 github.com/adlio/schema v1.3.3 h1:oBJn8I02PyTB466pZO1UZEn1TV5XLlifBSyMrmHl/1I=
-github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
@@ -105,23 +103,12 @@ github.com/bgentry/speakeasy v0.1.1-0.20220910012023-760eaf8b6816/go.mod h1:+zsy
 github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ=
 github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk=
 github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g=
-github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ=
-github.com/btcsuite/btcd v0.22.2 h1:vBZ+lGGd1XubpOWO67ITJpAEsICWhA0YzqkcpkgNBfo=
-github.com/btcsuite/btcd v0.22.2/go.mod h1:wqgTSL29+50LRkmOVknEdmt8ZojIzhuWvgu/iptuN7Y=
+github.com/btcsuite/btcd v0.22.1 h1:CnwP9LM/M9xuRrGSCGeMVs9iv09uMqwsVX7EeIpgV2c=
 github.com/btcsuite/btcd/btcec/v2 v2.3.2 h1:5n0X6hX0Zk+6omWcihdYvdAlGf2DfasC0GMf7DClJ3U=
 github.com/btcsuite/btcd/btcec/v2 v2.3.2/go.mod h1:zYzJ8etWJQIv1Ogk7OzpWjowwOdXY1W/17j2MW85J04=
 github.com/btcsuite/btcd/btcutil v1.1.2 h1:XLMbX8JQEiwMcYft2EGi8zPUkoa0abKIU6/BJSRsjzQ=
 github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1 h1:q0rUy8C/TYNBQS1+CGKw68tLOFYSNEs0TFnxxnS9+4U=
-github.com/btcsuite/btcd/chaincfg/chainhash v1.0.1/go.mod h1:7SFka0XMvUgj3hfZtydOrQY2mwhPclbT2snogU7SQQc=
-github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA=
-github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg=
 github.com/btcsuite/btcutil v1.0.3-0.20201208143702-a53e38424cce h1:YtWJF7RHm2pYCvA5t0RPmAaLUhREsKuKd+SLhxFbFeQ=
-github.com/btcsuite/btcutil v1.0.3-0.20201208143702-a53e38424cce/go.mod h1:0DVlHczLPewLcPGEIeUEzfOJhqGPQ0mJJRDBtD307+o=
-github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg=
-github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVaaLLH7j4eDXPRvw78tMflu7Ie2bzYOH4Y8rRKBY=
-github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc=
-github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY=
-github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs=
 github.com/buger/jsonparser v0.0.0-20181115193947-bf1c66bbce23/go.mod h1:bbYlZJ7hK1yFx9hf58LP0zeX7UjIGs20ufpu3evjr+s=
 github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
 github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
@@ -171,13 +158,10 @@ github.com/cosmos/cosmos-sdk v0.46.13/go.mod h1:EfY521ATNEla8eJ6oJuZBdgP5+p360s7
 github.com/cosmos/go-bip39 v0.0.0-20180819234021-555e2067c45d/go.mod h1:tSxLoYXyBmiFeKpvmq4dzayMdCjCnu8uqmCysIGBT2Y=
 github.com/cosmos/go-bip39 v1.0.0 h1:pcomnQdrdH22njcAatO0yWojsUnCO3y2tNoV1cb6hHY=
 github.com/cosmos/go-bip39 v1.0.0/go.mod h1:RNJv0H/pOIVgxw6KS7QeX2a0Uo0aKUlfhZ4xuwvCdJw=
-github.com/cosmos/gogoproto v1.4.3 h1:RP3yyVREh9snv/lsOvmsAPQt8f44LgL281X0IOIhhcI=
-github.com/cosmos/gogoproto v1.4.3/go.mod h1:0hLIG5TR7IvV1fme1HCFKjfzW9X2x0Mo+RooWXCnOWU=
 github.com/cosmos/gorocksdb v1.2.0 h1:d0l3jJG8M4hBouIZq0mDUHZ+zjOx044J3nGRskwTb4Y=
 github.com/cosmos/gorocksdb v1.2.0/go.mod h1:aaKvKItm514hKfNJpUJXnnOWeBnk2GL4+Qw9NHizILw=
 github.com/cosmos/iavl v0.19.6 h1:XY78yEeNPrEYyNCKlqr9chrwoeSDJ0bV2VjocTk//OU=
 github.com/cosmos/iavl v0.19.6/go.mod h1:X9PKD3J0iFxdmgNLa7b2LYWdsGd90ToV5cAONApkEPw=
-github.com/cosmos/ibc-go/v5 v5.2.0 h1:LxwttRQqdUJpQ3/Gc3XPg5lkRo3pcbzx65dxFIY6ONE=
 github.com/cosmos/ledger-cosmos-go v0.12.2 h1:/XYaBlE2BJxtvpkHiBm97gFGSGmYGKunKyF3nNqAXZA=
 github.com/cosmos/ledger-cosmos-go v0.12.2/go.mod h1:ZcqYgnfNJ6lAXe4HPtWgarNEY+B74i+2/8MhZw4ziiI=
 github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
@@ -189,7 +173,6 @@ github.com/creachadair/taskgroup v0.3.2/go.mod h1:wieWwecHVzsidg2CsUnFinW1faVN4+
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/danieljoos/wincred v1.1.2 h1:QLdCxFs1/Yl4zduvBdcHB8goaYk9RARS2SgLLRuAyr0=
 github.com/danieljoos/wincred v1.1.2/go.mod h1:GijpziifJoIBfYh+S7BbkdUTU4LfM+QnGqR5Vl2tAx0=
-github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -214,27 +197,23 @@ github.com/dgraph-io/ristretto v0.1.1/go.mod h1:S1GPSBCYCIhmVNfcth17y2zZtQT6wzkz
 github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
 github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WAFKLNi6ZS0675eEUC9y3AlwSbQu1Y=
 github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
-github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
-github.com/dlclark/regexp2 v1.4.1-0.20201116162257-a2a8dda75c91 h1:Izz0+t1Z5nI16/II7vuEo/nHjodOg0p7+OiDpjX5t1E=
 github.com/docker/go-connections v0.4.0 h1:El9xVISelRB7BuFusrZozjnkIM5YnzCViNKohAFqRJQ=
 github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
 github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
 github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
-github.com/dop251/goja v0.0.0-20220405120441-9037c2b61cbf h1:Yt+4K30SdjOkRoRRm3vYNQgR+/ZIy0RmeUDZo7Y8zeQ=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/dustin/go-humanize v1.0.1-0.20200219035652-afde56e7acac h1:opbrjaN/L8gg6Xh5D04Tem+8xVcz6ajZlGCs49mQgyg=
 github.com/dustin/go-humanize v1.0.1-0.20200219035652-afde56e7acac/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/dvsekhvalnov/jose2go v1.5.0 h1:3j8ya4Z4kMCwT5nXIKFSV84YS+HdqSSO0VsTQxaLAeM=
 github.com/dvsekhvalnov/jose2go v1.5.0/go.mod h1:QsHjhyTlD/lAVqn/NSbVZmSCGeDehTB/mPZadG+mhXU=
-github.com/dymensionxyz/cosmosclient v0.3.0-beta.0.20230514120937-449e9becd080 h1:ZNTHi2xEJ5reGw1k8X6QFM9n1TdW/3zMCbi27hEmSi0=
-github.com/dymensionxyz/cosmosclient v0.3.0-beta.0.20230514120937-449e9becd080/go.mod h1:+zZkh3ntB21qQsfJjdn9aRGLLMmeDWWO+FxnWl8RWpw=
+github.com/dymensionxyz/cosmosclient v0.3.0-beta.0.20230621132116-77eb2ae5ab92 h1:OIKQAadI4pa2LTi888nzEWrGAUW225ysETiEHIr+oLY=
+github.com/dymensionxyz/cosmosclient v0.3.0-beta.0.20230621132116-77eb2ae5ab92/go.mod h1:3y64ecWDzhnd0sSYZfaL4QpwgK0b0j6LFLVRGdygg+o=
 github.com/dymensionxyz/dymension v0.2.0-beta.0.20230607115558-745644a96ea6 h1:dnriGXmMdYEiF/8lMrj+PDlN1vyQc6zgs/ZHL67eoyI=
 github.com/dymensionxyz/dymension v0.2.0-beta.0.20230607115558-745644a96ea6/go.mod h1:rDkVuF+DxBDi5tTgVHFk1D2xpqf8bOccs6aB1wTOvP0=
 github.com/dymensionxyz/go-cnc v0.2.2 h1:C7WUFJ+PkkB62HPegBJJL+YlQExqvYudTTRdNiCNIDk=
 github.com/dymensionxyz/go-cnc v0.2.2/go.mod h1:CZBVUhQnJnAVcfQnnEAqREF+PNWr97m/BhJ5fp1K44Q=
 github.com/dymensionxyz/rpc v1.3.1 h1:7EXWIobaBes5zldRvTIg7TmNsEKjicrWA/OjCc0NaGs=
 github.com/dymensionxyz/rpc v1.3.1/go.mod h1:f+WpX8ysy8wt95iGc6auYlHcnHj2bUkhiRVkkKNys8c=
-github.com/edsrzf/mmap-go v1.0.0 h1:CEBF7HpRnUCSJgGUb5h1Gm7e3VkmVDrR8lvWVLtrOFw=
 github.com/elastic/gosigar v0.12.0/go.mod h1:iXRIGg2tLnu7LBdpqzyQfGDEidKCfWcCMS0WKyPWoMs=
 github.com/elastic/gosigar v0.14.2 h1:Dg80n8cr90OZ7x+bAax/QjoW/XqTI11RmA79ZwIm9/4=
 github.com/elastic/gosigar v0.14.2/go.mod h1:iXRIGg2tLnu7LBdpqzyQfGDEidKCfWcCMS0WKyPWoMs=
@@ -248,8 +227,6 @@ github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.m
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/ethereum/go-ethereum v1.10.26 h1:i/7d9RBBwiXCEuyduBQzJw/mKmnvzsN14jqBmytw72s=
 github.com/ethereum/go-ethereum v1.10.26/go.mod h1:EYFyF19u3ezGLD4RqOkLq+ZCXzYbLoNDdZlMt7kyKFg=
-github.com/evmos/ethermint v0.20.0 h1:WNRxhCeGiL9Itl4vWalNYMRqkrV8IarnJn0iPJywFso=
-github.com/evmos/ethermint v0.20.0/go.mod h1:6GwJlPogJh9aiWrDGNIOIQ0fX2Lo3Tc7sTvrSe+BFL4=
 github.com/facebookgo/ensure v0.0.0-20200202191622-63f1cf65ac4c h1:8ISkoahWXwZR41ois5lSJBSVw4D0OV19Ht/JSTzvSv0=
 github.com/facebookgo/stack v0.0.0-20160209184415-751773369052 h1:JWuenKqqX8nojtoVVWjGfOF9635RETekkoH6Cc9SX0A=
 github.com/facebookgo/subset v0.0.0-20200203212716-c811ad88dec4 h1:7HZCaLC5+BZpmbhCOZJ293Lz68O7PYrF2EzeiFMwCLk=
@@ -267,7 +244,6 @@ github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4
 github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU=
 github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
 github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw=
-github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff h1:tY80oXqGNY4FhTFhk+o9oFHGINQ/+vhlm8HFzi6znCI=
 github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
@@ -292,6 +268,7 @@ github.com/go-logfmt/logfmt v0.5.1/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KE
 github.com/go-logr/logr v1.2.3 h1:2DntVwHkVopvECVRSlL5PSo9eG+cAkDCuckLubN+rq0=
 github.com/go-ole/go-ole v1.2.5/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
+github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
 github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
@@ -301,7 +278,6 @@ github.com/go-playground/validator/v10 v10.2.0 h1:KgJ0snyC2R9VXYN2rneOtQcw5aHQB1
 github.com/go-playground/validator/v10 v10.2.0/go.mod h1:uOYAAleCW8F/7oMFd6aG0GOhaH6EGOAJShg8Id5JGkI=
 github.com/go-resty/resty/v2 v2.7.0 h1:me+K9p3uhSmXtrBZ4k9jcEAfJmuC8IivWHwaLZwPrFY=
 github.com/go-resty/resty/v2 v2.7.0/go.mod h1:9PWDzw47qPphMRFfhsyk0NnSgvluHcljSMVIq3w7q0I=
-github.com/go-sourcemap/sourcemap v2.1.3+incompatible h1:W1iEw64niKVGogNgBN3ePyLFfuisuzeidWPMPWmECqU=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/go-stack/stack v1.8.1 h1:ntEHSVwIt7PNXNpgPmVfMrNhLtgjlmnZha2kOpuRiDw=
 github.com/go-stack/stack v1.8.1/go.mod h1:dcoOX6HbPZSZptuspn9bctJ+N/CnF5gGygcUP3XYfe4=
@@ -359,7 +335,6 @@ github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaS
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
 github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
@@ -469,8 +444,6 @@ github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/hdevalence/ed25519consensus v0.0.0-20220222234857-c00d1f31bab3 h1:aSVUgRRRtOrZOC1fYmY9gV0e9z/Iu+xNVSASWjsuyGU=
 github.com/hdevalence/ed25519consensus v0.0.0-20220222234857-c00d1f31bab3/go.mod h1:5PC6ZNPde8bBqU/ewGZig35+UIZtw9Ytxez8/q5ZyFE=
-github.com/holiman/bloomfilter/v2 v2.0.3 h1:73e0e/V0tCydx14a0SCYS/EWCxgwLZ18CZcZKVu0fao=
-github.com/holiman/uint256 v1.2.1 h1:XRtyuda/zw2l+Bq/38n5XUoEF72aSOu/77Thd9pPp2o=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/huin/goupnp v1.0.0/go.mod h1:n9v9KO1tAxYH82qOn+UTIFQDmx5n1Zxd/ClZDMX7Bnc=
 github.com/huin/goupnp v1.0.3 h1:N8No57ls+MnjlB+JPiCVSOyy/ot7MJTqlo7rn+NYSqQ=
@@ -512,11 +485,9 @@ github.com/jbenet/go-temp-err-catcher v0.1.0/go.mod h1:0kJRvmDZXNMIiJirNPEYfhpPw
 github.com/jbenet/goprocess v0.1.4 h1:DRGOFReOMqqDNXwW70QkacFW0YN9QnwLV0Vqk+3oU0o=
 github.com/jbenet/goprocess v0.1.4/go.mod h1:5yspPrukOVuOLORacaBi858NqyClJPQxYZlqdZVfqY4=
 github.com/jellevandenhooff/dkim v0.0.0-20150330215556-f50fe3d243e1/go.mod h1:E0B/fFc00Y+Rasa88328GlI/XbtyysCtTHZS8h7IrBU=
-github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
 github.com/jmhodges/levigo v1.0.0 h1:q5EC36kV79HWeTBWsod3mG11EgStG3qArTKcvlksN1U=
 github.com/jmhodges/levigo v1.0.0/go.mod h1:Q6Qx+uH3RAqyK4rFQroq9RL7mdkABMcfhEI+nNuzMJQ=
-github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
@@ -527,7 +498,6 @@ github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfV
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
 github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4=
 github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/klauspost/compress v1.12.3/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg=
 github.com/klauspost/compress v1.16.0 h1:iULayQNOReoYUe+1qtKOqw9CwJv3aNQu8ivo7lw1HU4=
@@ -601,7 +571,6 @@ github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Ky
 github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
 github.com/mattn/go-isatty v0.0.18 h1:DOKFKCQ7FNG2L1rbrmstDN4QVRdS89Nkh85u68Uwp98=
 github.com/mattn/go-isatty v0.0.18/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.10 h1:CoZ3S2P7pvtP45xOtBw+/mDL2z0RKI576gSkzRRpdGg=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo=
 github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
@@ -609,7 +578,6 @@ github.com/microcosm-cc/bluemonday v1.0.1/go.mod h1:hsXNsILzKxV+sX77C5b8FSuKF00v
 github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJysuI=
 github.com/miekg/dns v1.1.50 h1:DQUfb9uc6smULcREF09Uc+/Gd46YWqJd5DbpPE9xkcA=
 github.com/miekg/dns v1.1.50/go.mod h1:e3IlAVfNqAllflbibAZEWOXOQ+Ynzk/dDozDxY7XnME=
-github.com/miguelmota/go-ethereum-hdwallet v0.1.1 h1:zdXGlHao7idpCBjEGTXThVAtMKs+IxAgivZ75xqkWK0=
 github.com/mikioh/tcp v0.0.0-20190314235350-803a9b46060c h1:bzE/A84HN25pxAuk9Eej1Kz9OUelF97nAc82bDquQI8=
 github.com/mikioh/tcp v0.0.0-20190314235350-803a9b46060c/go.mod h1:0SQS9kMwD2VsyFEB++InYyBJroV/FRmBgcydeSUcJms=
 github.com/mikioh/tcpinfo v0.0.0-20190314235526-30a79bb1804b h1:z78hV3sbSMAUoyUMM0I83AUIT6Hu17AWfgjzIbtrYFc=
@@ -683,10 +651,7 @@ github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLA
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
 github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
-github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
-github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
 github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vvnwo0=
 github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
@@ -694,7 +659,6 @@ github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042
 github.com/onsi/ginkgo/v2 v2.1.3/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c=
 github.com/onsi/ginkgo/v2 v2.5.1 h1:auzK7OI497k6x4OvWq+TKAcpcSAlod0doAH72oIN0Jw=
 github.com/onsi/ginkgo/v2 v2.5.1/go.mod h1:63DOGlLAH8+REH8jUGdL3YpCpu7JODesutUjdENfUAc=
-github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
@@ -758,8 +722,6 @@ github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsT
 github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
 github.com/prometheus/procfs v0.9.0 h1:wzCHvIvM5SxWqYvwgVL7yJY8Lz3PKn49KQtpgMYJfhI=
 github.com/prometheus/procfs v0.9.0/go.mod h1:+pB4zwohETzFnmlpe6yd2lSc+0/46IYZRB/chUwxUZY=
-github.com/prometheus/tsdb v0.10.0 h1:If5rVCMTp6W2SiRAQFlbpJNgVlgMEd+U2GZckwK38ic=
-github.com/prometheus/tsdb v0.10.0/go.mod h1:oi49uRhEe9dPUTlS3JRZOwJuVi6tmh10QSgwXEyGCt4=
 github.com/quic-go/qpack v0.4.0 h1:Cr9BXA1sQS2SmDUWjSofMPNKmvF6IiIfDRmgU0w1ZCo=
 github.com/quic-go/qpack v0.4.0/go.mod h1:UZVnYIfi5GRk+zI9UMaCPsmZ2xKJP7XBUvVyT1Knj9A=
 github.com/quic-go/qtls-go1-19 v0.2.1 h1:aJcKNMkH5ASEJB9FXNeZCyTEIHU1J7MmHyz1Q1TSG1A=
@@ -778,9 +740,6 @@ github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqn
 github.com/regen-network/cosmos-proto v0.3.1 h1:rV7iM4SSFAagvy8RiyhiACbWEGotmqzywPxOvwMdxcg=
 github.com/regen-network/protobuf v1.3.2-alpha.regen.4 h1:c9jEnU+xm6vqyrQe3M94UFWqiXxRIKKnqBOh2EACmBE=
 github.com/regen-network/protobuf v1.3.2-alpha.regen.4/go.mod h1:/J8/bR1T/NXyIdQDLUaq15LjNE83nRzkyrLAMcPewig=
-github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
-github.com/rjeczalik/notify v0.9.2 h1:MiTWrPj55mNDHEiIX5YUSKefw/+lCQVoAFmD6oQm5w8=
-github.com/rjeczalik/notify v0.9.2/go.mod h1:aErll2f0sUX9PXZnVNyeiObbmTlk5jnMoCa4QEjJeqM=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
@@ -853,7 +812,6 @@ github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An
 github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
 github.com/spf13/viper v1.14.0 h1:Rg7d3Lo706X9tHsJMUjdiwMpHB7W8WnSVOssIY+JElU=
 github.com/spf13/viper v1.14.0/go.mod h1:WT//axPky3FdvXHzGw33dNdXXXfFQqmEalje+egj8As=
-github.com/status-im/keycard-go v0.0.0-20200402102358-957c09536969 h1:Oo2KZNP70KE0+IUJSidPj/BFS/RXNHmKIJOdckzml2E=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
@@ -886,11 +844,11 @@ github.com/tidwall/btree v1.5.0 h1:iV0yVY/frd7r6qGBXfEYs7DH0gTDgrKTrDjS7xt/IyQ=
 github.com/tidwall/btree v1.5.0/go.mod h1:LGm8L/DZjPLmeWGjv5kFrY8dL4uVhMmzmmLYmsObdKE=
 github.com/tinylib/msgp v1.1.5/go.mod h1:eQsjooMTnV42mHu917E26IogZ2930nFyBQdofk10Udg=
 github.com/tklauser/go-sysconf v0.3.10 h1:IJ1AZGZRWbY8T5Vfk04D9WOA5WSejdflXxP03OUqALw=
+github.com/tklauser/go-sysconf v0.3.10/go.mod h1:C8XykCvCb+Gn0oNCWPIlcb0RuglQTYaQ2hGm7jmxEFk=
 github.com/tklauser/numcpus v0.4.0 h1:E53Dm1HjH1/R2/aoCtXtPgzmElmn51aOkhCFSuZq//o=
+github.com/tklauser/numcpus v0.4.0/go.mod h1:1+UI3pD8NW14VMwdgJNJ1ESk2UnwhAnz5hMwiKKqXCQ=
 github.com/ttacon/chalk v0.0.0-20160626202418-22c06c80ed31/go.mod h1:onvgF043R+lC5RZ8IT9rBXDaEDnpnw/Cl+HFiw+v/7Q=
 github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
-github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8=
-github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U=
 github.com/ugorji/go v1.1.7 h1:/68gy2h+1mWMrwZFeD1kQialdSzAb432dtpeJ42ovdo=
 github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
 github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
@@ -952,7 +910,6 @@ go.uber.org/zap v1.24.0 h1:FiJd5l1UOLj0wCgbSE0rwwXHzEdAZS6hiiSnxJN/D60=
 go.uber.org/zap v1.24.0/go.mod h1:2kMP+WWQ8aoFoedH3T2sq6iJ2yDWpHbP0f6MQbS9Gkg=
 go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE=
 golang.org/x/build v0.0.0-20190111050920-041ab4dc3f9d/go.mod h1:OWs+y06UdEOHN4y+MfF/py+xQ/tYqIWW03b70/CG9Rw=
-golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181030102418-4d3f4d9ffa16/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
@@ -963,7 +920,6 @@ golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8U
 golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200115085410-6d4e4cb37c7d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200602180216-279210d13fed/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
@@ -1091,7 +1047,6 @@ golang.org/x/sys v0.0.0-20180810173357-98c5dad5d1a0/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180926160741-c2ed4eda69e7/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181029174526-d69651ed3497/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -1152,6 +1107,7 @@ golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210819135213-f52c844e1c1c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

From 5c4f20bfd0143e277b393ed91cdc910f3738ee66 Mon Sep 17 00:00:00 2001
From: omritoptix <omritoptix@gmail.com>
Date: Sun, 25 Jun 2023 11:30:40 +0200
Subject: [PATCH 12/12] Fixed go-fmt.

---
 config/defaults.go | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/config/defaults.go b/config/defaults.go
index 77a066fc6..3ccc45bc4 100644
--- a/config/defaults.go
+++ b/config/defaults.go
@@ -28,12 +28,12 @@ func DefaultConfig(home, chainId string) *NodeConfig {
 			Seeds:         ""},
 		Aggregator: true,
 		BlockManagerConfig: BlockManagerConfig{
-    BlockTime:              200 * time.Millisecond,
-    EmptyBlocksMaxTime:     60 * time.Second,
-    BatchSubmitMaxTime:     600 * time.Second,
-    NamespaceID:            "000000000000ffff",
-    BlockBatchSize:         500,
-    BlockBatchMaxSizeBytes: 1500000},
+			BlockTime:              200 * time.Millisecond,
+			EmptyBlocksMaxTime:     60 * time.Second,
+			BatchSubmitMaxTime:     600 * time.Second,
+			NamespaceID:            "000000000000ffff",
+			BlockBatchSize:         500,
+			BlockBatchMaxSizeBytes: 1500000},
 		DALayer:         "mock",
 		SettlementLayer: "mock",
 	}