Method Put

driver/ipfs-synckv/db.go:226–274

(key, value []byte)

}

func (db *DB) Put(key, value []byte) error {
	db.versionMu.Lock()
	defer db.versionMu.Unlock()

	// Increment version
	db.versions[string(key)]++
	version := db.versions[string(key)]
	versionBytes := []byte(fmt.Sprintf("%d", version))

	// Prepare data for IPFS (encrypt if key is available)
	ipfsValue := value
	if db.encryptionKey != nil {
		ipfsValue = encrypt(value, db.encryptionKey)
	}

	// --- Atomic Write (IPFS-first) ---
	// 1. Write to IPFS first. This is the source of truth for the network.
	ipfsErr := db.ipfsDB.Put(db.ctx, key, ipfsValue)
	if ipfsErr != nil {
		// If IPFS write fails, we abort the whole operation.
		return fmt.Errorf("ipfs write failed, aborting put: %w", ipfsErr)
	}

	// 2. Write to local DB and metadata only after IPFS success.
	var wg sync.WaitGroup
	var localErr, metaErr error
	wg.Add(2)
	go func() {
		defer wg.Done()
		localErr = db.localDB.Put(key, value, nil)
	}()
	go func() {
		defer wg.Done()
		// Store version in both local and ipfs for consistency checks
		metaKey := append([]byte("_meta:"), key...)
		metaErr = db.localDB.Put(metaKey, versionBytes, nil)
		_ = db.ipfsDB.Put(db.ctx, metaKey, versionBytes) // Also store version on IPFS
	}()
	wg.Wait()

	if localErr != nil || metaErr != nil {
		// This indicates a critical local failure. The data is on IPFS but not fully on local disk.
		// A more robust solution might involve a local recovery process.
		return fmt.Errorf("local write failed after successful ipfs write: localErr=%v, metaErr=%v", localErr, metaErr)
	}

	db.cache.Set(key, value, 0)
	return nil
}

func (db *DB) Get(key []byte) ([]byte, error) {
	if v, ok := db.cache.Get(key); ok {