Add controller_transfer_to

integration/src/erc20_helper.rs

@@ -305,6 +305,38 @@ impl Token {
             .await
     }
 
+    pub async fn freeze_partial_tokens(
+        &self,
+        caller: &mut dyn ContractCaller,
+        account: Address,
+        amount: u128,
+    ) -> Result<Vec<ContractLog>> {
+        self.send(
+            caller,
+            ierc20::freezePartialTokensCall {
+                account,
+                amount: U256::from(amount),
+            },
+        )
+        .await
+    }
+
+    pub async fn unfreeze_partial_tokens(
+        &self,
+        caller: &mut dyn ContractCaller,
+        account: Address,
+        amount: u128,
+    ) -> Result<Vec<ContractLog>> {
+        self.send(
+            caller,
+            ierc20::unfreezePartialTokensCall {
+                account,
+                amount: U256::from(amount),
+            },
+        )
+        .await
+    }
+
     pub async fn set_symbol(
         &self,
         caller: &mut dyn ContractCaller,

integration/tests/revive_erc3643.rs

@@ -83,6 +83,78 @@ async fn erc3643_set_name() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+#[test_log::test]
+async fn erc3643_freeze_partial_tokens() -> Result<()> {
+    let (mut tester, node) = revive_tester().await?;
+    let mut users = tester.users(&["Erc3643Issuer", "Erc3643Holder"]).await?;
+    let api = tester.api.clone();
+    let (issuers, holders) = users.split_at_mut(1);
+    let issuer = &mut issuers[0];
+    let holder = &mut holders[0];
+
+    let (_, erc3643) = create_erc20_asset(&api, &node, issuer, "ERC3643 Freeze", MINT).await?;
+
+    let holder_address = eth_address_of(&api, holder).await?;
+    let mut caller = SubstrateCaller::new(&api, issuer).await?;
+
+    assert_eq!(erc3643.get_frozen_tokens(holder_address).await.unwrap(), 0);
+
+    erc3643
+        .freeze_partial_tokens(&mut caller, holder_address, 100)
+        .await?;
+
+    assert_eq!(
+        erc3643.get_frozen_tokens(holder_address).await.unwrap(),
+        100
+    );
+
+    // Freezing again adds to the amount already frozen, rather than replacing it.
+    erc3643
+        .freeze_partial_tokens(&mut caller, holder_address, 50)
+        .await?;
+
+    assert_eq!(
+        erc3643.get_frozen_tokens(holder_address).await.unwrap(),
+        150
+    );
+
+    Ok(())
+}
+
+#[tokio::test]
+#[test_log::test]
+async fn erc3643_unfreeze_partial_tokens() -> Result<()> {
+    let (mut tester, node) = revive_tester().await?;
+    let mut users = tester.users(&["Erc3643Issuer", "Erc3643Holder"]).await?;
+    let api = tester.api.clone();
+    let (issuers, holders) = users.split_at_mut(1);
+    let issuer = &mut issuers[0];
+    let holder = &mut holders[0];
+
+    let (_, erc3643) = create_erc20_asset(&api, &node, issuer, "ERC3643 Unfreeze", MINT).await?;
+
+    let holder_address = eth_address_of(&api, holder).await?;
+    let mut caller = SubstrateCaller::new(&api, issuer).await?;
+
+    erc3643
+        .freeze_partial_tokens(&mut caller, holder_address, 100)
+        .await?;
+
+    assert_eq!(
+        erc3643.get_frozen_tokens(holder_address).await.unwrap(),
+        100
+    );
+
+    erc3643
+        .unfreeze_partial_tokens(&mut caller, holder_address, 40)
+        .await?;
+
+    assert_eq!(erc3643.get_frozen_tokens(holder_address).await.unwrap(), 60);
+
+    Ok(())
+}
+
 #[tokio::test]
 #[test_log::test]
 async fn erc3643_pause_unpause() -> Result<()> {

pallets/asset/src/benchmarking.rs

@@ -563,6 +563,38 @@ benchmarks! {
         );
     }
 
+    controller_transfer_to {
+        let bob = UserBuilder::<T>::default().generate_did().build("Bob");
+        let alice = UserBuilder::<T>::default().generate_did().build("Alice");
+        let asset_id = create_sample_asset::<T>(&alice, true);
+
+        let alice_holdings = AssetHolder::from(PortfolioId::default_portfolio(alice.did()));
+        let bob_holdings = AssetHolder::from(PortfolioId::default_portfolio(bob.did()));
+
+        Pallet::<T>::issue(
+            alice.origin.clone().into(),
+            asset_id,
+            1_000_000,
+            alice_holdings.clone().into()
+        )
+        .unwrap();
+
+        let auth_id = pallet_identity::Pallet::<T>::add_auth(
+            alice.did(),
+            Signatory::from(bob.did()),
+            AuthorizationData::BecomeAgent(asset_id, AgentGroup::Full),
+            None,
+        )
+        .unwrap();
+        pallet_external_agents::Pallet::<T>::accept_become_agent(bob.origin().into(), auth_id)?;
+    }: _(bob.origin.clone(), asset_id, 1_000, alice_holdings, bob_holdings)
+    verify {
+        assert_eq!(
+            BalanceOf::<T>::get(asset_id, bob.did()),
+            1_000
+        );
+    }
+
     register_custom_asset_type {
         let n in 1 .. T::MaxLen::get() as u32;
 
@@ -1018,4 +1050,36 @@ benchmarks! {
         let bob_portfolio = create_portfolio::<T>(&bob, "SenderPortfolio");
         let asset_id = create_sample_asset::<T>(&alice, true);
     }: _(alice.origin, bob_portfolio.into(), asset_id, true)
+
+    freeze_partial_tokens {
+        let alice = UserBuilder::<T>::default().generate_did().build("Alice");
+        let asset_id = create_sample_asset::<T>(&alice, true);
+        let alice_portfolio = create_portfolio::<T>(&alice, "SenderPortfolio");
+    }: _(alice.origin, asset_id, alice_portfolio.clone(), ONE_UNIT)
+    verify {
+        assert_eq!(
+            Pallet::<T>::get_holders_frozen_balance(&alice_portfolio, &asset_id),
+            ONE_UNIT
+        );
+    }
+
+    unfreeze_partial_tokens {
+        let alice = UserBuilder::<T>::default().generate_did().build("Alice");
+        let asset_id = create_sample_asset::<T>(&alice, true);
+        let alice_portfolio = create_portfolio::<T>(&alice, "SenderPortfolio");
+
+        Pallet::<T>::freeze_partial_tokens(
+            alice.origin().into(),
+            asset_id,
+            alice_portfolio.clone(),
+            ONE_UNIT,
+        )
+        .unwrap();
+    }: _(alice.origin, asset_id, alice_portfolio.clone(), ONE_UNIT)
+    verify {
+        assert_eq!(
+            Pallet::<T>::get_holders_frozen_balance(&alice_portfolio, &asset_id),
+            0
+        );
+    }
 }