feat: add keyName

README.md

@@ -20,7 +20,7 @@ go-da defines a generic Data Availability interface for modular blockchains.
 | `GetProofs`      | `ids []id, namespace Namespace`                     | `[]Proof`          |
 | `Commit`      | `blobs []Blob, namespace Namespace`                      | `[]Commitment`  |
 | `Validate`    | `ids []Blob, proofs []Proof, namespace Namespace`        | `[]bool`        |
-| `Submit`      | `blobs []Blob, gasPrice float64, namespace Namespace`    | `[]ID` |
+| `Submit`      | `blobs []Blob, gasPrice float64, namespace Namespace, keyName keyName`    | `[]ID` |
 
 NOTE: The `Namespace` parameter in the interface methods is optional and used
 only on DA layers that support the functionality, for example Celestia

da.go

@@ -26,7 +26,7 @@
 	//
 	// This method is synchronous. Upon successful submission to Data Availability layer, it returns the IDs identifying blobs
 	// in DA.
-	Submit(ctx context.Context, blobs []Blob, gasPrice float64, namespace Namespace) ([]ID, error)
+	Submit(ctx context.Context, blobs []Blob, gasPrice float64, namespace Namespace, keyName keyName) ([]ID, error)
 
 	// Validate validates Commitments against the corresponding Proofs. This should be possible without retrieving the Blobs.
 	Validate(ctx context.Context, ids []ID, proofs []Proof, namespace Namespace) ([]bool, error)
@@ -36,6 +36,10 @@
 // posted to, for DA layers supporting the functionality.
 type Namespace = []byte
 
+// KeyName is an optional parameter used to set the keyring keyname for
+// the DA service.
+type KeyName = []byte
+
 // Blob is the data submitted/received from DA interface.
 type Blob = []byte
 

proto/da/da.proto

@@ -105,9 +105,14 @@ message CommitResponse {
 
 // SubmitRequest is the request type for the Submit rpc method.
 message SubmitRequest {
-	repeated Blob blobs = 1;
-	double gas_price = 2;
-	Namespace namespace = 3;
+        repeated Blob blobs = 1;
+        double gas_price = 2;
+        Namespace namespace = 3;
+        KeyName keyName = 4;
+}
+
+message KeyName {
+    bytes value = 1;
 }
 
 // SubmitResponse is the response type for the Submit rpc method.

proxy/grpc/client.go

@@ -5,7 +5,7 @@
 
 	"google.golang.org/grpc"
 
 	"github.com/rollkit/go-da"
 	pbda "github.com/rollkit/go-da/types/pb/da"
 )
 
