Skip to content

Commit 67ef15e

Browse files
thepastaclawthepastaclaw
committed
test(drive-abci): adapt address transition tests to client-side validation
1 parent 6029e2a commit 67ef15e

5 files changed

Lines changed: 300 additions & 87 deletions

File tree

  • packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions

‎packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/address_credit_withdrawal/tests.rs‎

Lines changed: 140 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,7 @@ mod tests {
2121
use dpp::identity::signer::Signer;
2222
use dpp::platform_value::BinaryData;
2323
use dpp::prelude::AddressNonce;
24-
use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
24+
use dpp::serialization::{PlatformDeserializable, PlatformSerializable, Signable};
2525
use dpp::state_transition::address_credit_withdrawal_transition::methods::AddressCreditWithdrawalTransitionMethodsV0;
2626
use dpp::state_transition::address_credit_withdrawal_transition::v0::AddressCreditWithdrawalTransitionV0;
2727
use dpp::state_transition::address_credit_withdrawal_transition::AddressCreditWithdrawalTransition;
@@ -170,6 +170,44 @@ mod tests {
170170
.expect("should create signed transition")
171171
}
172172

173+
/// Create a signed withdrawal transition without running constructor-time structure checks.
174+
fn create_manually_signed_withdrawal_transition(
175+
signer: &TestAddressSigner,
176+
inputs: BTreeMap<PlatformAddress, (AddressNonce, u64)>,
177+
output: Option<(PlatformAddress, u64)>,
178+
fee_strategy: AddressFundsFeeStrategy,
179+
core_fee_per_byte: u32,
180+
pooling: Pooling,
181+
output_script: CoreScript,
182+
user_fee_increase: u16,
183+
) -> StateTransition {
184+
let mut transition = AddressCreditWithdrawalTransitionV0 {
185+
inputs: inputs.clone(),
186+
output,
187+
fee_strategy,
188+
core_fee_per_byte,
189+
pooling,
190+
output_script,
191+
user_fee_increase,
192+
input_witnesses: vec![],
193+
};
194+
195+
let signable_bytes = StateTransition::from(transition.clone())
196+
.signable_bytes()
197+
.expect("should get signable bytes");
198+
199+
transition.input_witnesses = inputs
200+
.keys()
201+
.map(|address| {
202+
signer
203+
.sign_create_witness(address, &signable_bytes)
204+
.expect("should create witness")
205+
})
206+
.collect();
207+
208+
AddressCreditWithdrawalTransition::V0(transition).into()
209+
}
210+
173211
// ==========================================
174212
// STRUCTURE VALIDATION TESTS
175213
// These test basic structure validation (BasicError)
@@ -1099,12 +1137,17 @@ mod tests {
10991137
inputs.insert(input_address2, (1 as AddressNonce, dash_to_credits!(0.5)));
11001138
inputs.insert(input_address3, (1 as AddressNonce, dash_to_credits!(0.5)));
11011139

1102-
let transition = create_signed_address_credit_withdrawal_transition(
1140+
let transition = create_manually_signed_withdrawal_transition(
11031141
&signer,
11041142
inputs,
11051143
None,
1106-
vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
1144+
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
1145+
0,
1146+
)]),
1147+
1,
1148+
Pooling::Never,
11071149
create_random_output_script(&mut rng),
1150+
0,
11081151
);
11091152

11101153
let result = transition.serialize_to_bytes().expect("should serialize");
@@ -1316,12 +1359,17 @@ mod tests {
13161359
let mut inputs = BTreeMap::new();
13171360
inputs.insert(input_address, (1 as AddressNonce, withdrawal_amount));
13181361

1319-
let transition = create_signed_address_credit_withdrawal_transition(
1362+
let transition = create_manually_signed_withdrawal_transition(
13201363
&signer,
13211364
inputs,
13221365
None,
1323-
vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
1366+
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
1367+
0,
1368+
)]),
1369+
1,
1370+
Pooling::Never,
13241371
create_random_output_script(&mut rng),
1372+
0,
13251373
);
13261374

13271375
let result = transition.serialize_to_bytes().expect("should serialize");
@@ -1420,12 +1468,17 @@ mod tests {
14201468

14211469
let output = Some((output_address, output_amount));
14221470

1423-
let transition = create_signed_address_credit_withdrawal_transition(
1471+
let transition = create_manually_signed_withdrawal_transition(
14241472
&signer,
14251473
inputs,
14261474
output,
1427-
vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
1475+
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
1476+
0,
1477+
)]),
1478+
1,
1479+
Pooling::Never,
14281480
create_random_output_script(&mut rng),
1481+
0,
14291482
);
14301483

