From c49820cfe6ed4796b695740a56e86a0682df09d7 Mon Sep 17 00:00:00 2001 From: Nando Vieira Date: Thu, 29 Oct 2026 12:42:00 -0700 Subject: [PATCH] Support muxed contract (W) addresses in the CLI. --- cmd/crates/soroban-spec-tools/src/lib.rs | 38 +++++++- .../src/commands/contract/arg_parsing.rs | 14 ++- cmd/soroban-cli/src/log/auth.rs | 44 +++++---- cmd/soroban-cli/src/signer/mod.rs | 95 ++++++++++++++++--- 4 files changed, 153 insertions(+), 38 deletions(-) diff --git a/cmd/crates/soroban-spec-tools/src/lib.rs b/cmd/crates/soroban-spec-tools/src/lib.rs index 64b03da4b4..f9826d6757 100644 --- a/cmd/crates/soroban-spec-tools/src/lib.rs +++ b/cmd/crates/soroban-spec-tools/src/lib.rs @@ -132,7 +132,7 @@ impl Spec { | ScType::String | ScType::Bool => String::new(), ScType::MuxedAddress => { - String::from("Can be public key (G13..), contract ID (C13...), or a muxed account (M13..), or an identity") + String::from("Can be public key (G13..), contract ID (C13...), a muxed account (M13..), a muxed contract (W13..), or an identity") } ScType::Address => String::from( "Can be public key (G13..), a contract ID (C13...) or an identity (alice), ", @@ -2250,6 +2250,42 @@ mod tests { } } + #[test] + fn test_sc_muxed_contract_address_roundtrip() { + let expected_contract = [ + 0x36, 0x3e, 0xaa, 0x38, 0x67, 0x84, 0x1f, 0xba, 0xd0, 0xf4, 0xed, 0x88, 0xc7, 0x79, + 0xe4, 0xfe, 0x66, 0xe5, 0x6a, 0x24, 0x70, 0xdc, 0x98, 0xc0, 0xec, 0x9c, 0x07, 0x3d, + 0x05, 0xc7, 0xb1, 0x03, + ]; + let expected_id = 1_754_924_385_537_090_737_u64; + + let muxed_addr = format!( + "{}", + stellar_strkey::MuxedContract { + contract_id: expected_contract, + id: expected_id, + } + ); + + match sc_address_from_json(&muxed_addr) { + Ok(ScVal::Address(ScAddress::MuxedContract(MuxedContract { + id, + contract_id: ContractId(Hash(contract_id)), + }))) => { + assert_eq!(contract_id, expected_contract); + assert_eq!(id, expected_id); + } + Ok(_) => panic!("Expected ScVal::Address(ScAddress::MuxedContract(_))"), + Err(e) => panic!("Unexpected error parsing MuxedContract address: {e}"), + } + + let address = ScAddress::MuxedContract(MuxedContract { + id: expected_id, + contract_id: ContractId(Hash(expected_contract)), + }); + assert_eq!(sc_address_to_json(&address), Value::String(muxed_addr)); + } + #[test] fn test_u128_conversions() { // Test basic positive value diff --git a/cmd/soroban-cli/src/commands/contract/arg_parsing.rs b/cmd/soroban-cli/src/commands/contract/arg_parsing.rs index 8acbce9d7e..c5e0a47496 100644 --- a/cmd/soroban-cli/src/commands/contract/arg_parsing.rs +++ b/cmd/soroban-cli/src/commands/contract/arg_parsing.rs @@ -69,7 +69,7 @@ pub enum Error { expected: usize, actual: usize, }, - #[error("Unsupported address type '{address}'\n\nSupported formats:\n- Account addresses: G... (starts with G)\n- Contract addresses: C... (starts with C)\n- Muxed accounts: M... (starts with M)\n- Identity names: alice, bob, etc.\n\nReceived: '{address}'")] + #[error("Unsupported address type '{address}'\n\nSupported formats:\n- Account addresses: G... (starts with G)\n- Contract addresses: C... (starts with C)\n- Muxed accounts: M... (starts with M)\n- Muxed contracts: W... (starts with W)\n- Identity names: alice, bob, etc.\n\nReceived: '{address}'")] UnsupportedScAddress { address: String }, #[error("Duplicate map key '{key}' after alias resolution\n\nMultiple input keys resolved to the same address — likely an alias passed alongside its strkey, or two aliases pointing to the same identity.")] DuplicateMapKey { key: String }, @@ -627,7 +627,7 @@ fn get_type_name(type_def: &ScSpecTypeDef) -> String { ScSpecTypeDef::Address => { "address (G... for account, C... for contract, or identity name)".to_string() } - ScSpecTypeDef::MuxedAddress => "muxed address (M... or identity name)".to_string(), + ScSpecTypeDef::MuxedAddress => "muxed address (M... or W... or identity name)".to_string(), ScSpecTypeDef::Void => "void (no value)".to_string(), ScSpecTypeDef::Error => "error".to_string(), ScSpecTypeDef::Timepoint => "timepoint (timestamp)".to_string(), @@ -716,7 +716,7 @@ fn get_context_suggestions(expected_type: &ScSpecTypeDef, received_value: &str) "For addresses, use format: G... (account), C... (contract), or identity name (e.g., alice)".to_string() } ScSpecTypeDef::MuxedAddress => { - "For muxed addresses, use format: M... or identity name".to_string() + "For muxed addresses, use format: M... or W... or identity name".to_string() } ScSpecTypeDef::Vec(_) => { "For arrays, use JSON array format: [\"item1\", \"item2\"] or [{\"key\": \"value\"}]".to_string() @@ -1041,6 +1041,10 @@ mod tests { get_type_name(&ScSpecTypeDef::Address), "address (G... for account, C... for contract, or identity name)" ); + assert_eq!( + get_type_name(&ScSpecTypeDef::MuxedAddress), + "muxed address (M... or W... or identity name)" + ); } #[test] @@ -1213,6 +1217,10 @@ mod tests { let suggestion = get_context_suggestions(&ScSpecTypeDef::Address, "invalid_addr"); assert!(suggestion.contains("G... (account), C... (contract)")); + // Test muxed address type + let suggestion = get_context_suggestions(&ScSpecTypeDef::MuxedAddress, "invalid_addr"); + assert!(suggestion.contains("M... or W... or identity name")); + // Test boolean type let suggestion = get_context_suggestions(&ScSpecTypeDef::Bool, "yes"); assert!(suggestion.contains("'true' or 'false'")); diff --git a/cmd/soroban-cli/src/log/auth.rs b/cmd/soroban-cli/src/log/auth.rs index 199d57ea2f..7ede106096 100644 --- a/cmd/soroban-cli/src/log/auth.rs +++ b/cmd/soroban-cli/src/log/auth.rs @@ -3,10 +3,9 @@ use std::fmt::Write; use soroban_spec_tools::sanitize; use crate::xdr::{ - AccountId, ContractExecutable, ContractIdPreimage, ContractIdPreimageFromAddress, - CreateContractArgs, CreateContractArgsV2, Hash, InvokeContractArgs, PublicKey, ScAddress, - ScVal, SorobanAuthorizationEntry, SorobanAuthorizedFunction, SorobanAuthorizedInvocation, - SorobanCredentials, Uint256, VecM, + ContractExecutable, ContractIdPreimage, ContractIdPreimageFromAddress, CreateContractArgs, + CreateContractArgsV2, Hash, InvokeContractArgs, ScAddress, ScVal, SorobanAuthorizationEntry, + SorobanAuthorizedFunction, SorobanAuthorizedInvocation, SorobanCredentials, Uint256, VecM, }; /// Format a single auth entry for display. @@ -150,23 +149,7 @@ fn format_create_contract( /// Format an ScAddress as a strkey string for display. fn format_address(address: &ScAddress) -> String { - match address { - ScAddress::Account(AccountId(PublicKey::PublicKeyTypeEd25519(Uint256(bytes)))) => { - format!( - "{}", - stellar_strkey::Strkey::PublicKeyEd25519(stellar_strkey::ed25519::PublicKey( - *bytes - )) - ) - } - ScAddress::Contract(stellar_xdr::ContractId(stellar_xdr::Hash(bytes))) => { - format!( - "{}", - stellar_strkey::Strkey::Contract(stellar_strkey::Contract(*bytes)) - ) - } - _ => format!("{address:?}"), - } + address.to_string() } #[cfg(test)] @@ -229,4 +212,23 @@ mod tests { assert_no_control_chars(&format_auth_entry(&entry)); } + + #[test] + fn format_address_renders_muxed_contract_as_strkey() { + let contract = [7u8; 32]; + let id = 42u64; + let address = ScAddress::MuxedContract(stellar_xdr::MuxedContract { + id, + contract_id: stellar_xdr::ContractId(Hash(contract)), + }); + + let expected = format!( + "{}", + stellar_strkey::MuxedContract { + contract_id: contract, + id, + } + ); + assert_eq!(format_address(&address), expected); + } } diff --git a/cmd/soroban-cli/src/signer/mod.rs b/cmd/soroban-cli/src/signer/mod.rs index c63c50666a..f2e458f91d 100644 --- a/cmd/soroban-cli/src/signer/mod.rs +++ b/cmd/soroban-cli/src/signer/mod.rs @@ -29,6 +29,8 @@ pub mod secure_store; pub enum Error { #[error("Contract addresses are not supported to sign auth entries {address}")] ContractAddressAreNotSupported { address: String }, + #[error("Muxed account addresses are not supported to sign auth entries {address}")] + MuxedAccountAddressesAreNotSupported { address: String }, #[error(transparent)] Ed25519(#[from] ed25519_dalek::SignatureError), #[error("Missing signing key for account {address}")] @@ -130,25 +132,22 @@ pub async fn sign_soroban_authorizations( // See if we have a signer for this authorizationEntry // If not, then we Error let auth_address_bytes: &[u8; 32] = match address { - ScAddress::MuxedAccount(_) => todo!("muxed accounts are not supported"), - ScAddress::ClaimableBalance(_) => todo!("claimable balance not supported"), - ScAddress::LiquidityPool(_) => todo!("liquidity pool not supported"), ScAddress::Account(AccountId(PublicKey::PublicKeyTypeEd25519(Uint256(ref a)))) => a, - ScAddress::Contract(stellar_xdr::ContractId(Hash(c))) => { - // This address is for a contract. This means we're using a custom - // smart-contract account. Currently the CLI doesn't support that yet. - return Err(Error::MissingSignerForAddress { - address: format!( - "{}", - stellar_strkey::Strkey::Contract(stellar_strkey::Contract(*c)) - ), + // Contracts (including muxed contracts) authorize via their own + // `__check_auth`, not a CLI keypair, so they can't be signed here. + ScAddress::Contract(_) | ScAddress::MuxedContract(_) => { + return Err(Error::ContractAddressAreNotSupported { + address: address.to_string(), }); } - ScAddress::MuxedContract(_) => { - return Err(Error::MissingSignerForAddress { + // Muxed accounts aren't supported for signing auth entries; reject rather than panic. + ScAddress::MuxedAccount(_) => { + return Err(Error::MuxedAccountAddressesAreNotSupported { address: address.to_string(), }); } + ScAddress::ClaimableBalance(_) => todo!("claimable balance not supported"), + ScAddress::LiquidityPool(_) => todo!("liquidity pool not supported"), }; // Auth entries should not request a signature from the tx source account via the `Address` credential type @@ -535,6 +534,20 @@ mod tests { ScAddress::Account(AccountId(PublicKey::PublicKeyTypeEd25519(Uint256(bytes)))) } + fn muxed_contract_address(contract: [u8; 32], id: u64) -> ScAddress { + ScAddress::MuxedContract(stellar_xdr::MuxedContract { + id, + contract_id: stellar_xdr::ContractId(Hash(contract)), + }) + } + + fn muxed_account_address(ed25519: [u8; 32], id: u64) -> ScAddress { + ScAddress::MuxedAccount(stellar_xdr::MuxedEd25519Account { + id, + ed25519: Uint256(ed25519), + }) + } + fn invoke_args(contract: [u8; 32], fn_name: &str) -> InvokeContractArgs { InvokeContractArgs { contract_address: ScAddress::Contract(stellar_xdr::ContractId(Hash(contract))), @@ -753,6 +766,62 @@ mod tests { assert!(matches!(result, Err(Error::MissingSignerForAddress { .. }))); } + #[tokio::test] + async fn test_muxed_contract_address_is_rejected() { + let signer = local_signer([1u8; 32]); + let source = MuxedAccount::Ed25519(Uint256([9u8; 32])); + let contract = [42u8; 32]; + + let entry = address_auth( + muxed_contract_address(contract, 7), + invocation(contract, "hello"), + ); + let host_fn = HostFunction::InvokeContract(invoke_args(contract, "hello")); + let tx = build_tx(source, host_fn, vec![entry]); + + let result = sign_soroban_authorizations( + &tx, + &[signer], + EXPIRATION_LEDGER, + NETWORK, + false, + &Print::new(true), + ) + .await; + assert!(matches!( + result, + Err(Error::ContractAddressAreNotSupported { .. }) + )); + } + + #[tokio::test] + async fn test_muxed_account_address_is_rejected_without_panicking() { + let signer = local_signer([1u8; 32]); + let source = MuxedAccount::Ed25519(Uint256([9u8; 32])); + let contract = [42u8; 32]; + + let entry = address_auth( + muxed_account_address([5u8; 32], 7), + invocation(contract, "hello"), + ); + let host_fn = HostFunction::InvokeContract(invoke_args(contract, "hello")); + let tx = build_tx(source, host_fn, vec![entry]); + + let result = sign_soroban_authorizations( + &tx, + &[signer], + EXPIRATION_LEDGER, + NETWORK, + false, + &Print::new(true), + ) + .await; + assert!(matches!( + result, + Err(Error::MuxedAccountAddressesAreNotSupported { .. }) + )); + } + #[test] fn ledger_signer_get_public_key_returns_cached_without_device() { const TEST_PUBLIC_KEY: &str = "GAREAZZQWHOCBJS236KIE3AWYBVFLSBK7E5UW3ICI3TCRWQKT5LNLCEZ";