[x/programs] add program abstraction

x/programs/examples/counter_test.go

@@ -64,15 +64,17 @@ func TestCounterProgram(t *testing.T) {
 	err = storage.SetProgram(ctx, db, programID, wasmBytes)
 	require.NoError(err)
 
-	programIDPtr, err := argumentToSmartPtr(programID, rt.Memory())
+	mem, err := rt.Memory()
+	require.NoError(err)
+	programIDPtr, err := argumentToSmartPtr(programID, mem)
 	require.NoError(err)
 
 	// generate alice keys
 	_, aliceKey, err := newKey()
 	require.NoError(err)
 
 	// write alice's key to stack and get pointer
-	alicePtr, err := argumentToSmartPtr(aliceKey, rt.Memory())
+	alicePtr, err := argumentToSmartPtr(aliceKey, mem)
 	require.NoError(err)
 
 	// create counter for alice on program 1
@@ -105,11 +107,13 @@ func TestCounterProgram(t *testing.T) {
 	err = storage.SetProgram(ctx, db, program2ID, wasmBytes)
 	require.NoError(err)
 
-	programID2Ptr, err := argumentToSmartPtr(program2ID, rt2.Memory())
+	mem2, err := rt2.Memory()
+	require.NoError(err)
+	programID2Ptr, err := argumentToSmartPtr(program2ID, mem2)
 	require.NoError(err)
 
 	// write alice's key to stack and get pointer
-	alicePtr2, err := argumentToSmartPtr(aliceKey, rt2.Memory())
+	alicePtr2, err := argumentToSmartPtr(aliceKey, mem2)
 	require.NoError(err)
 
 	// initialize counter for alice on runtime 2
@@ -119,7 +123,7 @@ func TestCounterProgram(t *testing.T) {
 
 	// increment alice's counter on program 2 by 10
 	incAmount := int64(10)
-	incAmountPtr, err := argumentToSmartPtr(incAmount, rt2.Memory())
+	incAmountPtr, err := argumentToSmartPtr(incAmount, mem2)
 	require.NoError(err)
 	result, err = rt2.Call(ctx, "inc", programID2Ptr, alicePtr2, incAmountPtr)
 	require.NoError(err)
@@ -137,7 +141,7 @@ func TestCounterProgram(t *testing.T) {
 	require.NoError(err)
 
 	// increment alice's counter on program 1
-	onePtr, err := argumentToSmartPtr(int64(1), rt.Memory())
+	onePtr, err := argumentToSmartPtr(int64(1), mem)
 	require.NoError(err)
 	result, err = rt.Call(ctx, "inc", programIDPtr, alicePtr, onePtr)
 	require.NoError(err)
@@ -151,17 +155,17 @@ func TestCounterProgram(t *testing.T) {
 	)
 
 	// write program id 2 to stack of program 1
-	programID2Ptr, err = argumentToSmartPtr(program2ID, rt.Memory())
+	programID2Ptr, err = argumentToSmartPtr(program2ID, mem)
 	require.NoError(err)
 
 	caller := programIDPtr
 	target := programID2Ptr
 	maxUnitsProgramToProgram := int64(10000)
-	maxUnitsProgramToProgramPtr, err := argumentToSmartPtr(maxUnitsProgramToProgram, rt.Memory())
+	maxUnitsProgramToProgramPtr, err := argumentToSmartPtr(maxUnitsProgramToProgram, mem)
 	require.NoError(err)
 
 	// increment alice's counter on program 2
-	fivePtr, err := argumentToSmartPtr(int64(5), rt.Memory())
+	fivePtr, err := argumentToSmartPtr(int64(5), mem)
 	require.NoError(err)
 	result, err = rt.Call(ctx, "inc_external", caller, target, maxUnitsProgramToProgramPtr, alicePtr, fivePtr)
 	require.NoError(err)

x/programs/examples/imports/program/program.go

@@ -19,6 +19,7 @@ import (
 	"github.com/ava-labs/hypersdk/x/programs/engine"
 	"github.com/ava-labs/hypersdk/x/programs/examples/storage"
 	"github.com/ava-labs/hypersdk/x/programs/host"
+	"github.com/ava-labs/hypersdk/x/programs/program"
 	"github.com/ava-labs/hypersdk/x/programs/runtime"
 )
 
@@ -58,7 +59,7 @@ func (i *Import) Register(link *host.Link) error {
 
 // callProgramFn makes a call to an entry function of a program in the context of another program's ID.
 func (i *Import) callProgramFn(
-	caller *wasmtime.Caller,
+	wasmCaller *wasmtime.Caller,
 	callerID int64,
 	programID int64,
 	maxUnits int64,
@@ -68,17 +69,25 @@ func (i *Import) callProgramFn(
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	memory := runtime.NewMemory(runtime.NewExportClient(caller))
+	caller := program.NewCaller(wasmCaller)
+	memory, err := caller.Memory()
+	if err != nil {
+		i.log.Error("failed to get memory from caller",
+			zap.Error(err),
+		)
+		return -1
+	}
+
 	// get the entry function for invoke to call.
-	functionBytes, err := runtime.SmartPtr(function).Bytes(memory)
+	functionBytes, err := program.SmartPtr(function).Bytes(memory)
 	if err != nil {
 		i.log.Error("failed to read function name from memory",
 			zap.Error(err),
 		)
 		return -1
 	}
 
-	programIDBytes, err := runtime.SmartPtr(programID).Bytes(memory)
+	programIDBytes, err := program.SmartPtr(programID).Bytes(memory)
 	if err != nil {
 		i.log.Error("failed to read id from memory",
 			zap.Error(err),
@@ -133,15 +142,24 @@ func (i *Import) callProgramFn(
 		}
 	}()
 
-	argsBytes, err := runtime.SmartPtr(args).Bytes(memory)
+	argsBytes, err := program.SmartPtr(args).Bytes(memory)
 	if err != nil {
 		i.log.Error("failed to read program args name from memory",
 			zap.Error(err),
 		)
 		return -1
 	}
+
+	rtMemory, err := rt.Memory()
+	if err != nil {
+		i.log.Error("failed to get memory from runtime",
+			zap.Error(err),
+		)
+		return -1
+	}
+
 	// sync args to new runtime and return arguments to the invoke call
-	params, err := getCallArgs(ctx, rt.Memory(), argsBytes, programIDBytes)
+	params, err := getCallArgs(ctx, rtMemory, argsBytes, programIDBytes)
 	if err != nil {
 		i.log.Error("failed to unmarshal call arguments",
 			zap.Error(err),
@@ -162,18 +180,18 @@ func (i *Import) callProgramFn(
 }
 
 // getCallArgs returns the arguments to be passed to the program being invoked from [buffer].
-func getCallArgs(ctx context.Context, memory runtime.Memory, buffer []byte, programIDBytes []byte) ([]runtime.SmartPtr, error) {
+func getCallArgs(ctx context.Context, memory *program.Memory, buffer []byte, programIDBytes []byte) ([]program.SmartPtr, error) {
 	// first arg contains id of program to call
-	invokeProgramIDPtr, err := runtime.WriteBytes(memory, programIDBytes)
+	invokeProgramIDPtr, err := program.WriteBytes(memory, programIDBytes)
 	if err != nil {
 		return nil, err
 	}
-	argPtr, err := runtime.NewSmartPtr(uint32(invokeProgramIDPtr), len(programIDBytes))
+	argPtr, err := program.NewSmartPtr(uint32(invokeProgramIDPtr), len(programIDBytes))
 	if err != nil {
 		return nil, err
 	}
 
-	args := []runtime.SmartPtr{argPtr}
+	args := []program.SmartPtr{argPtr}
 
 	for i := 0; i < len(buffer); {
 		// unpacks uint32
@@ -184,11 +202,11 @@ func getCallArgs(ctx context.Context, memory runtime.Memory, buffer []byte, prog
 		i += int(length) + consts.Uint32Len
 
 		// every argument is a pointer
-		ptr, err := runtime.WriteBytes(memory, valueBytes)
+		ptr, err := program.WriteBytes(memory, valueBytes)
 		if err != nil {
 			return nil, err
 		}
-		argPtr, err := runtime.NewSmartPtr(uint32(ptr), int(length))
+		argPtr, err := program.NewSmartPtr(uint32(ptr), int(length))
 		if err != nil {
 			return nil, err
 		}