14311484
let result = transition.serialize_to_bytes().expect("should serialize");
@@ -1502,12 +1555,17 @@ mod tests {
15021555
inputs.insert(input_address1, (1 as AddressNonce, dash_to_credits!(0.3)));
15031556
inputs.insert(input_address2, (1 as AddressNonce, dash_to_credits!(0.3)));
15041557

1505-
let transition = create_signed_address_credit_withdrawal_transition(
1558+
let transition = create_manually_signed_withdrawal_transition(
15061559
&signer,
15071560
inputs,
15081561
None,
1509-
vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
1562+
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
1563+
0,
1564+
)]),
1565+
1,
1566+
Pooling::Never,
15101567
create_random_output_script(&mut rng),
1568+
0,
15111569
);
15121570

15131571
let result = transition.serialize_to_bytes().expect("should serialize");
@@ -1604,12 +1662,17 @@ mod tests {
16041662
let mut inputs = BTreeMap::new();
16051663
inputs.insert(input_address, (1 as AddressNonce, dash_to_credits!(0.5)));
16061664

1607-
let transition = create_signed_address_credit_withdrawal_transition(
1665+
let transition = create_manually_signed_withdrawal_transition(
16081666
&signer,
16091667
inputs,
16101668
None,
1611-
vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
1669+
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
1670+
0,
1671+
)]),
1672+
1,
1673+
Pooling::Never,
16121674
create_random_output_script(&mut rng),
1675+
0,
16131676
);
16141677

16151678
let result = transition.serialize_to_bytes().expect("should serialize");
@@ -3414,20 +3477,18 @@ mod tests {
34143477
inputs.insert(input_address, (1 as AddressNonce, dash_to_credits!(0.5)));
34153478

34163479
// Use Pooling::IfAvailable
3417-
let transition = AddressCreditWithdrawalTransitionV0::try_from_inputs_with_signer(
3480+
let transition = create_manually_signed_withdrawal_transition(
3481+
&signer,
34183482
inputs,
34193483
None,
34203484
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
34213485
0,
34223486
)]),
34233487
1,
3424-
Pooling::IfAvailable, // Different pooling mode
3488+
Pooling::IfAvailable,
34253489
create_random_output_script(&mut rng),
3426-
&signer,
34273490
0,
3428-
platform_version,
3429-
)
3430-
.expect("should create signed transition");
3491+
);
34313492

34323493
let result = transition.serialize_to_bytes().expect("should serialize");
34333494

@@ -3473,20 +3534,18 @@ mod tests {
34733534
inputs.insert(input_address, (1 as AddressNonce, dash_to_credits!(0.5)));
34743535

34753536
// Use Pooling::Standard
3476-
let transition = AddressCreditWithdrawalTransitionV0::try_from_inputs_with_signer(
3537+
let transition = create_manually_signed_withdrawal_transition(
3538+
&signer,
34773539
inputs,
34783540
None,
34793541
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
34803542
0,
34813543
)]),
34823544
1,
3483-
Pooling::Standard, // Standard pooling
3545+
Pooling::Standard,
34843546
create_random_output_script(&mut rng),
3485-
&signer,
34863547
0,
3487-
platform_version,
3488-
)
3489-
.expect("should create signed transition");
3548+
);
34903549

34913550
let result = transition.serialize_to_bytes().expect("should serialize");
34923551

@@ -3670,12 +3729,17 @@ mod tests {
36703729
let mut inputs = BTreeMap::new();
36713730
inputs.insert(input_address, (1 as AddressNonce, withdrawal_amount));
36723731

3673-
let transition = create_signed_address_credit_withdrawal_transition(
3732+
let transition = create_manually_signed_withdrawal_transition(
36743733
&signer,
36753734
inputs,
36763735
None,
3677-
vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
3736+
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
3737+
0,
3738+
)]),
3739+
1,
3740+
Pooling::Never,
36783741
create_random_output_script(&mut rng),
3742+
0,
36793743
);
36803744

36813745
let result = transition.serialize_to_bytes().expect("should serialize");
@@ -4744,12 +4808,17 @@ mod tests {
47444808
// Try to withdraw the tiny amount
47454809
inputs.insert(input_address, (1 as AddressNonce, 5000));
47464810

4747-
let transition = create_signed_address_credit_withdrawal_transition(
4811+
let transition = create_manually_signed_withdrawal_transition(
47484812
&signer,
47494813
inputs,
47504814
None,
4751-
vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
4815+
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
4816+
0,
4817+
)]),
4818+
1,
4819+
Pooling::Never,
47524820
create_random_output_script(&mut rng),
4821+
0,
47534822
);
47544823

