feat: avoid tracking unbounded balances

components/ledger/internal/engine/command/commander.go

@@ -17,7 +17,6 @@ import (
 	"github.com/formancehq/ledger/internal/bus"
 	"github.com/formancehq/ledger/internal/engine/utils/batching"
 	"github.com/formancehq/ledger/internal/machine/vm"
-	"github.com/formancehq/stack/libs/go-libs/collectionutils"
 	"github.com/formancehq/stack/libs/go-libs/metadata"
 	"github.com/pkg/errors"
 )
@@ -126,22 +125,13 @@ func (commander *Commander) exec(ctx context.Context, parameters Parameters, scr
 			return nil, NewErrCompilationFailed(err)
 		}
 
-		involvedAccounts, involvedSources, err := func() ([]string, []string, error) {
-			involvedAccounts, involvedSources, err := m.ResolveResources(ctx, commander.store)
-			if err != nil {
-				return nil, nil, NewErrCompilationFailed(err)
-			}
-
-			return involvedAccounts, involvedSources, nil
-		}()
+		readLockAccounts, writeLockAccounts, err := m.ResolveResources(ctx, commander.store)
 		if err != nil {
-			return nil, err
+			return nil, NewErrCompilationFailed(err)
 		}
-
-		worldFilter := collectionutils.FilterNot(collectionutils.FilterEq("world"))
 		lockAccounts := Accounts{
-			Read:  collectionutils.Filter(involvedAccounts, worldFilter),
-			Write: collectionutils.Filter(involvedSources, worldFilter),
+			Read:  readLockAccounts,
+			Write: writeLockAccounts,
 		}
 
 		unlock, err := func() (Unlock, error) {

components/ledger/internal/machine/script/compiler/compiler.go

@@ -26,6 +26,15 @@ type parseVisitor struct {
 	varIdx map[string]machine.Address
 	// needBalances store for each account, the set of assets needed
 	neededBalances map[machine.Address]map[machine.Address]struct{}
+
+	// The sources accounts that aren't unbounded
+	// that is, @world or sources that appear within a
+	// '.. allowing unboundeed overdraft' clause
+	writeLockAccounts map[machine.Address]struct{}
+
+	// all the accounts that appear in either the destination
+	// or in the balance() function
+	readLockAccounts map[machine.Address]struct{}
 }
 
 // Allocates constants if it hasn't already been,
@@ -580,6 +589,7 @@ func (p *parseVisitor) VisitVars(c *parser.VarListDeclContext) *CompileError {
 				Account: *accAddr,
 				Asset:   *assAddr,
 			})
+			p.readLockAccounts[*accAddr] = struct{}{}
 			if err != nil {
 				return LogicError(c, err)
 			}
@@ -674,12 +684,14 @@ func CompileFull(input string) CompileArtifacts {
 	}
 
 	visitor := parseVisitor{
-		errListener:    errListener,
-		instructions:   make([]byte, 0),
-		resources:      make([]program.Resource, 0),
-		varIdx:         make(map[string]machine.Address),
-		neededBalances: make(map[machine.Address]map[machine.Address]struct{}),
-		sources:        map[machine.Address]struct{}{},
+		errListener:       errListener,
+		instructions:      make([]byte, 0),
+		resources:         make([]program.Resource, 0),
+		varIdx:            make(map[string]machine.Address),
+		neededBalances:    make(map[machine.Address]map[machine.Address]struct{}),
+		sources:           map[machine.Address]struct{}{},
+		writeLockAccounts: map[machine.Address]struct{}{},
+		readLockAccounts:  map[machine.Address]struct{}{},
 	}
 
 	err := visitor.VisitScript(tree)
@@ -688,17 +700,24 @@ func CompileFull(input string) CompileArtifacts {
 		return artifacts
 	}
 
