da: replace submit options with gas price

da.go

@@ -29,7 +29,7 @@ type DA interface {
 	// This method is synchronous. Upon successful submission to Data Availability layer, it returns ID identifying blob
 	// in DA and Proof of inclusion.
 	// If options is nil, default options are used.
-	Submit(blobs []Blob, options *SubmitOptions) ([]ID, []Proof, error)
+	Submit(blobs []Blob, gasPrice float64) ([]ID, []Proof, error)
 
 	// Validate validates Commitments against the corresponding Proofs. This should be possible without retrieving the Blobs.
 	Validate(ids []ID, proofs []Proof) ([]bool, error)

proto/da/da.proto

@@ -81,16 +81,10 @@ message CommitResponse {
 	repeated Commitment commitments = 1;
 }
 
-// SubmitOptions is the options type for the Submit method.
-message SubmitOptions {
-    int64 fee = 1;
-    uint64 gas = 2;
-}
-
 // SubmitRequest is the request type for the Submit rpc method.
 message SubmitRequest {
 	repeated Blob blobs = 1;
-	SubmitOptions options = 2;
+	double gas_price = 2;
 }
 
 // SubmitResponse is the response type for the Submit rpc method.

proxy/client.go

@@ -89,10 +89,10 @@ func (c *Client) Commit(blobs []da.Blob) ([]da.Commitment, error) {
 }
 
 // Submit submits the Blobs to Data Availability layer.
-func (c *Client) Submit(blobs []da.Blob, options *da.SubmitOptions) ([]da.ID, []da.Proof, error) {
+func (c *Client) Submit(blobs []da.Blob, gasPrice float64) ([]da.ID, []da.Proof, error) {
 	req := &pbda.SubmitRequest{
-		Blobs:   blobsDA2PB(blobs),
-		Options: optionsDA2PB(options),
+		Blobs:    blobsDA2PB(blobs),
+		GasPrice: gasPrice,
 	}
 
 	resp, err := c.client.Submit(context.TODO(), req)

proxy/server.go

@@ -56,9 +56,8 @@ func (p *proxySrv) Commit(ctx context.Context, request *pbda.CommitRequest) (*pb
 
 func (p *proxySrv) Submit(ctx context.Context, request *pbda.SubmitRequest) (*pbda.SubmitResponse, error) {
 	blobs := blobsPB2DA(request.Blobs)
-	options := optionsPB2DA(request.GetOptions())
 
-	ids, proofs, err := p.target.Submit(blobs, options)
+	ids, proofs, err := p.target.Submit(blobs, request.GasPrice)
 	if err != nil {
 		return nil, err
 	}

proxy/util.go

@@ -21,26 +21,6 @@ func blobsPB2DA(pb []*pbda.Blob) []da.Blob {
 	return blobs
 }
 
-func optionsDA2PB(options *da.SubmitOptions) *pbda.SubmitOptions {
-	if options != nil {
-		return &pbda.SubmitOptions{
-			Fee: options.Fee,
-			Gas: options.Gas,
-		}
-	}
-	return &pbda.SubmitOptions{Fee: -1}
-}
-
-func optionsPB2DA(pb *pbda.SubmitOptions) *da.SubmitOptions {
-	if pb != nil {
-		return &da.SubmitOptions{
-			Fee: pb.Fee,
-			Gas: pb.Gas,
-		}
-	}
-	return da.DefaultSubmitOptions()
-}
-
 func idsPB2DA(pb []*pbda.ID) []da.ID {
 	ids := make([]da.ID, len(pb))
 	for i := range ids {

test/dummy.go

@@ -99,7 +99,7 @@ func (d *DummyDA) Commit(blobs []da.Blob) ([]da.Commitment, error) {
 }
 
 // Submit stores blobs in DA layer.
-func (d *DummyDA) Submit(blobs []da.Blob, options *da.SubmitOptions) ([]da.ID, []da.Proof, error) {
+func (d *DummyDA) Submit(blobs []da.Blob, gasPrice float64) ([]da.ID, []da.Proof, error) {
 	d.mu.Lock()
 	defer d.mu.Unlock()
 	ids := make([]da.ID, len(blobs))

test/test_suite.go

@@ -40,17 +40,17 @@ func BasicDATest(t *testing.T, da da.DA) {
 	msg1 := []byte("message 1")
 	msg2 := []byte("message 2")
 
-	id1, proof1, err := da.Submit([]Blob{msg1}, nil)
+	id1, proof1, err := da.Submit([]Blob{msg1}, 0)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, id1)
 	assert.NotEmpty(t, proof1)
 
-	id2, proof2, err := da.Submit([]Blob{msg2}, nil)
+	id2, proof2, err := da.Submit([]Blob{msg2}, 0)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, id2)
 	assert.NotEmpty(t, proof2)
 
-	id3, proof3, err := da.Submit([]Blob{msg1}, nil)
+	id3, proof3, err := da.Submit([]Blob{msg1}, 0)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, id3)
 	assert.NotEmpty(t, proof3)
@@ -110,7 +110,7 @@ func CheckErrors(t *testing.T, da da.DA) {
 func GetIDsTest(t *testing.T, da da.DA) {
 	msgs := [][]byte{[]byte("msg1"), []byte("msg2"), []byte("msg3")}
 
-	ids, proofs, err := da.Submit(msgs, nil)
+	ids, proofs, err := da.Submit(msgs, 0)
 	assert.NoError(t, err)
 	assert.Len(t, ids, len(msgs))
 	assert.Len(t, proofs, len(msgs))
@@ -162,7 +162,7 @@ func ConcurrentReadWriteTest(t *testing.T, da da.DA) {
 	go func() {
 		defer wg.Done()
 		for i := uint64(1); i <= 100; i++ {
-			_, _, err := da.Submit([][]byte{[]byte("test")}, nil)
+			_, _, err := da.Submit([][]byte{[]byte("test")}, 0)
 			assert.NoError(t, err)
 		}
 	}()