Accounts Refactor PR 2: Adding address_override param to tx

crates/full-node/sov-api-spec/openapi-v3.yaml

@@ -1218,6 +1218,10 @@ components:
           type: object
           description: Optional uniqueness data for the transaction
           additionalProperties: true
+        address_override:
+          type: string
+          nullable: true
+          description: Optional address override for execution; null uses default routing
       required:
         - sender
         - call

crates/full-node/sov-ethereum/tests/integration/evm/evm_account_abstraction.rs

@@ -67,6 +67,7 @@ fn create_insert_credentials(
             max_fee,
             UniquenessData::Nonce(nonce),
             gas_limit,
+            None,
         ),
     )
 }

crates/full-node/sov-rollup-apis/src/endpoints/simulate.rs

@@ -304,23 +304,34 @@ impl<S: Spec, R: Runtime<S>> SovereignSimulate<S, R> {
         &self,
         params: &SimulateParameters,
         state: &mut StateCheckpoint<S>,
-    ) -> AuthorizationData<S> {
-        let credential_id = CredentialId::from_str(&params.sender).unwrap();
+    ) -> Result<AuthorizationData<S>, SimulateError> {
+        let credential_id = CredentialId::from_str(&params.sender).map_err(|e| {
+            SimulateError::InvalidInput(format!("failed to parse sender credential id: {e:?}"))
+        })?;
+        let address_override = params
+            .address_override
+            .as_deref()
+            .map(S::Address::from_str)
+            .transpose()
+            .map_err(|e| {
+                SimulateError::InvalidInput(format!("failed to parse address override: {e:?}"))
+            })?;
         let uniqueness = params.uniqueness.unwrap_or_else(|| {
             let generation = Uniqueness::<S>::default()
                 .next_generation(&credential_id, state)
                 .unwrap();
             UniquenessData::Generation(generation)
         });
 
-        AuthorizationData {
+        Ok(AuthorizationData {
             tx_hash: NULL_TX_HASH,
             non_malleable_hash: NULL_TX_HASH,
             uniqueness,
             credential_id,
             default_address: credential_id.into(),
             credentials: Credentials::new(credential_id),
-        }
+            address_override,
+        })
     }
 
     fn outcome(&self, result: ApplyTxResult<S>) -> SimulateOutcome<R::RuntimeEvent> {
@@ -402,6 +413,8 @@ pub struct SimulateParameters {
     /// Optional uniqueness data for the transaction.
     /// If not provided a valid uniqueness will be used.
     pub uniqueness: Option<UniquenessData>,
+    /// Optional address override for execution; null uses default routing.
+    pub address_override: Option<String>,
 }
 
 impl<S: Spec, R: Runtime<S>> SimulateEndpoint for SovereignSimulate<S, R> {
@@ -427,7 +440,7 @@ impl<S: Spec, R: Runtime<S>> SimulateEndpoint for SovereignSimulate<S, R> {
             .chain_state()
             .base_fee_per_gas(&mut accessor)
             .ok_or(SimulateError::GasPriceRetrieval)?;
-        let auth_data = state.authorization_data(&params, &mut accessor);
+        let auth_data = state.authorization_data(&params, &mut accessor)?;
         let sequencer = state.sequencer(params.sequencer.unwrap_or_default())?;
         let auth_tx_data =
             AuthenticatedTransactionData(state.tx_details(params.tx_details.unwrap_or_default())?);

crates/full-node/sov-rollup-apis/tests/integration/rest_api.rs

@@ -1,10 +1,15 @@
 use sov_api_spec::types;
 use sov_bank::{config_gas_token_id, Bank};
 use sov_modules_api::prelude::tokio::{self};
-use sov_modules_api::{Amount, Gas, GasArray, GasSpec, Spec};
+use sov_modules_api::sov_universal_wallet::schema::RollupRoots;
+use sov_modules_api::{
+    get_runtime_schema, Amount, CredentialId, Gas, GasArray, GasSpec, Runtime, Spec,
+};
 use sov_rest_utils::json_obj;
 use sov_rollup_interface::node::SyncStatus;
-use sov_test_utils::{AsUser, TestUser, TransactionTestCase};
+use sov_test_utils::{
+    default_test_tx_details, AsUser, TestUser, TransactionTestCase, TransactionType,
+};
 
 use crate::{TestData, RT, S};
 
@@ -167,6 +172,90 @@ async fn test_simulation_success() {
     );
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn test_simulation_success_with_address_override() {
+    let mut data = TestData::setup().await;
+    let delegated_credential: CredentialId = [9u8; 32].into();
+    let registration_call = json_obj!({
+        "accounts": {
+            "insert_credential_id": delegated_credential,
+        },
+    });
+    let schema = get_runtime_schema::<S, RT>().unwrap();
+    let registration_call_bytes = schema
+        .json_to_borsh(
+            schema
+                .rollup_expected_index(RollupRoots::RuntimeCall)
+                .unwrap(),
+            &serde_json::to_string(&registration_call).unwrap(),
+        )
+        .unwrap();
+
+    data.runner.execute_transaction(TransactionTestCase {
+        input: TransactionType::Plain {
+            message: RT::decode_call(&registration_call_bytes).unwrap(),
+            key: data.user.private_key().clone(),
+            details: default_test_tx_details::<S>(),
+        },
+        assert: Box::new(move |result, _state| {
+            assert!(
+                result.tx_receipt.is_successful(),
+                "The credential registration should have succeeded"
+            );
+        }),
+    });
+    data.send_storage();
+
+    let address_override = data.user.address();
+    let receiver = TestUser::<S>::generate_with_default_balance().address();
+    let call = sov_bank::CallMessage::<S>::Transfer {
+        to: receiver,
+        coins: sov_bank::Coins {
+            amount: Amount::new(1000),
+            token_id: config_gas_token_id(),
+        },
+    };
+    let params = json_obj!({
+        "sender": delegated_credential.to_string(),
+        "address_override": address_override.to_string(),
+        "call": {
+            "bank": call,
+        },
+    });
+    let client = reqwest::Client::new();
+
+    let response = client
+        .post(format!("http://{}/rollup/simulate", data.axum_addr))
+        .json(&params)
+        .send()
+        .await
+        .unwrap();
+    let actual = response.json::<serde_json::Value>().await.unwrap();
+
+    assert_eq!(actual["outcome"], "success");
+    assert_eq!(
+        actual["events"][0],
+        serde_json::json!({
+            "key": "Bank/TokenTransferred",
+            "module": "Bank",
+            "value": {
+                "token_transferred": {
+                    "from": {
+                        "user": address_override
+                    },
+                    "to": {
+                        "user": receiver
+                    },
+                    "coins": {
+                        "amount": "1000",
+                        "token_id": "token_1nyl0e0yweragfsatygt24zmd8jrr2vqtvdfptzjhxkguz2xxx3vs0y07u7"
+                    }
+                }
+            }
+        })
+    );
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn test_simulation_fail() {
     let data = TestData::setup().await;

crates/full-node/sov-sequencer/tests/integration/uniqueness.rs

@@ -99,7 +99,7 @@ async fn test_mixed_nonce_and_generation_transactions() {
 
     let construct_tx = |uniqueness: UniquenessData| {
         let unsigned_tx =
-            UnsignedTransactionV0::new_with_details(msg.clone(), uniqueness, details.clone());
+            UnsignedTransactionV0::new_with_details(msg.clone(), uniqueness, details.clone(), None);
         Transaction::<RT, TestSpec>::new_signed_tx(
             &test_user.private_key,
             &RT::CHAIN_HASH,

crates/module-system/hyperlane/tests/integration/with_agent/helpers/mod.rs

@@ -215,9 +215,10 @@ impl HyperlaneBuilder {
         let docker_image = env::var("CUSTOM_HLP_DOCKER_IMAGE");
         let has_custom_image = !matches!(docker_image, Err(env::VarError::NotPresent));
 
-        // Current image is based on https://github.com/Sovereign-Labs/hyperlane-monorepo/tree/sovereign-lander-integration
-        let docker_image = docker_image
-            .unwrap_or_else(|_| "ghcr.io/theodorebugnet/hyperlane-agent:multisig_upgrade".into());
+        // Current image is based on https://github.com/Sovereign-Labs/hyperlane-monorepo/tree/sovereign-lander-integration-for-multisig
+        let docker_image = docker_image.unwrap_or_else(|_| {
+            "ghcr.io/citizen-stig/hyperlane-agent:multisig-upgrade-address-override-2".into()
+        });
         let (name, tag) = docker_image
             .split_once(':')
             .unwrap_or((&docker_image, "latest"));

crates/module-system/module-implementations/integration-tests/tests/stf_blueprint/mod.rs

@@ -19,7 +19,7 @@ use sov_test_utils::runtime::{config_gas_token_id, Payable, TestRunner};
 
 type S = sov_test_utils::TestSpec;
 
-use sov_modules_api::transaction::{Transaction, TxDetails, UnsignedTransactionV0};
+use sov_modules_api::transaction::{Transaction, TxDetails, UnsignedTransactionV0, Version0};
 use sov_modules_api::{PrivateKey, RawTx};
 use sov_test_utils::{EncodeCall, TestUser, TEST_DEFAULT_MAX_FEE};
 use sov_value_setter::ValueSetter;
@@ -243,6 +243,7 @@ pub fn create_tx_bad_sig<RT: Runtime<S>>(
         TEST_DEFAULT_MAX_FEE,
         UniquenessData::Nonce(nonce),
         None,
+        None,
     );
 
     let signed_tx = Transaction::<RT, S>::new_signed_tx(&signer.private_key, &RT::CHAIN_HASH, utx);
@@ -251,18 +252,19 @@ pub fn create_tx_bad_sig<RT: Runtime<S>>(
     let bad_signature = signer.private_key.sign(&[1, 2, 3]);
 
     match signed_tx {
-        Transaction::V0(inner) => Transaction::new_with_details_v0(
-            inner.pub_key,
-            inner.runtime_call,
-            bad_signature,
-            inner.uniqueness,
-            TxDetails {
+        Transaction::V0(inner) => Transaction::V0(Version0 {
+            signature: bad_signature,
+            pub_key: inner.pub_key,
+            runtime_call: inner.runtime_call,
+            uniqueness: inner.uniqueness,
+            details: TxDetails {
                 max_priority_fee_bips,
                 max_fee: Amount::new(200_000),
                 gas_limit: None,
                 chain_id,
             },
-        ),
+            address_override: inner.address_override,
+        }),
         Transaction::V1(_inner) => {
             todo!("Bad signature generation for multisig transactions is not yet supported");
         }
@@ -283,6 +285,7 @@ pub fn create_tx_bad_sender<RT: Runtime<S>>(
         Amount::new(200_000),
         UniquenessData::Nonce(nonce),
         None,
+        None,
     );
 
     let signer = TestUser::<S>::generate(Amount::ZERO);
@@ -303,6 +306,7 @@ pub fn create_tx_valid<RT: Runtime<S>>(
         TEST_DEFAULT_MAX_FEE,
         UniquenessData::Generation(generation),
         None,
+        None,
     );
 
     Transaction::<RT, S>::new_signed_tx(signer.private_key(), &RT::CHAIN_HASH, utx)
@@ -323,6 +327,7 @@ pub fn create_tx_out_of_gas<RT: Runtime<S>>(
         Amount::new(200_000),
         UniquenessData::Nonce(nonce),
         Some(<<S as Spec>::Gas as Gas>::zero()),
+        None,
     );
 
     Transaction::<RT, S>::new_signed_tx(signer.private_key(), &RT::CHAIN_HASH, utx)