radix-transactions 1.3.1

Various Radix transaction models and the manifest compiler/decompiler, from the Radix DLT project.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241

use crate::internal_prelude::*;

impl<T: SborEnumVariantFor<InstructionV2, ManifestCustomValueKind>> From<T> for InstructionV2 {
    fn from(value: T) -> Self {
        value.into_enum()
    }
}

impl ManifestInstructionSet for InstructionV2 {
    fn map_ref<M: InstructionRefMapper>(&self, mapper: M) -> M::Output<'_> {
        match self {
            InstructionV2::TakeFromWorktop(x) => mapper.apply(x),
            InstructionV2::TakeNonFungiblesFromWorktop(x) => mapper.apply(x),
            InstructionV2::TakeAllFromWorktop(x) => mapper.apply(x),
            InstructionV2::ReturnToWorktop(x) => mapper.apply(x),
            InstructionV2::BurnResource(x) => mapper.apply(x),
            InstructionV2::AssertWorktopContainsAny(x) => mapper.apply(x),
            InstructionV2::AssertWorktopContains(x) => mapper.apply(x),
            InstructionV2::AssertWorktopContainsNonFungibles(x) => mapper.apply(x),
            InstructionV2::AssertWorktopResourcesOnly(x) => mapper.apply(x),
            InstructionV2::AssertWorktopResourcesInclude(x) => mapper.apply(x),
            InstructionV2::AssertNextCallReturnsOnly(x) => mapper.apply(x),
            InstructionV2::AssertNextCallReturnsInclude(x) => mapper.apply(x),
            InstructionV2::AssertBucketContents(x) => mapper.apply(x),
            InstructionV2::CreateProofFromBucketOfAmount(x) => mapper.apply(x),
            InstructionV2::CreateProofFromBucketOfNonFungibles(x) => mapper.apply(x),
            InstructionV2::CreateProofFromBucketOfAll(x) => mapper.apply(x),
            InstructionV2::CreateProofFromAuthZoneOfAmount(x) => mapper.apply(x),
            InstructionV2::CreateProofFromAuthZoneOfNonFungibles(x) => mapper.apply(x),
            InstructionV2::CreateProofFromAuthZoneOfAll(x) => mapper.apply(x),
            InstructionV2::CloneProof(x) => mapper.apply(x),
            InstructionV2::DropProof(x) => mapper.apply(x),
            InstructionV2::PushToAuthZone(x) => mapper.apply(x),
            InstructionV2::PopFromAuthZone(x) => mapper.apply(x),
            InstructionV2::DropAuthZoneProofs(x) => mapper.apply(x),
            InstructionV2::DropAuthZoneRegularProofs(x) => mapper.apply(x),
            InstructionV2::DropAuthZoneSignatureProofs(x) => mapper.apply(x),
            InstructionV2::DropNamedProofs(x) => mapper.apply(x),
            InstructionV2::DropAllProofs(x) => mapper.apply(x),
            InstructionV2::CallFunction(x) => mapper.apply(x),
            InstructionV2::CallMethod(x) => mapper.apply(x),
            InstructionV2::CallRoyaltyMethod(x) => mapper.apply(x),
            InstructionV2::CallMetadataMethod(x) => mapper.apply(x),
            InstructionV2::CallRoleAssignmentMethod(x) => mapper.apply(x),
            InstructionV2::CallDirectVaultMethod(x) => mapper.apply(x),
            InstructionV2::AllocateGlobalAddress(x) => mapper.apply(x),
            InstructionV2::YieldToParent(x) => mapper.apply(x),
            InstructionV2::YieldToChild(x) => mapper.apply(x),
            InstructionV2::VerifyParent(x) => mapper.apply(x),
        }
    }

    fn map_self<M: OwnedInstructionMapper>(self, mapper: M) -> M::Output {
        match self {
            InstructionV2::TakeFromWorktop(x) => mapper.apply(x),
            InstructionV2::TakeNonFungiblesFromWorktop(x) => mapper.apply(x),
            InstructionV2::TakeAllFromWorktop(x) => mapper.apply(x),
            InstructionV2::ReturnToWorktop(x) => mapper.apply(x),
            InstructionV2::BurnResource(x) => mapper.apply(x),
            InstructionV2::AssertWorktopContainsAny(x) => mapper.apply(x),
            InstructionV2::AssertWorktopContains(x) => mapper.apply(x),
            InstructionV2::AssertWorktopContainsNonFungibles(x) => mapper.apply(x),
            InstructionV2::AssertWorktopResourcesOnly(x) => mapper.apply(x),
            InstructionV2::AssertWorktopResourcesInclude(x) => mapper.apply(x),
            InstructionV2::AssertNextCallReturnsOnly(x) => mapper.apply(x),
            InstructionV2::AssertNextCallReturnsInclude(x) => mapper.apply(x),
            InstructionV2::AssertBucketContents(x) => mapper.apply(x),
            InstructionV2::CreateProofFromBucketOfAmount(x) => mapper.apply(x),
            InstructionV2::CreateProofFromBucketOfNonFungibles(x) => mapper.apply(x),
            InstructionV2::CreateProofFromBucketOfAll(x) => mapper.apply(x),
            InstructionV2::CreateProofFromAuthZoneOfAmount(x) => mapper.apply(x),
            InstructionV2::CreateProofFromAuthZoneOfNonFungibles(x) => mapper.apply(x),
            InstructionV2::CreateProofFromAuthZoneOfAll(x) => mapper.apply(x),
            InstructionV2::CloneProof(x) => mapper.apply(x),
            InstructionV2::DropProof(x) => mapper.apply(x),
            InstructionV2::PushToAuthZone(x) => mapper.apply(x),
            InstructionV2::PopFromAuthZone(x) => mapper.apply(x),
            InstructionV2::DropAuthZoneProofs(x) => mapper.apply(x),
            InstructionV2::DropAuthZoneRegularProofs(x) => mapper.apply(x),
            InstructionV2::DropAuthZoneSignatureProofs(x) => mapper.apply(x),
            InstructionV2::DropNamedProofs(x) => mapper.apply(x),
            InstructionV2::DropAllProofs(x) => mapper.apply(x),
            InstructionV2::CallFunction(x) => mapper.apply(x),
            InstructionV2::CallMethod(x) => mapper.apply(x),
            InstructionV2::CallRoyaltyMethod(x) => mapper.apply(x),
            InstructionV2::CallMetadataMethod(x) => mapper.apply(x),
            InstructionV2::CallRoleAssignmentMethod(x) => mapper.apply(x),
            InstructionV2::CallDirectVaultMethod(x) => mapper.apply(x),
            InstructionV2::AllocateGlobalAddress(x) => mapper.apply(x),
            InstructionV2::YieldToParent(x) => mapper.apply(x),
            InstructionV2::YieldToChild(x) => mapper.apply(x),
            InstructionV2::VerifyParent(x) => mapper.apply(x),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, ManifestSbor, ScryptoDescribe, ScryptoSborAssertion)]
