diff --git a/x/thorchain/handler_solvency.go b/x/thorchain/handler_solvency.go
index be95c301ef6b42a7cf3d65ec51bb4796f68e3d1b..8ffae7c38034a64abf2dfd1300921df8a5398d62 100644
--- a/x/thorchain/handler_solvency.go
+++ b/x/thorchain/handler_solvency.go
@@ -72,6 +72,8 @@ func (h SolvencyHandler) handle(ctx cosmos.Context, msg MsgSolvency) (*cosmos.Re
ctx.Logger().Debug("handle Solvency request", "id", msg.Id.String(), "signer", msg.Signer.String())
version := h.mgr.GetVersion()
switch {
+ case version.GTE(semver.MustParse("1.97.0")):
+ return h.handleV97(ctx, msg)
case version.GTE(semver.MustParse("1.87.0")):
return h.handleV87(ctx, msg)
case version.GTE(semver.MustParse("0.79.0")):
@@ -87,7 +89,7 @@ func (h SolvencyHandler) handle(ctx cosmos.Context, msg MsgSolvency) (*cosmos.Re
// if wallet has less fund than asgard vault , and the gap is more than 1% , then the chain
// that is insolvent will be halt
// 3. When chain is halt , bifrost will not observe inbound , and will not sign outbound txs until the issue has been investigated , and enabled it again using mimir
-func (h SolvencyHandler) handleV87(ctx cosmos.Context, msg MsgSolvency) (*cosmos.Result, error) {
+func (h SolvencyHandler) handleV97(ctx cosmos.Context, msg MsgSolvency) (*cosmos.Result, error) {
voter, err := h.mgr.Keeper().GetSolvencyVoter(ctx, msg.Id, msg.Chain)
if err != nil {
return &cosmos.Result{}, fmt.Errorf("fail to get solvency voter, err: %w", err)
@@ -157,7 +159,7 @@ func (h SolvencyHandler) handleV87(ctx cosmos.Context, msg MsgSolvency) (*cosmos
ctx.Logger().Error("fail to get mimir", "error", err)
}
- if !h.insolvencyCheckV79(ctx, vault, voter.Coins, voter.Chain) {
+ if !h.insolvencyCheckV97(ctx, vault, voter.Coins, voter.Chain) {
// here doesn't override HaltChain when the vault is solvent
// in some case even the vault is solvent , the network might need to halt by admin mimir
// admin mimir halt chain usually set the value to 1
@@ -189,7 +191,7 @@ func (h SolvencyHandler) handleV87(ctx cosmos.Context, msg MsgSolvency) (*cosmos
// insolvencyCheck compare the coins in vault against the coins report by solvency message
// insolvent usually means vault has more coins than wallet
// return true means the vault is insolvent , the network should halt , otherwise false
-func (h SolvencyHandler) insolvencyCheckV79(ctx cosmos.Context, vault Vault, coins common.Coins, chain common.Chain) bool {
+func (h SolvencyHandler) insolvencyCheckV97(ctx cosmos.Context, vault Vault, coins common.Coins, chain common.Chain) bool {
adjustVault, err := h.excludePendingOutboundFromVault(ctx, vault)
if err != nil {
return false
@@ -204,7 +206,12 @@ func (h SolvencyHandler) insolvencyCheckV79(ctx cosmos.Context, vault Vault, coi
continue
}
// ETH.RUNE will be burned on the way in , so the wallet will not have any, thus exclude it from solvency check
- if c.Asset.IsRune() {
+ if c.Asset.Equals(common.ERC20RuneAsset()) {
+ continue
+ }
+ // If an Asgard vault somehow contains a synth,
+ // do not look for an equivalent wallet balance in MsgSolvency of the same chain.
+ if c.Asset.IsSyntheticAsset() {
continue
}
if c.IsEmpty() {
diff --git a/x/thorchain/handler_solvency_archive.go b/x/thorchain/handler_solvency_archive.go
index a8f8e388bc68adf59fadb2e68db57398cdf6bb3e..75fec3e09b28db25fb584416f4cab395729d9015 100644
--- a/x/thorchain/handler_solvency_archive.go
+++ b/x/thorchain/handler_solvency_archive.go
@@ -3,13 +3,122 @@ package thorchain
import (
"context"
"fmt"
+ "strconv"
+ "strings"
"github.com/armon/go-metrics"
"github.com/cosmos/cosmos-sdk/telemetry"
+
+ "gitlab.com/thorchain/thornode/common"
"gitlab.com/thorchain/thornode/common/cosmos"
"gitlab.com/thorchain/thornode/constants"
)
+// handleCurrent is the logic to process MsgSolvency, the feature works like this
+// 1. Bifrost report MsgSolvency to thornode , which is the balance of asgard wallet on each individual chain
+// 2. once MsgSolvency reach consensus , then the network compare the wallet balance against wallet
+// if wallet has less fund than asgard vault , and the gap is more than 1% , then the chain
+// that is insolvent will be halt
+// 3. When chain is halt , bifrost will not observe inbound , and will not sign outbound txs until the issue has been investigated , and enabled it again using mimir
+func (h SolvencyHandler) handleV87(ctx cosmos.Context, msg MsgSolvency) (*cosmos.Result, error) {
+ voter, err := h.mgr.Keeper().GetSolvencyVoter(ctx, msg.Id, msg.Chain)
+ if err != nil {
+ return &cosmos.Result{}, fmt.Errorf("fail to get solvency voter, err: %w", err)
+ }
+ observeSlashPoints := h.mgr.GetConstants().GetInt64Value(constants.ObserveSlashPoints)
+ observeFlex := h.mgr.GetConstants().GetInt64Value(constants.ObservationDelayFlexibility)
+
+ slashCtx := ctx.WithContext(context.WithValue(ctx.Context(), constants.CtxMetricLabels, []metrics.Label{
+ telemetry.NewLabel("reason", "failed_observe_solvency"),
+ telemetry.NewLabel("chain", string(msg.Chain)),
+ }))
+ h.mgr.Slasher().IncSlashPoints(slashCtx, observeSlashPoints, msg.Signer)
+
+ if voter.Empty() {
+ voter = NewSolvencyVoter(msg.Id, msg.Chain, msg.PubKey, msg.Coins, msg.Height, msg.Signer)
+ } else if !voter.Sign(msg.Signer) {
+ ctx.Logger().Info("signer already signed MsgSolvency", "signer", msg.Signer.String(), "id", msg.Id)
+ return &cosmos.Result{}, nil
+ }
+ h.mgr.Keeper().SetSolvencyVoter(ctx, voter)
+ active, err := h.mgr.Keeper().ListActiveValidators(ctx)
+ if err != nil {
+ return nil, wrapError(ctx, err, "fail to get list of active node accounts")
+ }
+ if !voter.HasConsensus(active) {
+ return &cosmos.Result{}, nil
+ }
+
+ // from this point , solvency reach consensus
+ if voter.ConsensusBlockHeight > 0 {
+ if (voter.ConsensusBlockHeight + observeFlex) >= ctx.BlockHeight() {
+ h.mgr.Slasher().DecSlashPoints(slashCtx, observeSlashPoints, msg.Signer)
+ }
+ // solvency tx already processed
+ return &cosmos.Result{}, nil
+ }
+ voter.ConsensusBlockHeight = ctx.BlockHeight()
+ h.mgr.Keeper().SetSolvencyVoter(ctx, voter)
+ // decrease the slash points
+ h.mgr.Slasher().DecSlashPoints(slashCtx, observeSlashPoints, voter.GetSigners()...)
+ vault, err := h.mgr.Keeper().GetVault(ctx, voter.PubKey)
+ if err != nil {
+ ctx.Logger().Error("fail to get vault", "error", err)
+ return &cosmos.Result{}, fmt.Errorf("fail to get vault: %w", err)
+ }
+ const StopSolvencyCheckKey = `StopSolvencyCheck`
+ stopSolvencyCheck, err := h.mgr.Keeper().GetMimir(ctx, StopSolvencyCheckKey)
+ if err != nil {
+ ctx.Logger().Error("fail to get mimir", "key", StopSolvencyCheckKey, "error", err)
+ }
+ if stopSolvencyCheck > 0 && stopSolvencyCheck < ctx.BlockHeight() {
+ return &cosmos.Result{}, nil
+ }
+ // stop solvency checker per chain
+ // this allows the network to stop solvency checker for ETH chain for example , while other chains like BNB/BTC chains
+ // their solvency checker are still active
+ stopSolvencyCheckChain, err := h.mgr.Keeper().GetMimir(ctx, fmt.Sprintf(StopSolvencyCheckKey+voter.Chain.String()))
+ if err != nil {
+ ctx.Logger().Error("fail to get mimir", "key", StopSolvencyCheckKey+voter.Chain.String(), "error", err)
+ }
+ if stopSolvencyCheckChain > 0 && stopSolvencyCheckChain < ctx.BlockHeight() {
+ return &cosmos.Result{}, nil
+ }
+ haltChainKey := fmt.Sprintf(`SolvencyHalt%sChain`, voter.Chain)
+ haltChain, err := h.mgr.Keeper().GetMimir(ctx, haltChainKey)
+ if err != nil {
+ ctx.Logger().Error("fail to get mimir", "error", err)
+ }
+
+ if !h.insolvencyCheckV79(ctx, vault, voter.Coins, voter.Chain) {
+ // here doesn't override HaltChain when the vault is solvent
+ // in some case even the vault is solvent , the network might need to halt by admin mimir
+ // admin mimir halt chain usually set the value to 1
+ if haltChain <= 1 {
+ return &cosmos.Result{}, nil
+ }
+ // if the chain was halted by previous solvency checker, auto unhalt it
+ ctx.Logger().Info("auto un-halt", "chain", voter.Chain, "previous halt height", haltChain, "current block height", ctx.BlockHeight())
+ h.mgr.Keeper().SetMimir(ctx, haltChainKey, 0)
+ mimirEvent := NewEventSetMimir(strings.ToUpper(haltChainKey), "0")
+ if err := h.mgr.EventMgr().EmitEvent(ctx, mimirEvent); err != nil {
+ ctx.Logger().Error("fail to emit set_mimir event", "error", err)
+ }
+ }
+
+ if haltChain > 0 && haltChain < ctx.BlockHeight() {
+ // Trading already halt
+ return &cosmos.Result{}, nil
+ }
+ h.mgr.Keeper().SetMimir(ctx, haltChainKey, ctx.BlockHeight())
+ mimirEvent := NewEventSetMimir(strings.ToUpper(haltChainKey), strconv.FormatInt(ctx.BlockHeight(), 10))
+ if err := h.mgr.EventMgr().EmitEvent(ctx, mimirEvent); err != nil {
+ ctx.Logger().Error("fail to emit set_mimir event", "error", err)
+ }
+ ctx.Logger().Info("chain is insolvent, halt until it is resolved", "chain", voter.Chain)
+ return &cosmos.Result{}, nil
+}
+
// handleCurrent is the logic to process MsgSolvency, the feature works like this
// 1. Bifrost report MsgSolvency to thornode , which is the balance of asgard wallet on each individual chain
// 2. once MsgSolvency reach consensus , then the network compare the wallet balance against wallet
@@ -106,3 +215,54 @@ func (h SolvencyHandler) handleV79(ctx cosmos.Context, msg MsgSolvency) (*cosmos
ctx.Logger().Info("chain is insolvent, halt until it is resolved", "chain", voter.Chain)
return &cosmos.Result{}, nil
}
+
+// insolvencyCheck compare the coins in vault against the coins report by solvency message
+// insolvent usually means vault has more coins than wallet
+// return true means the vault is insolvent , the network should halt , otherwise false
+func (h SolvencyHandler) insolvencyCheckV79(ctx cosmos.Context, vault Vault, coins common.Coins, chain common.Chain) bool {
+ adjustVault, err := h.excludePendingOutboundFromVault(ctx, vault)
+ if err != nil {
+ return false
+ }
+ permittedSolvencyGap, err := h.mgr.Keeper().GetMimir(ctx, constants.PermittedSolvencyGap.String())
+ if err != nil || permittedSolvencyGap <= 0 {
+ permittedSolvencyGap = h.mgr.GetConstants().GetInt64Value(constants.PermittedSolvencyGap)
+ }
+ // Use the coin in vault as baseline , wallet can have more coins than vault
+ for _, c := range adjustVault.Coins {
+ if !c.Asset.Chain.Equals(chain) {
+ continue
+ }
+ // ETH.RUNE will be burned on the way in , so the wallet will not have any, thus exclude it from solvency check
+ if c.Asset.IsRune() {
+ continue
+ }
+ if c.IsEmpty() {
+ continue
+ }
+ walletCoin := coins.GetCoin(c.Asset)
+ if walletCoin.IsEmpty() {
+ ctx.Logger().Info("asset exist in vault , but not in wallet, insolvent", "asset", c.Asset.String(), "amount", c.Amount.String())
+ return true
+ }
+ if c.Asset.IsGasAsset() {
+ gas, err := h.mgr.GasMgr().GetMaxGas(ctx, c.Asset.GetChain())
+ if err != nil {
+ ctx.Logger().Error("fail to get max gas", "error", err)
+ } else if c.Amount.LTE(gas.Amount.MulUint64(10)) {
+ // if the amount left in asgard vault is not enough for 10 * max gas, then skip it from solvency check
+ continue
+ }
+ }
+
+ if c.Amount.GT(walletCoin.Amount) {
+ gap := c.Amount.Sub(walletCoin.Amount)
+ permittedGap := walletCoin.Amount.MulUint64(uint64(permittedSolvencyGap)).QuoUint64(10000)
+ if gap.GT(permittedGap) {
+ ctx.Logger().Info("vault has more asset than wallet, insolvent", "asset", c.Asset.String(), "vault amount", c.Amount.String(), "wallet amount", walletCoin.Amount.String(), "gap", gap.String())
+ return true
+ }
+ }
+ }
+ return false
+}