Fixed the wrong PlayerCache object lookup in Proxy Join. Expanded test coverage to deal with failures better.

Author: abstrct

tests/test_chain.sh

@@ -1970,25 +1970,28 @@ section "PHASE 4e: Permission System"
 # SourceAllocation=256, GuildMembership=512, SubstationConnection=1024, AllocationConnection=2048
 
 # ─── permission-grant-on-object: grant Player 5 Grid permission on substation ───
+VAL_BEFORE_GRANT=$(get_permission_value_for_player "${SUBSTATION_ID}" "${PLAYER_5_ID}")
 run_tx "Granting Player 5 Grid permission (32) on substation ${SUBSTATION_ID}" \
     tx structs permission-grant-on-object "${SUBSTATION_ID}" "${PLAYER_5_ID}" 32 --from alice
 
-PERM_JSON=$(query query structs permission-by-object "${SUBSTATION_ID}" 2>/dev/null || echo '{}')
-info "Permissions on substation after grant:"
-echo "${PERM_JSON}" | jq -r '.permissionRecord[]? | "  player=\(.objectId) val=\(.value)"' 2>/dev/null || echo "  (no records)"
+VAL_AFTER_GRANT=$(get_permission_value_for_player "${SUBSTATION_ID}" "${PLAYER_5_ID}")
+EXPECTED_AFTER_GRANT=$(( VAL_BEFORE_GRANT | 32 ))
+assert_eq "Permission on substation after grant includes Grid" "${EXPECTED_AFTER_GRANT}" "${VAL_AFTER_GRANT}"
 
 # ─── permission-revoke-on-object ───
 run_tx "Revoking Player 5 Grid permission on substation" \
     tx structs permission-revoke-on-object "${SUBSTATION_ID}" "${PLAYER_5_ID}" 32 --from alice
 
+VAL_AFTER_REVOKE=$(get_permission_value_for_player "${SUBSTATION_ID}" "${PLAYER_5_ID}")
+EXPECTED_AFTER_REVOKE=$(( EXPECTED_AFTER_GRANT & ~32 ))
+assert_eq "Permission on substation after revoke removes Grid" "${EXPECTED_AFTER_REVOKE}" "${VAL_AFTER_REVOKE}"
+
 # ─── permission-set-on-object: set a specific permission set ───
 run_tx "Setting Player 5 permissions on substation to Assets+Grid (40)" \
     tx structs permission-set-on-object "${SUBSTATION_ID}" "${PLAYER_5_ID}" 40 --from alice
 
-# Verify with query
-PERM_JSON=$(query query structs permission-by-object "${SUBSTATION_ID}" 2>/dev/null || echo '{}')
-info "Permissions on substation after set:"
-echo "${PERM_JSON}" | jq -r '.permissionRecord[]? | "  player=\(.objectId) val=\(.value)"' 2>/dev/null || echo "  (no records)"
+VAL_AFTER_SET=$(get_permission_value_for_player "${SUBSTATION_ID}" "${PLAYER_5_ID}")
+assert_eq "Permission on substation after set (40)" "40" "${VAL_AFTER_SET}"
 
 # Clean up: revoke all from Player 5
 run_tx "Clearing Player 5 permissions on substation" \
@@ -2635,6 +2638,9 @@ run_tx "Granting Player 5 PermSubstationConnection on substation for connection
 run_tx "Connecting Player 5 allocation to substation" \
     tx structs substation-allocation-connect "${P5_ALLOC_ID}" "${SUBSTATION_ID}" --from player_5
 
+ALLOC_JSON=$(query query structs allocation "${P5_ALLOC_ID}")
+assert_eq "Allocation connected to substation" "${SUBSTATION_ID}" "$(jqr "${ALLOC_JSON}" '.Allocation.destinationId' '')"
+
 # ─── substation-allocation-disconnect ───
 run_tx "Disconnecting Player 5 allocation from substation" \
     tx structs substation-allocation-disconnect "${P5_ALLOC_ID}" --from player_5
@@ -2647,6 +2653,9 @@ assert_eq "Allocation disconnected" "" "${ALLOC_DST}"
 run_tx "Reconnecting Player 5 allocation" \
     tx structs substation-allocation-connect "${P5_ALLOC_ID}" "${SUBSTATION_ID}" --from player_5
 
