Prototype

finally some tests passing

other passing tests

fix edge cases

fix edge cases

cleaned up

remove comment

Author: ascandone

internal/analysis/check.go

@@ -61,6 +61,7 @@ const FnVarOriginBalance = "balance"
 const FnVarOriginOverdraft = "overdraft"
 const FnVarOriginGetAsset = "get_asset"
 const FnVarOriginGetAmount = "get_amount"
+const FnVarOriginVirtual = "virtual"
 
 var Builtins = map[string]FnCallResolution{
 	FnSetTxMeta: StatementFnCallResolution{
@@ -114,6 +115,18 @@ var Builtins = map[string]FnCallResolution{
 			},
 		},
 	},
+	FnVarOriginVirtual: VarOriginFnCallResolution{
+		Params: []string{},
+		Return: TypeAccount,
+		Docs:   "create a virtual account",
+		VersionConstraints: []VersionClause{
+			{
+				// TODO flag
+				Version: parser.NewVersionInterpreter(0, 0, 17),
+				// FeatureFlag: flags.ExperimentalGetAmountFunctionFeatureFlag,
+			},
+		},
+	},
 }
 
 type Diagnostic struct {

internal/interpreter/args_parser_test.go

@@ -36,7 +36,7 @@ func TestParseValid(t *testing.T) {
 
 	p := NewArgsParser([]Value{
 		NewMonetaryInt(42),
-		AccountAddress("user:001"),
+		Account{Repr: AccountAddress("user:001")},
 	})
 	a1 := parseArg(p, parser.Range{}, expectNumber)
 	a2 := parseArg(p, parser.Range{}, expectAccount)
@@ -47,16 +47,16 @@ func TestParseValid(t *testing.T) {
 	require.NotNil(t, a1, "a1 should not be nil")
 	require.NotNil(t, a2, "a2 should not be nil")
 
-	require.Equal(t, *a1, *big.NewInt(42))
-	require.Equal(t, *a2, "user:001")
+	require.Equal(t, *big.NewInt(42), *a1)
+	require.Equal(t, Account{AccountAddress("user:001")}, *a2)
 }
 
 func TestParseBadType(t *testing.T) {
 	t.Parallel()
 
 	p := NewArgsParser([]Value{
 		NewMonetaryInt(42),
-		AccountAddress("user:001"),
+		Account{Repr: AccountAddress("user:001")},
 	})
 	parseArg(p, parser.Range{}, expectMonetary)
 	parseArg(p, parser.Range{}, expectAccount)

internal/interpreter/batch_balances_query.go

@@ -31,7 +31,11 @@ func (st *programState) findBalancesQueriesInStatement(statement parser.Statemen
 		if err != nil {
 			return err
 		}
-		st.batchQuery(*account, *asset, nil)
+
+		if account, ok := account.Repr.(AccountAddress); ok {
+			st.batchQuery(string(account), *asset, nil)
+		}
+
 		return nil
 
 	case *parser.SendStatement:
@@ -95,7 +99,10 @@ func (st *programState) findBalancesQueries(source parser.Source) InterpreterErr
 			return err
 		}
 
-		st.batchQuery(*account, st.CurrentAsset, color)
+		if account, ok := account.Repr.(AccountAddress); ok {
+			st.batchQuery(string(account), st.CurrentAsset, color)
+		}
+
 		return nil
 
 	case *parser.SourceOverdraft:
@@ -113,7 +120,10 @@ func (st *programState) findBalancesQueries(source parser.Source) InterpreterErr
 			return err
 		}
 
-		st.batchQuery(*account, st.CurrentAsset, color)
+		if account, ok := account.Repr.(AccountAddress); ok {
+			st.batchQuery(string(account), st.CurrentAsset, color)
+		}
+
 		return nil
 
 	case *parser.SourceInorder:

internal/interpreter/evaluate_expr.go

@@ -216,7 +216,7 @@ func (st *programState) divOp(rng parser.Range, left parser.ValueExpr, right par
 
 func castToString(v Value, rng parser.Range) (string, InterpreterError) {
 	switch v := v.(type) {
-	case AccountAddress:
+	case Account:
 		return v.String(), nil
 	case String:
 		return v.String(), nil

internal/interpreter/function_exprs.go

@@ -19,7 +19,7 @@ func overdraft(
 
 	// TODO more precise args range location
 	p := NewArgsParser(args)
-	account := parseArg(p, r, expectAccount)
+	account := parseArg(p, r, expectAccountAddress) // TODO also handle virtual account
 	asset := parseArg(p, r, expectAsset)
 	err = p.parse()
 	if err != nil {
@@ -53,7 +53,7 @@ func meta(
 ) (string, InterpreterError) {
 	// TODO more precise location
 	p := NewArgsParser(args)
-	account := parseArg(p, rng, expectAccount)
+	account := parseArg(p, rng, expectAccountAddress)
 	key := parseArg(p, rng, expectString)
 	err := p.parse()
 	if err != nil {
@@ -86,7 +86,7 @@ func balance(
 ) (*Monetary, InterpreterError) {
 	// TODO more precise args range location
 	p := NewArgsParser(args)
-	account := parseArg(p, r, expectAccount)
+	account := parseArg(p, r, expectAccountAddress)
 	asset := parseArg(p, r, expectAsset)
 	err := p.parse()
 	if err != nil {
@@ -102,7 +102,7 @@ func balance(
 
 	if balance.Cmp(big.NewInt(0)) == -1 {
 		return nil, NegativeBalanceError{
-			Account: *account,
+			Account: Account{AccountAddress(*account)},
 			Amount:  *balance,
 		}
 	}
@@ -155,3 +155,7 @@ func getAmount(
 
 	return mon.Amount, nil
 }
+
+func virtual() Value {
+	return Account{Repr: NewVirtualAccount()}
+}

internal/interpreter/function_statements.go

@@ -17,7 +17,7 @@ func setTxMeta(st *programState, r parser.Range, args []Value) InterpreterError
 
 func setAccountMeta(st *programState, r parser.Range, args []Value) InterpreterError {
 	p := NewArgsParser(args)
-	account := parseArg(p, r, expectAccount)
+	account := parseArg(p, r, expectAccountAddress)
 	key := parseArg(p, r, expectString)
 	meta := parseArg(p, r, expectAnything)
 	err := p.parse()

internal/interpreter/funds_stack.go

@@ -5,9 +5,9 @@ import (
 )
 
 type Sender struct {
-	Name   string
-	Amount *big.Int
-	Color  string
+	Account AccountValue
+	Amount  *big.Int
+	Color   string
 }
 
 type stack[T any] struct {
@@ -76,15 +76,15 @@ func (s *fundsStack) compactTop() {
 			continue
 		}
 
-		if first.Name != second.Name || first.Color != second.Color {
+		if first.Account != second.Account || first.Color != second.Color {
 			return
 		}
 
 		s.senders = &stack[Sender]{
 			Head: Sender{
-				Name:   first.Name,
-				Color:  first.Color,
-				Amount: new(big.Int).Add(first.Amount, second.Amount),
+				Account: first.Account,
+				Color:   first.Color,
+				Amount:  new(big.Int).Add(first.Amount, second.Amount),
 			},
 			Tail: s.senders.Tail.Tail,
 		}
@@ -152,19 +152,19 @@ func (s *fundsStack) Pull(requiredAmount *big.Int, color *string) []Sender {
 		case 1: // more than enough
 			s.senders = &stack[Sender]{
 				Head: Sender{
-					Name:   available.Name,
-					Color:  available.Color,
-					Amount: new(big.Int).Sub(available.Amount, requiredAmount),
+					Account: available.Account,
+					Color:   available.Color,
+					Amount:  new(big.Int).Sub(available.Amount, requiredAmount),
 				},
 				Tail: s.senders,
 			}
 			fallthrough
 
 		case 0: // exactly the same
 			out = append(out, Sender{
-				Name:   available.Name,
-				Color:  available.Color,
-				Amount: new(big.Int).Set(requiredAmount),
+				Account: available.Account,
+				Color:   available.Color,
+				Amount:  new(big.Int).Set(requiredAmount),
 			})
 			return out
 		}
@@ -186,3 +186,78 @@ func (s fundsStack) Clone() fundsStack {
 
 	return fs
 }
+
+// Treat this stack as debts and filter out senders by "repaying" debts
+func (s *fundsStack) RepayWith(credits *fundsStack, asset string) []Posting {
+	var postings []Posting
+
+	// for s.senders != nil {
+	// 	// Peek head from debts and try to pull that much
+	// 	hd := s.senders.Head
+
+	// 	senders := credits.Pull(hd.Amount, &hd.Color)
+	// 	totalRepayed := big.NewInt(0)
+	// 	for _, sender := range senders {
+	// 		totalRepayed.Add(totalRepayed, sender.Amount)
+	// 		postings = append(postings, Posting{
+	// 			Source:      sender.Account,
+	// 			Destination: hd.Account,
+	// 			Amount:      sender.Amount,
+	// 			Asset:       coloredAsset(asset, &sender.Color),
+	// 		})
+	// 	}
+
+	// 	pulled := s.Pull(totalRepayed, &hd.Color)
+	// 	if len(pulled) == 0 {
+	// 		break
+	// 	}
+
+	// 	// careful: infinite loops possible with different colors
+	// 	// break
+	// }
+
+	return postings
+}
+
+// Treat this stack as debts and use the sender to repay debt.
+// Return the sender updated with the left amt (and the emitted postings)
+func (s *fundsStack) RepayWithSender(asset string, credit Sender) ([]Posting, Sender) {
+	// clone the amount so that we can modify it
+	credit.Amount = new(big.Int).Set(credit.Amount)
+
+	// Take away the debt that the credit allows for
+	clearedDebt := s.PullColored(credit.Amount, credit.Color)
+
+	var postings []Posting
+
+	for _, receiver := range clearedDebt {
+		switch creditAccount := credit.Account.(type) {
+		case VirtualAccount:
+
+			// pulled := creditAccount.Pull(asset, nil, credit)
+			// fmt.Printf("PULLED: %#v", credit)
+
+			panic("TODO handle vacc in credit scenario")
+
+		case AccountAddress:
+			credit.Amount.Sub(credit.Amount, receiver.Amount)
+
+			switch receiverAccount := receiver.Account.(type) {
+			case AccountAddress:
+				postings = append(postings, Posting{
+					Source:      string(creditAccount),
+					Destination: string(receiverAccount),
+					Amount:      receiver.Amount,
+					Asset:       coloredAsset(asset, &credit.Color),
+				})
+
+			case VirtualAccount:
+				panic("TODO repay vacc")
+			}
+		}
+
+	}
+
+	return postings, credit
+
+}