@@ -48,7 +48,7 @@
 }
 
 // Get returns Blob for each given ID, or an error.
 func (c *Client) Get(ctx context.Context, ids []da.ID, namespace da.Namespace) ([]da.Blob, error) {
 	req := &pbda.GetRequest{
 		Ids:       make([]*pbda.ID, len(ids)),
 		Namespace: &pbda.Namespace{Value: namespace},
@@ -65,7 +65,7 @@
 }
 
 // GetIDs returns IDs of all Blobs located in DA at given height.
 func (c *Client) GetIDs(ctx context.Context, height uint64, namespace da.Namespace) ([]da.ID, error) {
 	req := &pbda.GetIDsRequest{Height: height, Namespace: &pbda.Namespace{Value: namespace}}
 	resp, err := c.client.GetIDs(ctx, req)
 	if err != nil {
@@ -105,11 +105,16 @@
 }
 
 // Submit submits the Blobs to Data Availability layer.
-func (c *Client) Submit(ctx context.Context, blobs []da.Blob, gasPrice float64, namespace da.Namespace) ([]da.ID, error) {
+func (c *Client) Submit(ctx context.Context, blobs []da.Blob, gasPrice float64, namespace da.Namespace, keyName da.KeyName) ([]da.ID, error) {
 	req := &pbda.SubmitRequest{
 		Blobs:     blobsDA2PB(blobs),
 		GasPrice:  gasPrice,
 		Namespace: &pbda.Namespace{Value: namespace},
+		Namespace: &pbda.KeyName{Value: keyName},
+	}
+
+	if keyName != nil {
+		req.KeyName = &pbda.KeyName{Value: *keyName}
 	}
 
 	resp, err := c.client.Submit(ctx, req)

proxy/grpc/server.go

@@ -21,7 +21,7 @@
 }
 
 type proxySrv struct {
 	target da.DA
 }
 
 func (p *proxySrv) MaxBlobSize(
@@ -69,7 +69,12 @@
 func (p *proxySrv) Submit(ctx context.Context, request *pbda.SubmitRequest) (*pbda.SubmitResponse, error) {
 	blobs := blobsPB2DA(request.Blobs)
 
-	ids, err := p.target.Submit(ctx, blobs, request.GasPrice, request.Namespace.GetValue())
+	var keyName da.KeyName
+	if request.KeyName != nil {
+		keyName = (da.KeyName)(&request.KeyName.Value)
+	}
+
+	ids, err := p.target.Submit(ctx, blobs, request.GasPrice, request.Namespace.GetValue(), request.KeyName.GetValue())
 	if err != nil {
 		return nil, err
 	}

proxy/jsonrpc/client.go

@@ -26,7 +26,7 @@ type API struct {
 		GetProofs   func(ctx context.Context, ids []da.ID, ns da.Namespace) ([]da.Proof, error)          `perm:"read"`
 		Commit      func(ctx context.Context, blobs []da.Blob, ns da.Namespace) ([]da.Commitment, error) `perm:"read"`
 		Validate    func(context.Context, []da.ID, []da.Proof, da.Namespace) ([]bool, error)             `perm:"read"`
-		Submit      func(context.Context, []da.Blob, float64, da.Namespace) ([]da.ID, error)             `perm:"write"`
+		Submit      func(context.Context, []da.Blob, float64, da.Namespace, da.KeyName) ([]da.ID, error) `perm:"write"`
 	}
 }
 
@@ -61,8 +61,8 @@ func (api *API) Validate(ctx context.Context, ids []da.ID, proofs []da.Proof, ns
 }
 
 // Submit submits the Blobs to Data Availability layer.
-func (api *API) Submit(ctx context.Context, blobs []da.Blob, gasPrice float64, ns da.Namespace) ([]da.ID, error) {
-	return api.Internal.Submit(ctx, blobs, gasPrice, ns)
+func (api *API) Submit(ctx context.Context, blobs []da.Blob, gasPrice float64, ns da.Namespace, keyName da.KeyName) ([]da.ID, error) {
+	return api.Internal.Submit(ctx, blobs, gasPrice, ns, keyName)
 }
 
 // Client is the jsonrpc client

test/dummy.go

@@ -122,7 +122,7 @@ func (d *DummyDA) Commit(ctx context.Context, blobs []da.Blob, _ da.Namespace) (
 }
 
 // Submit stores blobs in DA layer.
-func (d *DummyDA) Submit(ctx context.Context, blobs []da.Blob, gasPrice float64, _ da.Namespace) ([]da.ID, error) {
+func (d *DummyDA) Submit(ctx context.Context, blobs []da.Blob, gasPrice float64, _ da.Namespace, keyName *da.KeyName) ([]da.ID, error) {
 	d.mu.Lock()
 	defer d.mu.Unlock()
 	ids := make([]da.ID, len(blobs))

test/test_suite.go

@@ -40,15 +40,15 @@ func BasicDATest(t *testing.T, d da.DA) {
 	msg2 := []byte("message 2")
 
 	ctx := context.TODO()
-	id1, err := d.Submit(ctx, []da.Blob{msg1}, 0, testNamespace)
+	id1, err := d.Submit(ctx, []da.Blob{msg1}, 0, testNamespace, nil)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, id1)
 
-	id2, err := d.Submit(ctx, []da.Blob{msg2}, 0, testNamespace)
+	id2, err := d.Submit(ctx, []da.Blob{msg2}, 0, testNamespace, nil)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, id2)
 
-	id3, err := d.Submit(ctx, []da.Blob{msg1}, 0, testNamespace)
+	id3, err := d.Submit(ctx, []da.Blob{msg1}, 0, testNamespace, nil)
 	assert.NoError(t, err)
 	assert.NotEmpty(t, id3)
 
@@ -92,7 +92,7 @@ func GetIDsTest(t *testing.T, d da.DA) {
 	msgs := [][]byte{[]byte("msg1"), []byte("msg2"), []byte("msg3")}
 
 	ctx := context.TODO()
-	ids, err := d.Submit(ctx, msgs, 0, testNamespace)
+	ids, err := d.Submit(ctx, msgs, 0, testNamespace, nil)
 	assert.NoError(t, err)
 	assert.Len(t, ids, len(msgs))
 
@@ -147,7 +147,7 @@ func ConcurrentReadWriteTest(t *testing.T, d da.DA) {
 	go func() {
 		defer wg.Done()
 		for i := uint64(1); i <= 100; i++ {
-			_, err := d.Submit(ctx, [][]byte{[]byte("test")}, 0, testNamespace)
+			_, err := d.Submit(ctx, [][]byte{[]byte("test")}, 0, testNamespace, nil)
 			assert.NoError(t, err)
 		}
 	}()