Type Alias Did 

pub type Did = Singleton<DidInfo>;

Contains all information needed to spend the outer puzzles of DID coins. The DidInfo is used to construct the puzzle, but the Proof is needed for the solution.

The only thing missing to create a valid coin spend is the inner puzzle and solution. However, this is handled separately to provide as much flexibility as possible.

This type should contain all of the information you need to store in a database for later. As long as you can figure out what puzzle the p2 puzzle hash corresponds to and spend it, you have enough information to spend the DID coin.

Aliased Type

pub struct Did {
    pub coin: Coin,
    pub proof: Proof,
    pub info: DidInfo,
}

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: DidInfo

The information needed to construct the outer puzzle.

Implementations

impl Did

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.

Trait Implementations

impl AddAsset for Did

fn add(self, spends: &mut Spends)

impl Asset for Did

fn coin_id(&self) -> Bytes32

fn full_puzzle_hash(&self) -> Bytes32

fn p2_puzzle_hash(&self) -> Bytes32

fn amount(&self) -> u64

fn constraints(&self) -> OutputConstraints

impl SingletonAsset for Did

type ChildInfo = ChildDidInfo

fn default_child_info(asset: &Self, spend_kind: &SpendKind) -> Self::ChildInfo

fn needs_additional_spend(child_info: &Self::ChildInfo) -> bool

fn finalize( ctx: &mut SpendContext, singleton: &mut SingletonSpend<Self>, _conditions_puzzle_hash: Bytes32, change_puzzle_hash: Bytes32, ) -> Result<Option<SingletonSpend<Self>>, DriverError>