Struct Singleton 

pub struct Singleton<I> {
    pub coin: Coin,
    pub proof: Proof,
    pub info: I,
}

A generic singleton primitive, which can be extended with the SingletonInfo trait.

Fields

coin: Coin

The coin that this Singleton represents. Its puzzle hash should match the singleton outer puzzle hash.

proof: Proof

The proof is needed by the singleton puzzle to prove that this coin is a legitimate singleton. It’s typically obtained by looking up and parsing the parent coin.

Note that while the proof will be a LineageProof for most coins, for the first singleton in the lineage it will be an EveProof instead. However, the eve coin is typically unhinted and spent in the same transaction as it was created, so this is not relevant for database storage or syncing unspent coins.

info: I

The information needed to construct the outer puzzle.

Implementations

impl Singleton<DidInfo>

pub fn child( &self, p2_puzzle_hash: Bytes32, metadata: HashedPtr, amount: u64, ) -> Did

Creates a new Did that represents a child of this one.

pub fn spend( &self, ctx: &mut SpendContext, inner_spend: Spend, ) -> Result<Option<Self>, DriverError>

Spends this DID coin with the provided inner spend. The spend is added to the SpendContext for convenience.

pub fn spend_with<I>( &self, ctx: &mut SpendContext, inner: &I, conditions: Conditions, ) -> Result<Option<Self>, DriverError>

where I: SpendWithConditions,

Spends this DID coin with a Layer that supports SpendWithConditions. This is a building block for built in spend methods, but can also be used to spend DID coins with conditions more easily.

However, if you need full flexibility of the inner spend, you can use Did::spend instead.

pub fn transfer<I>( self, ctx: &mut SpendContext, inner: &I, p2_puzzle_hash: Bytes32, extra_conditions: Conditions, ) -> Result<Did, DriverError>

where I: SpendWithConditions,

Transfers this DID coin to a new p2 puzzle hash.

This spend requires a Layer that supports SpendWithConditions. If it doesn’t, you can use Did::spend_with instead.

pub fn update_with_metadata<I>( self, ctx: &mut SpendContext, inner: &I, metadata: HashedPtr, extra_conditions: Conditions, ) -> Result<Did, DriverError>

where I: SpendWithConditions,

Updates the metadata of this DID.

Because DID coins aren’t wrapped automatically, and due to the way they are parsed in wallets, an additional update spend is needed. This additional spend is not handled by this method, so you will need to do it manually.

This spend requires a Layer that supports SpendWithConditions. If it doesn’t, you can use Did::spend_with instead.

pub fn update<I>( self, ctx: &mut SpendContext, inner: &I, extra_conditions: Conditions, ) -> Result<Did, DriverError>

where I: SpendWithConditions,

Spends the DID without changing its metadata or p2 puzzle hash.

This can be done to “settle” the DID’s updated metadata and make it parseable by wallets. It’s also useful if you just want to emit conditions from the DID, without transferring it. For example, when assigning a DID to one or more NFTs you can use an update spend to do so.

This spend requires a Layer that supports SpendWithConditions. If it doesn’t, you can use Did::spend_with instead.

pub fn parse_child( allocator: &mut Allocator, parent_coin: Coin, parent_puzzle: Puzzle, parent_solution: NodePtr, coin: Coin, ) -> Result<Option<Self>, DriverError>

where Self: Sized,

Parses the child of an Did from the parent coin spend.

This relies on the child being hinted and having the same metadata as the parent. If this is not the case, the DID cannot be parsed or spent without additional context.

pub fn parse( allocator: &Allocator, coin: Coin, puzzle: Puzzle, solution: NodePtr, ) -> Result<Option<(Self, Option<(Puzzle, NodePtr)>)>, DriverError>

where Self: Sized,

Parses a Did and its p2 spend from a coin spend.

If the puzzle is not a DID, this will return None instead of an error. However, if the puzzle should have been a DID but had a parsing error, this will return an error.

impl Singleton<NftInfo>

pub fn child( &self, p2_puzzle_hash: Bytes32, current_owner: Option<Bytes32>, metadata: HashedPtr, amount: u64, ) -> Nft

Creates a new Nft that represents a child of this one.

pub fn spend( &self, ctx: &mut SpendContext, inner_spend: Spend, ) -> Result<Self, DriverError>

