vuejs - good practices when using getters and/or computed properties

I love vue.js and I definitely love computed properties and VueX getters. But I have come to a point where I am not sure if the way I am using them might have some drawbacks in terms of performance.

This is a common pattern throughout my code (same applies to local components data and computed properties):

From this simple state (source of truth):

export default () => ({
   bonds: {
    eth: [],
    celo: []
  }
})

I will usually go as follows within my getters:

export default {
  getBondsEth(state) {
    return state.bonds.eth
  },
  getBondsCelo(state) {
    return state.bonds.celo
  },
  getTotalBondsEth(_, getters) {
    return getters.getBondsEth.length
  },
  getTotalBondsCelo(_, getters) {
    return getters.getBondsCelo.length
  },
  getTotalBonds(_, getters) {
    return getters.getTotalBondsEth + getters.getTotalBondsCelo
  },
  getWhateverComputationEth(_, getters) {
    return getters.getBondsEth.reduce... or map or filter or find etc....
  }
  ...
}

So, my questions will be

1. Will this be considered a bad practice since I am using getters that depends on others? Are these considered circular dependencies?

2. Should I always derived my getters directly from the source of truth? For example, change the above to...

getTotalBonds(state) {
    return state.bonds.eth.length + state.bonds.celo.length
}

3. Is there a way to debug my getters or computed properties using the browser console so I can make sure I do not have performance issues or weird iteration loops, etc?

And thank you very much if you take the time to answer!

This wouldn't be a circular dependency. It would be circular dependency in case when getter A would depend on getter B and getter B would depend on getter A, which would create an infinite recursion.

Getters are fine, but AFAIK they get called by Vue on every tick (more on what the tick is here), which would be wasteful most of the time. So for rarely changing values the use computed is encouraged, since computed gets called only once and Vue caches the result of execution.