clean up

config.toml

@@ -4,4 +4,4 @@ registry = "registry.json"
 [payment_info]
 rpc_url = "wss://rpc.ibp.network/polkadot"
 receiver = "126X27SbhrV19mBFawys3ovkyBS87SGfYwtwa8J2FjHrtbmA"
-cost = 100
+cost = "100"

registry.json

@@ -4,11 +4,5 @@
     "rpc_url": "wss://acala-rpc.dwellir.com",
     "para_id": 2000,
     "relay_chain": "Polkadot"
-  },
-  {
-    "name": "Acala",
-    "rpc_url": "wss://acala-rpc.dwellir.com",
-    "para_id": 2005,
-    "relay_chain": "Polkadot"
   }
 ]

routes/src/lib.rs

@@ -41,6 +41,8 @@ pub enum Error {
 	PaymentRequired,
 	/// Failed to validate they payment.
 	PaymentValidationFailed,
+	/// The payment was not found in the specified block.
+	PaymentNotFound,
 }
 
 impl<'r> Responder<'r, 'static> for Error {
@@ -61,6 +63,7 @@ impl From<String> for Error {
 			"ConsumptionDataNotFound" => Self::ConsumptionDataNotFound,
 			"InvalidData" => Self::InvalidData,
 			"PaymentValidationFailed" => Self::PaymentValidationFailed,
+			"PaymentNotFound" => Self::PaymentNotFound,
 			_ => panic!("UnknownError"),
 		}
 	}

routes/src/register.rs

@@ -63,6 +63,12 @@ pub struct RegistrationData {
 pub async fn register_para(registration_data: Json<RegistrationData>) -> Result<(), Error> {
 	let para = registration_data.para.clone();
 
+	log::info!(
+		target: LOG_TARGET,
+		"Attempting to register para: {}:{}",
+		para.relay_chain, para.para_id
+	);
+
 	let mut paras = registered_paras();
 
 	if registered_para(para.relay_chain.clone(), para.para_id).is_some() {
@@ -108,53 +114,60 @@ async fn validate_registration_payment(
 	payment_info: PaymentInfo,
 	receipt: Receipt,
 ) -> Result<(), Error> {
-	if let Ok(rpc_client) = RpcClient::from_url(&payment_info.rpc_url.clone()).await {
-		let params = rpc_params![Some(receipt.block_number)];
-		// TODO: ensure that the specified block is finalized.
-		let block_hash: H256 = rpc_client.request("chain_getBlockHash", params).await.unwrap();
-
-		let api = OnlineClient::<PolkadotConfig>::from_url(payment_info.rpc_url.clone())
-			.await
-			.unwrap();
-		let block = api.blocks().at(block_hash).await.unwrap();
-
-		let payment = opaque_payment_extrinsic(para, payment_info).await?;
-
-		let extrinsics = block.extrinsics().await.unwrap();
-		let extrinsics: Vec<Vec<u8>> = extrinsics
-			.iter()
-			.filter_map(|ext| {
-				ext.as_ref().ok().and_then(|e| e.as_root_extrinsic::<polkadot::Call>().ok())
-			})
-			.map(|ext| ext.encode())
-			.collect();
-
-		if extrinsics.contains(&payment.encode()) {
-			// Green light
-		} else {
-			// Red light
-		}
-
+	let rpc_client = RpcClient::from_url(&payment_info.rpc_url.clone())
+		.await
+		.map_err(|_| Error::PaymentValidationFailed)?;
+
+	let params = rpc_params![Some(receipt.block_number)];
+	// TODO: ensure that the specified block is finalized.
+	let block_hash: H256 = rpc_client.request("chain_getBlockHash", params).await.unwrap();
+
+	let api = OnlineClient::<PolkadotConfig>::from_url(payment_info.rpc_url.clone())
+		.await
+		.map_err(|_| Error::PaymentValidationFailed)?;
+
+	let block = api.blocks().at(block_hash).await.map_err(|_| Error::PaymentValidationFailed)?;
+	let payment = opaque_payment_extrinsic(para, payment_info).await?;
+
+	let extrinsics = block.extrinsics().await.unwrap();
+	let extrinsics: Vec<Vec<u8>> = extrinsics
+		.iter()
+		.filter_map(|ext| {
+			ext.as_ref().ok().and_then(|e| e.as_root_extrinsic::<polkadot::Call>().ok())
+		})
+		.map(|ext| ext.encode())
+		.collect();
+
+	if extrinsics.contains(&payment.encode()) {
 		Ok(())
 	} else {
-		Err(Error::PaymentValidationFailed)
+		Err(Error::PaymentNotFound)
 	}
 }
 
 async fn opaque_payment_extrinsic(
 	para: Parachain,
 	payment_info: PaymentInfo,
 ) -> Result<polkadot::Call, Error> {
-	let transfer_call = polkadot::Call::Balances(BalancesCall::transfer_keep_alive {
-		dest: payment_info.receiver.into(),
-		value: payment_info.cost as u128,
-	});
+	if let Ok(cost) = payment_info.cost.parse::<u128>() {
+		let transfer_call = polkadot::Call::Balances(BalancesCall::transfer_keep_alive {
+			dest: payment_info.receiver.into(),
+			value: cost,
+		});
 
-	let remark = format!("{}:{}", para.relay_chain, para.para_id).as_bytes().to_vec();
-	let remark_call = polkadot::Call::System(SystemCall::remark { remark });
+		let remark = format!("{}:{}", para.relay_chain, para.para_id).as_bytes().to_vec();
+		let remark_call = polkadot::Call::System(SystemCall::remark { remark });
 
-	let batch_call =
-		polkadot::Call::Utility(UtilityCall::batch_all { calls: vec![transfer_call, remark_call] });
+		let batch_call = polkadot::Call::Utility(UtilityCall::batch_all {
+			calls: vec![transfer_call, remark_call],
+		});
 
-	Ok(batch_call)
+		Ok(batch_call)
+	} else {
+		log::error!(
+			target: LOG_TARGET,
+			"Failed to parse cost",
+		);
+		Err(Error::PaymentValidationFailed)
+	}
 }

shared/Cargo.toml

@@ -11,7 +11,7 @@ license.workspace = true
 [dependencies]
 csv = "1.3.0"
 log = "0.4"
-toml = "0.5.8"
+toml = "0.8.8"
 serde = "1.0.193"
 serde_json = "1.0.108"
 subxt = "0.32.1"

shared/src/config.rs

@@ -14,7 +14,6 @@
 // along with RegionX.  If not, see <https://www.gnu.org/licenses/>.
 
 use subxt::utils::AccountId32;
-use types::Balance;
 
 const CONFIG_FILE: &str = "config.toml";
 
@@ -25,7 +24,9 @@ pub struct PaymentInfo {
 	/// The account that the payment should be sent to.
 	pub receiver: AccountId32,
 	/// The cost of the payment.
-	pub cost: u64,
+	//
+	// Defined as a `String` since the `toml` crate has issues parsing `u128`.
+	pub cost: String,
 }
 
 #[derive(serde::Deserialize)]