feat(database): unified certificate lookup table

Signed-off-by: Chris Gianelloni <[email protected]>

Author: wolf31o2

database/database_test.go

@@ -15,10 +15,16 @@
 package database_test
 
 import (
+	"math/big"
 	"testing"
 	"time"
 
 	"github.com/blinklabs-io/dingo/database"
+	"github.com/blinklabs-io/dingo/database/models"
+	"github.com/blinklabs-io/gouroboros/cbor"
+	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
+	ocommon "github.com/blinklabs-io/gouroboros/protocol/common"
+	"github.com/utxorpc/go-codegen/utxorpc/v1alpha/cardano"
 	"gorm.io/gorm"
 )
 
@@ -68,3 +74,317 @@ func TestInMemorySqliteMultipleTransaction(t *testing.T) {
 		t.Fatalf("unexpected error: %s", err)
 	}
 }
+
+// mockTransaction implements lcommon.Transaction for testing
+type mockTransaction struct {
+	hash         lcommon.Blake2b256
+	certificates []lcommon.Certificate
+	isValid      bool
+}
+
+func (m *mockTransaction) Hash() lcommon.Blake2b256 {
+	return m.hash
+}
+
+func (m *mockTransaction) Id() lcommon.Blake2b256 {
+	return m.hash
+}
+
+func (m *mockTransaction) Type() int {
+	return 0 // Shelley transaction
+}
+
+func (m *mockTransaction) Fee() uint64 {
+	return 1000
+}
+
+func (m *mockTransaction) TTL() uint64 {
+	return 1000000
+}
+
+func (m *mockTransaction) IsValid() bool {
+	return m.isValid
+}
+
+func (m *mockTransaction) Metadata() lcommon.TransactionMetadatum {
+	return nil
+}
+
+func (m *mockTransaction) CollateralReturn() lcommon.TransactionOutput {
+	return nil
+}
+
+func (m *mockTransaction) Produced() []lcommon.Utxo {
+	return nil
+}
+
+func (m *mockTransaction) Outputs() []lcommon.TransactionOutput {
+	return nil
+}
+
+func (m *mockTransaction) Inputs() []lcommon.TransactionInput {
+	return nil
+}
+
+func (m *mockTransaction) Collateral() []lcommon.TransactionInput {
+	return nil
+}
+
+func (m *mockTransaction) Certificates() []lcommon.Certificate {
+	return m.certificates
+}
+
+func (m *mockTransaction) ProtocolParameterUpdates() (uint64, map[lcommon.Blake2b224]lcommon.ProtocolParameterUpdate) {
+	return 0, nil
+}
+
+func (m *mockTransaction) AssetMint() *lcommon.MultiAsset[lcommon.MultiAssetTypeMint] {
+	return nil
+}
+
+func (m *mockTransaction) AuxDataHash() *lcommon.Blake2b256 {
+	return nil
+}
+
+func (m *mockTransaction) Cbor() []byte {
+	return []byte("mock_cbor")
+}
+
+func (m *mockTransaction) Consumed() []lcommon.TransactionInput {
+	return nil
+}
+
+func (m *mockTransaction) Witnesses() lcommon.TransactionWitnessSet {
+	return nil
+}
+
+func (m *mockTransaction) ValidityIntervalStart() uint64 {
+	return 0
+}
+
+func (m *mockTransaction) ReferenceInputs() []lcommon.TransactionInput {
+	return nil
+}
+
+func (m *mockTransaction) TotalCollateral() uint64 {
+	return 0
+}
+
+func (m *mockTransaction) Withdrawals() map[*lcommon.Address]uint64 {
+	return nil
+}
+
+func (m *mockTransaction) RequiredSigners() []lcommon.Blake2b224 {
+	return nil
+}
+
+func (m *mockTransaction) ScriptDataHash() *lcommon.Blake2b256 {
+	return nil
+}
+
+func (m *mockTransaction) VotingProcedures() lcommon.VotingProcedures {
+	return lcommon.VotingProcedures{}
+}
+
+func (m *mockTransaction) ProposalProcedures() []lcommon.ProposalProcedure {
+	return nil
+}
+
+func (m *mockTransaction) CurrentTreasuryValue() int64 {
+	return 0
+}
+
+func (m *mockTransaction) Donation() uint64 {
+	return 0
+}
+
+func (m *mockTransaction) Utxorpc() (*cardano.Tx, error) {
+	return nil, nil
+}
+
+func (m *mockTransaction) LeiosHash() lcommon.Blake2b256 {
+	return lcommon.Blake2b256{}
+}
+
+// TestUnifiedCertificateCreation tests that unified certificate records are created
+// when processing transactions with certificates
+func TestUnifiedCertificateCreation(t *testing.T) {
+	db, err := database.New(dbConfig)
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+
+	// Run auto-migration to ensure tables exist
+	if err := db.Metadata().DB().AutoMigrate(models.MigrateModels...); err != nil {
+		t.Fatalf("failed to auto-migrate: %v", err)
+	}
+
+	// Create a mock transaction with certificates
+	mockTx := &mockTransaction{
+		hash: lcommon.NewBlake2b256(
+			[]byte("test_hash_1234567890123456789012345678901234567890"),
+		),
+		isValid: true,
+		certificates: []lcommon.Certificate{
+			&lcommon.StakeRegistrationCertificate{
+				CertType: uint(lcommon.CertificateTypeStakeRegistration),
+				StakeCredential: lcommon.Credential{
+					CredType: lcommon.CredentialTypeAddrKeyHash,
+					Credential: lcommon.CredentialHash(
+						[]byte("stake_key_hash_1234567890123456789012345678"),
+					),
+				},
+			},
+			&lcommon.PoolRegistrationCertificate{
+				CertType: uint(lcommon.CertificateTypePoolRegistration),
+				Operator: lcommon.PoolKeyHash(
+					[]byte("pool_key_hash_1234567890123456789012345678"),
+				),
+				VrfKeyHash: lcommon.VrfKeyHash(
+					[]byte("vrf_key_hash_12345678901234567890123456789012"),
+				),
+				Pledge: 1000000,
+				Cost:   340000000,
+				Margin: cbor.Rat{Rat: big.NewRat(1, 100)},
+				RewardAccount: lcommon.AddrKeyHash(
+					[]byte("reward_account_1234567890123456789012345678"),
+				),
+				PoolOwners: []lcommon.AddrKeyHash{
+					lcommon.AddrKeyHash(
+						[]byte("owner1_1234567890123456789012345678"),
+					),
+				},
+			},
+			&lcommon.AuthCommitteeHotCertificate{
+				CertType: uint(lcommon.CertificateTypeAuthCommitteeHot),
+				ColdCredential: lcommon.Credential{
+					CredType: lcommon.CredentialTypeAddrKeyHash,
+					Credential: lcommon.CredentialHash(
+						[]byte("cold_cred_hash_1234567890123456789012345678"),
+					),
+				},
+				HotCredential: lcommon.Credential{
+					CredType: lcommon.CredentialTypeAddrKeyHash,
+					Credential: lcommon.CredentialHash(
+						[]byte("hot_cred_hash_1234567890123456789012345678"),
+					),
+				},
+			},
+		},
+	}
+
+	point := ocommon.Point{
+		Hash: []byte("block_hash_12345678901234567890123456789012"),
+		Slot: 1000000,
+	}
+
+	// Process the transaction
+	err = db.Metadata().
+		SetTransaction(mockTx, point, 0, map[int]uint64{0: 2000000, 1: 500000000}, nil)
+	if err != nil {
+		t.Fatalf("failed to set transaction: %v", err)
+	}
+
+	// Verify unified certificate records were created
+	var unifiedCerts []models.Certificate
+	if result := db.Metadata().DB().Order("cert_index ASC").Find(&unifiedCerts); result.Error != nil {
+		t.Fatalf("failed to query unified certificates: %v", result.Error)
+	}
+
+	if len(unifiedCerts) != 3 {
+		t.Errorf("expected 3 unified certificates, got %d", len(unifiedCerts))
+	}
+
+	// Verify the unified certificates have correct data
+	for i, cert := range unifiedCerts {
+		if cert.TransactionID == 0 {
+			t.Errorf("certificate %d has zero transaction ID", i)
+		}
+		if cert.CertIndex != uint(i) {
+			t.Errorf(
+				"certificate %d has cert_index %d, expected %d",
+				i,
+				cert.CertIndex,
+				i,
+			)
+		}
+		if cert.Slot != point.Slot {
+			t.Errorf(
+				"certificate %d has slot %d, expected %d",
+				i,
+				cert.Slot,
+				point.Slot,
+			)
+		}
+		if string(cert.BlockHash) != string(point.Hash) {
+			t.Errorf("certificate %d has wrong block hash", i)
+		}
+	}
+
+	// Verify specialized certificate records were created with correct CertificateID
+	var stakeReg models.StakeRegistration
+	if result := db.Metadata().DB().First(&stakeReg); result.Error != nil {
+		t.Fatalf("failed to query stake registration: %v", result.Error)
+	}
+
+	// Find the unified cert for stake registration (should be index 0)
+	var stakeUnified models.Certificate
+	if result := db.Metadata().DB().Where("cert_index = ? AND cert_type = ?", 0, uint(lcommon.CertificateTypeStakeRegistration)).First(&stakeUnified); result.Error != nil {
+		t.Fatalf(
+			"failed to find unified stake registration cert: %v",
+			result.Error,
+		)
+	}
+
+	if stakeReg.CertificateID != stakeUnified.ID {
+		t.Errorf(
+			"stake registration CertificateID %d does not match unified cert ID %d",
+			stakeReg.CertificateID,
+			stakeUnified.ID,
+		)
+	}
+
+	var poolReg models.PoolRegistration
+	if result := db.Metadata().DB().First(&poolReg); result.Error != nil {
+		t.Fatalf("failed to query pool registration: %v", result.Error)
+	}
+
+	// Find the unified cert for pool registration (should be index 1)
+	var poolUnified models.Certificate
+	if result := db.Metadata().DB().Where("cert_index = ? AND cert_type = ?", 1, uint(lcommon.CertificateTypePoolRegistration)).First(&poolUnified); result.Error != nil {
+		t.Fatalf(
+			"failed to find unified pool registration cert: %v",
+			result.Error,
+		)
+	}
+
+	if poolReg.CertificateID != poolUnified.ID {
+		t.Errorf(
+			"pool registration CertificateID %d does not match unified cert ID %d",
+			poolReg.CertificateID,
+			poolUnified.ID,
+		)
+	}
+
+	var authHot models.AuthCommitteeHot
+	if result := db.Metadata().DB().First(&authHot); result.Error != nil {
+		t.Fatalf("failed to query auth committee hot: %v", result.Error)
+	}
+
+	// Find the unified cert for auth committee hot (should be index 2)
+	var authUnified models.Certificate
+	if result := db.Metadata().DB().Where("cert_index = ? AND cert_type = ?", 2, uint(lcommon.CertificateTypeAuthCommitteeHot)).First(&authUnified); result.Error != nil {
+		t.Fatalf(
+			"failed to find unified auth committee hot cert: %v",
+			result.Error,
+		)
+	}
+
+	if authHot.CertificateID != authUnified.ID {
+		t.Errorf(
+			"auth committee hot CertificateID %d does not match unified cert ID %d",
+			authHot.CertificateID,
+			authUnified.ID,
+		)
+	}
+}

