Create SDK Time Hook (#1478)

* Use node time

* Update execution.go

* Remove ctx

* Use Node Mode for clockTimeGet

* Undo secondary hook

* Use mode

* Secondary time hook

* Implement SDK now

* Fix expected DonTime calls

* Panic on err

Author: DylanTinianov

pkg/workflows/wasm/host/execution.go

@@ -170,7 +170,7 @@ func (e *execution[T]) switchModes(_ *wasmtime.Caller, mode int32) {
 // clockTimeGet is the default time.Now() which is also called by Go many times.
 // This implementation uses Node Mode to not have to wait for OCR rounds.
 func (e *execution[T]) clockTimeGet(caller *wasmtime.Caller, id int32, precision int64, resultTimestamp int32) int32 {
-	donTime, err := e.timeFetcher.GetTime(e.mode)
+	donTime, err := e.timeFetcher.GetTime(sdkpb.Mode_MODE_NODE)
 	if err != nil {
 		return ErrnoInval
 	}
@@ -198,6 +198,21 @@ func (e *execution[T]) clockTimeGet(caller *wasmtime.Caller, id int32, precision
 	return ErrnoSuccess
 }
 
+// now is used by rawsdk for Workflows and should be called instead of Go's time.Now().
+func (e *execution[T]) now(caller *wasmtime.Caller, resultTimestamp int32) int32 {
+	donTime, err := e.timeFetcher.GetTime(e.mode)
+	if err != nil {
+		return ErrnoInval
+	}
+
+	val := donTime.UnixNano()
+	uint64Size := int32(8)
+	trg := make([]byte, uint64Size)
+	binary.LittleEndian.PutUint64(trg, uint64(val))
+	wasmWrite(caller, trg, resultTimestamp, uint64Size)
+	return ErrnoSuccess
+}
+
 // Loosely based off the implementation here:
 // https://github.com/tetratelabs/wazero/blob/main/imports/wasi_snapshot_preview1/poll.go#L52
 // For an overview of the spec, including the datatypes being referred to, see:

pkg/workflows/wasm/host/internal/rawsdk/helpers_wasip1.go

@@ -2,9 +2,11 @@ package rawsdk
 
 import (
 	"encoding/base64"
+	"encoding/binary"
 	"errors"
 	"fmt"
 	"os"
+	"time"
 	"unsafe"
 
 	"google.golang.org/protobuf/proto"
@@ -15,6 +17,10 @@ import (
 	valuespb "github.com/smartcontractkit/chainlink-protos/cre/go/values/pb"
 )
 
+const (
+	ErrnoSuccess = 0
+)
+
 func GetRequest() *sdk.ExecuteRequest {
 	if len(os.Args) != 2 {
 		SendError(errors.New("invalid request: request must contain a payload"))
@@ -54,6 +60,16 @@ func SendSubscription(subscriptions *sdk.TriggerSubscriptionRequest) {
 	sendResponse(BufferToPointerLen(Must(proto.Marshal(execResult))))
 }
 
+func Now() time.Time {
+	var buf [8]byte // host writes UnixNano as little-endian uint64
+	rc := now(unsafe.Pointer(&buf[0]))
+	if rc != ErrnoSuccess {
+		panic(fmt.Errorf("failed to fetch time from host: now() returned errno %d", rc))
+	}
+	ns := int64(binary.LittleEndian.Uint64(buf[:]))
+	return time.Unix(0, ns)
+}
+
 var donCall = int32(0)
 var nodeCall = int32(-1)
 
@@ -211,6 +227,9 @@ func sendResponse(response unsafe.Pointer, responseLen int32) int32
 //go:wasmimport env switch_modes
 func SwitchModes(mode int32)
 
+//go:wasmimport env now
+func now(response unsafe.Pointer) int32
+
 //go:wasmimport env call_capability
 func callCapability(req unsafe.Pointer, reqLen int32) int64
 

pkg/workflows/wasm/host/module.go

@@ -330,6 +330,13 @@ func linkNoDAG(m *module, store *wasmtime.Store, exec *execution[*sdkpb.Executio
 		return nil, fmt.Errorf("error wrapping getSeed func: %w", err)
 	}
 
+	if err = linker.FuncWrap(
+		"env",
+		"now",
+		exec.now); err != nil {
+		return nil, fmt.Errorf("error wrapping get_time func: %w", err)
+	}
+
 	return linker.Instantiate(store, m.module)
 }
 

pkg/workflows/wasm/host/standard_test.go

@@ -120,25 +120,20 @@ func TestStandardModeSwitch(t *testing.T) {
 		mockExecutionHelper := NewMockExecutionHelper(t)
 		mockExecutionHelper.EXPECT().GetWorkflowExecutionID().Return("id")
 		// Node calls may occur on initialization depending on the language.
-		var donCall1 bool
+		var donCall bool
 		var nodeCall bool
-		var donCall2 bool
 		mockExecutionHelper.EXPECT().GetNodeTime().RunAndReturn(func() time.Time {
-			if donCall1 {
+			if donCall {
 				nodeCall = true
 			}
 			return time.Now()
 		})
 
 		// We want to make sure time.Now() is called at least twice in DON mode and once in node Mode
 		mockExecutionHelper.EXPECT().GetDONTime().RunAndReturn(func() (time.Time, error) {
-			if nodeCall {
-				donCall2 = true
-			} else {
-				donCall1 = true
-			}
+			donCall = true
 			return time.Now(), nil
-		})
+		}).Times(2)
 		mockExecutionHelper.EXPECT().CallCapability(mock.Anything, mock.Anything).RunAndReturn(func(ctx context.Context, request *sdk.CapabilityRequest) (*sdk.CapabilityResponse, error) {
 			if request.Id == "[email protected]" {
 				input := &basicaction.Inputs{}
@@ -157,9 +152,8 @@ func TestStandardModeSwitch(t *testing.T) {
 		request := triggerExecuteRequest(t, 0, &basictrigger.Outputs{CoolOutput: anyTestTriggerValue})
 		result := executeWithResult[string](t, m, request, mockExecutionHelper)
 		require.Equal(t, "test556", result)
-		require.True(t, donCall1)
+		require.True(t, donCall)
 		require.True(t, nodeCall)
-		require.True(t, donCall2)
 	})
 
 	t.Run("node runtime in don mode", func(t *testing.T) {

pkg/workflows/wasm/host/standard_tests/mode_switch/successful_mode_switch/main_wasip1.go

@@ -48,9 +48,9 @@ func main() {
 	rawsdk.SendResponse(fmt.Sprintf("%s%d", doutput.AdaptedThing, coutput.OutputThing))
 }
 
-// ignoreTimeCall makes a time now call and forces the compiler not to optimize it away.
+// ignoreTimeCall makes a rawsdk now call and forces the compiler not to optimize it away.
 func ignoreTimeCall() {
-	t := time.Now()
+	t := rawsdk.Now()
 	if t.Before(time.Unix(-1, 322)) {
 		panic("Test should not run before 1970")
 	}