r0gue-io
diff --git a/‎crates/pop-cli/src/assets/index.html
+2-2 b/‎crates/pop-cli/src/assets/index.html
+2-2
diff --git a/‎crates/pop-cli/src/commands/call/contract.rs
+2-2 b/‎crates/pop-cli/src/commands/call/contract.rs
+2-2
diff --git a/‎crates/pop-cli/src/commands/up/rollup.rs
+109-13 b/‎crates/pop-cli/src/commands/up/rollup.rs
+109-13
diff --git a/‎crates/pop-common/src/account_id.rs
+39 b/‎crates/pop-common/src/account_id.rs
+39
diff --git a/‎crates/pop-common/src/errors.rs
+2 b/‎crates/pop-common/src/errors.rs
+2
diff --git a/‎crates/pop-common/src/lib.rs
+3 b/‎crates/pop-common/src/lib.rs
+3
diff --git a/‎crates/pop-contracts/src/call.rs
+2-2 b/‎crates/pop-contracts/src/call.rs
+2-2
diff --git a/‎crates/pop-contracts/src/errors.rs
-2 b/‎crates/pop-contracts/src/errors.rs
-2
diff --git a/‎crates/pop-contracts/src/lib.rs
+1-1 b/‎crates/pop-contracts/src/lib.rs
+1-1
@@ -11,11 +11,11 @@ use crate::{
 use anyhow::{anyhow, Result};
 use clap::Args;
 use cliclack::spinner;
-use pop_common::{DefaultConfig, Keypair};
+use pop_common::{parse_account, DefaultConfig, Keypair};
 use pop_contracts::{
 	build_smart_contract, call_smart_contract, call_smart_contract_from_signed_payload,
 	dry_run_call, dry_run_gas_estimate_call, get_call_payload, get_message, get_messages,
-	parse_account, set_up_call, CallExec, CallOpts, DefaultEnvironment, Verbosity,
+	set_up_call, CallExec, CallOpts, DefaultEnvironment, Verbosity,
 };
 use sp_weights::Weight;
 use std::path::PathBuf;
 
@@ -12,12 +12,18 @@ use crate::{
 };
 use anyhow::{anyhow, Result};
 use clap::Args;
-use pop_parachains::{find_dispatchable_by_name, Action, Payload, Reserved};
+use pop_common::parse_account;
+use pop_parachains::{
+	construct_proxy_extrinsic, find_dispatchable_by_name, Action, Payload, Reserved,
+};
 use std::path::{Path, PathBuf};
 use url::Url;
 
+type Proxy = Option<String>;
+
 const DEFAULT_URL: &str = "wss://paseo.rpc.amforc.com/";
 const HELP_HEADER: &str = "Chain deployment options";
+const PLACEHOLDER_ADDRESS: &str = "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty";
 
 #[derive(Args, Clone, Default)]
 #[clap(next_help_heading = HELP_HEADER)]
@@ -37,6 +43,10 @@ pub struct UpCommand {
 	/// Websocket endpoint of the relay chain.
 	#[arg(long)]
 	pub(crate) relay_chain_url: Option<Url>,
+	/// Proxied address. Your account must be registered as a proxy which can act on behalf of this
+	/// account.
+	#[arg(long = "proxy")]
+	pub(crate) proxied_address: Option<String>,
 }
 
 impl UpCommand {
@@ -69,18 +79,30 @@ impl UpCommand {
 		let chain =
 			configure("Enter the relay chain node URL", DEFAULT_URL, &self.relay_chain_url, cli)
 				.await?;
-		let id = self.resolve_id(&chain, cli).await?;
+		let proxy = self.resolve_proxied_address(cli)?;
+		let id = self.resolve_id(&chain, &proxy, cli).await?;
 		let (genesis_code, genesis_state) = self.resolve_genesis_files(id, cli).await?;
-		Ok(Registration { id, genesis_state, genesis_code, chain })
+		Ok(Registration { id, genesis_state, genesis_code, chain, proxy })
+	}
+
+	// Retrieves the proxied address, prompting the user if none is specified.
+	fn resolve_proxied_address(&self, cli: &mut impl Cli) -> Result<Proxy> {
+		if let Some(addr) = &self.proxied_address {
+			return Ok(parse_account(addr).map(|valid_addr| Some(format!("Id({valid_addr})")))?);
+		}
+		if cli.confirm("Would you like to use a proxy for registration? This is considered a best practice.").interact()? {
+			return Ok(Some(prompt_for_proxy_address(cli)?));
+		}
+		Ok(None)
 	}
 
 	// Resolves the ID, reserving a new one if necessary.
-	async fn resolve_id(&self, chain: &Chain, cli: &mut impl Cli) -> Result<u32> {
+	async fn resolve_id(&self, chain: &Chain, proxy: &Proxy, cli: &mut impl Cli) -> Result<u32> {
 		match self.id {
 			Some(id) => Ok(id),
 			None => {
 				cli.info(format!("You will need to sign a transaction to reserve an ID on {} using the `Registrar::reserve` function.", chain.url))?;
-				reserve(chain, cli).await
+				reserve(chain, proxy, cli).await
 			},
 		}
 	}
@@ -106,6 +128,7 @@ pub(crate) struct Registration {
 	genesis_state: StatePathBuf,
 	genesis_code: CodePathBuf,
 	chain: Chain,
+	proxy: Proxy,
 }
 impl Registration {
 	// Registers by submitting an extrinsic.
@@ -120,7 +143,7 @@ impl Registration {
 
 	// Prepares and returns the encoded call data for registering a chain.
 	fn prepare_register_call_data(&self, cli: &mut impl Cli) -> Result<Vec<u8>> {
-		let Registration { id, genesis_code, genesis_state, chain } = self;
+		let Registration { id, genesis_code, genesis_state, chain, proxy } = self;
 		let dispatchable = find_dispatchable_by_name(
 			&chain.pallets,
 			Action::Register.pallet_name(),
@@ -130,20 +153,23 @@ impl Registration {
 			.map_err(|err| anyhow!("Failed to read genesis state file: {}", err.to_string()))?;
 		let code = std::fs::read_to_string(genesis_code)
 			.map_err(|err| anyhow!("Failed to read genesis code file: {}", err.to_string()))?;
-		let xt = Call {
+		let mut xt = Call {
 			function: dispatchable.clone(),
 			args: vec![id.to_string(), state, code],
 			use_wallet: true,
 			..Default::default()
 		}
 		.prepare_extrinsic(&chain.client, cli)?;
+		if let Some(addr) = proxy {
+			xt = construct_proxy_extrinsic(&chain.pallets, addr.to_string(), xt)?;
+		}
 		Ok(xt.encode_call_data(&chain.client.metadata())?)
 	}
 }
 
 // Reserves an ID by submitting an extrinsic.
-async fn reserve(chain: &Chain, cli: &mut impl Cli) -> Result<u32> {
-	let call_data = prepare_reserve_call_data(chain, cli)?;
+async fn reserve(chain: &Chain, proxy: &Proxy, cli: &mut impl Cli) -> Result<u32> {
+	let call_data = prepare_reserve_call_data(chain, proxy, cli)?;
 	let events = submit_extrinsic(&chain.client, &chain.url, call_data, cli)
 		.await
 		.map_err(|e| anyhow::anyhow!("ID reservation failed: {}", e))?;
@@ -156,14 +182,17 @@ async fn reserve(chain: &Chain, cli: &mut impl Cli) -> Result<u32> {
 }
 
 // Prepares and returns the encoded call data for reserving an ID.
-fn prepare_reserve_call_data(chain: &Chain, cli: &mut impl Cli) -> Result<Vec<u8>> {
+fn prepare_reserve_call_data(chain: &Chain, proxy: &Proxy, cli: &mut impl Cli) -> Result<Vec<u8>> {
 	let dispatchable = find_dispatchable_by_name(
 		&chain.pallets,
 		Action::Reserve.pallet_name(),
 		Action::Reserve.function_name(),
 	)?;
-	let xt = Call { function: dispatchable.clone(), use_wallet: true, ..Default::default() }
+	let mut xt = Call { function: dispatchable.clone(), use_wallet: true, ..Default::default() }
 		.prepare_extrinsic(&chain.client, cli)?;
+	if let Some(addr) = proxy {
+		xt = construct_proxy_extrinsic(&chain.pallets, addr.to_string(), xt)?;
+	}
 	Ok(xt.encode_call_data(&chain.client.metadata())?)
 }
 
@@ -195,6 +224,19 @@ async fn generate_spec_files(
 	))
 }
 
+// Prompt the user to input an address and return it formatted as `Id(address)`
+fn prompt_for_proxy_address(cli: &mut impl Cli) -> Result<String> {
+	let address = cli
+		.input("Enter the account that the proxy will make a call on behalf of")
+		.placeholder(&format!("e.g {}", PLACEHOLDER_ADDRESS))
+		.validate(|input: &String| match parse_account(input) {
+			Ok(_) => Ok(()),
+			Err(_) => Err("Invalid address."),
+		})
+		.interact()?;
+	Ok(format!("Id({address})"))
+}
+
 #[cfg(test)]
 mod tests {
 	use super::*;
@@ -204,6 +246,8 @@ mod tests {
 	use tempfile::tempdir;
 	use url::Url;
 
+	const MOCK_PROXIED_ADDRESS: &str = "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty";
+	const MOCK_PROXY_ADDRESS_ID: &str = "Id(13czcAAt6xgLwZ8k6ZpkrRL5V2pjKEui3v9gHAN9PoxYZDbf)";
 	const POLKADOT_NETWORK_URL: &str = "wss://polkadot-rpc.publicnode.com";
 	const POP_NETWORK_TESTNET_URL: &str = "wss://rpc1.paseo.popnetwork.xyz";
 
@@ -216,6 +260,7 @@ mod tests {
 			id: Some(2000),
 			genesis_state: Some(genesis_state.clone()),
 			genesis_code: Some(genesis_code.clone()),
+			proxied_address: Some(MOCK_PROXIED_ADDRESS.to_string()),
 			..Default::default()
 		}
 		.prepare_for_registration(&mut cli)
@@ -225,6 +270,37 @@ mod tests {
 		assert_eq!(chain_config.genesis_code, genesis_code);
 		assert_eq!(chain_config.genesis_state, genesis_state);
 		assert_eq!(chain_config.chain.url, Url::parse(POLKADOT_NETWORK_URL)?);
+		assert_eq!(chain_config.proxy, Some(format!("Id({})", MOCK_PROXIED_ADDRESS.to_string())));
+		cli.verify()
+	}
+
+	#[test]
+	fn resolve_proxied_address_works() -> Result<()> {
+		let mut cli = MockCli::new()
+			.expect_confirm("Would you like to use a proxy for registration? This is considered a best practice.", true)
+			.expect_input(
+				"Enter the account that the proxy will make a call on behalf of",
+				MOCK_PROXIED_ADDRESS.into(),
+			);
+		let proxied_address = UpCommand::default().resolve_proxied_address(&mut cli)?;
+		assert_eq!(proxied_address, Some(format!("Id({})", MOCK_PROXIED_ADDRESS)));
+		cli.verify()?;
+
+		cli = MockCli::new().expect_confirm(
+			"Would you like to use a proxy for registration? This is considered a best practice.",
+			false,
+		);
+		let proxied_address = UpCommand::default().resolve_proxied_address(&mut cli)?;
+		assert_eq!(proxied_address, None);
+		cli.verify()?;
+
+		cli = MockCli::new();
+		let proxied_address = UpCommand {
+			proxied_address: Some(MOCK_PROXIED_ADDRESS.to_string()),
+			..Default::default()
+		}
+		.resolve_proxied_address(&mut cli)?;
+		assert_eq!(proxied_address, Some(format!("Id({})", MOCK_PROXIED_ADDRESS)));
 		cli.verify()
 	}
 
@@ -238,11 +314,20 @@ mod tests {
 			&mut cli,
 		)
 		.await?;
-		let call_data = prepare_reserve_call_data(&chain, &mut cli)?;
+		let call_data = prepare_reserve_call_data(&chain, &None, &mut cli)?;
 		// Encoded call data for a reserve extrinsic.
 		// Reference: https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Fpolkadot.public.curie.radiumblock.co%2Fws#/extrinsics/decode/0x4605
 		let encoded_reserve_extrinsic: &str = "0x4605";
 		assert_eq!(call_data, decode_call_data(encoded_reserve_extrinsic)?);
+
+		// Ensure `prepare_reserve_call_data` works with a proxy.
+		let call_data =
+			prepare_reserve_call_data(&chain, &Some(MOCK_PROXY_ADDRESS_ID.to_string()), &mut cli)?;
+		// Encoded call data for a proxy extrinsic with reserve as the call.
+		// Reference: https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Fpolkadot.public.curie.radiumblock.co%2Fws#/extrinsics/decode/0x1d000073ebf9c947490b9170ea4fd3031ae039452e428531317f76bf0a02124f8166de004605
+		let encoded_reserve_extrinsic: &str =
+			"0x1d000073ebf9c947490b9170ea4fd3031ae039452e428531317f76bf0a02124f8166de004605";
+		assert_eq!(call_data, decode_call_data(encoded_reserve_extrinsic)?);
 		Ok(())
 	}
 
@@ -259,6 +344,7 @@ mod tests {
 			genesis_code: Some(genesis_code.clone()),
 			relay_chain_url: Some(Url::parse(POP_NETWORK_TESTNET_URL)?),
 			path: None,
+			proxied_address: None,
 		}
 		.execute(&mut cli)
 		.await?;
@@ -279,6 +365,7 @@ mod tests {
 			genesis_code: Some(genesis_code.clone()),
 			relay_chain_url: Some(Url::parse(POP_NETWORK_TESTNET_URL)?),
 			path: None,
+			proxied_address: None,
 		}
 		.execute(&mut cli)
 		.await?;
@@ -300,11 +387,12 @@ mod tests {
 		let temp_dir = tempdir()?;
 		let genesis_state_path = temp_dir.path().join("genesis_state");
 		let genesis_code_path = temp_dir.path().join("genesis_code.wasm");
-		let up_chain = Registration {
+		let mut up_chain = Registration {
 			id: 2000,
 			genesis_state: genesis_state_path.clone(),
 			genesis_code: genesis_code_path.clone(),
 			chain,
+			proxy: None,
 		};
 
 		// Expect failure when the genesis state file cannot be read.
@@ -328,6 +416,14 @@ mod tests {
 			up_chain.prepare_register_call_data(&mut cli)?,
 			decode_call_data(encoded_register_extrinsic)?
 		);
+
+		// Ensure `prepare_register_call_data` works with a proxy.
+		up_chain.proxy = Some(MOCK_PROXY_ADDRESS_ID.to_string());
+		let call_data = up_chain.prepare_register_call_data(&mut cli)?;
+		// Encoded call data for a proxy extrinsic with register as the call.
+		// Reference: https://polkadot.js.org/apps/?rpc=wss%3A%2F%2Fpolkadot.public.curie.radiumblock.co%2Fws#/extrinsics/decode/0x1d000073ebf9c947490b9170ea4fd3031ae039452e428531317f76bf0a02124f8166de004600d0070000081234081234
+		let encoded_reserve_extrinsic: &str = "0x1d000073ebf9c947490b9170ea4fd3031ae039452e428531317f76bf0a02124f8166de004600d0070000081234081234";
+		assert_eq!(call_data, decode_call_data(encoded_reserve_extrinsic)?);
 		Ok(())
 	}
 
 
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-3.0
+
+use crate::{Config, DefaultConfig, Error};
+use std::str::FromStr;
+
+/// Parses an account ID from its string representation.
+///
+/// # Arguments
+/// * `account` - A string representing the account ID to parse.
+pub fn parse_account(account: &str) -> Result<<DefaultConfig as Config>::AccountId, Error> {
+	<DefaultConfig as Config>::AccountId::from_str(account)
+		.map_err(|e| Error::AccountAddressParsing(format!("{}", e)))
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use anyhow::Result;
+
+	#[test]
+	fn parse_account_works() -> Result<(), Error> {
+		let account = parse_account("5CLPm1CeUvJhZ8GCDZCR7nWZ2m3XXe4X5MtAQK69zEjut36A")?;
+		assert_eq!(account.to_string(), "5CLPm1CeUvJhZ8GCDZCR7nWZ2m3XXe4X5MtAQK69zEjut36A");
+		Ok(())
+	}
+
+	#[test]
+	fn parse_account_fails_wrong_value() -> Result<(), Error> {
+		assert!(matches!(
+			parse_account("5CLPm1CeUvJhZ8GCDZCR7"),
+			Err(super::Error::AccountAddressParsing(..))
+		));
+		assert!(matches!(
+			parse_account("wrongaccount"),
+			Err(super::Error::AccountAddressParsing(..))
+		));
+		Ok(())
+	}
+}
@@ -6,6 +6,8 @@ use thiserror::Error;
 /// Represents the various errors that can occur in the crate.
 #[derive(Error, Debug)]
 pub enum Error {
+	#[error("Failed to parse account address: {0}")]
+	AccountAddressParsing(String),
 	#[error("Anyhow error: {0}")]
 	AnyhowError(#[from] anyhow::Error),
 	#[error("Configuration error: {0}")]
 
@@ -2,6 +2,7 @@
 
 use std::net::TcpListener;
 
+pub use account_id::parse_account;
 pub use build::Profile;
 pub use errors::Error;
 pub use git::{Git, GitHub, Release};
@@ -14,6 +15,8 @@ pub use subxt::{Config, PolkadotConfig as DefaultConfig};
 pub use subxt_signer::sr25519::Keypair;
 pub use templates::extractor::extract_template_files;
 
+/// Module for parsing and handling account IDs.
+pub mod account_id;
 pub mod build;
 pub mod errors;
 pub mod git;
 
@@ -6,7 +6,7 @@ use crate::{
 	utils::{
 		get_manifest_path,
 		metadata::{process_function_args, FunctionType},
-		parse_account, parse_balance,
+		parse_balance,
 	},
 };
 use anyhow::Context;
@@ -16,7 +16,7 @@ use contract_extrinsics::{
 	DisplayEvents, ErrorVariant, ExtrinsicOptsBuilder, TokenMetadata,
 };
 use ink_env::{DefaultEnvironment, Environment};
-use pop_common::{create_signer, Config, DefaultConfig, Keypair};
+use pop_common::{create_signer, parse_account, Config, DefaultConfig, Keypair};
 use sp_weights::Weight;
 use std::path::PathBuf;
 use subxt::{tx::Payload, SubstrateConfig};
 
@@ -7,8 +7,6 @@ use thiserror::Error;
 #[derive(Error, Debug)]
 #[allow(clippy::enum_variant_names)]
 pub enum Error {
-	#[error("Failed to parse account address: {0}")]
-	AccountAddressParsing(String),
 	#[error("Anyhow error: {0}")]
 	AnyhowError(#[from] anyhow::Error),
 	#[error("Failed to parse balance: {0}")]
 
@@ -30,7 +30,7 @@ pub use up::{
 };
 pub use utils::{
 	metadata::{get_message, get_messages, ContractFunction},
-	parse_account, parse_hex_bytes,
+	parse_hex_bytes,
 };
 // External exports
 pub use contract_extrinsics::CallExec;