-	sources := make(machine.Addresses, 0)
-	for address := range visitor.sources {
-		sources = append(sources, address)
+	readLockAccounts := make(machine.Addresses, 0)
+	for address := range visitor.readLockAccounts {
+		readLockAccounts = append(readLockAccounts, address)
+	}
+	sort.Stable(readLockAccounts)
+
+	writeLockAccounts := make(machine.Addresses, 0)
+	for address := range visitor.writeLockAccounts {
+		writeLockAccounts = append(writeLockAccounts, address)
 	}
-	sort.Stable(sources)
+	sort.Stable(writeLockAccounts)
 
 	artifacts.Program = &program.Program{
-		Instructions:   visitor.instructions,
-		Resources:      visitor.resources,
-		NeededBalances: visitor.neededBalances,
-		Sources:        sources,
+		Instructions:      visitor.instructions,
+		Resources:         visitor.resources,
+		NeededBalances:    visitor.neededBalances,
+		ReadLockAccounts:  readLockAccounts,
+		WriteLockAccounts: writeLockAccounts,
 	}
 
 	return artifacts

components/ledger/internal/machine/script/compiler/compiler_test.go

@@ -1045,7 +1045,7 @@ func TestSetAccountMeta(t *testing.T) {
 					program2.OP_ASSET,
 					program2.OP_APUSH, 04, 00,
 					program2.OP_MONETARY_NEW,
-					program2.OP_TAKE_ALL,
+					program2.OP_TAKE_ALWAYS,
 					program2.OP_APUSH, 02, 00,
 					program2.OP_TAKE_MAX,
 					program2.OP_APUSH, 05, 00,
@@ -1177,7 +1177,7 @@ func TestVariableBalance(t *testing.T) {
 					program2.OP_ASSET,
 					program2.OP_APUSH, 04, 00,
 					program2.OP_MONETARY_NEW,
-					program2.OP_TAKE_ALL,
+					program2.OP_TAKE_ALWAYS,
 					program2.OP_APUSH, 02, 00,
 					program2.OP_TAKE_MAX,
 					program2.OP_APUSH, 05, 00,

components/ledger/internal/machine/script/compiler/destination.go

@@ -23,7 +23,7 @@ func (p *parseVisitor) VisitDestinationRecursive(c parser.IDestinationContext) *
 	case *parser.DestAccountContext:
 		p.AppendInstruction(program.OP_FUNDING_SUM)
 		p.AppendInstruction(program.OP_TAKE)
-		ty, _, err := p.VisitExpr(c.Expression(), true)
+		ty, destAddr, err := p.VisitExpr(c.Expression(), true)
 		if err != nil {
 			return err
 		}
@@ -32,6 +32,9 @@ func (p *parseVisitor) VisitDestinationRecursive(c parser.IDestinationContext) *
 				errors.New("wrong type: expected account as destination"),
 			)
 		}
+		if !p.isWorld(*destAddr) {
+			p.readLockAccounts[*destAddr] = struct{}{}
+		}
 		p.AppendInstruction(program.OP_SEND)
 		return nil
 	case *parser.DestInOrderContext:

components/ledger/internal/machine/script/compiler/source.go

@@ -99,6 +99,25 @@ func (p *parseVisitor) TakeFromSource(fallback *FallbackAccount) error {
 	return nil
 }
 
+func (p parseVisitor) isOverdraftUnbounded(overdraftCtx parser.ISourceAccountOverdraftContext) bool {
+	if overdraftCtx == nil {
+		return false
+	}
+
+	switch overdraftCtx.(type) {
+	case *parser.SrcAccountOverdraftUnboundedContext:
+		return true
+	case *parser.SrcAccountOverdraftSpecificContext:
+		return false
+
+	default:
+		// even though this branch should be unreachable,
+		// we default to `false` instead of panicking
+		// in order to have a more conservative behaviour
+		return false
+	}
+}
+
 // VisitSource returns the resource addresses of all the accounts,
 // the addresses of accounts already emptied,
 // and possibly a fallback account if the source has an unbounded overdraft allowance or contains @world
@@ -129,7 +148,11 @@ func (p *parseVisitor) VisitSource(c parser.ISourceContext, pushAsset func(), is
 				return nil, nil, nil, LogicError(c, err)
 			}
 			p.AppendInstruction(program.OP_MONETARY_NEW)
-			p.AppendInstruction(program.OP_TAKE_ALL)
+			if p.isWorld(*accAddr) {
+				p.AppendInstruction(program.OP_TAKE_ALWAYS)
+			} else {
+				p.AppendInstruction(program.OP_TAKE_ALL)
+			}
 		} else {
 			if p.isWorld(*accAddr) {
 				return nil, nil, nil, LogicError(c, errors.New("@world is already set to an unbounded overdraft"))
@@ -151,12 +174,18 @@ func (p *parseVisitor) VisitSource(c parser.ISourceContext, pushAsset func(), is
 					return nil, nil, nil, LogicError(c, err)
 				}
 				p.AppendInstruction(program.OP_MONETARY_NEW)
-				p.AppendInstruction(program.OP_TAKE_ALL)
+				p.AppendInstruction(program.OP_TAKE_ALWAYS)
 				f := FallbackAccount(*accAddr)
 				fallback = &f
 			}
 		}
