feat: track witness set for transaction

Signed-off-by: Jenita <jkawan@blinklabs.io>

Author: Jenita

database/models/models.go

@@ -40,6 +40,7 @@ var MigrateModels = []any{
 	&Redeemer{},
 	&ResignCommitteeCold{},
 	&Script{},
+	&ScriptContent{},
 	&StakeDelegation{},
 	&StakeDeregistration{},
 	&StakeRegistration{},

database/models/redeemer.go

@@ -20,7 +20,7 @@ type Redeemer struct {
 	TransactionID uint   `gorm:"index"`
 	Tag           uint8  `gorm:"index"` // Redeemer tag
 	Index         uint32 `gorm:"index"`
-	Data          []byte `gorm:"type:bytea"` // Plutus data
+	Data          []byte // Plutus data
 	ExUnitsMemory uint64
 	ExUnitsCPU    uint64
 	Transaction   *Transaction

database/models/script.go

@@ -14,17 +14,21 @@
 
 package models
 
-// Script represents a script entry in the witness set
+// Script represents a reference to a script in the witness set
 // Type corresponds to ScriptRefType constants from gouroboros/ledger/common:
 // 0=NativeScript (ScriptRefTypeNativeScript)
 // 1=PlutusV1 (ScriptRefTypePlutusV1)
 // 2=PlutusV2 (ScriptRefTypePlutusV2)
 // 3=PlutusV3 (ScriptRefTypePlutusV3)
+//
+// To avoid storing duplicate script data for the same script used in multiple
+// transactions, we store only the script hash here. The actual script content
+// is stored separately in ScriptContent table, indexed by hash.
 type Script struct {
 	ID            uint   `gorm:"primaryKey"`
 	TransactionID uint   `gorm:"index"`
 	Type          uint8  `gorm:"index"` // Script type
-	ScriptData    []byte `gorm:"type:bytea"`
+	ScriptHash    []byte `gorm:"index"` // Hash of the script
 	Transaction   *Transaction
 }
 

database/models/script_content.go

@@ -0,0 +1,30 @@
+// Copyright 2025 Blink Labs Software
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package models
+
+// ScriptContent represents the content of a script, indexed by its hash
+// This avoids storing duplicate script data when the same script appears
+// in multiple transactions
+type ScriptContent struct {
+	ID          uint   `gorm:"primaryKey"`
+	Hash        []byte `gorm:"index;unique"` // Script hash
+	Type        uint8  `gorm:"index"`        // Script type
+	Content     []byte // Script content
+	CreatedSlot uint64 // Slot when this script was first seen
+}
+
+func (ScriptContent) TableName() string {
+	return "script_content"
+}

database/models/witness.go

@@ -14,17 +14,24 @@
 
 package models
 
+const (
+	// KeyWitnessTypeVkey represents a Vkey witness
+	KeyWitnessTypeVkey uint8 = iota
+	// KeyWitnessTypeBootstrap represents a Bootstrap witness
+	KeyWitnessTypeBootstrap
+)
+
 // KeyWitness represents a key witness entry (Vkey or Bootstrap)
-// Type: 0 = VkeyWitness, 1 = BootstrapWitness
+// Type: KeyWitnessTypeVkey = VkeyWitness, KeyWitnessTypeBootstrap = BootstrapWitness
 type KeyWitness struct {
 	ID            uint   `gorm:"primaryKey"`
 	TransactionID uint   `gorm:"index"`
-	Type          uint8  `gorm:"index"` // 0=Vkey, 1=Bootstrap
-	Vkey          []byte `gorm:"type:bytea"`
-	Signature     []byte `gorm:"type:bytea"`
-	PublicKey     []byte `gorm:"type:bytea"` // For Bootstrap
-	ChainCode     []byte `gorm:"type:bytea"` // For Bootstrap
-	Attributes    []byte `gorm:"type:bytea"` // For Bootstrap
+	Type          uint8  `gorm:"index"` // See KeyWitnessType* constants
+	Vkey          []byte // Vkey witness key
+	Signature     []byte // Witness signature
+	PublicKey     []byte // For Bootstrap witness
+	ChainCode     []byte // For Bootstrap witness
+	Attributes    []byte // For Bootstrap witness
 	Transaction   *Transaction
 }
 

database/plugin/metadata/sqlite/script.go

@@ -0,0 +1,58 @@
+// Copyright 2025 Blink Labs Software
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sqlite
+
+import (
+	"errors"
+
+	"github.com/blinklabs-io/dingo/database/models"
+	lcommon "github.com/blinklabs-io/gouroboros/ledger/common"
+	"gorm.io/gorm"
+)
+
+// GetScriptContent returns the script content by its hash
+func (d *MetadataStoreSqlite) GetScriptContent(
+	hash lcommon.ScriptHash,
+	txn *gorm.DB,
+) (*models.ScriptContent, error) {
+	ret := &models.ScriptContent{}
+	if txn == nil {
+		txn = d.DB()
+	}
+	result := txn.First(ret, "hash = ?", hash[:])
+	if result.Error != nil {
+		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, result.Error
+	}
+	return ret, nil
+}
+
+// GetScriptsByTransaction returns all scripts (references) used in a particular transaction
+func (d *MetadataStoreSqlite) GetScriptsByTransaction(
+	txID uint,
+	txn *gorm.DB,
+) ([]models.Script, error) {
+	var scripts []models.Script
+	if txn == nil {
+		txn = d.DB()
+	}
+	result := txn.Where("transaction_id = ?", txID).Find(&scripts)
+	if result.Error != nil {
+		return nil, result.Error
+	}
+	return scripts, nil
+}

database/plugin/metadata/sqlite/transaction.go

@@ -89,7 +89,9 @@ func (d *MetadataStoreSqlite) SetTransaction(
 	if result.Error != nil {
 		return fmt.Errorf("create transaction: %w", result.Error)
 	}
-	// If ID is still zero (conflict path with SQLite), fetch it by hash
+	// SQLite's ON CONFLICT clause doesn't return the ID of an existing row when
+	// the conflict path is taken (no insert occurs). We need to fetch the ID
+	// explicitly so we can associate witness records with the correct transaction.
 	if tmpTx.ID == 0 {
 		existingTx, err := d.GetTransactionByHash(txHash, txn)
 		if err != nil {
@@ -304,14 +306,14 @@ func (d *MetadataStoreSqlite) SetTransaction(
 			return fmt.Errorf("delete existing plutus data: %w", result.Error)
 		}
 	}
-	if tx.Witnesses() != nil {
-		ws := tx.Witnesses()
+	ws := tx.Witnesses()
+	if ws != nil {
 
 		// Add Vkey Witnesses
 		for _, vkey := range ws.Vkey() {
 			keyWitness := models.KeyWitness{
 				TransactionID: tmpTx.ID,
-				Type:          0, // VkeyWitness
+				Type:          models.KeyWitnessTypeVkey,
 				Vkey:          vkey.Vkey,
 				Signature:     vkey.Signature,
 			}
@@ -324,7 +326,7 @@ func (d *MetadataStoreSqlite) SetTransaction(
 		for _, bootstrap := range ws.Bootstrap() {
 			keyWitness := models.KeyWitness{
 				TransactionID: tmpTx.ID,
-				Type:          1, // BootstrapWitness
+				Type:          models.KeyWitnessTypeBootstrap,
 				PublicKey:     bootstrap.PublicKey,
 				Signature:     bootstrap.Signature,
 				ChainCode:     bootstrap.ChainCode,
@@ -337,50 +339,106 @@ func (d *MetadataStoreSqlite) SetTransaction(
 
 		// Add Native Scripts
 		for _, script := range ws.NativeScripts() {
+			scriptHash := script.Hash()
 			scriptRecord := models.Script{
 				TransactionID: tmpTx.ID,
 				Type:          uint8(lcommon.ScriptRefTypeNativeScript),
-				ScriptData:    script.Cbor(),
+				ScriptHash:    scriptHash.Bytes(),
 			}
 			if result := txn.Create(&scriptRecord); result.Error != nil {
 				return fmt.Errorf("create native script: %w", result.Error)
 			}
+			// Also store the script content separately to avoid duplicates
+			scriptContent := models.ScriptContent{
+				Hash:        scriptHash.Bytes(),
+				Type:        uint8(lcommon.ScriptRefTypeNativeScript),
+				Content:     script.Cbor(),
+				CreatedSlot: point.Slot,
+			}
+			if result := txn.Clauses(clause.OnConflict{
+				Columns:   []clause.Column{{Name: "hash"}},
+				DoNothing: true,
+			}).Create(&scriptContent); result.Error != nil {
+				return fmt.Errorf("create native script content: %w", result.Error)
+			}
 		}
 
 		// Add PlutusV1 Scripts
 		for _, script := range ws.PlutusV1Scripts() {
+			scriptHash := script.Hash()
 			scriptRecord := models.Script{
 				TransactionID: tmpTx.ID,
 				Type:          uint8(lcommon.ScriptRefTypePlutusV1),
-				ScriptData:    script,
+				ScriptHash:    scriptHash.Bytes(),
 			}
 			if result := txn.Create(&scriptRecord); result.Error != nil {
 				return fmt.Errorf("create plutus v1 script: %w", result.Error)
 			}
+			// Also store the script content separately to avoid duplicates
+			scriptContent := models.ScriptContent{
+				Hash:        scriptHash.Bytes(),
+				Type:        uint8(lcommon.ScriptRefTypePlutusV1),
+				Content:     script.RawScriptBytes(),
+				CreatedSlot: point.Slot,
+			}
+			if result := txn.Clauses(clause.OnConflict{
+				Columns:   []clause.Column{{Name: "hash"}},
+				DoNothing: true,
+			}).Create(&scriptContent); result.Error != nil {
+				return fmt.Errorf("create plutus v1 script content: %w", result.Error)
+			}
 		}
 
 		// Add PlutusV2 Scripts
 		for _, script := range ws.PlutusV2Scripts() {
+			scriptHash := script.Hash()
 			scriptRecord := models.Script{
 				TransactionID: tmpTx.ID,
 				Type:          uint8(lcommon.ScriptRefTypePlutusV2),
-				ScriptData:    script,
+				ScriptHash:    scriptHash.Bytes(),
 			}
 			if result := txn.Create(&scriptRecord); result.Error != nil {
 				return fmt.Errorf("create plutus v2 script: %w", result.Error)
 			}
+			// Also store the script content separately to avoid duplicates
+			scriptContent := models.ScriptContent{
+				Hash:        scriptHash.Bytes(),
+				Type:        uint8(lcommon.ScriptRefTypePlutusV2),
+				Content:     script.RawScriptBytes(),
+				CreatedSlot: point.Slot,
+			}
+			if result := txn.Clauses(clause.OnConflict{
+				Columns:   []clause.Column{{Name: "hash"}},
+				DoNothing: true,
+			}).Create(&scriptContent); result.Error != nil {
+				return fmt.Errorf("create plutus v2 script content: %w", result.Error)
+			}
 		}
 
 		// Add PlutusV3 Scripts
 		for _, script := range ws.PlutusV3Scripts() {
+			scriptHash := script.Hash()
 			scriptRecord := models.Script{
 				TransactionID: tmpTx.ID,
 				Type:          uint8(lcommon.ScriptRefTypePlutusV3),
-				ScriptData:    script,
+				ScriptHash:    scriptHash.Bytes(),
 			}
 			if result := txn.Create(&scriptRecord); result.Error != nil {
 				return fmt.Errorf("create plutus v3 script: %w", result.Error)
 			}
+			// Also store the script content separately to avoid duplicates
+			scriptContent := models.ScriptContent{
+				Hash:        scriptHash.Bytes(),
+				Type:        uint8(lcommon.ScriptRefTypePlutusV3),
+				Content:     script.RawScriptBytes(),
+				CreatedSlot: point.Slot,
+			}
+			if result := txn.Clauses(clause.OnConflict{
+				Columns:   []clause.Column{{Name: "hash"}},
+				DoNothing: true,
+			}).Create(&scriptContent); result.Error != nil {
+				return fmt.Errorf("create plutus v3 script content: %w", result.Error)
+			}
 		}
 
 		// Add PlutusData (Datums)

database/plugin/metadata/store.go

@@ -83,6 +83,14 @@ type MetadataStore interface {
 		[]byte, // hash
 		*gorm.DB,
 	) (*models.Transaction, error)
+	GetScriptContent(
+		lcommon.ScriptHash,
+		*gorm.DB,
+	) (*models.ScriptContent, error)
+	GetScriptsByTransaction(
+		uint, // txID
+		*gorm.DB,
+	) ([]models.Script, error)
 
 	SetBlockNonce(
 		[]byte, // blockHash