Refactor xdr.LedgerEntry.LedgerKey method

ingest/change_compactor.go

@@ -84,7 +84,11 @@ func (c *ChangeCompactor) AddChange(change Change) error {
 // change is unexpected.
 func (c *ChangeCompactor) addCreatedChange(change Change) error {
 	// safe, since we later cast to string (causing a copy)
-	ledgerKey, err := c.encodingBuffer.UnsafeMarshalBinary(change.Post.LedgerKey())
+	key, err := change.Post.LedgerKey()
+	if err != nil {
+		return errors.Wrap(err, "Error LedgerKey")
+	}
+	ledgerKey, err := c.encodingBuffer.UnsafeMarshalBinary(key)
 	if err != nil {
 		return errors.Wrap(err, "Error MarshalBinary")
 	}
@@ -111,8 +115,12 @@ func (c *ChangeCompactor) addCreatedChange(change Change) error {
 	case xdr.LedgerEntryChangeTypeLedgerEntryRemoved:
 		// If existing type is removed it means that this entry does exist
 		// in a DB so we update entry change.
+		key, err := change.Post.LedgerKey()
+		if err != nil {
+			return errors.Wrap(err, "Error LedgerKey")
+		}
 		c.cache[ledgerKeyString] = Change{
-			Type: change.Post.LedgerKey().Type,
+			Type: key.Type,
 			Pre:  existingChange.Pre,
 			Post: change.Post,
 		}
@@ -127,7 +135,11 @@ func (c *ChangeCompactor) addCreatedChange(change Change) error {
 // change is unexpected.
 func (c *ChangeCompactor) addUpdatedChange(change Change) error {
 	// safe, since we later cast to string (causing a copy)
-	ledgerKey, err := c.encodingBuffer.UnsafeMarshalBinary(change.Post.LedgerKey())
+	key, err := change.Post.LedgerKey()
+	if err != nil {
+		return errors.Wrap(err, "Error LedgerKey")
+	}
+	ledgerKey, err := c.encodingBuffer.UnsafeMarshalBinary(key)
 	if err != nil {
 		return errors.Wrap(err, "Error MarshalBinary")
 	}
@@ -144,14 +156,22 @@ func (c *ChangeCompactor) addUpdatedChange(change Change) error {
 	case xdr.LedgerEntryChangeTypeLedgerEntryCreated:
 		// If existing type is created it means that this entry does not
 		// exist in a DB so we update entry change.
+		key, err := change.Post.LedgerKey()
+		if err != nil {
+			return errors.Wrap(err, "Error LedgerKey")
+		}
 		c.cache[ledgerKeyString] = Change{
-			Type: change.Post.LedgerKey().Type,
+			Type: key.Type,
 			Pre:  existingChange.Pre, // = nil
 			Post: change.Post,
 		}
 	case xdr.LedgerEntryChangeTypeLedgerEntryUpdated:
+		key, err := change.Post.LedgerKey()
+		if err != nil {
+			return errors.Wrap(err, "Error LedgerKey")
+		}
 		c.cache[ledgerKeyString] = Change{
-			Type: change.Post.LedgerKey().Type,
+			Type: key.Type,
 			Pre:  existingChange.Pre,
 			Post: change.Post,
 		}
@@ -171,7 +191,11 @@ func (c *ChangeCompactor) addUpdatedChange(change Change) error {
 // change is unexpected.
 func (c *ChangeCompactor) addRemovedChange(change Change) error {
 	// safe, since we later cast to string (causing a copy)
-	ledgerKey, err := c.encodingBuffer.UnsafeMarshalBinary(change.Pre.LedgerKey())
+	key, err := change.Pre.LedgerKey()
+	if err != nil {
+		return errors.Wrap(err, "Error LedgerKey")
+	}
+	ledgerKey, err := c.encodingBuffer.UnsafeMarshalBinary(key)
 	if err != nil {
 		return errors.Wrap(err, "Error MarshalBinary")
 	}
@@ -190,8 +214,12 @@ func (c *ChangeCompactor) addRemovedChange(change Change) error {
 		// Entry was created and is now removed in a single ledger.
 		delete(c.cache, ledgerKeyString)
 	case xdr.LedgerEntryChangeTypeLedgerEntryUpdated:
+		key, err := change.Pre.LedgerKey()
+		if err != nil {
+			return errors.Wrap(err, "Error LedgerKey")
+		}
 		c.cache[ledgerKeyString] = Change{
-			Type: change.Pre.LedgerKey().Type,
+			Type: key.Type,
 			Pre:  existingChange.Pre,
 			Post: nil,
 		}

ingest/checkpoint_change_reader.go

@@ -357,11 +357,18 @@ LoopBucketEntry:
 
 				// Generate a key
 				var key xdr.LedgerKey
+				var err error
 
 				switch entry.Type {
 				case xdr.BucketEntryTypeLiveentry, xdr.BucketEntryTypeInitentry:
 					liveEntry := entry.MustLiveEntry()
-					key = liveEntry.LedgerKey()
+					key, err = liveEntry.LedgerKey()
+					if err != nil {
+						r.readChan <- r.error(
+							errors.Wrapf(err, "Error generating ledger key for XDR record %d of hash '%s'", n, hash.String()),
+						)
+						return false
+					}
 				case xdr.BucketEntryTypeDeadentry:
 					key = entry.MustDeadEntry()
 				default:
@@ -396,6 +403,7 @@ LoopBucketEntry:
 		n++
 
 		var key xdr.LedgerKey
+		var err error
 
 		switch entry.Type {
 		case xdr.BucketEntryTypeMetaentry:
@@ -414,7 +422,13 @@ LoopBucketEntry:
 			continue LoopBucketEntry
 		case xdr.BucketEntryTypeLiveentry, xdr.BucketEntryTypeInitentry:
 			liveEntry := entry.MustLiveEntry()
-			key = liveEntry.LedgerKey()
+			key, err = liveEntry.LedgerKey()
+			if err != nil {
+				r.readChan <- r.error(
+					errors.Wrapf(err, "Error generating ledger key for XDR record %d of hash '%s'", n, hash.String()),
+				)
+				return false
+			}
 		case xdr.BucketEntryTypeDeadentry:
 			key = entry.MustDeadEntry()
 		default:
@@ -523,8 +537,12 @@ func (r *CheckpointChangeReader) Read() (Change, error) {
 	if result.e != nil {
 		return Change{}, errors.Wrap(result.e, "Error while reading from buckets")
 	}
+	entryType, err := result.entryChange.EntryType()
+	if err != nil {
+		return Change{}, errors.Wrap(err, "Error getting entry type")
+	}
 	return Change{
-		Type: result.entryChange.EntryType(),
+		Type: entryType,
 		Post: result.entryChange.State,
 	}, nil
 }

ingest/ledger_change_reader.go

@@ -126,7 +126,11 @@ func (r *LedgerChangeReader) Read() (Change, error) {
 		return r.Read()
 	case evictionChangesState:
 		// Get contract ledgerEntry evictions
-		changes, err := GetChangesFromLedgerEntryEvictions(r.ledgerCloseMeta.EvictedLedgerKeys())
+		keys, err := r.ledgerCloseMeta.EvictedLedgerKeys()
+		if err != nil {
+			return Change{}, err
+		}
+		changes, err := GetChangesFromLedgerEntryEvictions(keys)
 		if err != nil {
 			return Change{}, err
 		}

ingest/verify/main.go

@@ -87,7 +87,10 @@ func (v *StateVerifier) GetLedgerEntries(count int) ([]xdr.LedgerEntry, error) {
 			}
 		}
 
-		ledgerKey := entry.LedgerKey()
+		ledgerKey, err := entry.LedgerKey()
+		if err != nil {
+			return entries, errors.Wrap(err, "Error marshalling ledgerKey")
+		}
 		key, err := v.encodingBuffer.MarshalBinary(ledgerKey)
 		if err != nil {
 			return entries, errors.Wrap(err, "Error marshalling ledgerKey")
@@ -117,17 +120,21 @@ func (v *StateVerifier) Write(entry xdr.LedgerEntry) error {
 	}
 
 	// safe, since we convert to string right away (causing a copy)
-	key, err := v.encodingBuffer.UnsafeMarshalBinary(actualEntry.LedgerKey())
+	key, err := actualEntry.LedgerKey()
+	if err != nil {
+		return errors.Wrap(err, "Error marshalling ledgerKey")
+	}
+	keyBinary, err := v.encodingBuffer.UnsafeMarshalBinary(key)
 	if err != nil {
 		return errors.Wrap(err, "Error marshalling ledgerKey")
 	}
-	keyString := string(key)
+	keyString := string(keyBinary)
 	expectedEntry, exist := v.currentEntries[keyString]
 	if !exist {
 		return ingest.NewStateError(errors.Errorf(
 			"Cannot find entry in currentEntries map: %s (key = %s)",
 			base64.StdEncoding.EncodeToString(actualEntryMarshaled),
-			base64.StdEncoding.EncodeToString(key),
+			base64.StdEncoding.EncodeToString(keyBinary),
 		))
 	}
 	delete(v.currentEntries, keyString)

ingest/verify/main_test.go

@@ -63,7 +63,8 @@ func (s *StateVerifierTestSuite) TestCurrentEntriesNotEmpty() {
 	entryBase64, err := xdr.MarshalBase64(entry)
 	s.Assert().NoError(err)
 
-	ledgerKey := entry.LedgerKey()
+	ledgerKey, err := entry.LedgerKey()
+	s.Assert().NoError(err)
 	ledgerKeyBase64, err := xdr.MarshalBase64(ledgerKey)
 	s.Assert().NoError(err)
 
@@ -125,7 +126,9 @@ func (s *StateVerifierTestSuite) TestTransformFunction() {
 	s.Assert().NoError(err)
 
 	// Check currentEntries
-	ledgerKey, err := accountEntry.LedgerKey().MarshalBinary()
+	key, err := accountEntry.LedgerKey()
+	s.Assert().NoError(err)
+	ledgerKey, err := key.MarshalBinary()
 	s.Assert().NoError(err)
 
 	// Account entry transformed and offer entry ignored
@@ -164,7 +167,8 @@ func (s *StateVerifierTestSuite) TestWriteEntryNotExist() {
 	entryBase64, err := xdr.MarshalBase64(entry)
 	s.Assert().NoError(err)
 
-	ledgerKey := entry.LedgerKey()
+	ledgerKey, err := entry.LedgerKey()
+	s.Assert().NoError(err)
 	ledgerKeyBase64, err := xdr.MarshalBase64(ledgerKey)
 	s.Assert().NoError(err)
 

services/horizon/internal/ingest/processors/trades_processor.go

@@ -175,8 +175,14 @@ func (p *TradeProcessor) findOperationChange(tx ingest.LedgerTransaction, opidx
 	var change ingest.Change
 	for i := len(changes) - 1; i >= 0; i-- {
 		change = changes[i]
-		if change.Pre != nil && key.Equals(change.Pre.LedgerKey()) {
-			return change, nil
+		if change.Pre != nil {
+			preKey, err := change.Pre.LedgerKey()
+			if err != nil {
+				return ingest.Change{}, errors.Wrap(err, "could not determine ledger key for change")
+			}
+			if key.Equals(preKey) {
+				return change, nil
+			}
 		}
 	}
 	return ingest.Change{}, errors.Errorf("could not find operation for key %v", key)

services/horizon/internal/ingest/verify.go

@@ -205,13 +205,21 @@ func (s *system) verifyState(verifyAgainstLatestCheckpoint bool) error {
 				accounts = append(accounts, entry.Data.MustAccount().AccountId.Address())
 				totalByType["accounts"]++
 			case xdr.LedgerEntryTypeData:
-				data = append(data, *entry.LedgerKey().Data)
+				key, keyErr := entry.LedgerKey()
+				if keyErr != nil {
+					return errors.Wrap(keyErr, "entry.LedgerKey")
+				}
+				data = append(data, *key.Data)
 				totalByType["data"]++
 			case xdr.LedgerEntryTypeOffer:
 				offers = append(offers, int64(entry.Data.MustOffer().OfferId))
 				totalByType["offers"]++
 			case xdr.LedgerEntryTypeTrustline:
-				trustLines = append(trustLines, entry.LedgerKey().MustTrustLine())
+				key, keyErr := entry.LedgerKey()
+				if keyErr != nil {
+					return errors.Wrap(keyErr, "entry.LedgerKey")
+				}
+				trustLines = append(trustLines, key.MustTrustLine())
 				totalByType["trust_lines"]++
 			case xdr.LedgerEntryTypeClaimableBalance:
 				cBalances = append(cBalances, entry.Data.MustClaimableBalance().BalanceId)

xdr/account_id.go

@@ -55,13 +55,8 @@ func (aid *AccountId) Equals(other AccountId) bool {
 }
 
 // LedgerKey implements the `Keyer` interface
-func (aid *AccountId) LedgerKey() (ret LedgerKey) {
-	err := ret.SetAccount(*aid)
-	if err != nil {
-		panic(err)
-	}
-
-	return
+func (aid *AccountId) LedgerKey() (key LedgerKey, err error) {
+	return key, key.SetAccount(*aid)
 }
 
 func (e *EncodingBuffer) accountIdCompressEncodeTo(aid AccountId) error {

xdr/account_id_test.go

@@ -43,7 +43,8 @@ var _ = Describe("xdr.AccountId#LedgerKey()", func() {
 		err := aid.SetAddress("GCR22L3WS7TP72S4Z27YTO6JIQYDJK2KLS2TQNHK6Y7XYPA3AGT3X4FH")
 		Expect(err).ShouldNot(HaveOccurred())
 
-		key := aid.LedgerKey()
+		key, err := aid.LedgerKey()
+		Expect(err).ShouldNot(HaveOccurred())
 		packed := key.MustAccount().AccountId
 		Expect(packed.Equals(aid)).To(BeTrue())
 	})

xdr/ledger_close_meta.go

@@ -147,18 +147,22 @@ func (l LedgerCloseMeta) UpgradesProcessing() []UpgradeEntryMeta {
 // EvictedLedgerKeys returns the LedgerKeys for both the
 // EvictedTemporaryLedgerKeys and and the EvictedPersistentLedgerEntries in a
 // ledger.
-func (l LedgerCloseMeta) EvictedLedgerKeys() []LedgerKey {
+func (l LedgerCloseMeta) EvictedLedgerKeys() ([]LedgerKey, error) {
 	switch l.V {
 	case 0, 1:
-		return nil
+		return nil, nil
 	case 2:
 		v2 := l.MustV2()
 		keys := make([]LedgerKey, 0, len(v2.EvictedTemporaryLedgerKeys)+len(v2.EvictedPersistentLedgerEntries))
 		keys = append(keys, l.MustV2().EvictedTemporaryLedgerKeys...)
 		for _, entry := range l.MustV2().EvictedPersistentLedgerEntries {
-			keys = append(keys, entry.LedgerKey())
+			key, err := entry.LedgerKey()
+			if err != nil {
+				return nil, err
+			}
+			keys = append(keys, key)
 		}
-		return keys
+		return keys, nil
 	default:
 		panic(fmt.Sprintf("Unsupported LedgerCloseMeta.V: %d", l.V))
 	}