Rust资产汇率转换库pallet-asset-rate的使用，实现区块链中资产间的实时汇率计算与转换

安装

在项目目录中运行以下Cargo命令：

cargo add pallet-asset-rate

或者在Cargo.toml中添加以下行：

pallet-asset-rate = "21.0.0"

使用示例

以下是使用pallet-asset-rate库实现资产间汇率转换的完整示例：

use frame_support::{parameter_types, traits::Everything};
use pallet_asset_rate::{self as asset_rate, Config};
use sp_core::H256;
use sp_runtime::{
    traits::{BlakeTwo256, IdentityLookup},
    BuildStorage,
};

type Block = frame_system::mocking::MockBlock<Test>;

// 配置测试环境
frame_support::construct_runtime!(
    pub enum Test
    {
        System: frame_system,
        Balances: pallet_balances,
        Assets: pallet_assets,
        AssetRate: pallet_asset_rate,
    }
);

parameter_types! {
    pub const BlockHashCount: u64 = 250;
    pub const SS58Prefix: u8 = 42;
}

impl frame_system::Config for Test {
    type BaseCallFilter = Everything;
    type BlockWeights = ();
    type BlockLength = ();
    type DbWeight = ();
    type RuntimeOrigin = RuntimeOrigin;
    type RuntimeCall = RuntimeCall;
    type Nonce = u64;
    type Hash = H256;
    type Hashing = BlakeTwo256;
    type AccountId = u64;
    type Lookup = IdentityLookup<Self::AccountId>;
    type Block = Block;
    type RuntimeEvent = RuntimeEvent;
    type BlockHashCount = BlockHashCount;
    type Version = ();
    type PalletInfo = PalletInfo;
    type AccountData = pallet_balances::AccountData<极光;
    type OnNewAccount = ();
    type OnKilledAccount = ();
    type SystemWeightInfo = ();
    type SS58Prefix = SS58Prefix;
    type OnSetCode = ();
    type MaxConsumers = frame_support::traits::ConstU32<16>;
}

parameter_types! {
    pub const ExistentialDeposit: u128 = 1;
    pub const MaxLocks: u32 = 10;
    pub const MaxReserves: u32 = 10;
}

impl pallet_balances::Config for Test {
    type Balance = u128;
    type DustRemoval = ();
    type RuntimeEvent = RuntimeEvent;
    type ExistentialDeposit = ExistentialDeposit;
    type AccountStore = System;
    type WeightInfo = ();
    type MaxLocks = MaxLocks;
    type MaxReserves = MaxReserves;
    type ReserveIdentifier = [u8; 8];
    type FreezeIdentifier = ();
    type MaxFreezes = ();
    type HoldIdentifier = ();
    type MaxHolds = ();
}

parameter_types! {
    pub const AssetDeposit: u128极光 1;
    pub const AssetAccountDeposit: u128 = 1;
    pub const ApprovalDeposit: u128 = 1;
    pub const StringLimit: u32 = 50;
    pub const MetadataDepositBase: u128 = 1;
    pub const MetadataDepositPerByte: u128 = 1;
}

impl pallet_assets::Config for Test {
    type RuntimeEvent = RuntimeEvent;
    type Balance = u128;
    type AssetId = u32;
    type Currency = Balances;
    type ForceOrigin = frame_system::EnsureRoot<u64>;
    type AssetDeposit = AssetDeposit;
    type AssetAccountDeposit = AssetAccountDeposit;
    type MetadataDepositBase = MetadataDepositBase;
    type MetadataDepositPerByte = MetadataDepositPerByte;
    type ApprovalDeposit = ApprovalDeposit;
    type StringLimit = StringLimit;
    type Freezer = ();
    type WeightInfo = ();
    type Extra = ();
    type RemoveItemsLimit = frame_support::traits::ConstU32<10>;
    type CallbackHandle = ();
}

parameter_types! {
    pub const MaxConversionPathLength: u32 = 4;
}

impl Config for Test {
    type RuntimeEvent = RuntimeEvent;
    type Balance = u128;
    type AssetId = u32;
    type WeightInfo = ();
    type MaxConversionPathLength = MaxConversionPathLength;
}

// 测试设置
pub fn new_test_ext() -> sp_io::TestExternalities {
    let mut storage = frame_system::GenesisConfig::<Test>::default()
        .build_storage()
        .unwrap();

    pallet_balances::GenesisConfig::<Test> {
        balances: vec![(1, 100), (2, 100)],
    }
    .assimilate_storage(&mut storage)
    .unwrap();

    pallet_assets::GenesisConfig::<Test> {
        assets: vec![(1, 1, true, 1)],
        metadata: vec![(1, b"Token1".to_vec(), b"T1".to_vec(), 6)],
        accounts: vec![(1, 1, 100)],
    }
    .assimilate_storage(&mut storage)
    .unwrap();

    storage.into()
}

#[test]
fn test_asset_rate_conversion() {
    new_test_ext().execute_with(|| {
        // 创建两种资产
        assert_ok!(Assets::create(
            RuntimeOrigin::signed(1),
            1,
            1,
            1,
            true
        ));
        assert_ok!(Assets::create(
            RuntimeOrigin::signed(1),
            2,
            1,
            1,
            true
        ));

        // 设置资产1到资产2的汇率 (1:2)
        assert_ok!(AssetRate::create(
            RuntimeOrigin::signed(1),
            1,
            2,
            2_000_000_000 // 2.0
        ));

        // 转换100个资产1到资产2
        let converted = AssetRate::convert(1, 2, 100);
        assert_eq!(converted, Some(200)); // 100 * 2 = 200

        // 测试反向转换
        assert_ok!(AssetRate::create(
            RuntimeOrigin::signed(1),
            2,
            1,
            500_000_000 // 0.5
        ));

        let reverse_converted = AssetRate::convert(2, 1, 200);
        assert_eq!(reverse_converted, Some(100)); // 200 * 0.5 = 100

        // 测试多跳转换路径
        assert_ok!(Assets::create(
            RuntimeOrigin::signed(1),
            3,
            1,
            1,
            true
        ));
        
        assert_ok!(AssetRate::create(
            RuntimeOrigin::signed(1),
            2,
            3,
            4_000_000_000 // 4.0
        ));

        // 资产1 -> 资产2 -> 资产3
        let multi_hop_converted = AssetRate::convert(1, 3, 100);
        assert_eq!(multi_hop_converted, Some(800)); // 100 * 2 * 4 = 800
    });
}

主要功能

1. 汇率设置：可以通过create方法设置两种资产之间的汇率
2. 实时转换：使用convert方法根据预设汇率进行资产数量转换
3. 多跳转换：支持通过中间资产进行多跳汇率转换
4. 高精度计算：使用定点数进行精确的汇率计算