Refactor/binding addr (paritytech#176)

* let to_base58 accept bytes ref

* let BtcAddress be Vec<u8>

* refactor addrbinding

* integrate staking

Author: atenjin

Cargo.lock

@@ -57,6 +57,7 @@ pub type Token = Vec<u8>;
 pub type Name = Vec<u8>;
 pub type Precision = u8;
 pub type AddrStr = Vec<u8>;
+pub type ChainAddress = Vec<u8>;
 pub type AssetId = u32;
 
 /// Referral ID of validator.

primitives/src/lib.rs

@@ -65,8 +65,8 @@ pub use pallet_timestamp::Call as TimestampCall;
 pub use pallet_transaction_payment::{Multiplier, TargetedFeeAdjustment};
 
 pub use chainx_primitives::{
-    AccountId, AccountIndex, AddrStr, AssetId, Balance, BlockNumber, Hash, Index, Moment, Name,
-    ReferralId, Signature, Token,
+    AccountId, AccountIndex, AddrStr, AssetId, Balance, BlockNumber, ChainAddress, Hash, Index,
+    Moment, Name, ReferralId, Signature, Token,
 };
 pub use xp_runtime::Memo;
 
@@ -721,6 +721,7 @@ impl xpallet_gateway_bitcoin::Trait for Runtime {
     type TrusteeSessionProvider = trustees::bitcoin::BtcTrusteeSessionManager<Runtime>;
     type TrusteeMultiSigProvider = trustees::bitcoin::BtcTrusteeMultisig<Runtime>;
     type Channel = XGatewayCommon;
+    type AddrBinding = XGatewayCommon;
 }
 
 impl xpallet_dex_spot::Trait for Runtime {
@@ -759,18 +760,18 @@ impl xpallet_mining_staking::Trait for Runtime {
         xpallet_mining_staking::SimpleValidatorRewardPotAccountDeterminer<Runtime>;
 }
 
-pub struct DummyReferralGetter;
-impl xpallet_mining_asset::GatewayInterface<AccountId> for DummyReferralGetter {
-    fn referral_of(_who: &AccountId, _asset_id: AssetId) -> Option<AccountId> {
-        // FIXME impl this in gateway
-        None
+pub struct ReferralGetter;
+impl xpallet_mining_asset::GatewayInterface<AccountId> for ReferralGetter {
+    fn referral_of(who: &AccountId, asset_id: AssetId) -> Option<AccountId> {
+        use xpallet_gateway_common::traits::ChannelBinding;
+        XGatewayCommon::get_binding_info(&asset_id, who)
     }
 }
 
 impl xpallet_mining_asset::Trait for Runtime {
     type Event = Event;
     type StakingInterface = Self;
-    type GatewayInterface = DummyReferralGetter;
+    type GatewayInterface = ReferralGetter;
     type TreasuryAccount = SimpleTreasuryAccount;
     type DetermineRewardPotAccount =
         xpallet_mining_asset::SimpleAssetRewardPotAccountDeterminer<Runtime>;
@@ -1031,6 +1032,10 @@ impl_runtime_apis! {
     }
 
     impl xpallet_gateway_common_rpc_runtime_api::XGatewayCommonApi<Block, AccountId, Balance> for Runtime {
+        fn bound_addrs(who: AccountId) -> BTreeMap<Chain, Vec<ChainAddress>> {
+            XGatewayCommon::bound_addrs(&who)
+        }
+
         fn withdrawal_limit(asset_id: AssetId) -> Result<WithdrawalLimit<Balance>, DispatchError> {
             XGatewayCommon::withdrawal_limit(&asset_id)
         }

runtime/src/lib.rs

@@ -126,24 +126,13 @@
         "hot_address": "BtcTrusteeAddrInfo",
         "cold_address": "BtcTrusteeAddrInfo"
     },
-    "AddressHash": "H160",
     "BtcNetwork": {
         "_enum": [
             "Mainnet",
             "Testnet"
         ]
     },
-    "BtcAddrType": {
-        "_enum": [
-            "P2PKH",
-            "P2SH"
-        ]
-    },
-    "BtcAddress": {
-        "kind": "BtcAddrType",
-        "network": "BtcNetwork",
-        "hash": "AddressHash"
-    },
+    "BtcAddress": "Text",
     "BtcCompact": "u32",
     "BtcHeader": {
         "version": "u32",

scripts/chainx-js/chainx_types_manual.json

@@ -150,6 +150,7 @@
     "TradingPairId": "u32",
     "TradingHistoryIndex": "u64",
     "PriceFluctuation": "u32",
+    "BtcAddress": "Text",
     "FixedAssetPower": "u32",
     "StakingRequirement": "u32",
     "Precision": "u8",
@@ -191,11 +192,6 @@
         ]
     },
     "AssetRestrictions": "u32",
-    "BtcAddress": {
-        "kind": "BtcAddrType",
-        "network": "BtcNetwork",
-        "hash": "AddressHash"
-    },
     "BtcHeader": {
         "version": "u32",
         "previousHeaderHash": "H256",
@@ -302,13 +298,6 @@
         "hotAddress": "BtcTrusteeAddrInfo",
         "coldAddress": "BtcTrusteeAddrInfo"
     },
-    "AddressHash": "H160",
-    "BtcAddrType": {
-        "_enum": [
-            "P2PKH",
-            "P2SH"
-        ]
-    },
     "BtcCompact": "u32",
     "BtcTransaction": "Vec<u8>",
     "BtcHeaderIndex": {

scripts/chainx-js/res/chainx_types.json

@@ -29,7 +29,7 @@ use frame_system::{self as system, ensure_root, ensure_signed};
 use chainx_primitives::{AddrStr, AssetId};
 use xpallet_assets::{Chain, ChainT, WithdrawalLimit};
 use xpallet_gateway_common::{
-    traits::{ChannelBinding, Extractable, TrusteeSession},
+    traits::{AddrBinding, ChannelBinding, Extractable, TrusteeSession},
     trustees::bitcoin::BtcTrusteeAddrInfo,
 };
 use xpallet_support::{
@@ -39,7 +39,7 @@ use xpallet_support::{
 
 // light-bitcoin
 use btc_chain::Transaction;
-use btc_keys::{Address as BtcAddress, DisplayLayout};
+use btc_keys::{Address, DisplayLayout};
 use btc_ser::deserialize;
 // re-export
 pub use btc_chain::BlockHeader as BtcHeader;
@@ -48,12 +48,12 @@ pub use btc_keys::Network as BtcNetwork;
 pub use btc_primitives::h256_conv_endian_from_str;
 pub use btc_primitives::{Compact, H256, H264};
 
+pub use self::types::{BtcAddress, BtcParams, BtcTxVerifier, BtcWithdrawalProposal};
 use self::types::{
     BtcDepositCache, BtcHeaderIndex, BtcHeaderInfo, BtcRelayedTx, BtcTxResult, BtcTxState,
 };
-pub use self::types::{BtcParams, BtcTxVerifier, BtcWithdrawalProposal};
 use crate::trustee::get_trustee_address_pair;
-use crate::tx::{remove_pending_deposit, utils::addr2vecu8};
+use crate::tx::remove_pending_deposit;
 
 pub type BalanceOf<T> = <<T as xpallet_assets::Trait>::Currency as Currency<
     <T as frame_system::Trait>::AccountId,
@@ -70,6 +70,7 @@ pub trait Trait:
     type TrusteeSessionProvider: TrusteeSession<Self::AccountId, BtcTrusteeAddrInfo>;
     type TrusteeMultiSigProvider: MultiSig<Self::AccountId>;
     type Channel: ChannelBinding<Self::AccountId>;
+    type AddrBinding: AddrBinding<Self::AccountId, BtcAddress>;
 }
 
 decl_error! {
@@ -189,11 +190,6 @@ decl_storage! {
         pub TxState get(fn tx_state): map hasher(identity) H256 => Option<BtcTxState>;
         /// unclaimed deposit info, addr => tx_hash, btc value,
         pub PendingDeposits get(fn pending_deposits): map hasher(blake2_128_concat) BtcAddress => Vec<BtcDepositCache>;
-        // todo may move binding to common
-        ///
-        pub AddressBinding get(fn address_binding): map hasher(blake2_128_concat) BtcAddress => Option<T::AccountId>;
-        ///
-        pub BoundAddressOf get(fn bound_address_of): map hasher(blake2_128_concat) T::AccountId => Vec<BtcAddress>;
 
         /// withdrawal tx outs for account, tx_hash => outs ( out index => withdrawal account )
         pub WithdrawalProposal get(fn withdrawal_proposal): Option<BtcWithdrawalProposal<T::AccountId>>;
@@ -349,7 +345,7 @@ decl_module! {
             if let Some(w) = who {
                 remove_pending_deposit::<T>(&addr, &w);
             } else {
-                info!("[remove_pending]|release pending deposit directly, not deposit to someone|addr:{:?}", str!(addr2vecu8(&addr)));
+                info!("[remove_pending]|release pending deposit directly, not deposit to someone|addr:{:?}", str!(&addr));
                 PendingDeposits::remove(&addr);
             }
             Ok(())
@@ -417,15 +413,13 @@ impl<T: Trait> ChainT<BalanceOf<T>> for Module<T> {
 
     fn check_addr(addr: &[u8], _: &[u8]) -> DispatchResult {
         // this addr is base58 addr
-        let address = Self::verify_btc_address(addr)
-            .map_err(|_| Error::<T>::InvalidAddress)
-            .map_err(|e| {
-                error!(
-                    "[verify_btc_address]|failed, source addr is:{:?}",
-                    try_addr!(addr)
-                );
-                e
-            })?;
+        let address = Self::verify_btc_address(addr).map_err(|e| {
+            error!(
+                "[verify_btc_address]|failed, source addr is:{:?}",
+                try_addr!(addr)
+            );
+            e
+        })?;
 
         let (hot_addr, cold_addr) = get_trustee_address_pair::<T>()?;
         if address == hot_addr || address == cold_addr {
@@ -451,9 +445,9 @@ impl<T: Trait> ChainT<BalanceOf<T>> for Module<T> {
 }
 
 impl<T: Trait> Module<T> {
-    pub fn verify_btc_address(data: &[u8]) -> result::Result<BtcAddress, DispatchError> {
+    pub fn verify_btc_address(data: &[u8]) -> result::Result<Address, DispatchError> {
         let r = base58::from(data).map_err(|_| Error::<T>::InvalidBase58)?;
-        let addr = BtcAddress::from_layout(&r).map_err(|_| Error::<T>::InvalidAddr)?;
+        let addr = Address::from_layout(&r).map_err(|_| Error::<T>::InvalidAddr)?;
         Ok(addr)
     }
 

xpallets/gateway/bitcoin/src/lib.rs

@@ -21,7 +21,7 @@ use xpallet_gateway_common::{
 };
 use xpallet_support::{debug, error, info, RUNTIME_TARGET};
 
-use crate::tx::utils::{ensure_identical, parse_output_addr};
+use crate::tx::utils::{addr2vecu8, ensure_identical, parse_output_addr};
 use crate::tx::validator::parse_and_check_signed_tx;
 use crate::types::{BtcWithdrawalProposal, VoteResult};
 use crate::{Error, Module, RawEvent, Trait, WithdrawalProposal};
@@ -40,21 +40,31 @@ fn trustee_addr_info_pair<T: Trait>(
 
 #[inline]
 pub fn get_trustee_address_pair<T: Trait>() -> Result<(Address, Address), DispatchError> {
-    trustee_addr_info_pair::<T>().map(|(hot_info, cold_info)| (hot_info.addr, cold_info.addr))
+    trustee_addr_info_pair::<T>().map(|(hot_info, cold_info)| {
+        (
+            Module::<T>::verify_btc_address(&hot_info.addr)
+                .expect("should not parse error from storage data; qed"),
+            Module::<T>::verify_btc_address(&cold_info.addr)
+                .expect("should not parse error from storage data; qed"),
+        )
+    })
 }
 
 #[inline]
 pub fn get_last_trustee_address_pair<T: Trait>() -> Result<(Address, Address), DispatchError> {
     T::TrusteeSessionProvider::last_trustee_session().map(|session_info| {
         (
-            session_info.hot_address.addr,
-            session_info.cold_address.addr,
+            Module::<T>::verify_btc_address(&session_info.hot_address.addr)
+                .expect("should not parse error from storage data; qed"),
+            Module::<T>::verify_btc_address(&session_info.cold_address.addr)
+                .expect("should not parse error from storage data; qed"),
         )
     })
 }
 
 pub fn get_hot_trustee_address<T: Trait>() -> Result<Address, DispatchError> {
-    trustee_addr_info_pair::<T>().map(|(addr_info, _)| addr_info.addr)
+    trustee_addr_info_pair::<T>()
+        .and_then(|(addr_info, _)| Module::<T>::verify_btc_address(&addr_info.addr))
 }
 
 pub fn get_hot_trustee_redeem_script<T: Trait>() -> Result<Script, DispatchError> {
@@ -418,7 +428,7 @@ fn create_multi_address<T: Trait>(
     };
     let script_bytes: Bytes = redeem_script.into();
     Some(BtcTrusteeAddrInfo {
-        addr,
+        addr: addr2vecu8(&addr),
         redeem_script: script_bytes.into(),
     })
 }
@@ -462,8 +472,7 @@ fn check_withdraw_tx<T: Trait>(tx: &Transaction, withdrawal_id_list: &[u32]) ->
                         .ok_or(Error::<T>::NoWithdrawalRecord)?;
                 // record.addr() is base58
                 // verify btc address would conveRelayedTx a base58 addr to Address
-                let addr: Address = Module::<T>::verify_btc_address(&record.addr())
-                    .map_err(|_| Error::<T>::InvalidPublicKey)?;
+                let addr: Address = Module::<T>::verify_btc_address(&record.addr())?;
 
                 appl_withdrawal_list.push((addr, record.balance().saturated_into() as u64));
             }

xpallets/gateway/bitcoin/src/trustee.rs

@@ -15,7 +15,7 @@ use sp_std::{fmt::Debug, prelude::*, result};
 // ChainX
 use chainx_primitives::{AssetId, Name};
 use xpallet_assets::ChainT;
-use xpallet_gateway_common::traits::{ChannelBinding, Extractable};
+use xpallet_gateway_common::traits::{AddrBinding, ChannelBinding, Extractable};
 use xpallet_support::{debug, error, info, str, warn, RUNTIME_TARGET};
 
 // light-bitcoin
@@ -35,12 +35,9 @@ pub use self::validator::validate_transaction;
 use crate::trustee::{get_last_trustee_address_pair, get_trustee_address_pair};
 use crate::tx::utils::{addr2vecu8, ensure_identical};
 use crate::types::{
-    AccountInfo, BtcDepositCache, BtcTxResult, BtcTxState, DepositInfo, MetaTxType,
-};
-use crate::{
-    AddressBinding, BalanceOf, BoundAddressOf, Module, PendingDeposits, RawEvent, Trait,
-    WithdrawalProposal,
+    AccountInfo, BtcAddress, BtcDepositCache, BtcTxResult, BtcTxState, DepositInfo, MetaTxType,
 };
+use crate::{BalanceOf, Module, PendingDeposits, RawEvent, Trait, WithdrawalProposal};
 
 pub fn process_tx<T: Trait>(
     tx: Transaction,
@@ -295,10 +292,11 @@ fn deposit<T: Trait>(hash: H256, deposit_info: DepositInfo<T::AccountId>) -> Btc
     let account_info = match deposit_info.op_return {
         Some((accountid, channel_name)) => {
             if let Some(addr) = deposit_info.input_addr {
+                let addr = addr2vecu8(&addr);
                 // remove old unbinding deposit info
                 remove_pending_deposit::<T>(&addr, &accountid);
                 // update or override binding info
-                update_binding::<T>(&addr, &accountid);
+                T::AddrBinding::update_binding(Module::<T>::chain(), addr, accountid.clone());
             } else {
                 // no input addr
                 debug!("[deposit]|no input addr for this deposit tx, but has opreturn to get accountid|tx_hash:{:?}|who:{:?}", hash, accountid);
@@ -308,7 +306,8 @@ fn deposit<T: Trait>(hash: H256, deposit_info: DepositInfo<T::AccountId>) -> Btc
         None => {
             if let Some(addr) = deposit_info.input_addr {
                 // no opreturn, use addr to get accountid
-                match Module::<T>::address_binding(&addr) {
+                let addr_bytes = addr2vecu8(&addr);
+                match T::AddrBinding::get_binding(Module::<T>::chain(), addr_bytes) {
                     Some(accountid) => AccountInfo::Account((accountid, None)),
                     None => AccountInfo::Address(addr.clone()),
                 }
@@ -361,7 +360,7 @@ fn deposit_token<T: Trait>(who: &T::AccountId, balance: u64) -> DispatchResult {
     })?;
     Ok(())
 }
-
+/*
 fn update_binding<T: Trait>(address: &Address, who: &T::AccountId) {
     if let Some(accountid) = AddressBinding::<T>::get(&address) {
         if &accountid != who {
@@ -391,8 +390,8 @@ fn update_binding<T: Trait>(address: &Address, who: &T::AccountId) {
     );
     AddressBinding::<T>::insert(address, who.clone());
 }
-
-pub fn remove_pending_deposit<T: Trait>(input_address: &Address, who: &T::AccountId) {
+*/
+pub fn remove_pending_deposit<T: Trait>(input_address: &BtcAddress, who: &T::AccountId) {
     // notice this would delete this cache
     let records = PendingDeposits::take(input_address);
     for r in records {
@@ -407,23 +406,25 @@ pub fn remove_pending_deposit<T: Trait>(input_address: &Address, who: &T::Accoun
             who.clone(),
             r.balance.saturated_into(),
             r.txid,
-            addr2vecu8(input_address),
+            input_address.clone(),
         ));
     }
 }
 
 fn insert_pending_deposit<T: Trait>(input_address: &Address, txid: &H256, balance: u64) {
+    let addr_bytes = addr2vecu8(input_address);
+
     let cache = BtcDepositCache {
         txid: txid.clone(),
         balance,
     };
 
-    PendingDeposits::mutate(input_address, |list| {
+    PendingDeposits::mutate(&addr_bytes, |list| {
         if !list.contains(&cache) {
             native::debug!(
                 target: RUNTIME_TARGET,
                 "[insert_pending_deposit]|Add pending deposit|address:{:?}|txhash:{:}|balance:{:}",
-                str!(addr2vecu8(input_address)),
+                str!(addr_bytes),
                 txid,
                 balance
             );