feat: asset scaling

Lexer.g4

@@ -32,6 +32,9 @@ PLUS: '+';
 MINUS: '-';
 DIV: '/';
 RESTRICT: '\\';
+WITH: 'with';
+SCALING: 'scaling';
+THROUGH: 'through';
 
 PERCENTAGE_PORTION_LITERAL: [0-9]+ ('.' [0-9]+)? '%';
 

Numscript.g4

@@ -44,10 +44,10 @@ allotment:
 
 colorConstraint: RESTRICT valueExpr;
 
-source:
-	address = valueExpr colorConstraint? ALLOWING UNBOUNDED OVERDRAFT						# srcAccountUnboundedOverdraft
-	| address = valueExpr colorConstraint? ALLOWING OVERDRAFT UP TO maxOvedraft = valueExpr	#
-		srcAccountBoundedOverdraft
+source
+	: address = valueExpr colorConstraint? ALLOWING UNBOUNDED OVERDRAFT						# srcAccountUnboundedOverdraft
+	| address = valueExpr colorConstraint? ALLOWING OVERDRAFT UP TO maxOvedraft = valueExpr	#srcAccountBoundedOverdraft
+	| address = valueExpr WITH SCALING	THROUGH swap=valueExpr # srcAccountWithScaling
 	| valueExpr colorConstraint?		# srcAccount
 	| LBRACE allotmentClauseSrc+ RBRACE	# srcAllotment
 	| LBRACE source* RBRACE				# srcInorder

internal/analysis/check.go

@@ -673,6 +673,11 @@ func (res *CheckResult) checkSource(source parser.Source) {
 			res.unifyNodeWith(*source.Bounded, res.stmtType)
 		}
 
+	case *parser.SourceWithScaling:
+		res.checkExpression(source.Address, TypeAccount)
+		res.checkExpression(source.Through, TypeAccount)
+		res.checkExpression(source.Color, TypeString)
+
 	case *parser.SourceInorder:
 		for _, source := range source.Sources {
 			res.checkSource(source)

internal/analysis/hover.go

@@ -237,6 +237,18 @@ func hoverOnSource(source parser.Source, position parser.Position) Hover {
 				return hover
 			}
 		}
