Struct Consignment

pub struct Consignment<const TYPE: bool> {
    pub version: ContainerVer,
    pub transfer: bool,
    pub schema: SubSchema,
    pub ifaces: TinyOrdMap<IfaceId, IfacePair>,
    pub supplements: TinyOrdSet<ContractSuppl>,
    pub genesis: Genesis,
    pub terminals: SmallOrdMap<BundleId, Terminal>,
    pub bundles: LargeVec<AnchoredBundle>,
    pub extensions: LargeVec<Extension>,
    pub attachments: SmallOrdMap<AttachId, MediumBlob>,
    pub signatures: TinyOrdMap<ContentId, ContentSigs>,
    /* private fields */
}

Consignment represents contract-specific data, always starting with genesis, which must be valid under client-side-validation rules (i.e. internally consistent and properly committed into the commitment layer, like bitcoin blockchain or current state of the lightning channel).

All consignments-related procedures, including validation or merging consignments data into stash or schema-specific data storage, must start with endpoints and process up to the genesis. If any of the nodes within the consignments are not part of the paths connecting endpoints with the genesis, consignments validation will return [validation::Warning::ExcessiveNode] warning.

Fields

version: ContainerVer

Version.

transfer: bool

Specifies whether the consignment contains information about state transfer (true), or it is just a consignment with an information about a contract.

schema: SubSchema

Schema (plus root schema, if any) under which contract is issued.

ifaces: TinyOrdMap<IfaceId, IfacePair>

Interfaces supported by the contract.

supplements: TinyOrdSet<ContractSuppl>

Known supplements.

genesis: Genesis

Genesis data.

terminals: SmallOrdMap<BundleId, Terminal>

Set of seals which are history terminals.

bundles: LargeVec<AnchoredBundle>

Data on all anchored state transitions contained in the consignments.

extensions: LargeVec<Extension>

Data on all state extensions contained in the consignments.

attachments: SmallOrdMap<AttachId, MediumBlob>

Data containers coming with this consignment. For the purposes of in-memory consignments we are restricting the size of the containers to 24 bit value (RGB allows containers up to 32-bit values in size).

signatures: TinyOrdMap<ContentId, ContentSigs>

Signatures on the pieces of content which are the part of the consignment.

Implementations

impl<const TYPE: bool> Consignment<TYPE>

pub fn new(schema: SubSchema, genesis: Genesis) -> Self

Panics

If the provided schema is not the one which is used by genesis.

pub fn schema_id(&self) -> SchemaId

pub fn root_schema_id(&self) -> Option<SchemaId>

pub fn contract_id(&self) -> ContractId

pub fn anchored_bundle(&self, bundle_id: BundleId) -> Option<&AnchoredBundle>

pub fn validation_status(&self) -> Option<&Status>

pub fn into_validation_status(self) -> Option<Status>

pub fn update_history<R: ResolveHeight>( &self, history: Option<&ContractHistory>, resolver: &mut R, ) -> Result<ContractHistory, R::Error>

pub fn reveal_bundle_seal(&mut self, bundle_id: BundleId, revealed: GraphSeal)

pub fn into_contract(self) -> Contract

impl Consignment<true>

pub fn transfer_id(&self) -> TransferId

impl<const TYPE: bool> Consignment<TYPE>

pub fn validate<R: ResolveTx>( self, resolver: &mut R, ) -> Result<Consignment<TYPE>, Consignment<TYPE>>

Trait Implementations

impl<const TYPE: bool> Clone for Consignment<TYPE>

fn clone(&self) -> Consignment<TYPE>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const TYPE: bool> ConsignmentApi for Consignment<TYPE>

type BundleIter<'container> = Iter<'container, AnchoredBundle> where Self: 'container

fn schema(&self) -> &SubSchema

fn operation(&self, opid: OpId) -> Option<OpRef<'_>>

Retrieves reference to a operation (genesis, state transition or state extension) matching the provided id, or None otherwise

fn genesis(&self) -> &Genesis

Contract genesis.

fn transition(&self, opid: OpId) -> Option<&Transition>

Returns reference to a state transition, if known, matching the provided id. If id is unknown, or corresponds to other type of the operation (genesis or state extensions) a error is returned.

fn extension(&self, opid: OpId) -> Option<&Extension>

Returns reference to a state extension, if known, matching the provided id. If id is unknown, or corresponds to other type of the operation (genesis or state transition) a error is returned.

fn terminals(&self) -> BTreeSet<(BundleId, SecretSeal)>

The final state (“endpoints”) provided by this consignment.

fn anchored_bundles(&self) -> Self::BundleIter<'_>

Data on all anchored state transitions contained in the consignment

fn bundle_by_id(&self, bundle_id: BundleId) -> Option<&TransitionBundle>

fn op_ids_except(&self, ids: &BTreeSet<OpId>) -> BTreeSet<OpId>

fn has_operation(&self, opid: OpId) -> bool

fn known_transitions_by_bundle_id( &self, bundle_id: BundleId, ) -> Option<Vec<&Transition>>

impl<const TYPE: bool> Debug for Consignment<TYPE>

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

Formats the value using the given formatter.

impl<'de, const TYPE: bool> Deserialize<'de> for Consignment<TYPE>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const TYPE: bool> Serialize for Consignment<TYPE>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const TYPE: bool> StrictDecode for Consignment<TYPE>

fn strict_decode(reader: &mut impl TypedRead) -> Result<Self, DecodeError>

fn strict_read(lim: usize, reader: impl Read) -> Result<Self, DecodeError>

impl<const TYPE: bool> StrictDeserialize for Consignment<TYPE>

fn from_strict_serialized<const MAX: usize>( ast_data: Confined<Vec<u8>, 0, MAX>, ) -> Result<Self, DeserializeError>

fn strict_deserialize_from_file<const MAX: usize>( path: impl AsRef<Path>, ) -> Result<Self, DeserializeError>

impl<const TYPE: bool> StrictDumb for Consignment<TYPE>

fn strict_dumb() -> Self

impl<const TYPE: bool> StrictEncode for Consignment<TYPE>

fn strict_encode<W: TypedWrite>(&self, writer: W) -> Result<W>

fn strict_write(&self, lim: usize, writer: impl Write) -> Result<usize, Error>

impl<const TYPE: bool> StrictSerialize for Consignment<TYPE>

fn strict_serialized_len(&self) -> Result<usize, Error>

fn to_strict_serialized<const MAX: usize>( &self, ) -> Result<Confined<Vec<u8>, 0, MAX>, SerializeError>

fn strict_serialize_to_file<const MAX: usize>( &self, path: impl AsRef<Path>, ) -> Result<(), SerializeError>

impl<const TYPE: bool> StrictStruct for Consignment<TYPE>

const ALL_FIELDS: &'static [&'static str]

fn strict_check_fields()

fn strict_type_info() -> TypeInfo<Self>

impl<const TYPE: bool> StrictType for Consignment<TYPE>

const STRICT_LIB_NAME: &'static str = LIB_NAME_RGB_STD

fn strict_name() -> Option<TypeName>

impl<const TYPE: bool> StrictProduct for Consignment<TYPE>