replace the single Transfer struct with 4 distinct ones

crates/core/src/token.rs

@@ -13,10 +13,8 @@ use namada_migrations::*;
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
-use crate::address::Address;
 use crate::arith::{self, checked, CheckedAdd, CheckedSub};
 use crate::dec::{Dec, POS_DECIMAL_PRECISION};
-use crate::hash::Hash;
 use crate::ibc::apps::transfer::types::Amount as IbcAmount;
 use crate::storage;
 use crate::storage::{DbKeySeg, KeySeg};
@@ -950,34 +948,6 @@ impl From<DenominatedAmount> for IbcAmount {
  }
 }
 
-/// A simple bilateral token transfer
-#[derive(
- Debug,
- Clone,
- PartialEq,
- BorshSerialize,
- BorshDeserialize,
- BorshDeserializer,
- BorshSchema,
- Hash,
- Eq,
- PartialOrd,
- Serialize,
- Deserialize,
-)]
-pub struct Transfer {
- /// Source address will spend the tokens
- pub source: Address,
- /// Target address will receive the tokens
- pub target: Address,
- /// Token's address
- pub token: Address,
- /// The amount of tokens
- pub amount: DenominatedAmount,
- /// Shielded transaction part
- pub shielded: Option<Hash>,
-}
-
 #[allow(missing_docs)]
 #[derive(Error, Debug)]
 pub enum AmountError {
@@ -994,9 +964,6 @@ pub mod testing {
  use proptest::prelude::*;
 
  use super::*;
- use crate::address::testing::{
- arb_established_address, arb_non_internal_address,
- };
 
  impl std::ops::Add for Amount {
  type Output = Self;
@@ -1078,24 +1045,6 @@ pub mod testing {
  }
  }
 
- prop_compose! {
- /// Generate a transfer
- pub fn arb_transfer()(
- source in arb_non_internal_address(),
- target in arb_non_internal_address(),
- token in arb_established_address().prop_map(Address::Established),
- amount in arb_denominated_amount(),
- ) -> Transfer {
- Transfer {
- source,
- target,
- token,
- amount,
- shielded: None,
- }
- }
- }
-
  /// Generate an arbitrary token amount
  pub fn arb_amount() -> impl Strategy<Value = Amount> {
  any::<u64>().prop_map(|val| Amount::from_uint(val, 0).unwrap())

crates/token/Cargo.toml

@@ -15,14 +15,21 @@ version.workspace = true
 [features]
 default = []
 multicore = ["namada_shielded_token/multicore"]
-testing = ["namada_core/testing"]
+testing = ["namada_core/testing", "proptest"]
 
 [dependencies]
 namada_core = { path = "../core" }
 namada_events = { path = "../events", default-features = false }
+namada_macros = { path = "../macros" }
 namada_shielded_token = { path = "../shielded_token" }
 namada_storage = { path = "../storage" }
 namada_trans_token = { path = "../trans_token" }
 
+borsh.workspace = true
+proptest = { workspace = true, optional = true }
+serde.workspace = true
+
 [dev-dependencies]
 namada_core = { path = "../core", features = ["testing"] }
+
+proptest.workspace = true

crates/token/src/lib.rs

@@ -18,8 +18,12 @@
  clippy::print_stderr
 )]
 
+use namada_core::borsh::{BorshDeserialize, BorshSchema, BorshSerialize};
+use namada_core::hash::Hash;
+use namada_macros::BorshDeserializer;
 pub use namada_shielded_token::*;
 pub use namada_trans_token::*;
+use serde::{Deserialize, Serialize};
 
 /// Token storage keys
 pub mod storage_key {
@@ -28,8 +32,6 @@ pub mod storage_key {
 }
 
 use namada_core::address::Address;
-#[cfg(any(test, feature = "testing"))]
-pub use namada_core::token::testing;
 use namada_events::EmitEvents;
 use namada_storage::{Result, StorageRead, StorageWrite};
 
@@ -64,3 +66,134 @@ where
  }
  Ok(())
 }
