1336 set proper nonce (#1500)

<!-- Reference any GitHub issues resolved by this PR -->

Closes #

## Introduced changes

Change the way of getting nonce. Instead of obtaining it from the latest
block, it gets it from the pending.
map_script test from `crates/sncast/tests/e2e/script/general.rs` cover
this changes
## Checklist

<!-- Make sure all of these are complete -->

- [x] Linked relevant issue
- [x] Updated relevant documentation
- [x] Added relevant tests
- [x] Performed self-review of the code
- [x] Added changes to `CHANGELOG.md`

---------

Co-authored-by: Wojciech Szymczyk <[email protected]>

Author: tkumor3

CHANGELOG.md

@@ -22,6 +22,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Error message for tests that should panic but pass
 
+### Cast
+
+#### Changed
+
+- the 'pending' block is used instead of 'latest' as the default when obtaining the nonce
+
 ## [0.14.0] - 2024-01-11
 
 ### Forge

crates/sncast/src/lib.rs

@@ -168,12 +168,13 @@ pub async fn get_account<'a>(
     keystore: Option<Utf8PathBuf>,
 ) -> Result<SingleOwnerAccount<&'a JsonRpcClient<HttpTransport>, LocalWallet>> {
     let chain_id = get_chain_id(provider).await?;
-    let account = if let Some(keystore) = keystore {
+    let mut account = if let Some(keystore) = keystore {
         get_account_from_keystore(provider, chain_id, &keystore, account)?
     } else {
         get_account_from_accounts_file(account, accounts_file, provider, chain_id)?
     };
-    Ok(account)
+
+    Ok(account.set_block_id(get_block_id("pending")?).clone())
 }
 
 fn get_account_from_keystore<'a>(

crates/sncast/src/starknet_commands/declare.rs

@@ -2,13 +2,15 @@ use anyhow::{anyhow, Context, Result};
 use camino::Utf8PathBuf;
 use clap::Args;
 use scarb_api::{get_contracts_map, ScarbCommand};
+
 use sncast::helpers::scarb_utils::get_package_metadata;
 use sncast::helpers::scarb_utils::get_scarb_manifest;
 use sncast::response::structs::DeclareResponse;
 use sncast::response::structs::Hex;
 use sncast::{apply_optional, handle_rpc_error, handle_wait_for_tx, WaitForTx};
 use starknet::accounts::AccountError::Provider;
 use starknet::accounts::{ConnectedAccount, Declaration};
