Improve error handling around POOL account intent operations

Author: jeffyanta

pkg/code/data/account/postgres/model.go

@@ -393,6 +393,10 @@ func equivalentModels(obj1, obj2 *model) bool {
 		return false
 	}
 
+	if obj1.MintAccount != obj2.MintAccount {
+		return false
+	}
+
 	if obj1.Index != obj2.Index {
 		return false
 	}

pkg/code/server/transaction/errors.go

@@ -23,9 +23,10 @@ const (
 var (
 	ErrTimedOutReceivingRequest = errors.New("timed out receiving request")
 
-	ErrTooManyPayments          = NewIntentDeniedError("too many payments")
-	ErrTransactionLimitExceeded = NewIntentDeniedError("dollar value exceeds limit")
-	ErrNotManagedByCode         = NewIntentDeniedError("at least one account is no longer managed by code")
+	ErrTooManyPayments             = NewIntentDeniedError("too many payments")
+	ErrTransactionLimitExceeded    = NewIntentDeniedError("dollar value exceeds limit")
+	ErrSourceNotManagedByCode      = NewIntentDeniedError("at least one source account is no longer managed by code")
+	ErrDestinationNotManagedByCode = NewIntentDeniedError("a destination account is no longer managed by code")
 
 	ErrInvalidSignature  = errors.New("invalid signature provided")
 	ErrMissingSignature  = errors.New("at least one signature is missing")

pkg/code/server/transaction/intent_handler.go

@@ -596,8 +596,19 @@ func (h *SendPublicPaymentIntentHandler) validateActions(
 		}
 
 		// Code->Code public ayments can only be made to primary or pool accounts
+		// that are open and managed by Code
 		switch h.cachedDestinationAccountInfoRecord.AccountType {
 		case commonpb.AccountType_PRIMARY, commonpb.AccountType_POOL:
+			timelockRecord, err := h.data.GetTimelockByVault(ctx, destination.PublicKey().ToBase58())
+			if err != nil {
+				return err
+			}
+			if !common.IsManagedByCode(ctx, timelockRecord) {
+				if timelockRecord.IsClosed() {
+					return NewStaleStateError("destination account has been closed")
+				}
+				return ErrDestinationNotManagedByCode
+			}
 		default:
 			return NewIntentValidationError("destination account must be a PRIMARY or POOL account")
 		}
@@ -1381,7 +1392,7 @@ func validateAllUserAccountsManagedByCode(ctx context.Context, initiatorAccounts
 	// Try to unlock *ANY* latest account, and you're done
 	for _, accountRecords := range initiatorAccounts {
 		if !accountRecords.IsManagedByCode(ctx) {
-			return ErrNotManagedByCode
+			return ErrSourceNotManagedByCode
 		}
 	}
 
@@ -1683,15 +1694,14 @@ func validateClaimedGiftCard(ctx context.Context, data code_data.Provider, giftC
 		return err
 	}
 
-	isManagedByCode := common.IsManagedByCode(ctx, timelockRecord)
-	if !isManagedByCode {
+	if !common.IsManagedByCode(ctx, timelockRecord) {
 		if timelockRecord.IsClosed() {
 			// Better error messaging, since we know we'll never reopen the account
 			// and the balance is guaranteed to be claimed (not necessarily through
 			// Code server though).
 			return NewStaleStateError("gift card balance has already been claimed")
 		}
-		return ErrNotManagedByCode
+		return ErrSourceNotManagedByCode
 	}
 
 	//
@@ -1732,33 +1742,32 @@ func validateDistributedPool(ctx context.Context, data code_data.Provider, poolV
 	}
 
 	//
-	// Part 2: Is the full amount being distributed?
+	// Part 2: Is the pool account managed by Code?
 	//
 
-	poolBalance, err := balance.CalculateFromCache(ctx, data, poolVaultAccount)
+	timelockRecord, err := data.GetTimelockByVault(ctx, poolVaultAccount.PublicKey().ToBase58())
 	if err != nil {
 		return err
-	} else if poolBalance == 0 {
-		return NewStaleStateError("pool balance has already been distributed")
-	} else if distributedAmount != poolBalance {
-		return NewIntentValidationErrorf("must distribute entire pool balance of %d quarks", poolBalance)
+	}
+
+	if !common.IsManagedByCode(ctx, timelockRecord) {
+		if timelockRecord.IsClosed() {
+			return NewStaleStateError("pool balance has already been distributed")
+		}
+		return ErrSourceNotManagedByCode
 	}
 
 	//
-	// Part 3: Is the pool account managed by Code?
+	// Part 3: Is the full amount being distributed?
 	//
 
-	timelockRecord, err := data.GetTimelockByVault(ctx, poolVaultAccount.PublicKey().ToBase58())
+	poolBalance, err := balance.CalculateFromCache(ctx, data, poolVaultAccount)
 	if err != nil {
 		return err
-	}
-
-	isManagedByCode := common.IsManagedByCode(ctx, timelockRecord)
-	if !isManagedByCode {
-		if timelockRecord.IsClosed() {
-			return NewStaleStateError("pool balance has already been distributed")
-		}
-		return ErrNotManagedByCode
+	} else if poolBalance == 0 {
+		return NewStaleStateError("pool balance has already been distributed")
+	} else if distributedAmount != poolBalance {
+		return NewIntentValidationErrorf("must distribute entire pool balance of %d quarks", poolBalance)
 	}
 
 	return nil

pkg/code/server/transaction/local_simulation.go

@@ -285,7 +285,7 @@ func LocalSimulation(ctx context.Context, data code_data.Provider, actions []*tr
 	if len(tokenAccountsToFetchBalance) > 0 {
 		prefetchedBalances, err = balance.BatchCalculateFromCacheWithTokenAccounts(ctx, data, tokenAccountsToFetchBalance...)
 		if err == balance.ErrNotManagedByCode {
-			return nil, ErrNotManagedByCode
+			return nil, ErrSourceNotManagedByCode
 		} else if err != nil {
 			return nil, err
 		}