Enum Params

pub enum Params {
    Null,
    Boolean(bool),
    Integer(i64),
    BigInteger(BigInt),
    Decimal(BigDecimal),
    Text(String),
    ByteArray(Vec<u8>),
    Array(Vec<Params>),
    Dict(BTreeMap<String, Params>),
}

Represents different types of operation parameters.

This enum provides a type-safe way to handle various data types used in blockchain operations, including primitive types, collections, and special types like BigInteger.

Variants

Null

Represents a null value

Boolean(bool)

Represents a boolean value (true/false)

Integer(i64)

Represents a 64-bit signed integer

BigInteger(BigInt)

Represents an arbitrary-precision integer using BigInt

Decimal(BigDecimal)

Represents an arbitrary-precision decimal using BigDecimal

Text(String)

Represents a UTF-8 encoded string

ByteArray(Vec<u8>)

Represents a raw byte array

Array(Vec<Params>)

Represents an ordered collection of Params

Dict(BTreeMap<String, Params>)

Represents a key-value mapping where keys are strings

Implementations

impl Params

pub fn decimal_to_string(val: Box<f64>) -> String

Converts a boxed f64 value to its string representation.

Arguments

• val - Boxed f64 value to convert

Returns

String representation of the decimal value

pub fn dict_to_array(self) -> Vec<Params>

Converts a dictionary parameter to an array of its values.

Arguments

• self - Dictionary parameter to convert

Returns

Vector containing the values from the dictionary

Panics

Panics if self is not a Params::Dict

pub fn is_empty(self) -> bool

Checks if the parameter value is empty.

Works with Array, Dict, ByteArray, and Text parameter types.

Returns

true if the parameter value is empty

Panics

Panics if called on parameter types that don’t support emptiness check

pub fn len(self) -> usize

Returns the length of the parameter value.

Works with Array, Dict, ByteArray, and Text parameter types.

Returns

Length of the parameter value

Panics

Panics if called on parameter types that don’t support length

pub fn to_struct<T>(&self) -> Result<T, String>

where T: Default + Debug + for<'de> Deserialize<'de>,

Converts a dictionary parameter to a Rust struct.

Type Parameters

• T - The target struct type that implements Default + Debug + Deserialize

Returns

Result containing either the converted struct or an error message

Example

#[derive(Debug, Default, serde::Deserialize)]
struct MyStruct {
    field: String,
    value: i64,
}
 
let dict = Params::Dict(/* ... */);
let result: Result<MyStruct, String> = dict.to_struct();

pub fn to_json_value(&self) -> Value

Converts the parameter to a serde_json::Value.

This method handles all parameter types, including complex types like BigInteger and ByteArray.

Returns

JSON representation of the parameter

pub fn from_struct<T>(struct_instance: &T) -> Params

where T: Debug + Serialize + StructMetadata,

Creates a parameter from a Rust struct.

Type Parameters

• T - The source struct type that implements Debug + Serialize

Arguments

• struct_instance - Reference to the struct to convert

Returns

Dictionary parameter containing the struct’s fields

Example

#[derive(Debug, serde::Serialize)]
struct MyStruct {
    field: String,
    value: i64,
}
 
let my_struct = MyStruct { field: "test".into(), value: 42 };
let params = Params::from_struct(&my_struct);

pub fn from_struct_to_list<T>(struct_instance: &T) -> Vec<Params>

where T: Debug + Serialize + StructMetadata,

Creates a list of parameters from a Rust struct.

Similar to from_struct, but returns a vector of values instead of a dictionary.

Type Parameters

• T - The source struct type that implements Debug + Serialize

Arguments

• struct_instance - Reference to the struct to convert

Returns

Vector of parameters containing the struct’s field values

pub fn from_struct_to_vec<T>(struct_instance: &T) -> Vec<(String, Params)>

where T: Debug + Serialize,

Converts a struct into a Vec<(String, Params)>.

Type Parameters

• T - The struct type that implements Debug + Serialize

Arguments

• struct_instance - Reference to the struct to convert

Returns

Vector of tuples containing string keys and Params values

pub fn debug_print(&self)

Prints debug information about the parameter.

This method is only available in debug builds and provides detailed information about the parameter’s content.

Arguments

• self - The parameter to debug print

Trait Implementations

impl Clone for Params

fn clone(&self) -> Params

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Params

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

Formats the value using the given formatter.

impl From<Params> for BigDecimal

Converts Params to BigDecimal.

Panics

Panics if the Params variant is not Params::Decimal.

fn from(value: Params) -> Self

Converts to this type from the input type.

impl From<Params> for BigInt

Converts Params to BigInt.

Panics

Panics if the Params variant is not Params::BigInteger.

fn from(value: Params) -> Self

Converts to this type from the input type.

impl From<Params> for String

Converts Params to String.

Panics

Panics if the Params variant is not Params::Text.

fn from(value: Params) -> Self

Converts to this type from the input type.

impl From<Params> for Vec<u8>

Converts Params to Vec<u8>.

Panics

Panics if the Params variant is not Params::ByteArray.

fn from(value: Params) -> Self

Converts to this type from the input type.

impl From<Params> for bool

Converts Params to bool.

Panics

Panics if the Params variant is not Params::Boolean.

fn from(value: Params) -> Self

Converts to this type from the input type.

impl From<Params> for i64

Converts Params to i64.

Panics

Panics if the Params variant is not Params::Integer.

fn from(value: Params) -> Self

Converts to this type from the input type.

impl<'a> GTVParams for Params

fn to_writer(&self, writer: &mut Writer<'_>) -> WriteResult

impl Into<BTreeMap<String, Params>> for Params

Implements conversion from Params to BTreeMap<String, Params>.

This implementation allows converting a Dict parameter into a BTreeMap of string keys and parameter values.

Panics

Panics if the parameter is not a Dict type

fn into(self) -> BTreeMap<String, Params>

Converts this type into the (usually inferred) input type.

impl Into<Vec<Params>> for Params

Implements conversion from Params to Vec<Params>.

This implementation allows converting an Array parameter into a vector of parameters.

Panics

Panics if the parameter is not an Array type

fn into(self) -> Vec<Params>

Converts this type into the (usually inferred) input type.

impl PartialEq for Params

fn eq(&self, other: &Params) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Params