+
+/// Arguments for a transparent token transfer
+#[derive(
+ Debug,
+ Clone,
+ PartialEq,
+ BorshSerialize,
+ BorshDeserialize,
+ BorshDeserializer,
+ BorshSchema,
+ Hash,
+ Eq,
+ PartialOrd,
+ Serialize,
+ Deserialize,
+)]
+pub struct TransparentTransfer {
+ /// Source address will spend the tokens
+ pub source: Address,
+ /// Target address will receive the tokens
+ pub target: Address,
+ /// Token's address
+ pub token: Address,
+ /// The amount of tokens
+ pub amount: DenominatedAmount,
+}
+
+/// Arguments for a shielded token transfer
+#[derive(
+ Debug,
+ Clone,
+ PartialEq,
+ BorshSerialize,
+ BorshDeserialize,
+ BorshDeserializer,
+ BorshSchema,
+ Hash,
+ Eq,
+ PartialOrd,
+ Serialize,
+ Deserialize,
+)]
+pub struct ShieldedTransfer {
+ /// Hash of tx section that contains the MASP transaction
+ pub section_hash: Hash,
+}
+
+/// Arguments for a shielding transfer (from a transparent token to a shielded
+/// token)
+#[derive(
+ Debug,
+ Clone,
+ PartialEq,
+ BorshSerialize,
+ BorshDeserialize,
+ BorshDeserializer,
+ BorshSchema,
+ Hash,
+ Eq,
+ PartialOrd,
+ Serialize,
+ Deserialize,
+)]
+pub struct ShieldingTransfer {
+ /// Source address will spend the tokens
+ pub source: Address,
+ /// Token's address
+ pub token: Address,
+ /// The amount of tokens
+ pub amount: DenominatedAmount,
+ /// Hash of tx section that contains the MASP transaction
+ pub shielded_section_hash: Hash,
+}
+
+/// Arguments for an unshielding transfer (from a shielded token to a
+/// transparent token)
+#[derive(
+ Debug,
+ Clone,
+ PartialEq,
+ BorshSerialize,
+ BorshDeserialize,
+ BorshDeserializer,
+ BorshSchema,
+ Hash,
+ Eq,
+ PartialOrd,
+ Serialize,
+ Deserialize,
+)]
+pub struct UnshieldingTransfer {
+ /// Target address will receive the tokens
+ pub target: Address,
+ /// Token's address
+ pub token: Address,
+ /// The amount of tokens
+ pub amount: DenominatedAmount,
+ /// Hash of tx section that contains the MASP transaction
+ pub shielded_section_hash: Hash,
+}
+
+#[cfg(any(test, feature = "testing"))]
+/// Testing helpers and strategies for tokens
+pub mod testing {
+ use namada_core::address::testing::{
+ arb_established_address, arb_non_internal_address,
+ };
+ use namada_core::address::Address;
+ pub use namada_core::token::*;
+ pub use namada_trans_token::testing::*;
+ use proptest::prelude::*;
+
+ use super::TransparentTransfer;
+
+ prop_compose! {
+ /// Generate a transparent transfer
+ pub fn arb_transparent_transfer()(
+ source in arb_non_internal_address(),
+ target in arb_non_internal_address(),
+ token in arb_established_address().prop_map(Address::Established),
+ amount in arb_denominated_amount(),
+ ) -> TransparentTransfer {
+ TransparentTransfer {
+ source,
+ target,
+ token,
+ amount,
+ }
+ }
+ }
+}

crates/tx_prelude/src/token.rs

@@ -5,13 +5,14 @@ use namada_events::{EmitEvents, EventLevel};
 #[cfg(any(test, feature = "testing"))]
 pub use namada_token::testing;
 pub use namada_token::{
- storage_key, utils, Amount, DenominatedAmount, Transfer,
+ storage_key, utils, Amount, DenominatedAmount, ShieldedTransfer,
+ ShieldingTransfer, TransparentTransfer, UnshieldingTransfer,
 };
 use namada_tx_env::TxEnv;
 
 use crate::{Ctx, TxResult};
 
-/// A token transfer that can be used in a transaction.
+/// A transparent token transfer that can be used in a transaction.
 pub fn transfer(
  ctx: &mut Ctx,
  src: &Address,