Struct Cat 

pub struct Cat {
    pub coin: Coin,
    pub lineage_proof: Option<LineageProof>,
    pub info: CatInfo,
}

Contains all information needed to spend the outer puzzles of CAT coins. The CatInfo is used to construct the puzzle, but the LineageProof 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 CAT coin.

Fields

coin: Coin

The coin that this Cat represents. Its puzzle hash should match the CatInfo::puzzle_hash.

lineage_proof: Option<LineageProof>

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

This can get a bit tedious, so a helper method Cat::parse_children is provided to parse the child Cat objects from the parent (once you have looked up its information on-chain).

Note that while the lineage proof is needed for most coins, it is optional if you are issuing more of the CAT by running its TAIL program.

info: CatInfo

The information needed to construct the outer puzzle of a CAT. See CatInfo for more details.

Implementations

impl Cat

pub fn new( coin: Coin, lineage_proof: Option<LineageProof>, info: CatInfo, ) -> Self

pub fn issue_with_coin( ctx: &mut SpendContext, parent_coin_id: Bytes32, amount: u64, extra_conditions: Conditions, ) -> Result<(Conditions, Vec<Cat>), DriverError>

pub fn issue_with_key( ctx: &mut SpendContext, parent_coin_id: Bytes32, public_key: PublicKey, amount: u64, extra_conditions: Conditions, ) -> Result<(Conditions, Vec<Cat>), DriverError>

pub fn issue_revocable_with_coin( ctx: &mut SpendContext, parent_coin_id: Bytes32, hidden_puzzle_hash: Bytes32, amount: u64, extra_conditions: Conditions, ) -> Result<(Conditions, Vec<Cat>), DriverError>

pub fn issue_revocable_with_key( ctx: &mut SpendContext, parent_coin_id: Bytes32, public_key: PublicKey, hidden_puzzle_hash: Bytes32, amount: u64, extra_conditions: Conditions, ) -> Result<(Conditions, Vec<Cat>), DriverError>

pub fn issue( ctx: &mut SpendContext, parent_coin_id: Bytes32, hidden_puzzle_hash: Option<Bytes32>, amount: u64, run_tail: RunCatTail<NodePtr, NodePtr>, conditions: Conditions, ) -> Result<(Conditions, Vec<Cat>), DriverError>

pub fn spend_all( ctx: &mut SpendContext, cat_spends: &[CatSpend], ) -> Result<Vec<Cat>, DriverError>

Constructs a CoinSpend for each CatSpend in the list. The spends are added to the SpendContext (in order) for convenience.

All of the ring announcements and proofs required by the CAT puzzle are calculated automatically. This requires running the inner spends to get the conditions, so any errors will be propagated.

It’s important not to spend CATs with different asset IDs at the same time, since they are not compatible.

Additionally, you should group all CAT spends done in the same transaction together so that the value of one coin can be freely used in the output of another. If you spend them separately, there will be multiple announcement rings and a non-zero delta will be calculated.

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

Spends this CAT coin with the provided solution parameters. Other parameters are inferred from the Cat instance.

This is useful if you have already calculated the conditions and want to spend the coin directly. However, it’s more common to use Cat::spend_all which handles the details of calculating the solution (including ring announcements) for multiple CATs and spending them all at once.

pub fn child_lineage_proof(&self) -> LineageProof

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

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

Creates a new Cat that represents a child of this one. The child will have the same revocation layer (or lack thereof) as the current Cat.

If you need to construct a child without the revocation layer, use Cat::unrevocable_child.

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

Creates a new Cat that represents a child of this one. The child will not have a revocation layer.

If you need to construct a child with the same revocation layer, use Cat::child.

pub fn child_with(&self, info: CatInfo, amount: u64) -> Self

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

You can specify the CatInfo to use for the child manually. In most cases, you will want to use Cat::child or Cat::unrevocable_child instead.

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

Parses a Cat and its p2 spend from a coin spend by extracting the CatLayer and RevocationLayer if present.

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

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

Parses the children of a Cat from the parent coin spend.

This can be used to construct a valid spendable Cat for a hinted coin. You simply need to look up the parent coin’s spend, parse the children, and find the one that matches the hinted coin.

There is special handling for the revocation layer. See Cat::child_from_p2_create_coin for more details.

pub fn child_from_p2_create_coin( &self, allocator: &Allocator, create_coin: CreateCoin<NodePtr>, revoke: bool, ) -> Self

Creates a new Cat that reflects the create coin condition in the p2 spend’s conditions.

There is special handling for the revocation layer:

1. If there is no revocation layer for the parent, the child will not have one either.
2. If the parent was not revoked, the child will have the same revocation layer.
3. If the parent was revoked, the child will not have a revocation layer.
4. If the parent was revoked, and the child was hinted (and wrapped with the revocation layer), it will detect it.

Trait Implementations

impl AddAsset for Cat

fn add(self, spends: &mut Spends)

impl Asset for Cat

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 Clone for Cat

fn clone(&self) -> Cat

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Cat

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

Formats the value using the given formatter.

impl FungibleAsset for Cat

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

fn child_memos( &self, ctx: &mut SpendContext, p2_puzzle_hash: Bytes32, ) -> Result<Memos, DriverError>

impl PartialEq for Cat

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

impl Eq for Cat

impl StructuralPartialEq for Cat