Spends this NFT coin with the provided inner spend. The spend is added to the SpendContext for convenience.

pub fn spend_with<I>( &self, ctx: &mut SpendContext, inner: &I, conditions: Conditions, ) -> Result<Self, DriverError>

where I: SpendWithConditions,

Spends this NFT coin with a Layer that supports SpendWithConditions. This is a building block for built in spend methods, but can also be used to spend NFTs with conditions more easily.

However, if you need full flexibility of the inner spend, you can use Nft::spend instead.

pub fn transfer_with_metadata<I>( self, ctx: &mut SpendContext, inner: &I, p2_puzzle_hash: Bytes32, metadata_update: Spend, extra_conditions: Conditions, ) -> Result<Nft, DriverError>

where I: SpendWithConditions,

Transfers this NFT coin to a new p2 puzzle hash and runs the metadata updater with the provided spend.

This spend requires a Layer that supports SpendWithConditions. If it doesn’t, you can use Nft::spend_with instead.

pub fn transfer<I>( self, ctx: &mut SpendContext, inner: &I, p2_puzzle_hash: Bytes32, extra_conditions: Conditions, ) -> Result<Nft, DriverError>

where I: SpendWithConditions,

Transfers this NFT coin to a new p2 puzzle hash.

This spend requires a Layer that supports SpendWithConditions. If it doesn’t, you can use Nft::spend_with instead.

pub fn lock_settlement<I>( self, ctx: &mut SpendContext, inner: &I, trade_prices: Vec<TradePrice>, extra_conditions: Conditions, ) -> Result<Nft, DriverError>

where I: SpendWithConditions,

Transfers this NFT coin to the settlement puzzle hash and runs the transfer program to remove the assigned owner and reveal the trade prices for the offer.

This spend requires a Layer that supports SpendWithConditions. If it doesn’t, you can use Nft::spend_with instead.

pub fn unlock_settlement( self, ctx: &mut SpendContext, notarized_payments: Vec<NotarizedPayment>, ) -> Result<Nft, DriverError>

Spends this NFT with the settlement puzzle as its inner puzzle, with the provided notarized payments. This only works if the NFT has been locked in an offer already.

pub fn assign_owner<I>( self, ctx: &mut SpendContext, inner: &I, p2_puzzle_hash: Bytes32, transfer_condition: TransferNft, extra_conditions: Conditions, ) -> Result<(Conditions, Nft), DriverError>

where I: SpendWithConditions,

Transfers this NFT coin to a new p2 puzzle hash and runs the transfer program.

This will return the conditions that must be emitted by the singleton you’re assigning the NFT to. The singleton must be spent in the same spend bundle as the NFT spend and emit these conditions.

However, if the NFT is being unassigned, there is no singleton spend and the conditions are empty.

This spend requires a Layer that supports SpendWithConditions. If it doesn’t, you can use Nft::spend_with instead.

pub fn parse_child( allocator: &mut Allocator, parent_coin: Coin, parent_puzzle: Puzzle, parent_solution: NodePtr, ) -> Result<Option<Self>, DriverError>

Parses the child of an Nft from the parent coin spend.

This can be used to construct a valid spendable Nft for a hinted coin. You simply need to look up the parent coin’s spend, parse the child, and ensure it matches the hinted coin.

This will automatically run the transfer program or metadata updater, if they are revealed in the p2 spend’s output conditions. This way the returned Nft will have the correct owner (if present) and metadata.

pub fn parse( allocator: &Allocator, coin: Coin, puzzle: Puzzle, solution: NodePtr, ) -> Result<Option<(Self, Puzzle, NodePtr)>, DriverError>

Parses an Nft and its p2 spend from a coin spend.

If the puzzle is not an NFT, this will return None instead of an error. However, if the puzzle should have been an NFT but had a parsing error, this will return an error.

impl Singleton<OptionInfo>

pub fn parse_child( allocator: &mut Allocator, parent_coin: Coin, parent_puzzle: Puzzle, parent_solution: NodePtr, ) -> Result<Option<Self>, DriverError>

pub fn parse( allocator: &Allocator, coin: Coin, puzzle: Puzzle, solution: NodePtr, ) -> Result<Option<(Self, Puzzle, NodePtr)>, DriverError>

Parses an OptionContract and its p2 spend from a coin spend.

