Struct TypedProcInfo 

pub struct TypedProcInfo { /* private fields */ }

The typed signature of one exported procedure.

Build it with Self::new, then use Self::encode_args for arguments and Self::decode_result for results. fmt::Display prints the signature, like add-points(point, point) -> point.

Implementations

impl TypedProcInfo

pub fn new( name: impl Into<String>, signature: FunctionType, ) -> Result<TypedProcInfo, TypedError>

Builds the typed view of the procedure name, with the signature signature.

The caller picks the procedure. It knows which one it wants, and it keeps the signature and anything else it reads about it, like its digest, on the same procedure.

The signature has to be component-model. Another convention puts the same value on the stack in another shape, and we would read and write felts the procedure never sees.

The result has WordCodec and FeltCodec. Add more with Self::with_scalar_codec.

pub fn with_scalar_codec(self, codec: Box<dyn WitScalarCodec>) -> TypedProcInfo

Adds a WitScalarCodec. The codec then handles its own WIT type, instead of the normal field by field way.

We match a codec by name and by interface, so the built-in ones only take the core types. If two codecs want the same type, the first one wins. So you cannot replace a built-in codec, you can only add new ones.

pub fn encode_args<T>(&self, tokens: &[T]) -> Result<Vec<Felt>, TypedError>

where T: AsRef<str>,

Turns tokens into the felts the procedure needs on the stack, in parameter order.

The first felt goes on top of the stack, because the first argument sits on top: f(1u32, 2u32) gives [1, 2]. A caller that pushes them one by one starts at the back. See docs/external/src/appendix/calling-conventions.md in the compiler.

We check the count first. So if the caller passes the wrong number of arguments, the error gives the procedure name and both counts.

pub fn returns_value(&self) -> bool

Whether the procedure have a result.

pub fn output_felt_count(&self) -> Option<usize>

How many felts the procedure leaves on the stack, or None if a result type has no place on the stack.

pub fn decode_result( &self, stack: &[Felt], ) -> Result<Option<String>, TypedError>

Turns the result felts at the start of stack into text. stack[0] is the top of the stack. The first result sits there, and so does the first field of a struct.

Ok(None) means the procedure returns nothing. That is the only case that is not a problem. Everything else is an error the caller can show: a result type we cannot decode, a stack that is too short, or felts that are not a valid value of the type. A value that a codec says is bad is also an error. The user should hear about that, not see raw felts.

Trait Implementations

impl Display for TypedProcInfo

Prints the signature, like add-points(point, point) -> point.

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.