router-wasm-bindings 1.0.3

use cosmwasm_std::Uint128;

use crate::types::{RequestMetaData, EVM_ADDRESS_LENGTH};
use crate::{
    types::{AckType, ChainType},
    utils::{
        convert_address_from_bytes_to_string, convert_address_from_string_to_bytes,
        evm_address_to_router_address, router_address_to_evm_address,
    },
    Bytes,
};

#[test]
fn test_evm_address_conversion() {
    let byte_addr: [u8; EVM_ADDRESS_LENGTH] = [
        160, 184, 105, 145, 198, 33, 139, 54, 193, 209, 157, 74, 46, 158, 176, 206, 54, 6, 235, 72,
    ];
    let chain_type: u64 = ChainType::ChainTypeEvm.get_chain_code();

    let address: String = String::from("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48");
    let bytes_address = convert_address_from_string_to_bytes(address.clone(), chain_type).unwrap();
    assert_eq!(bytes_address.len(), EVM_ADDRESS_LENGTH);
    assert_eq!(bytes_address, byte_addr);

    let address: String = String::from("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48");
    let bytes_address = convert_address_from_string_to_bytes(address.clone(), chain_type).unwrap();
    assert_eq!(bytes_address.len(), EVM_ADDRESS_LENGTH);
    assert_eq!(bytes_address, byte_addr);

    let address: String = String::from("0Xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48");
    let bytes_address = convert_address_from_string_to_bytes(address.clone(), chain_type).unwrap();
    assert_eq!(bytes_address.len(), EVM_ADDRESS_LENGTH);
    assert_eq!(bytes_address, byte_addr);

    let address: Vec<u8> = vec![0; EVM_ADDRESS_LENGTH];
    assert_eq!(
        convert_address_from_bytes_to_string(&address, chain_type).unwrap(),
        "0x0000000000000000000000000000000000000000"
    );

    let address: Vec<u8> = vec![255; EVM_ADDRESS_LENGTH];
    assert_eq!(
        convert_address_from_bytes_to_string(&address, chain_type).unwrap(),
        "0xffffffffffffffffffffffffffffffffffffffff"
    );
}

#[test]
fn test_invalid_evm_address_conversion() {
    let chain_type: u64 = ChainType::ChainTypeEvm.get_chain_code();

    let address: String = String::from("0x1234");
    let result = convert_address_from_string_to_bytes(address.clone(), chain_type);
    assert_eq!(result.is_err(), true);
    assert_eq!(
        result.unwrap_err().to_string(),
        "Generic error: Invalid EVM address length"
    );

    let address: String = String::from("0x2323a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48");
    assert_eq!(
        convert_address_from_string_to_bytes(address.clone(), chain_type).is_ok(),
        false
    );

    let address: String = String::from("W0b86991c6218b36c1d19d4a2e9eb0ce3606eb48");
    let result = convert_address_from_string_to_bytes(address.clone(), chain_type);
    assert_eq!(result.is_err(), true);
    assert_eq!(
        result.unwrap_err().to_string(),
        "Generic error: Invalid character 'W' at position 0"
    );

    let address: Vec<u8> = vec![0; 40];
    let result = convert_address_from_bytes_to_string(&address, chain_type);
    assert_eq!(result.is_err(), true);
    assert_eq!(
        result.unwrap_err().to_string(),
        "Generic error: Invalid EVM address length"
    );
}

#[test]
fn test_cosmos_address_conversion() {
    let address: String = String::from("router1apapk9zfz3rp4x87fsm6h0s3zd0wlmkz0fx8tx");
    let chain_type: u64 = ChainType::ChainTypeCosmos.get_chain_code();
    let bytes_address = convert_address_from_string_to_bytes(address.clone(), chain_type).unwrap();

    let cosmos_address: String =
        convert_address_from_bytes_to_string(&bytes_address, chain_type).unwrap();
    assert_eq!(cosmos_address, address);
}

#[test]
fn test_polkadot_address_conversion() {
    let address: String = String::from("5E7PkJdvNqjKHRPqJ4ypTZk92Q1VV3A7RifE6gekXsrzRgmE");
    let chain_type: u64 = ChainType::ChainTypePolkadot.get_chain_code();
    let bytes_address = convert_address_from_string_to_bytes(address.clone(), chain_type).unwrap();

    let polkadot_address: String =
        convert_address_from_bytes_to_string(&bytes_address, chain_type).unwrap();
    assert_eq!(polkadot_address, address);
}

#[test]
fn test_address_conversion() {
    let eth_address_vec: Vec<u8> = vec![0; 22];
    assert_eq!(
        evm_address_to_router_address(&eth_address_vec).is_err(),
        true
    );

    let eth_address_vec: Vec<u8> = vec![0; 20];
    let router_address: String = evm_address_to_router_address(&eth_address_vec).unwrap();
    assert_eq!(
        "router1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqxcp8cd",
        router_address
    );

    let data: Vec<u8> = router_address_to_evm_address(&router_address).unwrap();
    assert_eq!(data, eth_address_vec);

    let router_address: String =
        String::from("router17r3faruez552kdxy0lsjydmj0nu22mxax33azx326039hfe7pnhq7xma7f");
    assert_eq!(
        router_address_to_evm_address(&router_address).is_ok(),
        false
    );
}

#[test]
fn test_encoding() {
    let request_metadata: RequestMetaData = RequestMetaData {
        dest_gas_limit: 300_000,
        dest_gas_price: 30_000_000_000,
        ack_gas_limit: 300_000,
        ack_gas_price: 30_000_000_000,
        relayer_fee: Uint128::zero(),
        ack_type: AckType::AckOnBoth,
        is_read_call: false,
        asm_address: String::default(),
    };

    let encoded_data: Bytes = request_metadata.get_abi_encoded_bytes();

    assert_eq!(encoded_data.len(), 50);
    assert_eq!(hex::encode(encoded_data.clone()), "00000000000493e000000006fc23ac0000000000000493e000000006fc23ac00000000000000000000000000000000000300");
    println!(
        "{:?}",
        RequestMetaData::from_abi_encoded_bytes(encoded_data)
    );
}