fix: save & overdraft interaction + world var error (#1177)

Azorlogh · web-flow · commit 4835b766718b · 2025-12-05T10:42:05.000Z
* fix save &amp; overdraft interaction + properly handle world var error

* test fmt tweak

* improve error message &amp; add tests for world var behavior
diff --git a/internal/machine/vm/machine.go b/internal/machine/vm/machine.go
@@ -434,11 +434,23 @@ func (m *Machine) tick() (bool, error) {
 	case program.OP_SAVE:
 		a := pop[machine.AccountAddress](m)
 		v := m.popValue()
+		// note: if the balance is not present, it means it's never used as a source so we don't need to save anything
 		switch v := v.(type) {
 		case machine.Asset:
-			m.Balances[a][v] = machine.Zero
+			if balances, ok := m.Balances[a]; ok {
+				if balance, ok := balances[v]; ok {
+					if balance.ToBigInt().Sign() > 0 {
+						balances[v] = machine.Zero
+					}
+				}
+			}
+
 		case machine.Monetary:
-			m.Balances[a][v.Asset] = m.Balances[a][v.Asset].Sub(v.Amount)
+			if balances, ok := m.Balances[a]; ok {
+				if balance, ok := balances[v.Asset]; ok {
+					balances[v.Asset] = balance.Sub(v.Amount)
+				}
+			}
 		default:
 			panic(fmt.Errorf("invalid value type: %T", v))
 		}
@@ -494,13 +506,18 @@ func (m *Machine) ResolveBalances(ctx context.Context, store Store) error {
 		assignBalanceAsResource[address][string(monetary.Asset)] = resourceIndex
 	}
 
+	m.Balances = make(map[machine.AccountAddress]map[machine.Asset]*machine.MonetaryInt)
+
 	// for every account that we need balances of, check if it's there
 	for addr, neededAssets := range m.Program.NeededBalances {
 		account, ok := m.getResource(addr)
 		if !ok {
 			return errors.New("invalid program (resolve balances: invalid address of account)")
 		}
 		accountAddress := (*account).(machine.AccountAddress)
+		if string(accountAddress) == "world" {
+			return machine.NewErrInvalidVars("`@world` can only be used as a variable in the experimental interpreter, or if it is never used as a source")
+		}
 
 		// for every asset, register the query
 		for addr := range neededAssets {
@@ -510,16 +527,11 @@ func (m *Machine) ResolveBalances(ctx context.Context, store Store) error {
 			}
 
 			asset := (*mon).(machine.HasAsset).GetAsset()
-			if string(accountAddress) == "world" {
-				m.Balances[accountAddress][asset] = machine.Zero
-				continue
-			}
 
 			balancesQuery[string(accountAddress)] = append(balancesQuery[string(accountAddress)], string(asset))
 		}
 	}
 
-	m.Balances = make(map[machine.AccountAddress]map[machine.Asset]*machine.MonetaryInt)
 	if len(balancesQuery) > 0 {
 		balances, err := store.GetBalances(ctx, balancesQuery)
 		if err != nil {
diff --git a/internal/machine/vm/machine_test.go b/internal/machine/vm/machine_test.go
@@ -134,7 +134,7 @@ func testImpl(t *testing.T, prog *program.Program, expected CaseResult, exec fun
 
 	err := exec(m)
 	if expected.Error != nil {
-		require.True(t, errors.Is(err, expected.Error), "got wrong error, want: %v, got: %v", expected.Error, err)
+		require.True(t, errors.Is(err, expected.Error), "got wrong error, want: %[1]v (%[1]T), got: %v", expected.Error, err)
 		if expected.ErrorContains != "" {
 			require.ErrorContains(t, err, expected.ErrorContains)
 		}
@@ -1699,6 +1699,54 @@ func TestVariablesErrors(t *testing.T) {
 	test(t, tc)
 }
 
+func TestWorldSourceVariable(t *testing.T) {
+	tc := NewTestCase()
+	tc.compile(t, `vars {
+		account $foo
+	}
+	send [COIN 1] (
+		source = $foo
+		destination = @bob
+	)`)
+	tc.vars = map[string]string{
+		"foo": "world",
+	}
+	tc.expected = CaseResult{
+		Printed:       []machine.Value{},
+		Postings:      []Posting{},
+		Error:         &machine.ErrInvalidVars{},
+		ErrorContains: "`@world` can only be used as a variable in the experimental interpreter, or if it is never used as a source",
+	}
+	test(t, tc)
+}
+
+func TestWorldNonSourceVariable(t *testing.T) {
+	tc := NewTestCase()
+	tc.compile(t, `vars {
+		account $foo
+	}
+	send [COIN 1] (
+		source = @alice
+		destination = $foo
+	)`)
+	tc.setBalance("alice", "COIN", 1)
+	tc.vars = map[string]string{
+		"foo": "world",
+	}
+	tc.expected = CaseResult{
+		Printed: []machine.Value{},
+		Postings: []Posting{
+			{
+				Source:      "alice",
+				Destination: "world",
+				Asset:       "COIN",
+				Amount:      machine.NewMonetaryInt(1),
+			},
+		},
+	}
+	test(t, tc)
+}
+
 func TestSetVarsFromJSON(t *testing.T) {
 
 	type testCase struct {
@@ -2267,6 +2315,25 @@ func TestSaveFromAccount(t *testing.T) {
 		}
 		test(t, tc)
 	})
+
+	t.Run("save all and overdraft", func(t *testing.T) {
+		script := `
+ 			save [USD *] from @alice
+
+ 			send [USD 10] (
+ 			   source = @alice allowing overdraft up to [USD 10]
+ 			   destination = @world
+ 			)`
+		tc := NewTestCase()
+		tc.compile(t, script)
+		tc.setBalance("alice", "USD", -10)
+		tc.expected = CaseResult{
+			Printed:       []machine.Value{},
+			ErrorContains: "insufficient funds",
+			Error:         &machine.ErrInsufficientFund{},
+		}
+		test(t, tc)
+	})
 }
 
 func TestUseDifferentAssetsWithSameSourceAccount(t *testing.T) {