47554824
let result = transition.serialize_to_bytes().expect("should serialize");
@@ -5100,12 +5169,17 @@ mod tests {
51005169
// Change output goes back to the same address (should fail)
51015170
let output = Some((input_address, dash_to_credits!(0.5)));
51025171

5103-
let transition = create_signed_address_credit_withdrawal_transition(
5172+
let transition = create_manually_signed_withdrawal_transition(
51045173
&signer,
51055174
inputs,
51065175
output,
5107-
vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
5176+
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
5177+
0,
5178+
)]),
5179+
1,
5180+
Pooling::Never,
51085181
create_random_output_script(&mut rng),
5182+
0,
51095183
);
51105184

51115185
let result = transition.serialize_to_bytes().expect("should serialize");
@@ -5150,12 +5224,17 @@ mod tests {
51505224
// Change output goes to a different address
51515225
let output = Some((change_address, dash_to_credits!(0.5)));
51525226

5153-
let transition = create_signed_address_credit_withdrawal_transition(
5227+
let transition = create_manually_signed_withdrawal_transition(
51545228
&signer,
51555229
inputs,
51565230
output,
5157-
vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
5231+
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
5232+
0,
5233+
)]),
5234+
1,
5235+
Pooling::Never,
51585236
create_random_output_script(&mut rng),
5237+
0,
51595238
);
51605239

51615240
let result = transition.serialize_to_bytes().expect("should serialize");
@@ -5197,12 +5276,17 @@ mod tests {
51975276
// Zero credits change output
51985277
let output = Some((input_address, 0));
51995278

5200-
let transition = create_signed_address_credit_withdrawal_transition(
5279+
let transition = create_manually_signed_withdrawal_transition(
52015280
&signer,
52025281
inputs,
52035282
output,
5204-
vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
5283+
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
5284+
0,
5285+
)]),
5286+
1,
5287+
Pooling::Never,
52055288
create_random_output_script(&mut rng),
5289+
0,
52065290
);
52075291

52085292
let result = transition.serialize_to_bytes().expect("should serialize");
@@ -5244,12 +5328,17 @@ mod tests {
52445328
// Change output exceeds remaining (after withdrawal + fees)
52455329
let output = Some((input_address, dash_to_credits!(2.0)));
52465330

5247-
let transition = create_signed_address_credit_withdrawal_transition(
5331+
let transition = create_manually_signed_withdrawal_transition(
52485332
&signer,
52495333
inputs,
52505334
output,
5251-
vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
5335+
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
5336+
0,
5337+
)]),
5338+
1,
5339+
Pooling::Never,
52525340
create_random_output_script(&mut rng),
5341+
0,
52535342
);
52545343

52555344
let result = transition.serialize_to_bytes().expect("should serialize");
@@ -5582,7 +5671,8 @@ mod tests {
55825671
output_script: CoreScript,
55835672
core_fee_per_byte: u32,
55845673
) -> StateTransition {
5585-
AddressCreditWithdrawalTransitionV0::try_from_inputs_with_signer(
5674+
create_manually_signed_withdrawal_transition(
5675+
signer,
55865676
inputs,
55875677
None,
55885678
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
@@ -5591,11 +5681,8 @@ mod tests {
55915681
core_fee_per_byte,
55925682
Pooling::Never,
55935683
output_script,
5594-
signer,
55955684
0,
5596-
PlatformVersion::latest(),
55975685
)
5598-
.expect("should create signed transition")
55995686
}
56005687

56015688
#[test]
@@ -5923,12 +6010,17 @@ mod tests {
59236010
// withdrawal_amount = 0.01 - 0.5 = UNDERFLOW
59246011
let output_address = create_platform_address(2);
59256012

5926-
let transition = create_signed_address_credit_withdrawal_transition(
6013+
let transition = create_manually_signed_withdrawal_transition(
59276014
&signer,
59286015
inputs,
59296016
Some((output_address, dash_to_credits!(0.5))),
5930-
vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
6017+
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
6018+
0,
6019+
)]),
6020+
1,
6021+
Pooling::Never,
59316022
create_random_output_script(&mut rng),
6023+
0,
59326024
);
59336025

59346026
let result = transition.serialize_to_bytes().expect("should serialize");
@@ -6176,12 +6268,17 @@ mod tests {
61766268

61776269
let output_address = create_platform_address(2);
61786270

6179-
let transition = create_signed_address_credit_withdrawal_transition(
6271+
let transition = create_manually_signed_withdrawal_transition(
61806272
&signer,
61816273
inputs,
61826274
Some((output_address, output_amount)),
6183-
vec![AddressFundsFeeStrategyStep::DeductFromInput(0)],
6275+
AddressFundsFeeStrategy::from(vec![AddressFundsFeeStrategyStep::DeductFromInput(
6276+
0,
6277+
)]),
6278+
1,
6279+
Pooling::Never,
61846280
create_random_output_script(&mut rng),
6281+
0,
61856282
);
61866283

61876284
let result = transition.serialize_to_bytes().expect("should serialize");

0 commit comments

Comments
 (0)