database/models/auth_committee_hot.go

@@ -18,6 +18,7 @@ type AuthCommitteeHot struct {
 	ColdCredential []byte `gorm:"index"`
 	HostCredential []byte `gorm:"index"`
 	ID             uint   `gorm:"primarykey"`
+	CertificateID  uint   `gorm:"index"`
 	AddedSlot      uint64
 }
 

database/models/certs.go

@@ -14,17 +14,19 @@
 
 package models
 
-import "github.com/blinklabs-io/dingo/database/types"
-
+// Certificate maps transaction certificates to their specialized table records.
+// Provides unified indexing across all certificate types without requiring joins.
+//
+// All certificate types now have dedicated specialized models. The CertificateID field
+// references the ID of the specific certificate record based on CertType.
 type Certificate struct {
-	Cbor       []byte `gorm:"-"`
-	Pool       []byte
-	Credential []byte
-	Drep       []byte
-	CertType   uint `gorm:"index"`
-	Epoch      uint64
-	Amount     types.Uint64
-	ID         uint `gorm:"primaryKey"`
+	BlockHash     []byte `gorm:"index"`
+	ID            uint   `gorm:"primaryKey"`
+	TransactionID uint   `gorm:"index;uniqueIndex:uniq_tx_cert;constraint:OnDelete:CASCADE"`
+	CertificateID uint   `gorm:"index"` // Polymorphic FK to certificate table based on CertType. Not DB-enforced.
+	Slot          uint64 `gorm:"index"`
+	CertIndex     uint   `gorm:"column:cert_index;uniqueIndex:uniq_tx_cert"`
+	CertType      uint   `gorm:"index"`
 }
 
 func (Certificate) TableName() string {

database/models/resign_committee_cold.go

@@ -19,6 +19,7 @@ type ResignCommitteeCold struct {
 	ColdCredential []byte `gorm:"index"`
 	AnchorHash     []byte
 	ID             uint `gorm:"primarykey"`
+	CertificateID  uint `gorm:"index"`
 	AddedSlot      uint64
 }