Update to GCT script library (#496)

* * Adds script link to GCT logger package
* Adds ability to save data as csv via script

* addr nits

* go mod tidy

* add glorious suggestion

* rm unused function

* fix linter issues

* clean up some issues

* Add in configuration fields to object for reflection to the csv file

* RM line :D

* address nits

* update to check for target already being set and add more test coverage

* force usage of .csv file extention && append date to client filename as to not overwrite file if collision occurs

* fix whoopsie

* linter issues

* purge getter methods

* Added glorious suggestion

* go mod tidy after merge

* niterinos

gctscript/modules/gct/common.go

@@ -0,0 +1,457 @@
+package gct
+
+import (
+	"errors"
+	"fmt"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	objects "github.com/d5/tengo/v2"
+	"github.com/thrasher-corp/gocryptotrader/common/file"
+	"github.com/thrasher-corp/gocryptotrader/gctscript/modules/ta/indicators"
+	"github.com/thrasher-corp/gocryptotrader/log"
+)
+
+var commonModule = map[string]objects.Object{
+	"writeascsv": &objects.UserFunction{Name: "writeascsv", Value: WriteAsCSV},
+}
+
+// OutputDir is the default script output directory
+var OutputDir string
+
+// WriteAsCSV takes in a slice matrix to save to file
+func WriteAsCSV(args ...objects.Object) (objects.Object, error) {
+	if len(args) == 0 {
+		return nil, errors.New("cannot write to file, no data present")
+	}
+
+	var bucket [][]string
+	var err error
+	var target string
+	for i := range args {
+		if args[i] == nil {
+			return nil, errors.New("data is nil")
+		}
+		var front bool
+		var temp [][]string
+		switch args[i].TypeName() {
+		case indicators.AverageTrueRange:
+			temp, err = convertATR(args[i])
+		case indicators.BollingerBands:
+			temp, err = convertBollingerBands(args[i])
+		case indicators.ExponentialMovingAverage:
+			temp, err = convertEMA(args[i])
+		case indicators.MovingAverageConvergenceDivergence:
+			temp, err = convertMACD(args[i])
+		case indicators.MoneyFlowIndex:
+			temp, err = convertMFI(args[i])
+		case indicators.OnBalanceVolume:
+			temp, err = convertOBV(args[i])
+		case indicators.RelativeStrengthIndex:
+			temp, err = convertRSI(args[i])
+		case indicators.SimpleMovingAverage:
+			temp, err = convertSMA(args[i])
+		case indicators.OHLCV:
+			temp, err = convertOHLCV(args[i])
+			front = true
+		case "string":
+			if target != "" {
+				return nil, fmt.Errorf("filename already set, extra string %v cannot be processed", args[i])
+			}
+			var ok bool
+			target, ok = objects.ToString(args[i])
+			if !ok {
+				return nil, errors.New("failed to convert incoming output to string")
+			}
+
+			if target == "" {
+				return nil, errors.New("script context details not specified")
+			}
+
+			// Removes file transversal
+			target = filepath.Base(target)
+
+			// checks to see if file is context defined, if not it will allow
+			// a client defined filename and append a date, forces the use of
+			// .csv file extension
+			switch {
+			case filepath.Ext(target) != ".csv" && strings.Contains(target, ".gct"):
+				target += ".csv"
+			case filepath.Ext(target) == ".csv":
+				s := strings.Split(target, ".")
+				if len(s) == 2 {
+					target = s[0] + "-" + strconv.FormatInt(time.Now().UnixNano(), 10) + ".csv"
+				}
+			default:
+				target += "-" + strconv.FormatInt(time.Now().UnixNano(), 10) + ".csv"
+			}
+
+			target = filepath.Join(OutputDir, target)
+
+		default:
+			err = fmt.Errorf("%s type is not handled", args[i].TypeName())
+		}
+		if err != nil {
+			return nil, err
+		}
+
+		if front {
+			var newBucket [][]string
+			newBucket = append(newBucket, temp...)
+			for x := range bucket {
+				newBucket[x] = append(newBucket[x], bucket[x]...)
+			}
+
+			bucket = newBucket
+			front = false
+			continue
+		}
+
+		if len(bucket) == 0 {
+			bucket = temp
+		} else {
+			for i := range temp {
+				bucket[i] = append(bucket[i], temp[i]...)
+			}
+		}
+	}
+
+	if target == "" {
+		return nil, errors.New("filename unset please set in writeascsv as ctx or client defined filename")
+	}
+
+	err = file.WriteAsCSV(target, bucket)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Infof(log.GCTScriptMgr,
+		"CSV file successfully saved to: %s",
+		target)
+	return nil, nil
+}
+
+func convertATR(a objects.Object) ([][]string, error) {
+	obj, ok := objects.ToInterface(a).(*indicators.ATR)
+	if !ok {
+		return nil, errors.New("casting failure")
+	}
+
+	var bucket = [][]string{
+		{
+			indicators.AverageTrueRange,
+		},
+		{
+			fmt.Sprintf("Period:%d", obj.Period),
+		},
+	}
+
+	var val string
+	for i := range obj.Value {
+		val, ok = objects.ToString(obj.Value[i])
+		if !ok {
+			return nil, errors.New("cannot convert object to string")
+		}
+
+		bucket = append(bucket, []string{val})
+	}
+	return bucket, nil
+}
+
+func convertBollingerBands(a objects.Object) ([][]string, error) {
+	obj, ok := objects.ToInterface(a).(*indicators.BBands)
+	if !ok {
+		return nil, errors.New("casting failure")
+	}
+
+	upperS := fmt.Sprintf("Upper_Band (NBDevUp:%f)", obj.STDDevUp)
+	lowerS := fmt.Sprintf("Lower_band(NBDevDown:%f)", obj.STDDevDown)
+	middleS := fmt.Sprintf("Middle_Band (Period:%d)", obj.Period)
+	MAType := "MA_TYPE:SMA"
+	if obj.MAType != 0 {
+		MAType = "MA_TYPE:EMA"
+	}
+
+	var bucket = [][]string{
+		{
+			indicators.BollingerBands, "", MAType,
+		},
+		{
+			upperS, middleS, lowerS,
+		},
+	}
+
+	for x := range obj.Value {
+		element := obj.Value[x].Iterate()
+		var upper, middle, lower string
+		for i := 0; element.Next(); i++ {
+			switch i {
+			case 0:
+				upper, ok = objects.ToString(element.Value())
+				if !ok {
+					return nil, errors.New("cannot convert object to string")
+				}
+			case 1:
+				middle, ok = objects.ToString(element.Value())
+				if !ok {
+					return nil, errors.New("cannot convert object to string")
+				}
+			case 2:
+				lower, ok = objects.ToString(element.Value())
+				if !ok {
+					return nil, errors.New("cannot convert object to string")
+				}
+			}
+		}
+		bucket = append(bucket, []string{upper, middle, lower})
+	}
+	return bucket, nil
+}
+
+func convertEMA(a objects.Object) ([][]string, error) {
+	obj, ok := objects.ToInterface(a).(*indicators.EMA)
+	if !ok {
+		return nil, errors.New("casting failure")
+	}
+
+	var bucket = [][]string{
+		{
+			indicators.ExponentialMovingAverage,
+		},
+		{
+			fmt.Sprintf("Period:%d", obj.Period),
+		},
+	}
+
+	var val string
+	for i := range obj.Value {
+		val, ok = objects.ToString(obj.Value[i])
+		if !ok {
+			return nil, errors.New("cannot convert object to string")
+		}
+		bucket = append(bucket, []string{val})
+	}
+	return bucket, nil
+}
+
+func convertMACD(a objects.Object) ([][]string, error) {
+	obj, ok := objects.ToInterface(a).(*indicators.MACD)
+	if !ok {
+		return nil, errors.New("casting failure")
+	}
+
+	var bucket = [][]string{
+		{
+			indicators.MovingAverageConvergenceDivergence,
+			fmt.Sprintf("Period:%d Fast:%d Slow:%d",
+				obj.Period,
+				obj.PeriodFast,
+				obj.PeriodSlow),
+			"",
+		},
+		{
+			"MACD", "Signal", "Histogram",
+		},
+	}
+
+	for x := range obj.Value {
+		element := obj.Value[x].Iterate()
+		var macd, signal, hist string
+		for i := 0; element.Next(); i++ {
+			switch i {
+			case 0:
+				macd, ok = objects.ToString(element.Value())
+				if !ok {
+					return nil, errors.New("cannot convert object to string")
+				}
+			case 1:
+				signal, ok = objects.ToString(element.Value())
+				if !ok {
+					return nil, errors.New("cannot convert object to string")
+				}
+			case 2:
+				hist, ok = objects.ToString(element.Value())
+				if !ok {
+					return nil, errors.New("cannot convert object to string")
+				}
+			}
+		}
+		bucket = append(bucket, []string{macd, signal, hist})
+	}
+	return bucket, nil
+}
+
+func convertMFI(a objects.Object) ([][]string, error) {
+	obj, ok := objects.ToInterface(a).(*indicators.MFI)
+	if !ok {
+		return nil, errors.New("casting failure")
+	}
+
+	var bucket = [][]string{
+		{
+			indicators.MoneyFlowIndex,
+		},
+		{
+			fmt.Sprintf("Period:%d", obj.Period),
+		},
+	}
+
+	var val string
+	for i := range obj.Value {
+		val, ok = objects.ToString(obj.Value[i])
+		if !ok {
+			return nil, errors.New("cannot convert object to string")
+		}
+		bucket = append(bucket, []string{val})
+	}
+	return bucket, nil
+}
+
+func convertOBV(a objects.Object) ([][]string, error) {
+	var bucket = [][]string{
+		{
+			indicators.OnBalanceVolume,
+		},
+		{
+			"",
+		},
+	}
+
+	obj, ok := objects.ToInterface(a).(*indicators.OBV)
+	if !ok {
+		return nil, errors.New("casting failure")
+	}
+
+	var val string
+	for i := range obj.Value {
+		val, ok = objects.ToString(obj.Value[i])
+		if !ok {
+			return nil, errors.New("cannot convert object to string")
+		}
+		bucket = append(bucket, []string{val})
+	}
+	return bucket, nil
+}
+
+func convertRSI(a objects.Object) ([][]string, error) {
+	obj, ok := objects.ToInterface(a).(*indicators.RSI)
+	if !ok {
+		return nil, errors.New("casting failure")
+	}
+
+	var bucket = [][]string{
+		{
+			indicators.RelativeStrengthIndex,
+		},
+		{
+			fmt.Sprintf("Period:%d", obj.Period),
+		},
+	}
+
+	var val string
+	for i := range obj.Value {
+		val, ok = objects.ToString(obj.Value[i])
+		if !ok {
+			return nil, errors.New("cannot convert object to string")
+		}
+		bucket = append(bucket, []string{val})
+	}
+	return bucket, nil
+}
+
+func convertSMA(a objects.Object) ([][]string, error) {
+	obj, ok := objects.ToInterface(a).(*indicators.SMA)
+	if !ok {
+		return nil, errors.New("casting failure")
+	}
+
+	var bucket = [][]string{
+		{
+			indicators.SimpleMovingAverage,
+		},
+		{
+			fmt.Sprintf("Period:%d", obj.Period),
+		},
+	}
+
+	var val string
+	for i := range obj.Value {
+		val, ok = objects.ToString(obj.Value[i])
+		if !ok {
+			return nil, errors.New("cannot convert object to string")
+		}
+		bucket = append(bucket, []string{val})
+	}
+	return bucket, nil
+}
+
+func convertOHLCV(a objects.Object) ([][]string, error) {
+	obj, ok := objects.ToInterface(a).(*OHLCV)
+	if !ok {
+		return nil, errors.New("casting failure")
+	}
+
+	exchange, ok := objects.ToString(obj.Value["exchange"])
+	if !ok {
+		return nil, errors.New("cannot convert object to string")
+	}
+
+	pair, ok := objects.ToString(obj.Value["pair"])
+	if !ok {
+		return nil, errors.New("cannot convert object to string")
+	}
+
+	asset, ok := objects.ToString(obj.Value["asset"])
+	if !ok {
+		return nil, errors.New("cannot convert object to string")
+	}
+
+	interval, ok := objects.ToString(obj.Value["intervals"])
+	if !ok {
+		return nil, errors.New("cannot convert object to string")
+	}
+
+	var bucket = [][]string{
+		{
+			indicators.OHLCV, "Exchange:" + exchange, pair, asset, interval, "",
+		},
+		{
+			"Date", "Volume", "Open", "High", "Low", "Close",
+		},
+	}
+
+	candles, ok := obj.Value["candles"]
+	if !ok {
+		return nil, errors.New("candles not found in object map")
+	}
+
+	data := candles.Iterate()
+
+	for data.Next() {
+		var date, open, high, low, closed, volume string
+		candle := data.Value().Iterate()
+		for i := 0; candle.Next(); i++ {
+			switch i {
+			case 0:
+				date, ok = objects.ToString(candle.Value())
+			case 1:
+				open, ok = objects.ToString(candle.Value())
+			case 2:
+				high, ok = objects.ToString(candle.Value())
+			case 3:
+				low, ok = objects.ToString(candle.Value())
+			case 4:
+				closed, ok = objects.ToString(candle.Value())
+			case 5:
+				volume, ok = objects.ToString(candle.Value())
+			}
+			if !ok {
+				return nil, errors.New("failed to convert")
+			}
+		}
+		bucket = append(bucket, []string{date, volume, open, high, low, closed})
+	}
+	return bucket, nil
+}

gctscript/modules/gct/common_test.go

@@ -0,0 +1,175 @@
+package gct
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	objects "github.com/d5/tengo/v2"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
+	"github.com/thrasher-corp/gocryptotrader/gctscript/modules/ta/indicators"
+)
+
+var (
+	atrPayload    = &indicators.ATR{Array: oneElement}
+	bbandsPayload = &indicators.BBands{Array: threeElement}
+	emaPayload    = &indicators.EMA{Array: oneElement}
+	macdPayload   = &indicators.MACD{Array: threeElement}
+	mfiPayload    = &indicators.MFI{Array: oneElement}
+	obvPayload    = &indicators.OBV{Array: oneElement}
+	rsiPayload    = &indicators.RSI{Array: oneElement}
+	smaPayload    = &indicators.SMA{Array: oneElement}
+	ohlcPayload   = &OHLCV{Map: ohlcdata}
+	unhandled     = &objects.Array{}
+
+	oneElement = objects.Array{
+		Value: []objects.Object{
+			&objects.Float{Value: 1},
+			&objects.Float{Value: 2},
+			&objects.Float{Value: 3},
+			&objects.Float{Value: 4},
+			&objects.Float{Value: 5},
+		},
+	}
+
+	threeElement = objects.Array{
+		Value: []objects.Object{
+			&objects.Array{
+				Value: []objects.Object{
+					&objects.Float{Value: 11},
+					&objects.Float{Value: 12},
+					&objects.Float{Value: 13},
+				},
+			},
+			&objects.Array{
+				Value: []objects.Object{
+					&objects.Float{Value: 21},
+					&objects.Float{Value: 22},
+					&objects.Float{Value: 23},
+				},
+			},
+			&objects.Array{
+				Value: []objects.Object{
+					&objects.Float{Value: 31},
+					&objects.Float{Value: 32},
+					&objects.Float{Value: 33},
+				},
+			},
+			&objects.Array{
+				Value: []objects.Object{
+					&objects.Float{Value: 41},
+					&objects.Float{Value: 42},
+					&objects.Float{Value: 43},
+				},
+			},
+			&objects.Array{
+				Value: []objects.Object{
+					&objects.Float{Value: 51},
+					&objects.Float{Value: 52},
+					&objects.Float{Value: 53},
+				},
+			},
+		},
+	}
+
+	ohlcv = []objects.Object{
+		&objects.Time{Value: time.Now()},
+		&objects.Float{Value: 100},
+		&objects.Float{Value: 100},
+		&objects.Float{Value: 100},
+		&objects.Float{Value: 100},
+		&objects.Float{Value: 1},
+	}
+
+	ohlcdata = objects.Map{
+		Value: map[string]objects.Object{
+			"exchange":  &objects.String{Value: "exchange"},
+			"pair":      &objects.String{Value: "BTC-USD"},
+			"asset":     &objects.String{Value: asset.Spot.String()},
+			"intervals": &objects.String{Value: time.Minute.String()},
+			"candles": &objects.Array{
+				Value: []objects.Object{
+					&objects.Array{
+						Value: ohlcv,
+					},
+					&objects.Array{
+						Value: ohlcv,
+					},
+					&objects.Array{
+						Value: ohlcv,
+					},
+					&objects.Array{
+						Value: ohlcv,
+					},
+					&objects.Array{
+						Value: ohlcv,
+					},
+				},
+			},
+		},
+	}
+)
+
+func TestCommonWriteToCSV(t *testing.T) {
+	t.Parallel()
+
+	OutputDir = filepath.Join(os.TempDir(), "script-temp")
+	defer func() {
+		err := os.RemoveAll(OutputDir)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+
+	_, err := WriteAsCSV()
+	if err == nil {
+		t.Fatal("error cannot be nil")
+	}
+
+	_, err = WriteAsCSV(nil)
+	if err == nil {
+		t.Fatal("error cannot be nil")
+	}
+
+	_, err = WriteAsCSV(&objects.String{Value: "something.txt"})
+	if err == nil {
+		t.Fatal(err)
+	}
+
+	_, err = WriteAsCSV(&objects.String{Value: "something.txt"},
+		&objects.String{Value: "extra string"})
+	if err == nil {
+		t.Fatal(err)
+	}
+
+	_, err = WriteAsCSV(&objects.String{Value: "script-temp.csv"}, unhandled)
+	if err == nil {
+		t.Fatal("error cannot be nil")
+	}
+
+	_, err = WriteAsCSV(&objects.String{Value: "script-temp.csv"},
+		atrPayload,
+		bbandsPayload,
+		emaPayload,
+		macdPayload,
+		mfiPayload,
+		obvPayload,
+		rsiPayload,
+		smaPayload,
+		ohlcPayload)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = WriteAsCSV(atrPayload)
+	if err == nil {
+		t.Fatal(err)
+	}
+
+	_, err = WriteAsCSV(&objects.String{Value: "test.gct-script-temp2"},
+		atrPayload)
+	if err != nil {
+		t.Fatal(err)
+	}
+}

gctscript/modules/gct/exchange.go

@@ -10,6 +10,7 @@ import (
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/order"
+	"github.com/thrasher-corp/gocryptotrader/gctscript/modules/ta/indicators"
 	"github.com/thrasher-corp/gocryptotrader/gctscript/wrappers"
 	"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
 )
@@ -498,6 +499,16 @@ func ExchangeWithdrawFiat(args ...objects.Object) (objects.Object, error) {
 	return &objects.String{Value: rtn}, nil
 }
 
+// OHLCV defines a custom Open High Low Close Volume tengo object
+type OHLCV struct {
+	objects.Map
+}
+
+// TypeName returns the name of the custom type.
+func (o *OHLCV) TypeName() string {
+	return indicators.OHLCV
+}
+
 func exchangeOHLCV(args ...objects.Object) (objects.Object, error) {
 	if len(args) != 7 {
 		return nil, objects.ErrWrongNumArguments
@@ -567,9 +578,9 @@ func exchangeOHLCV(args ...objects.Object) (objects.Object, error) {
 	retValue["intervals"] = &objects.String{Value: ret.Interval.String()}
 	retValue["candles"] = &candles
 
-	return &objects.Map{
-		Value: retValue,
-	}, nil
+	c := new(OHLCV)
+	c.Value = retValue
+	return c, nil
 }
 
 // parseInterval will parse the interval param of indictors that have them and convert to time.Duration

gctscript/modules/gct/gct_types.go

@@ -17,4 +17,5 @@ var supportedDurations = []string{"1m", "3m", "5m", "15m", "30m", "1h", "2h", "4
 // Modules map of all loadable modules
 var Modules = map[string]map[string]tengo.Object{
 	"exchange": exchangeModule,
+	"common":   commonModule,
 }

gctscript/modules/loader/loader.go

@@ -37,3 +37,8 @@ func GetModuleMap() *tengo.ModuleMap {
 	}
 	return modules
 }
+
+// SetDefaultScriptOutput sets the output folder
+func SetDefaultScriptOutput(path string) {
+	gct.OutputDir = path
+}

gctscript/modules/ta/indicators/atr.go

@@ -17,12 +17,25 @@ var AtrModule = map[string]objects.Object{
 	"calculate": &objects.UserFunction{Name: "calculate", Value: atr},
 }
 
+// AverageTrueRange is the string constant
+const AverageTrueRange = "Average True Range"
+
+// ATR defines a custom Average True Range indicator tengo object
+type ATR struct {
+	objects.Array
+	Period int
+}
+
+// TypeName returns the name of the custom type.
+func (o *ATR) TypeName() string {
+	return AverageTrueRange
+}
+
 func atr(args ...objects.Object) (objects.Object, error) {
 	if len(args) != 2 {
 		return nil, objects.ErrWrongNumArguments
 	}
-
-	r := &objects.Array{}
+	r := new(ATR)
 	if validator.IsTestExecution.Load() == true {
 		return r, nil
 	}
@@ -71,6 +84,7 @@ func atr(args ...objects.Object) (objects.Object, error) {
 		return nil, errors.New(strings.Join(allErrors, ", "))
 	}
 
+	r.Period = inTimePeriod
 	ret := indicators.ATR(ohlcvData[2], ohlcvData[3], ohlcvData[4], inTimePeriod)
 	for x := range ret {
 		r.Value = append(r.Value, &objects.Float{Value: math.Round(ret[x]*100) / 100})

gctscript/modules/ta/indicators/bbands.go

@@ -17,14 +17,30 @@ var BBandsModule = map[string]objects.Object{
 	"calculate": &objects.UserFunction{Name: "calculate", Value: bbands},
 }
 
+// BollingerBands is the string constant
+const BollingerBands = "Bollinger Bands"
+
+// BBands defines a custom Bollinger Bands indicator tengo object
+type BBands struct {
+	objects.Array
+	Period               int
+	STDDevUp, STDDevDown float64
+	MAType               indicators.MaType
+}
+
+// TypeName returns the name of the custom type.
+func (o *BBands) TypeName() string {
+	return BollingerBands
+}
+
 func bbands(args ...objects.Object) (objects.Object, error) {
 	if len(args) != 6 {
 		return nil, objects.ErrWrongNumArguments
 	}
 
-	var ret objects.Array
+	r := new(BBands)
 	if validator.IsTestExecution.Load() == true {
-		return &ret, nil
+		return r, nil
 	}
 
 	ohlcIndicatorType, ok := objects.ToString(args[0])
@@ -101,6 +117,11 @@ func bbands(args ...objects.Object) (objects.Object, error) {
 		return nil, err
 	}
 
+	r.Period = inTimePeriod
+	r.STDDevDown = inNbDevDn
+	r.STDDevUp = inNbDevUp
+	r.MAType = MAType
+
 	retUpper, retMiddle, retLower := indicators.BBANDS(ohlcvData[selector], inTimePeriod, inNbDevDn, inNbDevDn, MAType)
 	for x := range retMiddle {
 		temp := &objects.Array{}
@@ -111,8 +132,8 @@ func bbands(args ...objects.Object) (objects.Object, error) {
 		if retLower != nil {
 			temp.Value = append(temp.Value, &objects.Float{Value: math.Round(retLower[x]*100) / 100})
 		}
-		ret.Value = append(ret.Value, temp)
+		r.Value = append(r.Value, temp)
 	}
 
-	return &ret, nil
+	return r, nil
 }

gctscript/modules/ta/indicators/ema.go

@@ -17,12 +17,26 @@ var EMAModule = map[string]objects.Object{
 	"calculate": &objects.UserFunction{Name: "calculate", Value: ema},
 }
 
+// ExponentialMovingAverage is the string constant
+const ExponentialMovingAverage = "Exponential Moving Average"
+
+// EMA defines a custom Exponential Moving Average indicator tengo object
+type EMA struct {
+	objects.Array
+	Period int
+}
+
+// TypeName returns the name of the custom type.
+func (o *EMA) TypeName() string {
+	return ExponentialMovingAverage
+}
+
 func ema(args ...objects.Object) (objects.Object, error) {
 	if len(args) != 2 {
 		return nil, objects.ErrWrongNumArguments
 	}
 
-	r := &objects.Array{}
+	r := new(EMA)
 	if validator.IsTestExecution.Load() == true {
 		return r, nil
 	}
@@ -54,6 +68,8 @@ func ema(args ...objects.Object) (objects.Object, error) {
 		return nil, errors.New(strings.Join(allErrors, ", "))
 	}
 
+	r.Period = inTimePeriod
+
 	ret := indicators.EMA(ohlcvClose, inTimePeriod)
 	for x := range ret {
 		r.Value = append(r.Value, &objects.Float{Value: math.Round(ret[x]*100) / 100})

gctscript/modules/ta/indicators/macd.go

@@ -17,12 +17,27 @@ var MACDModule = map[string]objects.Object{
 	"calculate": &objects.UserFunction{Name: "calculate", Value: macd},
 }
 
+// MovingAverageConvergenceDivergence is the string constant
+const MovingAverageConvergenceDivergence = "Moving Average Convergence Divergence"
+
+// MACD defines a custom Moving Average Convergence Divergence tengo indicator
+// object type
+type MACD struct {
+	objects.Array
+	Period, PeriodSlow, PeriodFast int
+}
+
+// TypeName returns the name of the custom type.
+func (o *MACD) TypeName() string {
+	return MovingAverageConvergenceDivergence
+}
+
 func macd(args ...objects.Object) (objects.Object, error) {
 	if len(args) != 4 {
 		return nil, objects.ErrWrongNumArguments
 	}
 
-	r := &objects.Array{}
+	r := new(MACD)
 	if validator.IsTestExecution.Load() == true {
 		return r, nil
 	}
@@ -63,6 +78,10 @@ func macd(args ...objects.Object) (objects.Object, error) {
 		return nil, errors.New(strings.Join(allErrors, ", "))
 	}
 
+	r.Period = inTimePeriod
+	r.PeriodFast = inFastPeriod
+	r.PeriodSlow = inSlowPeriod
+
 	macd, macdSignal, macdHist := indicators.MACD(ohlcvClose, inFastPeriod, inSlowPeriod, inTimePeriod)
 	for x := range macdHist {
 		tempMACD := &objects.Array{}

gctscript/modules/ta/indicators/mfi.go

@@ -17,12 +17,26 @@ var MfiModule = map[string]objects.Object{
 	"calculate": &objects.UserFunction{Name: "calculate", Value: mfi},
 }
 
+// MoneyFlowIndex is the string constant
+const MoneyFlowIndex = "Money Flow Index"
+
+// MFI defines a custom Money Flow Index tengo indicator object type
+type MFI struct {
+	objects.Array
+	Period int
+}
+
+// TypeName returns the name of the custom type.
+func (o *MFI) TypeName() string {
+	return MoneyFlowIndex
+}
+
 func mfi(args ...objects.Object) (objects.Object, error) {
 	if len(args) != 2 {
 		return nil, objects.ErrWrongNumArguments
 	}
 
-	r := &objects.Array{}
+	r := new(MFI)
 	if validator.IsTestExecution.Load() == true {
 		return r, nil
 	}
@@ -69,6 +83,8 @@ func mfi(args ...objects.Object) (objects.Object, error) {
 		return nil, fmt.Errorf(modules.ErrParameterConvertFailed, inTimePeriod)
 	}
 
+	r.Period = inTimePeriod
+
 	ret := indicators.MFI(ohlcvData[2], ohlcvData[3], ohlcvData[4], ohlcvData[5], inTimePeriod)
 	for x := range ret {
 		r.Value = append(r.Value, &objects.Float{Value: math.Round(ret[x]*100) / 100})

gctscript/modules/ta/indicators/obv.go

@@ -17,12 +17,25 @@ var ObvModule = map[string]objects.Object{
 	"calculate": &objects.UserFunction{Name: "calculate", Value: obv},
 }
 
+// OnBalanceVolume is the string constant
+const OnBalanceVolume = "On Balance Volume"
+
+// OBV defines a custom On Balance Volume tengo indicator object type
+type OBV struct {
+	objects.Array
+}
+
+// TypeName returns the name of the custom type.
+func (o *OBV) TypeName() string {
+	return OnBalanceVolume
+}
+
 func obv(args ...objects.Object) (objects.Object, error) {
 	if len(args) != 1 {
 		return nil, objects.ErrWrongNumArguments
 	}
 
-	r := &objects.Array{}
+	r := new(OBV)
 	if validator.IsTestExecution.Load() == true {
 		return r, nil
 	}

gctscript/modules/ta/indicators/rsi.go

@@ -17,12 +17,26 @@ var RsiModule = map[string]objects.Object{
 	"calculate": &objects.UserFunction{Name: "calculate", Value: rsi},
 }
 
+// RelativeStrengthIndex is the string constant
+const RelativeStrengthIndex = "Relative Strength Index"
+
+// RSI defines a custom Relative Strength Index indicator tengo object type
+type RSI struct {
+	objects.Array
+	Period int
+}
+
+// TypeName returns the name of the custom type.
+func (o *RSI) TypeName() string {
+	return RelativeStrengthIndex
+}
+
 func rsi(args ...objects.Object) (objects.Object, error) {
 	if len(args) != 2 {
 		return nil, objects.ErrWrongNumArguments
 	}
 
-	r := &objects.Array{}
+	r := new(RSI)
 	if validator.IsTestExecution.Load() == true {
 		return r, nil
 	}
@@ -54,6 +68,7 @@ func rsi(args ...objects.Object) (objects.Object, error) {
 		return nil, errors.New(strings.Join(allErrors, ", "))
 	}
 
+	r.Period = inTimePeriod
 	ret := indicators.RSI(ohlcvClose, inTimePeriod)
 	for x := range ret {
 		r.Value = append(r.Value, &objects.Float{Value: math.Round(ret[x]*100) / 100})

gctscript/modules/ta/indicators/sma.go

@@ -17,12 +17,26 @@ var SMAModule = map[string]objects.Object{
 	"calculate": &objects.UserFunction{Name: "calculate", Value: sma},
 }
 
+// SimpleMovingAverage is the string constant
+const SimpleMovingAverage = "Simple Moving Average"
+
+// SMA defines a custom Simple Moving Average indicator tengo object type
+type SMA struct {
+	objects.Array
+	Period int
+}
+
+// TypeName returns the name of the custom type.
+func (o *SMA) TypeName() string {
+	return SimpleMovingAverage
+}
+
 func sma(args ...objects.Object) (objects.Object, error) {
 	if len(args) != 2 {
 		return nil, objects.ErrWrongNumArguments
 	}
 
-	r := &objects.Array{}
+	r := new(SMA)
 	if validator.IsTestExecution.Load() == true {
 		return r, nil
 	}
@@ -52,6 +66,7 @@ func sma(args ...objects.Object) (objects.Object, error) {
 	if len(allErrors) > 0 {
 		return nil, errors.New(strings.Join(allErrors, ", "))
 	}
+	r.Period = inTimePeriod
 	ret := indicators.SMA(ohlcvClose, inTimePeriod)
 	for x := range ret {
 		r.Value = append(r.Value, &objects.Float{Value: math.Round(ret[x]*100) / 100})