+ALLOC_JSON=$(query query structs allocation "${P5_ALLOC_ID}")
+assert_eq "Allocation reconnected to substation" "${SUBSTATION_ID}" "$(jqr "${ALLOC_JSON}" '.Allocation.destinationId' '')"
+
 # ─── Dual-path disconnect: substation owner disconnects player's allocation ───
 # CanBeDisconnectedBy checks PermAllocationConnection on allocation first,
 # then falls back to PermAllocationConnection on destination (substation).
@@ -2847,6 +2856,11 @@ run_tx "Proxy joining guild for external address" \
     0c1623a753074f49bc20c6e8bb9e6572903b90e386598c4baa34e056e468e53076938ec4ab411f5889adb771f63b2be9b15912d5e1e70a97d1b091926181c8ae01 \
     --from alice
 
+# Verify proxy join created a player for the target address
+PROXY_JOIN_JSON=$(query query structs address structs1wfs4s5er9lpkxlcrh8ezdqayewjnudkrlwpxqc)
+PROXY_PLAYER=$(jqr "${PROXY_JOIN_JSON}" '.playerId')
+assert_not_empty "Proxy joined player ID" "${PROXY_PLAYER}"
+
 fi # phase 5
 
 if run_phase 550; then
@@ -3566,17 +3580,17 @@ if [ -n "${STEALTH_BOMBER_ID}" ]; then
         tx structs struct-stealth-activate "${STEALTH_BOMBER_ID}" --from player_3
 
     SB_JSON=$(query query structs struct "${STEALTH_BOMBER_ID}" 2>/dev/null || echo '{}')
-    SB_HIDDEN=$(jqr "${SB_JSON}" '.Struct.status' '')
-    info "Stealth Bomber status after activate: '${SB_HIDDEN}'"
+    SB_HIDDEN=$(jqr "${SB_JSON}" '.structAttributes.isHidden' 'false')
+    assert_eq "Stealth Bomber hidden after activate" "true" "${SB_HIDDEN}"
 
     # ─── struct-stealth-deactivate ───
     wait_for_charge "${PLAYER_3_ID}" "${CHARGE_ACTIVATE}"
     run_tx "Deactivating stealth on Stealth Bomber" \
         tx structs struct-stealth-deactivate "${STEALTH_BOMBER_ID}" --from player_3
 
     SB_JSON=$(query query structs struct "${STEALTH_BOMBER_ID}" 2>/dev/null || echo '{}')
-    SB_HIDDEN_AFTER=$(jqr "${SB_JSON}" '.Struct.status' '')
-    info "Stealth Bomber status after deactivate: '${SB_HIDDEN_AFTER}'"
+    SB_HIDDEN_AFTER=$(jqr "${SB_JSON}" '.structAttributes.isHidden' 'false')
+    assert_eq "Stealth Bomber visible after deactivate" "false" "${SB_HIDDEN_AFTER}"
 
     # struct-attribute query coverage
     info "Struct attribute query coverage:"

testutil/keeper/structs.go

@@ -183,11 +183,40 @@ func (m *MockBankKeeper) BurnCoins(ctx context.Context, moduleName string, amt s
 	return nil
 }
 
