Trying to implement U256 in rust ink! 4.0

Question

I've implemented use primitive_types::U256 and now Im trying to return a U256 int as a result from one of my functions, but Im getting the following error the trait TypeInfo is not implemented for primitive_types::U256 , I understand that i need to implement TypeInfo in my smart contract but i just dont understand how.

Here is the mentioned function:

        #[ink(message)]
        pub fn get_est_price_psp22_to_a01(
            &self,
            psp22_amount_in:Balance
        )   -> Result<U256, TradingPairErrors> {

            let caller = self.env().caller();

            //fetching caller current PSP22 balance
            let caller_current_balance:Balance = PSP22Ref::balance_of(
                &self.panx_contract,
                caller
            );

            let actual_fee:Balance;

            //calculating the actual LP fee
            match self.fee.checked_div(10u128.pow(18)) {
                Some(result) => {
                    actual_fee = result;
                }
                None => {
                    return Err(TradingPairErrors::Overflow);
                }
            };

            let mut amount_in_with_lp_fees:Balance;

            //reducting the LP fee from the PSP22 amount in
            match psp22_amount_in.checked_mul(100u128 - actual_fee) {
                Some(result) => {
                    amount_in_with_lp_fees = result;
                }
                None => {
                    return Err(TradingPairErrors::Overflow);
                }
            };

            let tokens_to_validate:Balance = 3500u128 * 10u128.pow(18);

            //validating if caller has more than 3500 PANX to verify if the caller is eligible for the incentive program 
            if caller_current_balance >= tokens_to_validate{

                if self.fee  <= 1400000000000u128 {

                    //reducting HALF of the LP fee from PSP22 amount in, if the caller has more than 3500 PANX and the LP fee is less than 1.4%
                    match psp22_amount_in.checked_mul(100u128 - (actual_fee / 2u128)) {
                        Some(result) => {
                            amount_in_with_lp_fees = result;
                        }
                        None => {
                            return Err(TradingPairErrors::Overflow);
                        }
                    };   
                }
 
                if self.fee  > 1400000000000u128 {

                    //reducting (LP fee - 1) of the LP fee from PSP22 amount in, if the caller has more than 3500 PANX and the LP fee is more than 1.4%
                    match psp22_amount_in.checked_mul(100u128 - (actual_fee - 1u128)) {
                        Some(result) => {
                            amount_in_with_lp_fees = result;
                        }
                        None => {
                            return Err(TradingPairErrors::Overflow);
                        }
                    };  
                }

            }

             
            let a0_amount_out = self.casted_div(amount_in_with_lp_fees * self.get_a0_balance(),(self.get_psp22_balance() * 100u128) + amount_in_with_lp_fees);
            
            //calculating the final A0 amount to transfer to the caller.
            //match (amount_in_with_lp_fees * self.get_a0_balance()).checked_div((self.get_psp22_balance() * 100u128) + amount_in_with_lp_fees) {
            //    Some(result) => {
            //        a0_amount_out = result;
            //    }
            //    None => {
            //        return Err(TradingPairErrors::Overflow);
            //    }
            //};

            Ok(a0_amount_out)  

        }

Im using "casted_div" function which takes 2 u128 objects and turns them into U256:

        fn casted_div(
            &self,
            value1: u128,
            value2: u128
        ) -> U256 {

            U256::from(value1) / U256::from(value2)

        }

Thank you and have a pleasant day :)

Answer 1

It is not possible to implement a Trait on a type outside of his crate (Rust oprhan rule). So the only option is to create a new type that will wrap arround U256 and derive TypeInfo:

#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Encode, Decode)]
#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
pub struct WrappedU256(U256);

impl From<WrappedU256> for U256 {
    fn from(value: WrappedU256) -> Self {
        value.0
    }
}

impl From<U256> for WrappedU256 {
    fn from(value: U256) -> Self {
        WrappedU256(value)
    }
}

Answer 2

U256 does implement TypeInfo, but it is behind a feature: https://github.com/paritytech/parity-common/blob/master/primitive-types/src/lib.rs#L40.

Enable the `features = ["scale-info"]" for your primtive-types dependency and it should work.