#[sbor(impl_variant_traits)]
#[sbor_assert(
    backwards_compatible(
        v1 = "FILE:../v1/instruction_v1_schema.txt",
        v2 = "FILE:instruction_v2_schema.bin",
    ),
    settings(
        comparison_between_versions = "EXPR: |s| s.allow_all_name_changes()",
        comparison_between_current_and_latest = "EXPR: |s| s",
    )
)]
pub enum InstructionV2 {
    //===============
    // Bucket Lifecycle
    //===============
    #[sbor(discriminator(TakeFromWorktop::ID))]
    TakeFromWorktop(#[sbor(flatten)] TakeFromWorktop),

    #[sbor(discriminator(TakeNonFungiblesFromWorktop::ID))]
    TakeNonFungiblesFromWorktop(#[sbor(flatten)] TakeNonFungiblesFromWorktop),

    #[sbor(discriminator(TakeAllFromWorktop::ID))]
    TakeAllFromWorktop(#[sbor(flatten)] TakeAllFromWorktop),

    #[sbor(discriminator(ReturnToWorktop::ID))]
    ReturnToWorktop(#[sbor(flatten)] ReturnToWorktop),

    #[sbor(discriminator(BurnResource::ID))]
    BurnResource(#[sbor(flatten)] BurnResource),

    //==============
    // Resource Assertions
    //==============
    #[sbor(discriminator(AssertWorktopContainsAny::ID))]
    AssertWorktopContainsAny(#[sbor(flatten)] AssertWorktopContainsAny),

    #[sbor(discriminator(AssertWorktopContains::ID))]
    AssertWorktopContains(#[sbor(flatten)] AssertWorktopContains),

    #[sbor(discriminator(AssertWorktopContainsNonFungibles::ID))]
    AssertWorktopContainsNonFungibles(#[sbor(flatten)] AssertWorktopContainsNonFungibles),

    #[sbor(discriminator(AssertWorktopResourcesOnly::ID))]
    AssertWorktopResourcesOnly(#[sbor(flatten)] AssertWorktopResourcesOnly),

    #[sbor(discriminator(AssertWorktopResourcesInclude::ID))]
    AssertWorktopResourcesInclude(#[sbor(flatten)] AssertWorktopResourcesInclude),

    #[sbor(discriminator(AssertNextCallReturnsOnly::ID))]
    AssertNextCallReturnsOnly(#[sbor(flatten)] AssertNextCallReturnsOnly),

    #[sbor(discriminator(AssertNextCallReturnsInclude::ID))]
    AssertNextCallReturnsInclude(#[sbor(flatten)] AssertNextCallReturnsInclude),

    #[sbor(discriminator(AssertBucketContents::ID))]
    AssertBucketContents(#[sbor(flatten)] AssertBucketContents),

    //==============
    // Proof Lifecycle
    //==============
    #[sbor(discriminator(CreateProofFromBucketOfAmount::ID))]
    CreateProofFromBucketOfAmount(#[sbor(flatten)] CreateProofFromBucketOfAmount),

    #[sbor(discriminator(CreateProofFromBucketOfNonFungibles::ID))]
    CreateProofFromBucketOfNonFungibles(#[sbor(flatten)] CreateProofFromBucketOfNonFungibles),

    #[sbor(discriminator(CreateProofFromBucketOfAll::ID))]
    CreateProofFromBucketOfAll(#[sbor(flatten)] CreateProofFromBucketOfAll),

    #[sbor(discriminator(CreateProofFromAuthZoneOfAmount::ID))]
    CreateProofFromAuthZoneOfAmount(#[sbor(flatten)] CreateProofFromAuthZoneOfAmount),

    #[sbor(discriminator(CreateProofFromAuthZoneOfNonFungibles::ID))]
    CreateProofFromAuthZoneOfNonFungibles(#[sbor(flatten)] CreateProofFromAuthZoneOfNonFungibles),

    #[sbor(discriminator(CreateProofFromAuthZoneOfAll::ID))]
    CreateProofFromAuthZoneOfAll(#[sbor(flatten)] CreateProofFromAuthZoneOfAll),

    #[sbor(discriminator(CloneProof::ID))]
    CloneProof(#[sbor(flatten)] CloneProof),

    #[sbor(discriminator(DropProof::ID))]
    DropProof(#[sbor(flatten)] DropProof),

    #[sbor(discriminator(PushToAuthZone::ID))]
    PushToAuthZone(#[sbor(flatten)] PushToAuthZone),

    #[sbor(discriminator(PopFromAuthZone::ID))]
    PopFromAuthZone(#[sbor(flatten)] PopFromAuthZone),

    #[sbor(discriminator(DropAuthZoneProofs::ID))]
    DropAuthZoneProofs(#[sbor(flatten)] DropAuthZoneProofs),

    #[sbor(discriminator(DropAuthZoneRegularProofs::ID))]
    DropAuthZoneRegularProofs(#[sbor(flatten)] DropAuthZoneRegularProofs),

    #[sbor(discriminator(DropAuthZoneSignatureProofs::ID))]
    DropAuthZoneSignatureProofs(#[sbor(flatten)] DropAuthZoneSignatureProofs),

    #[sbor(discriminator(DropNamedProofs::ID))]
    DropNamedProofs(#[sbor(flatten)] DropNamedProofs),

    #[sbor(discriminator(DropAllProofs::ID))]
    DropAllProofs(#[sbor(flatten)] DropAllProofs),

    //==============
    // Invocation
    //==============
    #[sbor(discriminator(CallFunction::ID))]
    CallFunction(#[sbor(flatten)] CallFunction),

    #[sbor(discriminator(CallMethod::ID))]
    CallMethod(#[sbor(flatten)] CallMethod),

    #[sbor(discriminator(CallRoyaltyMethod::ID))]
    CallRoyaltyMethod(#[sbor(flatten)] CallRoyaltyMethod),

    #[sbor(discriminator(CallMetadataMethod::ID))]
    CallMetadataMethod(#[sbor(flatten)] CallMetadataMethod),

    #[sbor(discriminator(CallRoleAssignmentMethod::ID))]
    CallRoleAssignmentMethod(#[sbor(flatten)] CallRoleAssignmentMethod),

    #[sbor(discriminator(CallDirectVaultMethod::ID))]
    CallDirectVaultMethod(#[sbor(flatten)] CallDirectVaultMethod),

    //==============
    // Address Allocation
    //==============
    #[sbor(discriminator(AllocateGlobalAddress::ID))]
    AllocateGlobalAddress(#[sbor(flatten)] AllocateGlobalAddress),

    //==============
    // Interaction with other intents
    //==============
    #[sbor(discriminator(YieldToParent::ID))]
    YieldToParent(#[sbor(flatten)] YieldToParent),

    #[sbor(discriminator(YieldToChild::ID))]
    YieldToChild(#[sbor(flatten)] YieldToChild),

    #[sbor(discriminator(VerifyParent::ID))]
    VerifyParent(#[sbor(flatten)] VerifyParent),
}