-// MockStakingKeeper is a mock implementation of the StakingKeeper interface
-type MockStakingKeeper struct{}
+// delegationKey uniquely identifies a delegation by delegator+validator.
+type delegationKey struct {
+	Delegator string
+	Validator string
+}
+
+// MockStakingKeeper is a stateful mock of the StakingKeeper interface.
+// It tracks validators, delegations, and unbonding delegations so that
+// reactor infuse/defuse/migrate/cancel tests can exercise the full handler path.
+type MockStakingKeeper struct {
+	validators   map[string]stakingtypes.Validator
+	delegations  map[delegationKey]stakingtypes.Delegation
+	unbondings   map[delegationKey]stakingtypes.UnbondingDelegation
+	nextUnbondID uint64
+}
 
 func NewMockStakingKeeper() *MockStakingKeeper {
-	return &MockStakingKeeper{}
+	return &MockStakingKeeper{
+		validators:   make(map[string]stakingtypes.Validator),
+		delegations:  make(map[delegationKey]stakingtypes.Delegation),
+		unbondings:   make(map[delegationKey]stakingtypes.UnbondingDelegation),
+		nextUnbondID: 1,
+	}
+}
+
+// AddValidator registers a bonded validator with 1:1 token-to-share ratio.
+func (m *MockStakingKeeper) AddValidator(operatorAddr sdk.ValAddress, tokens math.Int) {
+	val := stakingtypes.Validator{
+		OperatorAddress: operatorAddr.String(),
+		Status:          stakingtypes.Bonded,
+		Tokens:          tokens,
+		DelegatorShares: math.LegacyNewDecFromInt(tokens),
+	}
+	m.validators[operatorAddr.String()] = val
 }
 
 func (m *MockStakingKeeper) ConsensusAddressCodec() address.Codec {
@@ -199,70 +228,212 @@ func (m *MockStakingKeeper) ValidatorByConsAddr(ctx context.Context, consAddr sd
 }
 
 func (m *MockStakingKeeper) GetValidator(ctx context.Context, addr sdk.ValAddress) (stakingtypes.Validator, error) {
-	return stakingtypes.Validator{}, nil
+	val, ok := m.validators[addr.String()]
+	if !ok {
+		return stakingtypes.Validator{}, stakingtypes.ErrNoValidatorFound
+	}
+	return val, nil
 }
 
 func (m *MockStakingKeeper) GetAllValidators(ctx context.Context) ([]stakingtypes.Validator, error) {
-	return nil, nil
+	vals := make([]stakingtypes.Validator, 0, len(m.validators))
+	for _, v := range m.validators {
+		vals = append(vals, v)
+	}
+	return vals, nil
 }
 
 func (m *MockStakingKeeper) GetValidators(ctx context.Context, maxRetrieve uint32) ([]stakingtypes.Validator, error) {
-	return nil, nil
+	return m.GetAllValidators(ctx)
 }
 
 func (m *MockStakingKeeper) GetValidatorDelegations(ctx context.Context, valAddr sdk.ValAddress) ([]stakingtypes.Delegation, error) {
-	return nil, nil
+	var result []stakingtypes.Delegation
+	for k, d := range m.delegations {
+		if k.Validator == valAddr.String() {
+			result = append(result, d)
+		}
+	}
+	return result, nil
 }
 
 func (m *MockStakingKeeper) GetDelegation(ctx context.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) (stakingtypes.Delegation, error) {
-	return stakingtypes.Delegation{}, nil
+	dk := delegationKey{Delegator: delAddr.String(), Validator: valAddr.String()}
+	del, ok := m.delegations[dk]
+	if !ok {
+		return stakingtypes.Delegation{}, stakingtypes.ErrNoDelegation
+	}
+	return del, nil
 }
 
 func (m *MockStakingKeeper) GetUnbondingDelegation(ctx context.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress) (stakingtypes.UnbondingDelegation, error) {
-	return stakingtypes.UnbondingDelegation{}, nil
+	dk := delegationKey{Delegator: delAddr.String(), Validator: valAddr.String()}
+	ubd, ok := m.unbondings[dk]
+	if !ok {
+		return stakingtypes.UnbondingDelegation{}, stakingtypes.ErrNoUnbondingDelegation
+	}
+	return ubd, nil
 }
 
 func (m *MockStakingKeeper) GetUnbondingDelegationByUnbondingID(ctx context.Context, id uint64) (stakingtypes.UnbondingDelegation, error) {
-	return stakingtypes.UnbondingDelegation{}, nil
+	for _, ubd := range m.unbondings {
+		for _, entry := range ubd.Entries {
+			if entry.UnbondingId == id {
+				return ubd, nil
+			}
+		}
+	}
+	return stakingtypes.UnbondingDelegation{}, stakingtypes.ErrNoUnbondingDelegation
 }
 
 func (m *MockStakingKeeper) GetDelegatorDelegations(ctx context.Context, delegator sdk.AccAddress, maxRetrieve uint16) ([]stakingtypes.Delegation, error) {
-	return nil, nil
+	var result []stakingtypes.Delegation
+	for k, d := range m.delegations {
+		if k.Delegator == delegator.String() {
+			result = append(result, d)
+			if uint16(len(result)) >= maxRetrieve {
+				break
+			}
+		}
+	}
+	return result, nil
 }
 
 func (m *MockStakingKeeper) SetDelegation(ctx context.Context, delegation stakingtypes.Delegation) error {
+	dk := delegationKey{Delegator: delegation.DelegatorAddress, Validator: delegation.ValidatorAddress}
+	m.delegations[dk] = delegation
 	return nil
 }
 
 func (m *MockStakingKeeper) RemoveDelegation(ctx context.Context, delegation stakingtypes.Delegation) error {
+	dk := delegationKey{Delegator: delegation.DelegatorAddress, Validator: delegation.ValidatorAddress}
+	delete(m.delegations, dk)
 	return nil
 }
 
+// ValidateUnbondAmount returns the shares corresponding to amt using a 1:1 ratio.
+// Returns an error if no delegation exists or the amount exceeds delegated shares.
 func (m *MockStakingKeeper) ValidateUnbondAmount(ctx context.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, amt math.Int) (math.LegacyDec, error) {
-	return math.LegacyZeroDec(), nil
+	dk := delegationKey{Delegator: delAddr.String(), Validator: valAddr.String()}
+	del, ok := m.delegations[dk]
+	if !ok {
+		return math.LegacyZeroDec(), stakingtypes.ErrNoDelegation
+	}
+	shares := math.LegacyNewDecFromInt(amt)
+	if shares.GT(del.Shares) {
+		return math.LegacyZeroDec(), stakingtypes.ErrNotEnoughDelegationShares
+	}
+	return shares, nil
 }
 
 func (m *MockStakingKeeper) BeginRedelegation(ctx context.Context, delAddr sdk.AccAddress, valSrcAddr, valDstAddr sdk.ValAddress, sharesAmount math.LegacyDec) (time.Time, error) {
-	return time.Now(), nil
+	srcKey := delegationKey{Delegator: delAddr.String(), Validator: valSrcAddr.String()}
+	srcDel, ok := m.delegations[srcKey]
+	if !ok {
+		return time.Time{}, stakingtypes.ErrNoDelegation
+	}
+	if sharesAmount.GT(srcDel.Shares) {
+		return time.Time{}, stakingtypes.ErrNotEnoughDelegationShares
+	}
+	srcDel.Shares = srcDel.Shares.Sub(sharesAmount)
+	if srcDel.Shares.IsZero() {
+		delete(m.delegations, srcKey)
+	} else {
+		m.delegations[srcKey] = srcDel
+	}
+	dstKey := delegationKey{Delegator: delAddr.String(), Validator: valDstAddr.String()}
+	dstDel, exists := m.delegations[dstKey]
+	if !exists {
+		dstDel = stakingtypes.Delegation{
+			DelegatorAddress: delAddr.String(),
+			ValidatorAddress: valDstAddr.String(),
+			Shares:           math.LegacyZeroDec(),
+		}
+	}
+	dstDel.Shares = dstDel.Shares.Add(sharesAmount)
+	m.delegations[dstKey] = dstDel
+	return time.Now().Add(21 * 24 * time.Hour), nil
 }
 
 func (m *MockStakingKeeper) BondDenom(ctx context.Context) (string, error) {
 	return "stake", nil
 }
 
+// Delegate creates or adds to a delegation using a 1:1 token-to-share ratio.
 func (m *MockStakingKeeper) Delegate(ctx context.Context, delAddr sdk.AccAddress, bondAmt math.Int, tokenSrc stakingtypes.BondStatus, validator stakingtypes.Validator, subtractAccount bool) (math.LegacyDec, error) {
-	return math.LegacyZeroDec(), nil
+	dk := delegationKey{Delegator: delAddr.String(), Validator: validator.OperatorAddress}
+	del, exists := m.delegations[dk]
+	if !exists {
+		del = stakingtypes.Delegation{
+			DelegatorAddress: delAddr.String(),
+			ValidatorAddress: validator.OperatorAddress,
+			Shares:           math.LegacyZeroDec(),
+		}
+	}
+	newShares := math.LegacyNewDecFromInt(bondAmt)
+	del.Shares = del.Shares.Add(newShares)
+	m.delegations[dk] = del
+
+	if val, ok := m.validators[validator.OperatorAddress]; ok {
+		val.Tokens = val.Tokens.Add(bondAmt)
+		val.DelegatorShares = val.DelegatorShares.Add(newShares)
+		m.validators[validator.OperatorAddress] = val
+	}
+	return newShares, nil
 }
 
+// Undelegate removes shares from a delegation and creates an unbonding entry.
 func (m *MockStakingKeeper) Undelegate(ctx context.Context, delAddr sdk.AccAddress, valAddr sdk.ValAddress, sharesAmount math.LegacyDec) (time.Time, math.Int, error) {
-	return time.Now(), math.ZeroInt(), nil
+	dk := delegationKey{Delegator: delAddr.String(), Validator: valAddr.String()}
+	del, ok := m.delegations[dk]
+	if !ok {
+		return time.Time{}, math.ZeroInt(), stakingtypes.ErrNoDelegation
+	}
+	if sharesAmount.GT(del.Shares) {
+		return time.Time{}, math.ZeroInt(), stakingtypes.ErrNotEnoughDelegationShares
+	}
+	del.Shares = del.Shares.Sub(sharesAmount)
+	if del.Shares.IsZero() {
+		delete(m.delegations, dk)
+	} else {
+		m.delegations[dk] = del
+	}
+
+	returnAmount := sharesAmount.TruncateInt()
+	sdkCtx := sdk.UnwrapSDKContext(ctx)
+	completionTime := sdkCtx.BlockTime().Add(21 * 24 * time.Hour)
+
+	ubd, exists := m.unbondings[dk]
+	if !exists {
+		ubd = stakingtypes.UnbondingDelegation{
+			DelegatorAddress: delAddr.String(),
+			ValidatorAddress: valAddr.String(),
+		}
+	}
+	id := m.nextUnbondID
+	m.nextUnbondID++
+	ubd.Entries = append(ubd.Entries, stakingtypes.UnbondingDelegationEntry{
+		CreationHeight:          sdkCtx.BlockHeight(),
+		CompletionTime:          completionTime,
+		InitialBalance:          returnAmount,
+		Balance:                 returnAmount,
+		UnbondingId:             id,
+		UnbondingOnHoldRefCount: 0,
+	})
+	m.unbondings[dk] = ubd
+
+	return completionTime, returnAmount, nil
 }
 
 func (m *MockStakingKeeper) RemoveUnbondingDelegation(ctx context.Context, ubd stakingtypes.UnbondingDelegation) error {
+	dk := delegationKey{Delegator: ubd.DelegatorAddress, Validator: ubd.ValidatorAddress}
+	delete(m.unbondings, dk)
 	return nil
 }
 
 func (m *MockStakingKeeper) SetUnbondingDelegation(ctx context.Context, ubd stakingtypes.UnbondingDelegation) error {
+	dk := delegationKey{Delegator: ubd.DelegatorAddress, Validator: ubd.ValidatorAddress}
+	m.unbondings[dk] = ubd
 	return nil
 }
 

x/structs/keeper/keeper.go

@@ -114,6 +114,11 @@ func (k Keeper) BankKeeper() types.BankKeeper {
 	return k.bankKeeper
 }
 
+// StakingKeeper returns the staking keeper
+func (k Keeper) StakingKeeper() types.StakingKeeper {
+	return k.stakingKeeper
+}
+
 // AccountKeeper returns the account keeper
 func (k Keeper) AccountKeeper() types.AccountKeeper {
 	return k.accountKeeper

x/structs/keeper/msg_server_guild_membership_join_proxy.go

@@ -23,7 +23,10 @@ func (k msgServer) GuildMembershipJoinProxy(goCtx context.Context, msg *types.Ms
 	k.AddressEmitActivity(ctx, msg.Creator)
 
 	// Look up requesting account
-	proxyPlayer := cc.UpsertPlayer(msg.Creator)
+	proxyPlayer, err := cc.GetPlayerByAddress(msg.Creator)
+	if err != nil {
+		return emptyResponse, err
+	}
 
 	// look up destination guild
 	guild := cc.GetGuild(proxyPlayer.GetGuildId())