Add guest import examples

Signed-off-by: Sam Batschelet <sam.batschelet@avalabs.org>

x/programs/examples/imports/balance/balance.go

@@ -0,0 +1,205 @@
+// Copyright (C) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package balance
+
+import (
+	"context"
+
+	"go.uber.org/zap"
+
+	"github.com/bytecodealliance/wasmtime-go/v12"
+
+	"github.com/ava-labs/avalanchego/utils/logging"
+	"github.com/ava-labs/hypersdk/state"
+	"github.com/ava-labs/hypersdk/x/programs/examples/storage"
+	"github.com/ava-labs/hypersdk/x/programs/runtime"
+)
+
+const Name = "balance"
+
+func New(log logging.Logger, mu state.Mutable) *Import {
+	return &Import{mu: mu, log: log}
+}
+
+type Import struct {
+	mu    state.Mutable
+	log   logging.Logger
+	meter runtime.Meter
+}
+
+func (i *Import) Name() string {
+	return Name
+}
+
+func (i *Import) Register(link runtime.Link, meter runtime.Meter) error {
+	if err := link.FuncWrap(Name, "get", i.getFn); err != nil {
+		return err
+	}
+	if err := link.FuncWrap(Name, "set", i.setFn); err != nil {
+		return err
+	}
+	if err := link.FuncWrap(Name, "add", i.addFn); err != nil {
+		return err
+	}
+	if err := link.FuncWrap(Name, "subtract", i.subFn); err != nil {
+		return err
+	}
+	if err := link.FuncWrap(Name, "delete", i.delFn); err != nil {
+		return err
+	}
+
+	i.meter = meter
+
+	return nil
+}
+
+func (i *Import) getFn(caller *wasmtime.Caller, assetPtr, keyPtr int32) int32 {
+	pk, err := runtime.PublicKeyFromOffset(caller, storage.HRP, keyPtr)
+	if err != nil {
+		i.log.Error("failed to read key from memory",
+			zap.Error(err),
+		)
+		return -1
+	}
+	assetID, err := runtime.IDFromOffset(caller, assetPtr)
+	if err != nil {
+		i.log.Error("failed to read assetID from memory",
+			zap.Error(err),
+		)
+		return -1
+	}
+
+	// TODO: add cost for state access?
+	// i.meter.Spend(BalanceCost)
+
+	balance, err := storage.GetBalance(context.Background(), i.mu, pk, assetID)
+	if err != nil {
+		i.log.Error("failed to get balance",
+			zap.Error(err),
+		)
+		return -1
+	}
+
+	return int32(balance)
+}
+
+func (i *Import) setFn(caller *wasmtime.Caller, assetPtr, keyPtr, balance int32) int32 {
+	pk, err := runtime.PublicKeyFromOffset(caller, storage.HRP, keyPtr)
+	if err != nil {
+		i.log.Error("failed to read key from memory",
+			zap.Error(err),
+		)
+		return -1
+	}
+	assetID, err := runtime.IDFromOffset(caller, assetPtr)
+	if err != nil {
+		i.log.Error("failed to read assetID from memory",
+			zap.Error(err),
+		)
+		return -1
+	}
+
+	// TODO: add cost for state access?
+	// i.meter.Spend(BalanceCost)
+
+	err = storage.SetBalance(context.Background(), i.mu, pk, assetID, uint64(balance))
+	if err != nil {
+		i.log.Error("failed to set balance",
+			zap.Error(err),
+		)
+		return -1
+	}
+
+	return 0
+}
+
+func (i *Import) addFn(caller *wasmtime.Caller, assetPtr, keyPtr, amount int32) int32 {
+	pk, err := runtime.PublicKeyFromOffset(caller, storage.HRP, keyPtr)
+	if err != nil {
+		i.log.Error("failed to read key from memory",
+			zap.Error(err),
+		)
+		return -1
+	}
+	assetID, err := runtime.IDFromOffset(caller, assetPtr)
+	if err != nil {
+		i.log.Error("failed to read assetID from memory",
+			zap.Error(err),
+		)
+		return -1
+	}
+
+	// TODO: add cost for state access?
+	// i.meter.Spend(BalanceCost)
+
+	err = storage.AddBalance(context.Background(), i.mu, pk, assetID, uint64(amount), false)
+	if err != nil {
+		i.log.Error("failed to add balance",
+			zap.Error(err),
+		)
+		return -1
+	}
+
+	return 0
+}
+
+func (i *Import) subFn(caller *wasmtime.Caller, assetPtr, keyPtr, amount int32) int32 {
+	pk, err := runtime.PublicKeyFromOffset(caller, storage.HRP, keyPtr)
+	if err != nil {
+		i.log.Error("failed to read key from memory",
+			zap.Error(err),
+		)
+		return -1
+	}
+	assetID, err := runtime.IDFromOffset(caller, assetPtr)
+	if err != nil {
+		i.log.Error("failed to read assetID from memory",
+			zap.Error(err),
+		)
+		return -1
+	}
+
+	// TODO: add cost for state access?
+	// i.meter.Spend(BalanceCost)
+
+	err = storage.SubBalance(context.Background(), i.mu, pk, assetID, uint64(amount))
+	if err != nil {
+		i.log.Error("failed to add balance",
+			zap.Error(err),
+		)
+		return -1
+	}
+
+	return 0
+}
+
+func (i *Import) delFn(caller *wasmtime.Caller, assetPtr, keyPtr int32) int32 {
+	pk, err := runtime.PublicKeyFromOffset(caller, storage.HRP, keyPtr)
+	if err != nil {
+		i.log.Error("failed to read key from memory",
+			zap.Error(err),
+		)
+		return -1
+	}
+	assetID, err := runtime.IDFromOffset(caller, assetPtr)
+	if err != nil {
+		i.log.Error("failed to read assetID from memory",
+			zap.Error(err),
+		)
+		return -1
+	}
+
+	// TODO: add cost for state access?
+	// i.meter.Spend(BalanceCost)
+
+	err = storage.DeleteBalance(context.Background(), i.mu, pk, assetID)
+	if err != nil {
+		i.log.Error("failed to delete balance",
+			zap.Error(err),
+		)
+		return -1
+	}
+
+	return 0
+}

