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 into an array of alternating keys and values.

Returns

A vector where each key from the dictionary is followed by its corresponding value as Params.

Panics

Panics if called on a Params variant that is not Dict.

Example

let dict = Params::Dict(BTreeMap::from([
    ("a".to_string(), Params::Integer(1)),
    ("b".to_string(), Params::Text("foo".to_string())),
]));
let arr = dict.dict_to_array();
// arr = [Params::Text("a"), Params::Integer(1), Params::Text("b"), Params::Text("foo")]

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

Converts a dictionary parameter to an array of its values.

Returns

A vector containing only the values from the dictionary, in the order of their keys.

Panics

Panics if called on a Params variant that is not Dict.

Example

let dict = Params::Dict(BTreeMap::from([
    ("a".to_string(), Params::Integer(1)),
    ("b".to_string(), Params::Text("foo".to_string())),
]));
let arr = dict.dict_to_array_values();
// arr = [Params::Integer(1), Params::Text("foo")]

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_hex_encode(self) -> String

pub fn to_vec(self) -> Vec<u8>

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 duplicate 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 Display for Params

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

Formats the value using the given formatter.

impl From<Params> for BTreeMap<String, 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 from(val: Params) -> Self

Converts to this type from the input type.

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<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 from(val: 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 GTVParams for Params

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

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