merging qchain to main

.github/workflows/push-docker-dev.yaml

@@ -0,0 +1,25 @@
+name: Deploy dev images to GHCR
+
+on:
+  push:
+    branches:
+      - 'dev'
+
+jobs:
+  push-store-image:
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Checkout GitHub Action'
+        uses: actions/checkout@main
+
+      - name: 'Login to GitHub Container Registry'
+        uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: ${{github.actor}}
+          password: ${{secrets.GITHUB_TOKEN}}
+
+      - name: 'Build Inventory Image'
+        run: |
+          docker build . --tag ghcr.io/qubic/qubic-archiver:dev
+          docker push ghcr.io/qubic/qubic-archiver:dev

.github/workflows/push-docker.yaml

@@ -1,4 +1,4 @@
-name: Deploy Images to GHCR
+name: Deploy prod images to GHCR
 
 on:
   push:

.github/workflows/test.yaml

@@ -5,7 +5,7 @@ jobs:
     strategy:
       matrix:
         go-version: [1.20.x]
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [ubuntu-latest]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v3

processor/processor.go

@@ -95,7 +95,7 @@ func (p *Processor) processOneByOne() error {
 	}
 
 	val := validator.New(client, p.ps)
-	err = val.ValidateTick(ctx, nextTick)
+	err = val.ValidateTick(ctx, uint64(tickInfo.InitialTick), nextTick)
 	if err != nil {
 		return errors.Wrapf(err, "validating tick %d", nextTick)
 	}

protobuff/archive.proto

@@ -180,6 +180,14 @@ message GetTransferTransactionsPerTickResponse {
   TransferTransactionsPerTick transfer_transactions_per_tick = 1;
 }
 
+message GetQChainHashRequest {
+  uint32 tick_number = 1;
+}
+
+message GetQChainHashResponse {
+  string hex_digest = 1;
+}
+
 service ArchiveService {
   rpc GetTickData(GetTickDataRequest) returns (GetTickDataResponse);
   rpc GetTickTransactions(GetTickTransactionsRequest) returns (GetTickTransactionsResponse);
@@ -192,4 +200,5 @@ service ArchiveService {
   rpc GetSkippedTicks(GetSkippedTicksRequest) returns (GetSkippedTicksResponse);
   rpc GetTransferTransactions(GetTransferTransactionsRequest) returns (GetTransferTransactionsResponse);
   rpc GetTransferTransactionsPerTick(GetTransferTransactionsPerTickRequest) returns (GetTransferTransactionsPerTickResponse);
+  rpc GetQChainHash(GetQChainHashRequest) returns (GetQChainHashResponse);
 }

rpc/rpc_server.go

@@ -207,6 +207,18 @@ func (s *Server) GetTransferTransactionsPerTick(ctx context.Context, req *protob
 	return &protobuff.GetTransferTransactionsPerTickResponse{TransferTransactionsPerTick: txs}, nil
 }
 
+func (s *Server) GetQChainHash(ctx context.Context, req *protobuff.GetQChainHashRequest) (*protobuff.GetQChainHashResponse, error) {
+	hash, err := s.store.GetQChainDigest(ctx, uint64(req.TickNumber))
+	if err != nil {
+		if errors.Cause(err) == store.ErrNotFound {
+			return nil, status.Errorf(codes.NotFound, "qChain hash for specified tick not found")
+		}
+		return nil, status.Errorf(codes.Internal, "getting qChain hash: %v", err)
+	}
+
+	return &protobuff.GetQChainHashResponse{HexDigest: hex.EncodeToString(hash[:])}, nil
+}
+
 func (s *Server) Start() error {
 	srv := grpc.NewServer(
 		grpc.MaxRecvMsgSize(600*1024*1024),

store/keys.go

@@ -13,6 +13,7 @@ const (
 	LastProcessedTickPerEpoch    = 0x05
 	SkippedTicksInterval         = 0x06
 	IdentityTransferTransactions = 0x07
+	QChainDigest                 = 0x08
 )
 
 func tickDataKey(tickNumber uint64) []byte {
@@ -72,3 +73,10 @@ func identityTransferTransactions(identity string) []byte {
 
 	return key
 }
+
+func qChainDigestKey(tickNumber uint64) []byte {
+	key := []byte{QChainDigest}
+	key = binary.BigEndian.AppendUint64(key, tickNumber)
+
+	return key
+}

store/store.go

@@ -399,3 +399,29 @@ func (s *PebbleStore) GetTransferTransactionsPerTick(ctx context.Context, identi
 
 	return &perTick, nil
 }
+
+func (s *PebbleStore) PutQChainDigest(ctx context.Context, tickNumber uint64, digest []byte) error {
+	key := qChainDigestKey(tickNumber)
+
+	err := s.db.Set(key, digest, pebble.Sync)
+	if err != nil {
+		return errors.Wrap(err, "setting qChain digest")
+	}
+
+	return nil
+}
+
+func (s *PebbleStore) GetQChainDigest(ctx context.Context, tickNumber uint64) ([]byte, error) {
+	key := qChainDigestKey(tickNumber)
+	value, closer, err := s.db.Get(key)
+	if err != nil {
+		if errors.Is(err, pebble.ErrNotFound) {
+			return nil, ErrNotFound
+		}
+
+		return nil, errors.Wrap(err, "getting qChain digest")
+	}
+	defer closer.Close()
+
+	return value, nil
+}

store/store_test.go

@@ -541,3 +541,37 @@ func TestPebbleStore_TransferTransactions(t *testing.T) {
 	_, err = store.GetTransferTransactionsPerTick(ctx, idOne, 14)
 	require.EqualError(t, err, ErrNotFound.Error())
 }
+
+func TestPebbleStore_QChainHash(t *testing.T) {
+	ctx := context.Background()
+
+	// Setup test environment
+	dbDir, err := os.MkdirTemp("", "pebble_test")
+	require.NoError(t, err)
+	defer os.RemoveAll(dbDir)
+
+	db, err := pebble.Open(filepath.Join(dbDir, "testdb"), &pebble.Options{})
+	require.NoError(t, err)
+	defer db.Close()
+
+	logger, _ := zap.NewDevelopment()
+	store := NewPebbleStore(db, logger)
+
+	// Sample QChainHash for testing
+	tickNumber := uint64(12795005)
+	qChainHash := []byte("qChainHash")
+
+	// Set QChainHash
+	err = store.PutQChainDigest(ctx, tickNumber, qChainHash)
+	require.NoError(t, err)
+
+	// Get QChainHash
+	retrievedQChainHash, err := store.GetQChainDigest(ctx, tickNumber)
+	require.NoError(t, err)
+	require.Equal(t, qChainHash, retrievedQChainHash)
+
+	// Test retrieval of non-existent QChainHash
+	_, err = store.GetQChainDigest(ctx, 999) // Assuming 999 is a tick number that wasn't stored
+	require.Error(t, err)
+	require.Equal(t, ErrNotFound, err)
+}