wasm

type Argument interface {
	Name() string
}

type BaseArgument struct {
	// contains filtered or unexported fields
}

type BaseValueArgument struct {
	// contains filtered or unexported fields
}

type Call struct {
	Clock      *pbsubstreams.Clock // Used by WASM extensions
	ModuleName string
	Entrypoint string

	Logs           []string
	LogsByteCount  uint64
	ExecutionStack []string
	// contains filtered or unexported fields
}

type InputType int

type Instance interface {
	// Cleanup is called between each calls, for lightweight clean-up (remove allocation)
	// in case we're not using a fully deterministic execution strategy.
	Cleanup(ctx context.Context) error

	// Close is called once we know we won't be reusing this instance, and it can be
	// freed from memory.  When using cached instances, this won't be called between
	// each execution, but only at the end of a user's request.
	Close(ctx context.Context) error
}

type MapInput struct {
	BaseArgument
	BaseValueArgument
}

type Module interface {
	// NewInstance can be used to create up-front a new instance, which will be
	// cached and reused for the duration execution of ExecuteNewCall.
	NewInstance(ctx context.Context) (instance Instance, err error)

	// ExecuteNewCall is called once per module execution for each block.
	// If caching is enabled, the returned Instance will be saved and passed in
	// as the `cachedInstance` argument upon the next call. In which case, the runtime
	// would benefit from using it back. It is the runtime's responsibility to determine
	// whether this caching entails risks to determinism (leaking of global state for instance).
	ExecuteNewCall(ctx context.Context, call *Call, cachedInstance Instance, arguments []Argument) (instance Instance, err error)

	// Close gets called when the module can be unloaded at the end of a user's request.
	Close(ctx context.Context) error
}

type ModuleFactory interface {
	NewModule(ctx context.Context, wasmCode []byte, wasmCodeType string, registry *Registry) (module Module, err error)
}

type ModuleFactoryFunc func(ctx context.Context, wasmCode []byte, wasmCodeType string, registry *Registry) (module Module, err error)

type PanicError struct {
	// contains filtered or unexported fields
}

type ParamsInput struct {
	BaseArgument
	BaseValueArgument
}

type ProtoScopeValueArgument interface {
	ProtoScopeValue() string
}

type Registry struct {
	Extensions map[string]map[string]WASMExtension
	// contains filtered or unexported fields
}

type RuntimeExtension struct {
	ID    RuntimeExtensionID
	Value *string
}

type RuntimeExtensionID string

type RuntimeExtensions []RuntimeExtension

type SourceInput struct {
	BaseArgument
	BaseValueArgument
}

type StoreDeltaInput struct {
	BaseArgument
	BaseValueArgument
}

type StoreReaderInput struct {
	BaseArgument
	Store store.Store
}

type StoreWriterOutput struct {
	BaseArgument
	Store        store.Store
	UpdatePolicy pbsubstreams.Module_KindStore_UpdatePolicy
	ValueType    string
}

type ValueArgument interface {
	Argument
	Value() []byte
	SetValue([]byte)
	Active(blk uint64) bool
}

type WASMExtension func(ctx context.Context, requestID string, clock *pbsubstreams.Clock, in []byte) (out []byte, err error)

type WASMExtensioner interface {
	Params() map[string]string // tier1 gives me the params directly, tier2 would return nil
	WASMExtensions(map[string]string) (map[string]map[string]WASMExtension, error)
}