Enum TestTransaction

pub enum TestTransaction {
    V1(TestIntentV1),
    V2 {
        root_intent: TestIntentV2,
        subintents: Vec<TestIntentV2>,
    },
}

Variants

V1(TestIntentV1)

V2

Fields

root_intent: TestIntentV2

subintents: Vec<TestIntentV2>

Implementations

impl TestTransaction

pub fn new_v1_from_nonce( manifest: TransactionManifestV1, nonce: u32, initial_proofs: BTreeSet<NonFungibleGlobalId>, ) -> TestTransaction

The nonce needs to be globally unique amongst test transactions on your ledger

pub fn new_from_any_manifest( any_manifest: AnyManifest, nonce: u32, initial_proofs: BTreeSet<NonFungibleGlobalId>, ) -> Result<TestTransaction, String>

pub fn new_v1( manifest: TransactionManifestV1, hash: Hash, initial_proofs: BTreeSet<NonFungibleGlobalId>, ) -> TestTransaction

pub fn new_v2_builder(nonce: u32) -> TestTransactionV2Builder

Example usage

let mut ledger = LedgerSimulatorBuilder::new().build();
let mut builder = TestTransaction::new_v2_builder(ledger.next_transaction_nonce());

let child = builder.add_subintent(
    ManifestBuilder::new_subintent_v2()
        .yield_to_parent(())
        .build(),
    [child_public_key.signature_proof()],
);

let transaction = builder.finish_with_root_intent(
    ManifestBuilder::new_v2()
        .use_child("child", child)
        .lock_standard_test_fee(account)
        .yield_to_child("child", ())
        .build(),
    [public_key.signature_proof()],
);

let receipt = ledger.execute_test_transaction(transaction);

pub fn prepare( self, settings: &PreparationSettingsV1, ) -> Result<PreparedTestTransaction, PrepareError>

Trait Implementations

impl Categorize<ManifestCustomValueKind> for TestTransaction

fn value_kind() -> ValueKind<ManifestCustomValueKind>

impl<D> Decode<ManifestCustomValueKind, D> for TestTransaction

where D: Decoder<ManifestCustomValueKind>,

fn decode_body_with_value_kind( decoder: &mut D, value_kind: ValueKind<ManifestCustomValueKind>, ) -> Result<TestTransaction, DecodeError>

Decodes the type from the decoder, which should match a preloaded value kind.

impl<E> Encode<ManifestCustomValueKind, E> for TestTransaction

where E: Encoder<ManifestCustomValueKind>,

fn encode_value_kind(&self, encoder: &mut E) -> Result<(), EncodeError>

Encodes the SBOR value’s kind to the encoder

fn encode_body(&self, encoder: &mut E) -> Result<(), EncodeError>

Encodes the SBOR body of the type to the encoder.

impl IntoExecutable for TestTransaction

type Error = PrepareError

fn into_executable( self, validator: &TransactionValidator, ) -> Result<ExecutableTransaction, <TestTransaction as IntoExecutable>::Error>

fn into_executable_unwrap(self) -> ExecutableTransaction

where Self: Sized,

For use in tests as a quick mechanism to get an executable. Validates with a network-independent validator, using the latest settings.

impl SborEnum<ManifestCustomValueKind> for TestTransaction

fn get_discriminator(&self) -> u8

fn get_length(&self) -> usize