-		neededAccounts[*accAddr] = struct{}{}
+
+		isUnboundedOverdraft := p.isWorld(*accAddr) || p.isOverdraftUnbounded(overdraft)
+		if !isUnboundedOverdraft {
+			p.writeLockAccounts[*accAddr] = struct{}{}
+			neededAccounts[*accAddr] = struct{}{}
+		}
+
 		emptiedAccounts[*accAddr] = struct{}{}
 
 		if fallback != nil && isAll {

components/ledger/internal/machine/vm/machine.go

@@ -13,6 +13,7 @@ import (
 	"encoding/binary"
 	"fmt"
 	"math/big"
+	"slices"
 
 	"github.com/formancehq/ledger/internal/machine"
 
@@ -139,16 +140,16 @@ func (m *Machine) withdrawAlways(account machine.AccountAddress, mon machine.Mon
 	if accBalance, ok := m.Balances[account]; ok {
 		if balance, ok := accBalance[mon.Asset]; ok {
 			accBalance[mon.Asset] = balance.Sub(mon.Amount)
-			return &machine.Funding{
-				Asset: mon.Asset,
-				Parts: []machine.FundingPart{{
-					Account: account,
-					Amount:  mon.Amount,
-				}},
-			}, nil
 		}
 	}
-	return nil, fmt.Errorf("missing %v balance from %v", mon.Asset, account)
+
+	return &machine.Funding{
+		Asset: mon.Asset,
+		Parts: []machine.FundingPart{{
+			Account: account,
+			Amount:  mon.Amount,
+		}},
+	}, nil
 }
 
 func (m *Machine) credit(account machine.AccountAddress, funding machine.Funding) {
@@ -170,8 +171,16 @@ func (m *Machine) repay(funding machine.Funding) {
 		if part.Account == "world" {
 			continue
 		}
-		balance := m.Balances[part.Account][funding.Asset]
-		m.Balances[part.Account][funding.Asset] = balance.Add(part.Amount)
+		accountBalance, ok := m.Balances[part.Account]
+		if !ok {
+			// no asset: the source has to be an unbounded source
+			// which NEVER appears as bounded
+			// this means we don't need to track it's balance
+			continue
+		}
+
+		balance := accountBalance[funding.Asset]
+		accountBalance[funding.Asset] = balance.Add(part.Amount)
 	}
 }
 
@@ -574,6 +583,9 @@ func (m *Machine) ResolveResources(ctx context.Context, store Store) ([]string,
 			if err != nil {
 				return nil, nil, err
 			}
+			if val.GetType() == machine.TypeAccount {
+				involvedAccountsMap[machine.Address(idx)] = string(val.(machine.AccountAddress))
+			}
 		case program.VariableAccountBalance:
 			acc, _ := m.getResource(res.Account)
 			address := string((*acc).(machine.AccountAddress))
@@ -607,16 +619,19 @@ func (m *Machine) ResolveResources(ctx context.Context, store Store) ([]string,
 		m.Resources = append(m.Resources, val)
 	}
 
-	involvedAccounts := make([]string, 0)
-	involvedSources := make([]string, 0)
-	for _, accountAddress := range involvedAccountsMap {
-		involvedAccounts = append(involvedAccounts, accountAddress)
+	readLockAccounts := make([]string, 0)
+	for _, accountAddress := range m.Program.ReadLockAccounts {
+		readLockAccounts = append(readLockAccounts, involvedAccountsMap[accountAddress])
 	}
-	for _, machineAddress := range m.Program.Sources {
-		involvedSources = append(involvedSources, involvedAccountsMap[machineAddress])
+
+	writeLockAccounts := make([]string, 0)
+	for _, machineAddress := range m.Program.WriteLockAccounts {
+		writeLockAccounts = append(writeLockAccounts, involvedAccountsMap[machineAddress])
 	}
 
-	return involvedAccounts, involvedSources, nil
+	slices.Sort(readLockAccounts)
+	slices.Sort(writeLockAccounts)
+	return readLockAccounts, writeLockAccounts, nil
 }
 
 func (m *Machine) SetVarsFromJSON(vars map[string]string) error {