Update sncast scripts

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 #### Added
 
 - `--l1-gas`, `--l1-gas-price`, `--l2-gas`, `--l2-gas-price`, `--l1-data-gas`, `--l1-data-gas-price` flags
+- methods for fee settings creation, in `FeeSettingsTrait`: `max_fee()`, `resource_bounds()` and `estimate()` (in `sncast_std`)
 
 #### Changed
 
@@ -20,6 +21,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 #### Removed
 
 - `--max-gas` and `--max-gas-unit-price` flags
+- `max_gas`, `max_gas_unit_price` fields in `FeeSettings` (in `sncast_std`)
 
 ## [0.39.0] - 2025-03-19
 

crates/sncast/src/helpers/fee.rs

@@ -84,7 +84,6 @@ impl FeeArgs {
     }
 }
 
-// TODO(#3102): Refactor to be enum with max fee and triplet variants
 /// Struct used in `sncast script` for deserializing from cairo, `FeeSettings` can't be
 /// used as it missing `max_fee`
 #[derive(Debug, PartialEq, CairoDeserialize)]

crates/sncast/tests/data/scripts/declare/src/fee_settings.cairo

@@ -1,18 +1,13 @@
 use sncast_std::{
-    get_nonce, declare, DeclareResult, ScriptCommandError, ProviderError, StarknetError, FeeSettings
+    get_nonce, declare, DeclareResult, ScriptCommandError, ProviderError, StarknetError,
+    FeeSettingsTrait
 };
 
 fn main() {
+    let fee_settings = FeeSettingsTrait::resource_bounds(
+        100000, 10000000000000, 1000000000, 100000000000000000000, 100000, 10000000000000,
+    );
     let declare_nonce = get_nonce('latest');
-    declare(
-        "Mapa",
-        FeeSettings {
-            max_gas: Option::Some(99999),
-            max_gas_unit_price: Option::Some(999999999999),
-            max_fee: Option::None
-        },
-        Option::Some(declare_nonce)
-    )
-        .expect('declare failed');
+    declare("Mapa", fee_settings, Option::Some(declare_nonce)).expect('declare failed');
     println!("success");
 }

crates/sncast/tests/data/scripts/declare/src/insufficient_account_balance.cairo

