zkgm: move local asset class records unto the proxy realm

this will make grc20 escrow classification survives implementation swaps

Author: notJoon

gno.land/r/core/ibc/v1/apps/zkgm/proxy.gno

@@ -24,6 +24,7 @@ var (
 	gRealmSet     bool
 	receivers     = bptree.NewBPTree32()
 	escrowedGRC20 = bptree.NewBPTree32()
+	assetClassOf  = bptree.NewBPTree32()
 )
 
 const proxyPkgPath = "gno.land/r/onbloc/unionibc/v1/apps/zkgm"
@@ -162,7 +163,7 @@ func BatchSend(cur realm, msg core.MsgBatchSend) core.H256 {
 //
 // ReleaseNative is used by implementation-side sendNative calls so refunds and
 // releases are sourced from the escrow where the user's -send funds land.
-func ReleaseNative(cur realm, denom string, recipient address, amount int64) {
+func ReleaseNative(cur realm, denom string, recipient address, amount int64) error {
 	cacheRealm(cur)
 	requireImplRealm(cur, "release native")
 
@@ -172,9 +173,14 @@ func ReleaseNative(cur realm, denom string, recipient address, amount int64) {
 	if denom == "" {
 		panic("zkgm: ReleaseNative denom must not be empty")
 	}
+	rb := banker.NewReadonlyBanker()
+	if rb.GetCoins(cur.Address()).AmountOf(denom) < amount {
+		return errors.New("zkgm: insufficient native escrow balance")
+	}
 	b := banker.NewBanker(banker.BankerTypeRealmSend, cur)
 	b.SendCoins(cur.Address(), recipient, chain.NewCoins(chain.NewCoin(denom, amount)))
 	emitZkgmNativeReleasedEvent(cur.Previous().PkgPath(), denom, recipient, amount)
+	return nil
 }
 
 func EscrowGRC20(cur realm, denomKey string, from address, amount int64) error {
@@ -231,6 +237,22 @@ func escrowedGRC20Token(denomKey string) (*grc20.Token, error) {
 	return tok, nil
 }
 
+func RecordAssetClass(cur realm, denom string, class uint8) {
+	requireImplRealm(cur, "record asset class")
+	if _, ok := assetClassOf.Get(denom); ok {
+		return
+	}
+	assetClassOf.Set(denom, class)
+}
+
+func GetAssetClass(denom string) (uint8, bool) {
+	value, ok := assetClassOf.Get(denom)
+	if !ok {
+		return 0, false
+	}
+	return value.(uint8), true
+}
+
 // requireImplRealm panics unless the caller is the registered implementation
 // realm or an allowed implementation realm.
 func requireImplRealm(cur realm, action string) {

gno.land/r/core/ibc/v1/apps/zkgm/v0/impl/asset.gno

@@ -5,7 +5,6 @@ import (
 	"strings"
 
 	u256 "gno.land/p/gnoswap/uint256"
-	"gno.land/p/nt/bptree/v0"
 	"gno.land/r/demo/defi/grc20reg"
 	zkgm "gno.land/r/onbloc/unionibc/v1/apps/zkgm"
 )
@@ -18,8 +17,6 @@ const (
 	classLocalGRC20
 )
 
-var assetClassOf = bptree.NewBPTree32()
-
 func classify(denom string) assetClass {
 	// Voucher wire denoms are `ibc/<hash>`, while their grc20reg keys use the
 	// voucher realm path and hash slug. Check the prefix before registry lookup.
@@ -32,16 +29,13 @@ func classify(denom string) assetClass {
 	return classNative
 }
 
-func recordAssetClass(denom string, c assetClass) {
-	if _, ok := assetClassOf.Get(denom); ok {
-		return
-	}
-	assetClassOf.Set(denom, c)
+func recordAssetClass(cur realm, denom string, c assetClass) {
+	zkgm.RecordAssetClass(cross(cur), denom, uint8(c))
 }
 
 func assetClassFor(denom string) assetClass {
-	if v, ok := assetClassOf.Get(denom); ok {
-		return v.(assetClass)
+	if v, ok := zkgm.GetAssetClass(denom); ok {
+		return assetClass(v)
 	}
 	// Compatibility fallback for pre-upgrade in-flight native/voucher orders.
 	// New local-GRC20 escrow records its class before channel balance is credited,
@@ -55,8 +49,8 @@ func assetClassFor(denom string) assetClass {
 func escrowAsset(cur realm, denom string, sender string, amount *u256.Uint, budget *sentCoinBudget) error {
 	liveClass := classify(denom)
 	c := liveClass
-	if value, ok := assetClassOf.Get(denom); ok {
-		c = value.(assetClass)
+	if value, ok := zkgm.GetAssetClass(denom); ok {
+		c = assetClass(value)
 		if c != liveClass {
 			return errors.New("zkgm/v1: asset class changed for " + denom)
 		}
@@ -79,7 +73,7 @@ func escrowAsset(cur realm, denom string, sender string, amount *u256.Uint, budg
 			return err
 		}
 	}
-	recordAssetClass(denom, c)
+	recordAssetClass(cur, denom, c)
 	return nil
 }
 

gno.land/r/core/ibc/v1/apps/zkgm/v0/impl/channel_balance.gno

@@ -5,8 +5,8 @@ import (
 	"errors"
 
 	u256 "gno.land/p/gnoswap/uint256"
-	core "gno.land/r/onbloc/unionibc/v1/core"
 	zkgm "gno.land/r/onbloc/unionibc/v1/apps/zkgm"
+	core "gno.land/r/onbloc/unionibc/v1/core"
 )
 
 // ChannelBalanceKeyV2 returns the storage key for a v2 channel balance entry.
@@ -31,10 +31,10 @@ func decreaseChannelBalanceV2(cur realm, channelId core.ChannelId, path *u256.Ui
 		return nil
 	}
 	key := ChannelBalanceKeyV2(channelId, path, baseToken, quoteToken)
-	curAmount := zkgm.GetChannelBalanceV2(key)
-	if curAmount == nil || curAmount.Cmp(amount) < 0 {
-		return errors.New("zkgm/channel_balance: underflow")
+	if err := ensureChannelBalanceV2(key, amount); err != nil {
+		return err
 	}
+	curAmount := zkgm.GetChannelBalanceV2(key)
 	next := new(u256.Uint).Sub(curAmount, amount)
 	if next.IsZero() {
 		zkgm.RemoveChannelBalanceV2(cross(cur), key)
@@ -43,3 +43,11 @@ func decreaseChannelBalanceV2(cur realm, channelId core.ChannelId, path *u256.Ui
 	}
 	return nil
 }
+
+func ensureChannelBalanceV2(key string, amount *u256.Uint) error {
+	curAmount := zkgm.GetChannelBalanceV2(key)
+	if curAmount == nil || curAmount.Cmp(amount) < 0 {
+		return errors.New("zkgm/channel_balance: underflow")
+	}
+	return nil
+}

gno.land/r/core/ibc/v1/apps/zkgm/v0/impl/dispatch_test.gno

@@ -145,7 +145,7 @@ func TestRecvTokenOrderGRC20ReleaseFailureAborts(cur realm, t *testing.T) {
 	resetTokenOrderTest(cur)
 
 	denom, _, _ := registerImplTestGRC20(cur, "recv_release_fail")
-	recordAssetClass(denom, classLocalGRC20)
+	recordAssetClass(cur, denom, classLocalGRC20)
 	path := u256.Zero()
 	reversed, err := z.ReverseChannelPath(path)
 	uassert.NoError(t, err)
@@ -168,6 +168,34 @@ func TestRecvTokenOrderGRC20ReleaseFailureAborts(cur realm, t *testing.T) {
 	})
 }
 
+func TestRecvTokenOrderNativeReleaseFailureAbortsAndKeepsChannelBalance(cur realm, t *testing.T) {
+	resetTokenOrderTest(cur)
+
+	denom := "unfunded-native-release"
+	path := u256.Zero()
+	reversed, err := z.ReverseChannelPath(path)
+	uassert.NoError(t, err)
+	order := z.TokenOrderV2{
+		Kind:        z.TOKEN_ORDER_KIND_UNESCROW,
+		Sender:      []byte(testAddress("native-relfail-send")),
+		Receiver:    []byte(testAddress("native-relfail-rx")),
+		BaseToken:   []byte("remote"),
+		BaseAmount:  u256.NewUint(20),
+		QuoteToken:  []byte(denom),
+		QuoteAmount: u256.NewUint(17),
+	}
+	destChan := core.ChannelId(17)
+	increaseChannelBalanceV2(cross(cur), destChan, reversed, order.QuoteToken, order.BaseToken, order.BaseAmount)
+	data := mustZkgmPacketBytes(batchMustOrderInstruction(order))
+	packet := core.NewPacket(cross(cur), core.ChannelId(1), destChan, data, 0, 0)
+
+	uassert.AbortsContains(t, cur, "insufficient native escrow balance", func(cur realm) {
+		(&ZkgmV1{}).Recv(cur, packet, address(testAddress("native-relfail-relay")), nil)
+	})
+	balance := zkgm.GetChannelBalanceV2(ChannelBalanceKeyV2(destChan, reversed, order.QuoteToken, order.BaseToken))
+	uassert.Equal(t, "20", balance.ToString())
+}
+
 func mustZkgmPacketBytes(instr z.Instruction) []byte {
 	out, err := z.EncodeZkgmPacket(z.ZkgmPacket{
 		Salt:        [32]byte{},

gno.land/r/core/ibc/v1/apps/zkgm/v0/impl/token_order.gno

@@ -201,7 +201,8 @@ func (v *ZkgmV1) executeTokenOrderV2(cur realm, packet core.Packet, relayer addr
 		if _, err := amountInt64(fee); err != nil {
 			return core.NewRecvPacketResult(cross(cur), core.PacketStatusUnknown, nil), err
 		}
-		if err := decreaseChannelBalanceV2(cross(cur), packet.DestinationChannelId, reversedPath, order.QuoteToken, order.BaseToken, order.BaseAmount); err != nil {
+		balanceKey := ChannelBalanceKeyV2(packet.DestinationChannelId, reversedPath, order.QuoteToken, order.BaseToken)
+		if err := ensureChannelBalanceV2(balanceKey, order.BaseAmount); err != nil {
 			return core.NewRecvPacketResult(cross(cur), core.PacketStatusUnknown, nil), err
 		}
 		if !order.QuoteAmount.IsZero() {
@@ -214,6 +215,9 @@ func (v *ZkgmV1) executeTokenOrderV2(cur realm, packet core.Packet, relayer addr
 				panic(execFatal{err.Error()})
 			}
 		}
+		if err := decreaseChannelBalanceV2(cross(cur), packet.DestinationChannelId, reversedPath, order.QuoteToken, order.BaseToken, order.BaseAmount); err != nil {
+			panic(execFatal{err.Error()})
+		}
 	case z.TOKEN_ORDER_KIND_SOLVE:
 		return core.NewRecvPacketResult(cross(cur), core.PacketStatusUnknown, nil), errors.New("zkgm/v1: solve recv not implemented")
 	default:
@@ -332,6 +336,5 @@ func sendNative(cur realm, denom string, receiver string, amount *u256.Uint) err
 		return err
 	}
 
-	zkgm.ReleaseNative(cross(cur), denom, address(receiver), n)
-	return nil
+	return zkgm.ReleaseNative(cross(cur), denom, address(receiver), n)
 }

gno.land/r/core/ibc/v1/apps/zkgm/v0/impl/token_order_test.gno

@@ -9,7 +9,6 @@ import (
 
 	"gno.land/p/demo/tokens/grc20"
 	u256 "gno.land/p/gnoswap/uint256"
-	"gno.land/p/nt/bptree/v0"
 	"gno.land/p/nt/testutils/v0"
 	"gno.land/p/nt/uassert/v0"
 	tb "gno.land/p/onbloc/tokenbucket"
@@ -105,6 +104,35 @@ func TestTokenOrderAckMarketMakerEscrowWithLocalGRC20RewardsMarketMaker(cur real
 	uassert.True(t, balance == nil || balance.IsZero())
 }
 
+func TestTokenOrderAckMarketMakerGRC20AfterImplResetUsesRecordedClass(cur realm, t *testing.T) {
+	resetTokenOrderTest(cur)
+
+	sender := testAddress("mm-g20-up-send")
+	marketMaker := testAddress("mm-g20-up-maker")
+	channelId := core.ChannelId(26)
+	denom, tok, ledger := registerImplTestGRC20(cur, "mm_grc20_upgrade")
+	uassert.NoError(t, ledger.Mint(address(sender), 50))
+	uassert.NoError(t, ledger.Approve(address(sender), zkgm.ProxyAddress(), 13))
+	order := z.TokenOrderV2{
+		Sender:      []byte(sender),
+		BaseToken:   []byte(denom),
+		BaseAmount:  u256.NewUint(13),
+		QuoteToken:  []byte("quote-upgrade"),
+		QuoteAmount: u256.NewUint(13),
+		Kind:        z.TOKEN_ORDER_KIND_ESCROW,
+	}
+	uassert.NoError(t, (&ZkgmV1{}).verifyTokenOrderV2(cur, channelId, sender, newSentCoinBudget(nil), u256.Zero(), order))
+
+	resetTokenOrderTest(cur)
+	err := (&ZkgmV1{}).acknowledgeTokenOrderV2(cur, channelId, u256.Zero(), order, marketMakerAck(marketMaker))
+
+	uassert.NoError(t, err)
+	uassert.Equal(t, int64(13), tok.BalanceOf(address(marketMaker)))
+	uassert.Equal(t, int64(0), tok.BalanceOf(zkgm.ProxyAddress()))
+	balance := zkgm.GetChannelBalanceV2(ChannelBalanceKeyV2(channelId, u256.Zero(), order.BaseToken, order.QuoteToken))
+	uassert.True(t, balance == nil || balance.IsZero())
+}
+
 func TestTokenOrderVerifyNativeRequiresSentCoin(cur realm, t *testing.T) {
 	order := z.TokenOrderV2{
 		Sender:     []byte(testAddress("v1-native-sender")),
@@ -274,7 +302,7 @@ func TestTokenOrderExecuteUnescrowReleasesLocalGRC20(cur realm, t *testing.T) {
 	relayer := testAddress("g20-unescrow-relay")
 	denom, tok, ledger := registerImplTestGRC20(cur, "unescrow_release")
 	uassert.NoError(t, ledger.Mint(zkgm.ProxyAddress(), 20))
-	recordAssetClass(denom, classLocalGRC20)
+	recordAssetClass(cur, denom, classLocalGRC20)
 	path := u256.NewUint(7)
 	reversed, err := z.ReverseChannelPath(path)
 	uassert.NoError(t, err)
@@ -304,7 +332,7 @@ func TestTokenOrderAckFailureRefundsLocalGRC20(cur realm, t *testing.T) {
 	sender := testAddress("v1-grc20-ack-refund")
 	denom, tok, ledger := registerImplTestGRC20(cur, "ack_refund")
 	uassert.NoError(t, ledger.Mint(zkgm.ProxyAddress(), 13))
-	recordAssetClass(denom, classLocalGRC20)
+	recordAssetClass(cur, denom, classLocalGRC20)
 	order := z.TokenOrderV2{
 		Sender:      []byte(sender),
 		BaseToken:   []byte(denom),
@@ -354,7 +382,7 @@ func TestTokenOrderTimeoutRefundsLocalGRC20(cur realm, t *testing.T) {
 	sender := testAddress("g20-timeout-refund")
 	denom, tok, ledger := registerImplTestGRC20(cur, "timeout_refund")
 	uassert.NoError(t, ledger.Mint(zkgm.ProxyAddress(), 13))
-	recordAssetClass(denom, classLocalGRC20)
+	recordAssetClass(cur, denom, classLocalGRC20)
 	order := z.TokenOrderV2{
 		Sender:      []byte(sender),
 		BaseToken:   []byte(denom),
@@ -1035,7 +1063,6 @@ func TestAckConstantConstructorsReturnIndependentInstances(cur realm, t *testing
 }
 
 func resetTokenOrderTest(cur realm) {
-	assetClassOf = bptree.NewBPTree32()
 	zkgm.UpdateImpl(cross(cur), zkgm.NewUpdateRequest(cross(cur), &ZkgmV1{}, nil))
 }
 

gno.land/r/core/ibc/v1/apps/zkgm/z1_app_test.gno

@@ -96,6 +96,7 @@ func resetZkgmForTest() {
 	bootstrapped = false
 	paused = false
 	escrowedGRC20 = bptree.NewBPTree32()
+	assetClassOf = bptree.NewBPTree32()
 }
 
 func TestAppChannelOpenInitVersion(cur realm, t *testing.T) {

gno.land/r/core/ibc/v1/apps/zkgm/z1_proxy_test.gno

@@ -235,6 +235,20 @@ func TestReleaseNativeRejectsUnlistedCaller(cur realm, t *testing.T) {
 	uassert.Equal(t, int64(7), bk.GetCoins(ProxyAddress()).AmountOf(denom))
 }
 
+func TestReleaseNativeReturnsErrorForMissingEscrow(cur realm, t *testing.T) {
+	resetZkgmForTest()
+	cacheRealm(cur)
+	implPath = "gno.land/r/not-this-realm"
+	allowedImpls = []string{ProxyPkgPath()}
+
+	recipient := address("g1wymu47drhr0kuq2098m792lytgtj2nyx77yrsm")
+	testing.SetRealm(testing.NewCodeRealm(ProxyPkgPath()))
+	uassert.NotAborts(t, cur, func(cur realm) {
+		err := ReleaseNative(cross(cur), "unfunded-native", recipient, 7)
+		uassert.ErrorContains(t, err, "insufficient native escrow balance")
+	})
+}
+
 func TestEscrowGRC20AllowsAuthorizedImplCaller(cur realm, t *testing.T) {
 	resetZkgmForTest()
 	cacheRealm(cur)