+
 use starknet::core::types::FieldElement;
 use starknet::{
     accounts::{Account, SingleOwnerAccount},
@@ -83,10 +85,10 @@ pub async fn declare(
     let casm_class_hash = casm_contract_definition.class_hash()?;
 
     let declaration = account.declare(Arc::new(contract_definition.flatten()?), casm_class_hash);
+
     let declaration = apply_optional(declaration, max_fee, Declaration::max_fee);
     let declaration = apply_optional(declaration, nonce, Declaration::nonce);
     let declared = declaration.send().await;
-
     match declared {
         Ok(result) => {
             handle_wait_for_tx(

crates/sncast/src/starknet_commands/deploy.rs

@@ -53,22 +53,21 @@ pub async fn deploy(
     wait_config: WaitForTx,
 ) -> Result<DeployResponse> {
     let salt = extract_or_generate_salt(salt);
-
     let factory = ContractFactory::new(class_hash, account);
-    let deployment = factory.deploy(constructor_calldata.clone(), salt, unique);
+    let execution = factory.deploy(constructor_calldata.clone(), salt, unique);
 
     // TODO(#1396): use apply_optional here when `Deployment` in starknet-rs is public
     //  otherwise we cannot pass the necessary reference to a function
-    let execution_with_fee = if let Some(max_fee) = max_fee {
-        deployment.max_fee(max_fee)
+    let execution = if let Some(max_fee) = max_fee {
+        execution.max_fee(max_fee)
     } else {
-        deployment
+        execution
     };
 
     let execution = if let Some(nonce) = nonce {
-        execution_with_fee.nonce(nonce)
+        execution.nonce(nonce)
     } else {
-        execution_with_fee
+        execution
     };
 
     let result = execution.send().await;

crates/sncast/tests/data/accounts/user1_representation

@@ -1 +1 @@
-SingleOwnerAccount { provider: JsonRpcClient { transport: HttpTransport { client: Client { accepts: Accepts, proxies: [Proxy(System({}), None)], referer: true, default_headers: {"accept": "*/*"} }, url: Url { scheme: "http", cannot_be_a_base: false, username: "", password: None, host: Some(Ipv4(127.0.0.1)), port: Some(5055), path: "/rpc", query: None, fragment: None } } }, signer: LocalWallet { private_key: SigningKey { secret_scalar: FieldElement { inner: 0x00000000000000000000000000000000ffd33878eed7767e7c546ce3fc026295 } } }, address: FieldElement { inner: 0x00f6ecd22832b7c3713cfa7826ee309ce96a2769833f093795fafa1b8f20c48b }, chain_id: FieldElement { inner: 0x0000000000000000000000000000000000000000000000534e5f474f45524c49 }, block_id: Tag(Latest), encoding: Legacy }
+SingleOwnerAccount { provider: JsonRpcClient { transport: HttpTransport { client: Client { accepts: Accepts, proxies: [Proxy(System({}), None)], referer: true, default_headers: {"accept": "*/*"} }, url: Url { scheme: "http", cannot_be_a_base: false, username: "", password: None, host: Some(Ipv4(127.0.0.1)), port: Some(5055), path: "/rpc", query: None, fragment: None } } }, signer: LocalWallet { private_key: SigningKey { secret_scalar: FieldElement { inner: 0x00000000000000000000000000000000ffd33878eed7767e7c546ce3fc026295 } } }, address: FieldElement { inner: 0x00f6ecd22832b7c3713cfa7826ee309ce96a2769833f093795fafa1b8f20c48b }, chain_id: FieldElement { inner: 0x0000000000000000000000000000000000000000000000534e5f474f45524c49 }, block_id: Tag(Pending), encoding: Legacy }

crates/sncast/tests/data/scripts/map_script/scripts/src/map_script.cairo

@@ -31,7 +31,7 @@ fn main() {
     let declare_result = declare('Mapa', Option::Some(max_fee), Option::Some(declare_nonce));
 
     let class_hash = declare_result.class_hash;
-    let deploy_nonce = get_nonce('latest');
+    let deploy_nonce = get_nonce('pending');
     let deploy_result = deploy(
         class_hash,
         ArrayTrait::new(),

crates/sncast/tests/integration/wait_for_tx.rs

@@ -47,7 +47,6 @@ async fn test_rejected_transaction() {
         .deploy(Vec::new(), FieldElement::ONE, false)
         .max_fee(FieldElement::ONE);
     let resp = deployment.send().await.unwrap_err();
-    dbg!(&resp);
 
     assert!(resp.to_string().contains("InsufficientMaxFee"));
 }

docs/src/starknet/script.md

@@ -13,6 +13,19 @@ have a `main` function in the module you want to run. `cast_std` docs can be fou
 Please note that **`sncast script` is in development**. While it is already possible to declare, deploy, invoke and call
 contracts from within Cairo, its interface, internals and feature set can change rapidly each version.
 
+> ⚠️⚠️ By default, the nonce for each transaction is being taken from the pending block ⚠️⚠️
+>
+> Some RPC nodes can be configured with higher poll itervals, which means they may return "older" nonces
+> in pending blocks, or even not be able to obtain pending blocks at all. When running a script you get an error like
+> "Invalid transaction nonce", this might be the case and you may need to manually set both nonce and max_fee for
+> transactions.
+>
+> Example:
+>
+>```cairo
+>  let declare_result = declare('Map', Option::Some(max_fee), Option::Some(nonce));
+>```
+
 Some of the planned features that will be included in future versions are:
 
 - scripts idempotency