@@ -1,20 +1,19 @@
 use sncast_std::{
     get_nonce, declare, DeclareResult, ScriptCommandError, ProviderError, StarknetError,
-    FeeSettings,
+    FeeSettingsTrait,
 };
 
 fn main() {
+    let fee_settings = FeeSettingsTrait::resource_bounds(
+        9999999999999999999,
+        99999999999999999999999999999999999999,
+        9999999999999999999,
+        99999999999999999999999999999999999999,
+        9999999999999999999,
+        99999999999999999999999999999999999999
+    );
     let declare_nonce = get_nonce('latest');
-    let declare_result = declare(
-        "Mapa",
-        FeeSettings {
-            max_fee: Option::None,
-            max_gas: Option::Some(9999999999999999999),
-            max_gas_unit_price: Option::Some(99999999999999999999999999999999999999)
-        },
-        Option::Some(declare_nonce)
-    )
-        .unwrap_err();
+    let declare_result = declare("Mapa", fee_settings, Option::Some(declare_nonce)).unwrap_err();
     println!("{:?}", declare_result);
 
     assert(

crates/sncast/tests/data/scripts/declare/src/no_contract.cairo

@@ -1,16 +1,10 @@
 use sncast_std::{
-    declare, DeclareResult, ScriptCommandError, ProviderError, StarknetError, FeeSettings,
+    declare, DeclareResult, ScriptCommandError, ProviderError, StarknetError, FeeSettingsTrait,
 };
 
 fn main() {
-    let declare_result = declare(
-        "Mapaaaa",
-        FeeSettings {
-            max_fee: Option::None, max_gas: Option::None, max_gas_unit_price: Option::None
-        },
-        Option::None
-    )
-        .unwrap_err();
+    let fee_settings = FeeSettingsTrait::estimate();
+    let declare_result = declare("Mapaaaa", fee_settings, Option::None).unwrap_err();
     println!("{:?}", declare_result);
 }
 

crates/sncast/tests/data/scripts/declare/src/same_contract_twice.cairo

@@ -1,19 +1,14 @@
 use sncast_std::{
     get_nonce, declare, DeclareResult, DeclareResultTrait, ScriptCommandError, ProviderError,
-    StarknetError, FeeSettings
+    StarknetError, FeeSettingsTrait
 };
 
 fn main() {
+    let fee_settings = FeeSettingsTrait::resource_bounds(
+        100000, 10000000000000, 1000000000, 100000000000000000000, 100000, 10000000000000,
+    );
     let declare_nonce = get_nonce('latest');
-    let first_declare_result = declare(
-        "Mapa",
-        FeeSettings {
-            max_fee: Option::None,
-            max_gas: Option::Some(999999),
-            max_gas_unit_price: Option::Some(100000000000)
-        },
-        Option::Some(declare_nonce)
-    )
+    let first_declare_result = declare("Mapa", fee_settings, Option::Some(declare_nonce))
         .expect('declare failed');
     println!("success");
 
@@ -27,15 +22,7 @@ fn main() {
     assert(*first_declare_result.class_hash() == class_hash, 'Class hashes must be equal');
 
     let declare_nonce = get_nonce('latest');
-    let second_declare_result = declare(
-        "Mapa",
-        FeeSettings {
-            max_fee: Option::None,
-            max_gas: Option::Some(999999),
-            max_gas_unit_price: Option::Some(100000000000)
-        },
-        Option::Some(declare_nonce)
-    )
+    let second_declare_result = declare("Mapa", fee_settings, Option::Some(declare_nonce))
         .expect('second declare failed');
 
     // Check if already declared contract was handled correctly

crates/sncast/tests/data/scripts/declare/src/time_out.cairo

@@ -1,19 +1,14 @@
 use sncast_std::{
-    get_nonce, declare, DeclareResult, ScriptCommandError, ProviderError, StarknetError, FeeSettings
+    get_nonce, declare, DeclareResult, ScriptCommandError, ProviderError, StarknetError,
+    FeeSettingsTrait
 };
 
 fn main() {
-    let max_fee = 99999999999999999;
-
+    let fee_settings = FeeSettingsTrait::resource_bounds(
+        100000, 10000000000000, 1000000000, 100000000000000000000, 100000, 10000000000000,
+    );
     let declare_nonce = get_nonce('latest');
-    let declare_result = declare(
-        "Mapa",
-        FeeSettings {
-            max_fee: Option::Some(max_fee), max_gas: Option::None, max_gas_unit_price: Option::None
-        },
-        Option::Some(declare_nonce)
-    )
-        .unwrap_err();
+    let declare_result = declare("Mapa", fee_settings, Option::Some(declare_nonce)).unwrap_err();
 
     println!("{:?}", declare_result);
 }

crates/sncast/tests/data/scripts/declare/src/with_invalid_max_fee.cairo

@@ -1,22 +1,17 @@
 use sncast_std::{
-    get_nonce, declare, DeclareResult, ScriptCommandError, ProviderError, StarknetError, FeeSettings
+    get_nonce, declare, DeclareResult, ScriptCommandError, ProviderError, StarknetError,
+    FeeSettingsTrait
 };
 
 fn main() {
+    let fee_settings = FeeSettingsTrait::resource_bounds(1, 1, 1, 1, 1, 1,);
     let declare_nonce = get_nonce('latest');
-    let declare_result = declare(
-        "Mapa",
-        FeeSettings {
-            max_fee: Option::None, max_gas: Option::Some(1), max_gas_unit_price: Option::Some(1)
-        },
-        Option::Some(declare_nonce)
-    )
-        .unwrap_err();
+    let declare_result = declare("Mapa", fee_settings, Option::Some(declare_nonce)).unwrap_err();
     println!("{:?}", declare_result);
 
     assert(
         ScriptCommandError::ProviderError(
-            ProviderError::StarknetError(StarknetError::InsufficientMaxFee)
+            ProviderError::StarknetError(StarknetError::InsufficientResourcesForValidate)
         ) == declare_result,
         'ohno'
     )

crates/sncast/tests/data/scripts/declare/src/with_invalid_nonce.cairo

@@ -1,19 +1,14 @@
 use sncast_std::{
-    get_nonce, declare, DeclareResult, ScriptCommandError, ProviderError, StarknetError, FeeSettings
+    get_nonce, declare, DeclareResult, ScriptCommandError, ProviderError, StarknetError,
+    FeeSettingsTrait
 };
 
 fn main() {
-    let max_fee = 99999999999999999;
-
+    let fee_settings = FeeSettingsTrait::resource_bounds(
+        100000, 10000000000000, 1000000000, 100000000000000000000, 100000, 10000000000000,
+    );
     let declare_nonce = get_nonce('pending') + 100;
-    let declare_result = declare(
-        "Mapa",
-        FeeSettings {
-            max_fee: Option::Some(max_fee), max_gas: Option::None, max_gas_unit_price: Option::None
-        },
-        Option::Some(declare_nonce)
-    )
-        .unwrap_err();
+    let declare_result = declare("Mapa", fee_settings, Option::Some(declare_nonce)).unwrap_err();
     println!("{:?}", declare_result);
 
     assert(

crates/sncast/tests/data/scripts/deploy/src/fee_settings.cairo

@@ -1,24 +1,18 @@
-use sncast_std::{deploy, DeployResult, FeeSettings};
+use sncast_std::{deploy, DeployResult, FeeSettingsTrait};
 use starknet::{ClassHash, Felt252TryIntoClassHash};
 use traits::Into;
 
 fn main() {
+    let fee_settings = FeeSettingsTrait::resource_bounds(
+        100000, 10000000000000, 1000000000, 100000000000000000000, 100000, 10000000000000,
+    );
     let salt = 0x3;
     let class_hash: ClassHash = 0x059426c817fb8103edebdbf1712fa084c6744b2829db9c62d1ea4dce14ee6ded
         .try_into()
         .expect('Invalid class hash value');
 
     let deploy_result = deploy(
-        class_hash,
-        array![0x2, 0x2, 0x0],
-        Option::Some(salt),
-        true,
-        FeeSettings {
-            max_gas: Option::Some(999),
-            max_gas_unit_price: Option::Some(999999999999),
-            max_fee: Option::None
-        },
-        Option::None
+        class_hash, array![0x2, 0x2, 0x0], Option::Some(salt), true, fee_settings, Option::None
     )
         .expect('deploy failed');
 

crates/sncast/tests/data/scripts/deploy/src/invalid_calldata.cairo

@@ -1,11 +1,14 @@
 use sncast_std::{
-    get_nonce, deploy, DeployResult, ScriptCommandError, ProviderError, StarknetError, FeeSettings,
+    get_nonce, deploy, DeployResult, ScriptCommandError, ProviderError, StarknetError,
+    FeeSettingsTrait,
 };
 use starknet::{ClassHash, Felt252TryIntoClassHash};
 use traits::Into;
 
 fn main() {
-    let max_fee = 99999999999999999;
+    let fee_settings = FeeSettingsTrait::resource_bounds(
+        100000, 10000000000000, 1000000000, 100000000000000000000, 100000, 10000000000000,
+    );
     let salt = 0x3;
 
     let class_hash: ClassHash = 0x059426c817fb8103edebdbf1712fa084c6744b2829db9c62d1ea4dce14ee6ded
@@ -14,14 +17,7 @@ fn main() {
 
     let deploy_nonce = get_nonce('pending');
     let deploy_result = deploy(
-        class_hash,
-        array![0x2],
-        Option::Some(salt),
-        true,
-        FeeSettings {
-            max_fee: Option::Some(max_fee), max_gas: Option::None, max_gas_unit_price: Option::None
-        },
-        Option::Some(deploy_nonce)
+        class_hash, array![0x2], Option::Some(salt), true, fee_settings, Option::Some(deploy_nonce)
     )
         .unwrap_err();
 

crates/sncast/tests/data/scripts/deploy/src/invalid_class_hash.cairo

@@ -1,11 +1,14 @@
 use sncast_std::{
-    get_nonce, deploy, DeployResult, ScriptCommandError, ProviderError, StarknetError, FeeSettings,
+    get_nonce, deploy, DeployResult, ScriptCommandError, ProviderError, StarknetError,
+    FeeSettingsTrait,
 };
 use starknet::{ClassHash, Felt252TryIntoClassHash};
 use traits::Into;
 
 fn main() {
-    let max_fee = 99999999999999999;
+    let fee_settings = FeeSettingsTrait::resource_bounds(
+        100000, 10000000000000, 1000000000, 100000000000000000000, 100000, 10000000000000,
+    );
     let salt = 0x3;
 
     let class_hash: ClassHash = 0xdddd.try_into().expect('Invalid class hash value');
@@ -16,9 +19,7 @@ fn main() {
         array![0x2, 0x2, 0x0],
         Option::Some(salt),
         true,
-        FeeSettings {
-            max_fee: Option::Some(max_fee), max_gas: Option::None, max_gas_unit_price: Option::None
-        },
+        fee_settings,
         Option::Some(deploy_nonce)
     )
         .unwrap_err();

crates/sncast/tests/data/scripts/deploy/src/invalid_nonce.cairo

@@ -1,13 +1,15 @@
 use sncast_std::{
-    get_nonce, deploy, DeployResult, ScriptCommandError, ProviderError, StarknetError, FeeSettings,
-    TransactionExecutionErrorData
+    get_nonce, deploy, DeployResult, ScriptCommandError, ProviderError, StarknetError,
+    FeeSettingsTrait, TransactionExecutionErrorData
 };
 
 use starknet::{ClassHash, Felt252TryIntoClassHash};
 use traits::Into;
 
 fn main() {
-    let max_fee = 99999999999999999;
+    let fee_settings = FeeSettingsTrait::resource_bounds(
+        100000, 10000000000000, 1000000000, 100000000000000000000, 100000, 10000000000000,
+    );
     let salt = 0x3;
 
     let class_hash: ClassHash = 0x059426c817fb8103edebdbf1712fa084c6744b2829db9c62d1ea4dce14ee6ded
@@ -20,9 +22,7 @@ fn main() {
         array![0x2, 0x2, 0x0],
         Option::Some(salt),
         true,
-        FeeSettings {
-            max_fee: Option::Some(max_fee), max_gas: Option::None, max_gas_unit_price: Option::None
-        },
+        fee_settings,
         Option::Some(deploy_nonce)
     )
         .unwrap_err();

crates/sncast/tests/data/scripts/deploy/src/same_class_hash_and_salt.cairo

@@ -1,11 +1,14 @@
 use sncast_std::{
-    get_nonce, deploy, DeployResult, ScriptCommandError, ProviderError, StarknetError, FeeSettings,
+    get_nonce, deploy, DeployResult, ScriptCommandError, ProviderError, StarknetError,
+    FeeSettingsTrait,
 };
 use starknet::{ClassHash, Felt252TryIntoClassHash};
 use traits::Into;
 
 fn main() {
-    let max_fee = 99999999999999999;
+    let fee_settings = FeeSettingsTrait::resource_bounds(
+        100000, 10000000000000, 1000000000, 100000000000000000000, 100000, 10000000000000,
+    );
     let salt = 0x34542;
 
     let class_hash: ClassHash = 0x059426c817fb8103edebdbf1712fa084c6744b2829db9c62d1ea4dce14ee6ded
@@ -18,9 +21,7 @@ fn main() {
         array![0x2, 0x2, 0x0],
         Option::Some(salt),
         true,
-        FeeSettings {
-            max_fee: Option::Some(max_fee), max_gas: Option::None, max_gas_unit_price: Option::None
-        },
+        fee_settings,
         Option::Some(deploy_nonce)
     )
         .expect('1st deploy failed');
@@ -35,9 +36,7 @@ fn main() {
         array![0x2, 0x2, 0x0],
         Option::Some(salt),
         true,
-        FeeSettings {
-            max_fee: Option::Some(max_fee), max_gas: Option::None, max_gas_unit_price: Option::None
-        },
+        fee_settings,
         Option::Some(deploy_nonce)
     )
         .unwrap_err();