+	case *parser.SourceWithScaling:
+		hover := hoverOnExpression(source.Address, position)
+		if hover != nil {
+			return hover
+		}
+
+		hover = hoverOnExpression(source.Through, position)
+		if hover != nil {
+			return hover
+		}
+
+		return nil
 
 	case *parser.SourceAllotment:
 		for _, item := range source.Items {

internal/analysis/hover_test.go

@@ -523,3 +523,32 @@ send [ASSET *] (
 	resolved := checkResult.ResolveVar(variableHover.Node)
 	require.NotNil(t, resolved)
 }
+
+func TestHover(t *testing.T) {
+
+	input := `vars {
+	account $x
+}
+
+send [EUR/2 *] (
+  source = {
+    @acc1
+    @acc2 with scaling through $x
+  }
+  destination = @dest
+)
+
+`
+
+	rng := parser.RangeOfIndexed(input, "$x", 1)
+	program := parser.Parse(input).Value
+	hover := analysis.HoverOn(program, rng.Start)
+
+	varHover, ok := hover.(*analysis.VariableHover)
+	if !ok {
+		t.Fatalf("Expected a VariableHover")
+	}
+
+	require.Equal(t, varHover.Node.Name, "x")
+
+}

internal/flags/flags.go

@@ -10,6 +10,7 @@ const (
 	ExperimentalAccountInterpolationFlag     FeatureFlag = "experimental-account-interpolation"
 	ExperimentalMidScriptFunctionCall        FeatureFlag = "experimental-mid-script-function-call"
 	ExperimentalAssetColors                  FeatureFlag = "experimental-asset-colors"
+	AssetScaling                             FeatureFlag = "experimental-asset-scaling"
 )
 
 var AllFlags []string = []string{
@@ -20,4 +21,5 @@ var AllFlags []string = []string{
 	ExperimentalAccountInterpolationFlag,
 	ExperimentalMidScriptFunctionCall,
 	ExperimentalAssetColors,
+	AssetScaling,
 }

internal/interpreter/asset_scaling.go

@@ -0,0 +1,135 @@
+package interpreter
+
+import (
+	"fmt"
+	"math/big"
+	"slices"
+	"strconv"
+	"strings"
+
+	"github.com/formancehq/numscript/internal/utils"
+)
+
+func assetToScaledAsset(asset string) string {
+	parts := strings.Split(asset, "/")
+	if len(parts) == 1 {
+		return asset + "/*"
+	}
+	return parts[0] + "/*"
+}
+
+func buildScaledAsset(baseAsset string, scale int64) string {
+	if scale == 0 {
+		return baseAsset
+	}
+	return fmt.Sprintf("%s/%d", baseAsset, scale)
+}
+
+func getAssetScale(asset string) (string, int64) {
+	parts := strings.Split(asset, "/")
+	if len(parts) == 2 {
+		scale, err := strconv.ParseInt(parts[1], 10, 64)
+		if err == nil {
+			return parts[0], scale
+		}
+		// fallback if parsing fails
+		return parts[0], 0
+	}
+	return asset, 0
+}
+
+func getAssets(balance AccountBalance, baseAsset string) map[int64]*big.Int {
+	result := make(map[int64]*big.Int)
+	for asset, amount := range balance {
+		if strings.HasPrefix(asset, baseAsset) {
+			_, scale := getAssetScale(asset)
+			result[scale] = amount
+		}
+	}
+	return result
+}
+
+type scalePair struct {
+	scale  int64
+	amount *big.Int
+}
+
+// e.g.
+//
+// need=[EUR/2 100], got={EUR/2: 100, EUR: 1}
+// => {EUR/2: 100, EUR: 1}
+//
+// need=[EUR 1], got={EUR/2: 100, EUR: 0}
+// => {EUR/2: 100, EUR: 0}
+//
+// need=[EUR/2 199], got={EUR/2: 100, EUR: 2}
+// => {EUR/2: 100, EUR: 1}
+func findSolution(
+	neededAmt *big.Int, // <- can be nil
+	neededAmtScale int64,
+	scales map[int64]*big.Int,
+) ([]scalePair, *big.Int) {
+	var assets []scalePair
+	for k, v := range scales {
+		assets = append(assets, scalePair{
+			scale:  k,
+			amount: v,
+		})
+	}
+
+	// Sort in ASC order (e.g. EUR, EUR/2, ..)
+	slices.SortFunc(assets, func(p scalePair, other scalePair) int {
+		return int(p.scale - other.scale)
+	})
+
+	var out []scalePair
+
+	totalSent := big.NewInt(0)
+
+	for _, p := range assets {
+		scaleDiff := neededAmtScale - p.scale
+
+		exp := big.NewInt(scaleDiff)
+		exp.Abs(exp)
+		exp.Exp(big.NewInt(10), exp, nil)
+
+		// scalingFactor := 10 ^ (neededAmtScale - p.scale)
+		// note that 10^0 == 1 and 10^(-n) == 1/(10^n)
+		scalingFactor := new(big.Rat).SetInt(exp)
+		if scaleDiff < 0 {
+			scalingFactor.Inv(scalingFactor)
+		}
+
+		allowed := new(big.Int).Mul(p.amount, scalingFactor.Num())
+		allowed.Div(allowed, scalingFactor.Denom())
+
+		var leftAmt *big.Int
+		var taken *big.Int
+		if neededAmt == nil {
+			taken = new(big.Int).Set(allowed)
+		} else {
+			leftAmt = new(big.Int).Sub(neededAmt, totalSent)
+			taken = utils.MinBigInt(allowed, leftAmt)
+		}
+
+		totalSent.Add(totalSent, taken)
+
+		intPart := new(big.Int).Mul(taken, scalingFactor.Denom())
+		intPart.Div(intPart, scalingFactor.Num())
+
+		if intPart.Cmp(big.NewInt(0)) == 0 {
+			continue
+		}
+
+		out = append(out, scalePair{
+			scale:  p.scale,
+			amount: intPart,
+		})
+
+		if leftAmt != nil && leftAmt.Cmp(big.NewInt(0)) != 1 {
+			break
+		}
+	}
+
+	return out, totalSent
+}

internal/interpreter/asset_scaling_test.go

@@ -0,0 +1,153 @@
+package interpreter
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestScalingZeroNeeded(t *testing.T) {
+	t.Skip()
+
+	// need [EUR/2 ]
+	sol, _ := findSolution(
+		big.NewInt(0),
+		42,
+		map[int64]*big.Int{
+			2: big.NewInt(100),
+			1: big.NewInt(1),
+		})
+
+	require.Equal(t, []scalePair{
+		{42, big.NewInt(0)},
+	}, sol)
+}
+
+func TestScalingSameAsset(t *testing.T) {
+	sol, _ := findSolution(
+		// Need [EUR/2 200]
+		big.NewInt(200),
+		2,
+
+		// Have: {EUR/2: 201}
+		map[int64]*big.Int{
+			2: big.NewInt(201),
+		})
+
+	require.Equal(t, []scalePair{
+		{2, big.NewInt(200)},
+	}, sol)
+}
+
+func TestScalingSolutionLowerScale(t *testing.T) {
+	sol, _ := findSolution(
+		big.NewInt(1),
+		0,
+		map[int64]*big.Int{
+			2: big.NewInt(900),
+		})
+
+	require.Equal(t, []scalePair{
+		{2, big.NewInt(100)},
+	}, sol)
+}
+
+func TestScalingSolutionHigherScale(t *testing.T) {
+	sol, _ := findSolution(
+		// Need [EUR/2 200]
+		big.NewInt(200),
+		2,
+
+		// Have: {EUR: 4} (eq to EUR/2 400)
+		map[int64]*big.Int{
+			0: big.NewInt(4),
+		})
+
+	require.Equal(t, []scalePair{
+		{0, big.NewInt(2)},
+	}, sol)
+}
+
+func TestScalingSolutionHigherScaleNoSolution(t *testing.T) {
+	sol, _ := findSolution(
+		big.NewInt(1),
+		2,
+		map[int64]*big.Int{
+			0: big.NewInt(100),
+			1: big.NewInt(100),
+		})
+
+	require.Nil(t, sol)
+}
+
+func TestMixedFail(t *testing.T) {
+	t.Skip()
+
+	sol, _ := findSolution(
+		big.NewInt(400),
+		2,
+		map[int64]*big.Int{
+			0: big.NewInt(1),
+			2: big.NewInt(200),
+			3: big.NewInt(10),
+		})
+
+	require.Nil(t, sol)
+}
+
+func TestUnboundedScalingSameAsset(t *testing.T) {
+	sol, _ := findSolution(
+		nil,
+		// Need USD/2
+		2,
+		// Have: {EUR/2: 201}
+		map[int64]*big.Int{
+			2: big.NewInt(123),
+		})
+
+	require.Equal(t, []scalePair{
+		{2, big.NewInt(123)},
+	}, sol)
+}
+
+func TestUnboundedScalingLowerAsset(t *testing.T) {
+	sol, _ := findSolution(
+		nil,
+		2,
+		map[int64]*big.Int{
+			0: big.NewInt(1),
+		})
+
+	require.Equal(t, []scalePair{
+		{0, big.NewInt(1)},
+	}, sol)
+}
+
+func TestUnboundedScalinHigherAsset(t *testing.T) {
+	sol, _ := findSolution(
+		nil,
+		2,
+		map[int64]*big.Int{
+			3: big.NewInt(10),
+		})
+
+	require.Equal(t,
+		[]scalePair{
+			{3, big.NewInt(10)},
+		},
+		sol)
+}
+
+func TestUnboundedScalinHigherAssetTrimRemainder(t *testing.T) {
+	sol, _ := findSolution(
+		nil,
+		2,
+		map[int64]*big.Int{
+			3: big.NewInt(15),
+		})
+
+	require.Equal(t, []scalePair{
+		{3, big.NewInt(10)},
+	}, sol)
+}