Struct SpendContext 

pub struct SpendContext { /* private fields */ }

A wrapper around Allocator that caches puzzles and keeps track of a list of CoinSpend. It’s used to construct spend bundles in an easy and efficient way.

Implementations

impl SpendContext

pub fn new() -> Self

pub fn iter(&self) -> impl Iterator<Item = &CoinSpend>

pub fn take(&mut self) -> Vec<CoinSpend>

Remove all of the CoinSpend that have been collected so far.

pub fn insert(&mut self, coin_spend: CoinSpend)

Adds a CoinSpend to the collection.

pub fn spend(&mut self, coin: Coin, spend: Spend) -> Result<(), DriverError>

Serializes a Spend and adds it to the list of CoinSpend.

pub fn alloc<T>(&mut self, value: &T) -> Result<NodePtr, DriverError>

where T: ToClvm<Allocator>,

Allocate a new node and return its pointer.

pub fn alloc_hashed<T>(&mut self, value: &T) -> Result<HashedPtr, DriverError>

where T: ToClvm<Allocator>,

Allocate a new node and return its pointer pre-hashed.

pub fn extract<T>(&self, ptr: NodePtr) -> Result<T, DriverError>

where T: FromClvm<Allocator>,

Extract a value from a node pointer.

pub fn tree_hash(&self, ptr: NodePtr) -> TreeHash

Compute the tree hash of a node pointer.

pub fn run( &mut self, puzzle: NodePtr, solution: NodePtr, ) -> Result<NodePtr, DriverError>

Run a puzzle with a solution and return the result.

pub fn serialize<T>(&mut self, value: &T) -> Result<Program, DriverError>

where T: ToClvm<Allocator>,

Allocate a value and serialize it into a Program.

pub fn serialize_with_backrefs<T>( &mut self, value: &T, ) -> Result<Program, DriverError>

where T: ToClvm<Allocator>,

Allocate a value and serialize it into a Program with back references enabled.

pub fn memos<T>(&mut self, value: &T) -> Result<Memos<NodePtr>, DriverError>

where T: ToClvm<Allocator>,

pub fn hint(&mut self, hint: Bytes32) -> Result<Memos<NodePtr>, DriverError>

pub fn alloc_mod<T>(&mut self) -> Result<NodePtr, DriverError>

where T: Mod,

pub fn curry<T>(&mut self, args: T) -> Result<NodePtr, DriverError>

where T: Mod + ToClvm<Allocator>,

pub fn get_puzzle(&self, puzzle_hash: &TreeHash) -> Option<NodePtr>

pub fn puzzle( &mut self, puzzle_hash: TreeHash, puzzle_bytes: &[u8], ) -> Result<NodePtr, DriverError>

pub fn delegated_spend( &mut self, conditions: Conditions, ) -> Result<Spend, DriverError>

Methods from Deref<Target = Allocator>

pub fn checkpoint(&self) -> Checkpoint

pub fn restore_checkpoint(&mut self, cp: &Checkpoint)

pub fn new_atom(&mut self, v: &[u8]) -> Result<NodePtr, EvalErr>

pub fn new_small_number(&mut self, v: u32) -> Result<NodePtr, EvalErr>

pub fn new_number(&mut self, v: BigInt) -> Result<NodePtr, EvalErr>

pub fn new_g1(&mut self, g1: PublicKey) -> Result<NodePtr, EvalErr>

pub fn new_g2(&mut self, g2: Signature) -> Result<NodePtr, EvalErr>

pub fn new_pair( &mut self, first: NodePtr, rest: NodePtr, ) -> Result<NodePtr, EvalErr>

pub fn add_ghost_pair(&mut self, amount: usize) -> Result<(), EvalErr>

pub fn remove_ghost_pair(&mut self, amount: usize) -> Result<(), EvalErr>

pub fn new_substr( &mut self, node: NodePtr, start: u32, end: u32, ) -> Result<NodePtr, EvalErr>

pub fn new_concat( &mut self, new_size: usize, nodes: &[NodePtr], ) -> Result<NodePtr, EvalErr>

pub fn atom_eq(&self, lhs: NodePtr, rhs: NodePtr) -> bool

pub fn atom(&self, node: NodePtr) -> Atom<'_>

pub fn atom_len(&self, node: NodePtr) -> usize

pub fn small_number(&self, node: NodePtr) -> Option<u32>

pub fn number(&self, node: NodePtr) -> BigInt

pub fn g1(&self, node: NodePtr) -> Result<PublicKey, EvalErr>

pub fn g2(&self, node: NodePtr) -> Result<Signature, EvalErr>

pub fn node(&self, node: NodePtr) -> NodeVisitor<'_>

pub fn sexp(&self, node: NodePtr) -> SExp

pub fn next(&self, n: NodePtr) -> Option<(NodePtr, NodePtr)>

pub fn nil(&self) -> NodePtr

pub fn one(&self) -> NodePtr

Trait Implementations

impl Debug for SpendContext

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

Formats the value using the given formatter.

impl Default for SpendContext

fn default() -> SpendContext

Returns the “default value” for a type.

impl Deref for SpendContext

type Target = Allocator

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for SpendContext

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl From<Allocator> for SpendContext

fn from(allocator: Allocator) -> Self

Converts to this type from the input type.

impl IntoIterator for SpendContext

type Item = CoinSpend

The type of the elements being iterated over.

type IntoIter = IntoIter<<SpendContext as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.