x/programs/examples/imports/hashmap/hashmap.go

@@ -0,0 +1,153 @@
+// Copyright (C) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package hashmap
+
+import (
+	"github.com/bytecodealliance/wasmtime-go/v12"
+
+	"go.uber.org/zap"
+
+	"github.com/ava-labs/avalanchego/utils/logging"
+
+	"github.com/ava-labs/hypersdk/state"
+	"github.com/ava-labs/hypersdk/x/programs/runtime"
+)
+
+// GlobalStorage is a global variable that holds program state.
+var GlobalStorage = storage{
+	state: make(map[int64]maps),
+}
+
+type maps map[string][]byte
+
+// Key value store for program data
+type storage struct {
+	state map[int64]maps
+}
+
+const Name = "map"
+
+func New(log logging.Logger, mu state.Mutable) *Import {
+	return &Import{mu: mu, log: log}
+}
+
+func AddProgramID(id int64) {
+	GlobalStorage.state[id] = make(maps)
+}
+
+type Import struct {
+	mu    state.Mutable
+	log   logging.Logger
+	meter runtime.Meter
+}
+
+func (i *Import) Name() string {
+	return Name
+}
+
+func (i *Import) Register(link runtime.Link, meter runtime.Meter) error {
+	if err := link.FuncWrap(Name, "store_bytes", i.storeBytesFn); err != nil {
+		return err
+	}
+	if err := link.FuncWrap(Name, "get_bytes_len", i.getBytesLenFn); err != nil {
+		return err
+	}
+	if err := link.FuncWrap(Name, "get_bytes", i.getBytesFn); err != nil {
+		return err
+	}
+
+	i.meter = meter
+
+	return nil
+}
+
+func (i *Import) storeBytesFn(caller *wasmtime.Caller, id int64, keyPtr int32, keyLength int32, valuePtr int32, valueLength int32) int32 {
+	memory := runtime.NewMemory(runtime.NewExportClient(caller))
+
+	_, ok := GlobalStorage.state[int64(id)]
+	if !ok {
+		i.log.Error("failed to find program id in storage")
+		return -1
+	}
+
+	keyBytes, err := memory.Range(uint32(keyPtr), uint32(keyLength))
+	if err != nil {
+		i.log.Error("failed to read key from memory",
+			zap.Error(err),
+		)
+		return -1
+	}
+
+	valueBytes, err := memory.Range(uint32(valuePtr), uint32(valueLength))
+	if err != nil {
+		i.log.Error("failed to read value from memory",
+			zap.Error(err),
+		)
+		return -1
+	}
+
+	// Need to copy the value because the GC can collect the value after this function returns
+	// is this still true?
+	copiedValue := make([]byte, len(valueBytes))
+	copy(copiedValue, valueBytes)
+	GlobalStorage.state[id][string(keyBytes)] = copiedValue
+
+	return 0
+}
+
+func (i *Import) getBytesLenFn(caller *wasmtime.Caller, id int64, keyPtr int32, keyLength int32) int32 {
+	memory := runtime.NewMemory(runtime.NewExportClient(caller))
+
+	_, ok := GlobalStorage.state[int64(id)]
+	if !ok {
+		i.log.Error("failed to find program id in storage")
+		return -1
+	}
+
+	keyBytes, err := memory.Range(uint32(keyPtr), uint32(keyLength))
+	if err != nil {
+		i.log.Error("failed to read key from memory",
+			zap.Error(err),
+		)
+		return -1
+	}
+	val, ok := GlobalStorage.state[id][string(keyBytes)]
+	if !ok {
+		return -1
+	}
+
+	return int32(len(val))
+}
+
+func (i *Import) getBytesFn(caller *wasmtime.Caller, id int64, keyPtr int32, keyLength int32, valLength int32) int32 {
+	memory := runtime.NewMemory(runtime.NewExportClient(caller))
+
+	_, ok := GlobalStorage.state[int64(id)]
+	if !ok {
+		i.log.Error("failed to find program id in storage")
+		return -1
+	}
+
+	keyBytes, err := memory.Range(uint32(keyPtr), uint32(keyLength))
+	if err != nil {
+		i.log.Error("failed to read key from memory",
+			zap.Error(err),
+		)
+		return -1
+	}
+	val, ok := GlobalStorage.state[id][string(keyBytes)]
+	if !ok {
+		return -1
+	}
+
+	ptr, err := runtime.WriteBytes(memory, val)
+	if err != nil {
+		i.log.Error("failed to write to memory",
+			zap.Error(err),
+		)
+		return -1
+	}
+
+	return int32(ptr)
+}