If the puzzle is not an option contract, this will return None instead of an error. However, if the puzzle should have been an option contract but had a parsing error, this will return an error.

pub fn parse_metadata( allocator: &mut Allocator, launcher_solution: NodePtr, ) -> Result<OptionMetadata, DriverError>

pub fn spend( &self, ctx: &mut SpendContext, inner_spend: Spend, ) -> Result<Option<Self>, DriverError>

pub fn spend_with<I>( &self, ctx: &mut SpendContext, inner: &I, conditions: Conditions, ) -> Result<Option<Self>, DriverError>

where I: SpendWithConditions,

pub fn transfer<I>( self, ctx: &mut SpendContext, inner: &I, p2_puzzle_hash: Bytes32, extra_conditions: Conditions, ) -> Result<Self, DriverError>

where I: SpendWithConditions,

pub fn exercise<I>( self, ctx: &mut SpendContext, inner: &I, extra_conditions: Conditions, ) -> Result<(), DriverError>

where I: SpendWithConditions,

pub fn child(&self, p2_puzzle_hash: Bytes32, amount: u64) -> Self

impl<I> Singleton<I>

where I: SingletonInfo,

pub fn new(coin: Coin, proof: Proof, info: I) -> Self

pub fn child_lineage_proof(&self) -> LineageProof

Creates a LineageProof for which would be valid for any children created by this Singleton.

pub fn child_with<N>(&self, info: N, amount: u64) -> Singleton<N>

where N: SingletonInfo,

Creates a new Singleton that represents a child of this one.

You can specify the new SingletonInfo to use for the child.

It’s important to use the right SingletonInfo instead of modifying it afterward, otherwise the puzzle hash of the child will not match the one expected by the coin.

impl Singleton<VaultInfo>

pub fn child(&self, custody_hash: TreeHash, amount: u64) -> Self

pub fn spend( &self, ctx: &mut SpendContext, spend: &MipsSpend, ) -> Result<(), DriverError>

impl Singleton<MedievalVaultInfo>

pub fn from_launcher_spend( ctx: &mut SpendContext, launcher_spend: &CoinSpend, ) -> Result<Option<Self>, DriverError>

pub fn child(&self, new_m: usize, new_public_key_list: Vec<PublicKey>) -> Self

pub fn from_parent_spend( ctx: &mut SpendContext, parent_spend: &CoinSpend, ) -> Result<Option<Self>, DriverError>

pub fn delegated_conditions( conditions: Conditions, coin_id: Bytes32, genesis_challenge: NodePtr, ) -> Conditions

pub fn spend_sunsafe( self, ctx: &mut SpendContext, used_pubkeys: &[PublicKey], delegated_puzzle: NodePtr, delegated_solution: NodePtr, ) -> Result<(), DriverError>

pub fn spend( self, ctx: &mut SpendContext, used_pubkeys: &[PublicKey], conditions: Conditions, genesis_challenge: Bytes32, ) -> Result<(), DriverError>

pub fn rekey_create_coin_unsafe( ctx: &mut SpendContext, launcher_id: Bytes32, new_m: usize, new_pubkeys: Vec<PublicKey>, ) -> Result<Conditions, DriverError>

pub fn delegated_puzzle_for_rekey( ctx: &mut SpendContext, launcher_id: Bytes32, new_m: usize, new_pubkeys: Vec<PublicKey>, coin_id: Bytes32, genesis_challenge: Bytes32, ) -> Result<NodePtr, DriverError>

pub fn delegated_puzzle_for_flexible_send_message<M>( ctx: &mut SpendContext, message: M, receiver_launcher_id: Bytes32, my_coin: Coin, my_info: &MedievalVaultInfo, genesis_challenge: Bytes32, ) -> Result<NodePtr, DriverError>

where M: ToClvm<Allocator>,

Trait Implementations

impl<I: Clone> Clone for Singleton<I>

fn clone(&self) -> Singleton<I>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug> Debug for Singleton<I>

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

Formats the value using the given formatter.

impl<I: PartialEq> PartialEq for Singleton<I>

fn eq(&self, other: &Singleton<I>) -> 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<I: Copy> Copy for Singleton<I>

impl<I: Eq> Eq for Singleton<I>

impl<I> StructuralPartialEq for Singleton<I>