Rust-sdk, calling external contract, type arguments, error: "FAILED_TO_DESERIALIZE_ARGUMENT"

[ylish]

Hello everyone!
I'm trying to execute external contract (Liquidswap, changing coins) with Rust-SDK and get the error.

First, this is payload for real transaction (as an example):

{
  "function": "0x99465840349525b3d648e609eacb056d5b61e3915e8a3972b431afc26e3f05a1::router::swap_coin_for_coin_x1",
  "type_arguments": [
    "0x1::aptos_coin::AptosCoin",
    "0xf22bede237a07e121b56d91a491eb7bcdfd1f5907926a9e58338f964a01b17fa::asset::USDT",
    "0x190d44266241744264b964a37b8f09863167a12d3e70cda39376cfb4e3561e12::curves::Uncorrelated"
  ],
  "arguments": [
    "1000000",
    [
      "97209"
    ],
    "0x00"
  ],
  "type": "entry_function_payload"
}

I fill args and type args with values and construct payload:

    let args = vec![ bcs::to_bytes(&amount).unwrap(),.........];
    let ty_args = vec![TypeTag::from_str(APT_COIN).unwrap()..........];
    let entry_function = EntryFunction::new(........ ty_args, args);
    let payload = TransactionPayload::EntryFunction(entry_function);

Payload looks like that (I formatted the output to make it more readable):

EntryFunction(EntryFunction {
	module: ModuleId {
		address: 99465840349525b3d648e609eacb056d5b61e3915e8a3972b431afc26e3f05a1,
		name: Identifier("router") 
	},
	function: Identifier("swap_coin_for_coin_x1"),
	ty_args: [
		Struct(StructTag {
			address: 0000000000000000000000000000000000000000000000000000000000000001,
			module: Identifier("aptos_coin"),
			name: Identifier("AptosCoin"),
			type_params: [] 
			}),
		Struct(StructTag {
			address: f22bede237a07e121b56d91a491eb7bcdfd1f5907926a9e58338f964a01b17fa,
			module: Identifier("asset"),
			name: Identifier("USDT"),
			type_params: []
			}),
		Struct(StructTag {
			address: 190d44266241744264b964a37b8f09863167a12d3e70cda39376cfb4e3561e12,
			module: Identifier("curves"),
			name: Identifier("Uncorrelated"),
			type_params: []
		})],
	args: [[128, 150, 152, 0, 0, 0, 0, 0], [224, 15, 151, 0, 0, 0, 0, 0], [5]] 
})

Then I send transaction to simulation and get the error:

success: false
"Transaction Executed and Committed with Error FAILED_TO_DESERIALIZE_ARGUMENT\nExecution failed with status: Couldn't read bytes"

I suppose, there is something wrong with parameters. I am surprised, how type arguments turned out into json structures. Maybe there's an error?

Longer example of code is here:

pub async fn call_test(logger: &Logger, rest_client: &Client, sender: &LocalAccount) {
    static APT_COIN: &str = "0x1::aptos_coin::AptosCoin";
    static OTHER_COIN: &str = "0xf22bede237a07e121b56d91a491eb7bcdfd1f5907926a9e58338f964a01b17fa::asset::USDT";
    static CONTRACT_ADDR: &str = "0x99465840349525b3d648e609eacb056d5b61e3915e8a3972b431afc26e3f05a1";
    static MODULE_NAME: &str = "router";
    static FUNC_NAME: &str = "swap_coin_for_coin_x1";
    static CURVE: &str =  "0x190d44266241744264b964a37b8f09863167a12d3e70cda39376cfb4e3561e12::curves::Uncorrelated";
    let max_gas_amount = 5_000;
    let gas_unit_price = 100;
    let timeout_secs = 10;
    let ls_version: u8 = 5;

    let chain_id = rest_client.get_index().await.unwrap().inner().chain_id;
    let chain_id = ChainId::new(chain_id);

    let module = ModuleId::new(
        AccountAddress::from_hex_literal(CONTRACT_ADDR).unwrap(),
        Identifier::new(MODULE_NAME).unwrap(),
    );
    let ident = Identifier::new(FUNC_NAME).unwrap();

    let amount: u64 = 10000000;
    let threshold: u64 = 9900000;

    let args = vec![
        bcs::to_bytes(&amount).unwrap(),
        bcs::to_bytes(&threshold).unwrap(),
        bcs::to_bytes(&ls_version).unwrap(),
    ];
    let ty_args = vec![
        TypeTag::from_str(APT_COIN).unwrap(),
        TypeTag::from_str(OTHER_COIN).unwrap(),
        TypeTag::from_str(CURVE).unwrap(),
    ];

    let entry_function = EntryFunction::new(module, ident, ty_args, args);
    let payload = TransactionPayload::EntryFunction(entry_function);
    println!("Payload:\r\n{:?}", payload);

    let expiration_timestamp = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap()
        .as_secs()
        + timeout_secs;
    let transaction_builder = TransactionBuilder::new(payload, expiration_timestamp, chain_id)
        .sender(sender.address())
        .sequence_number(sender.sequence_number())
        .max_gas_amount(max_gas_amount)
        .gas_unit_price(gas_unit_price);

    let raw_txn = transaction_builder
        .sender(sender.address())
        .sequence_number(sender.increment_sequence_number())
        .build();

    // simulate transaction
    let fake_acc = LocalAccount::generate(&mut rand::rngs::OsRng);
    let signed_txn = raw_txn
        .sign(fake_acc.private_key(), sender.public_key().clone())
        .unwrap()
        .into_inner();
    let res = rest_client
        .simulate(&signed_txn)
        .await
        .unwrap()
        .into_inner();

    println!("success: {}", res[0].info.success);
    println!("{:?}", res[0].info.vm_status);
}

[heliuchuan]

Haven't looked too closely, but at first glance it seems like in the real txn

  "arguments": [
    "1000000",
    [
      "97209"
    ],
    "0x00"
  ],

^ the second parameter is a vector

where as your code does not match that structure

args: [[128, 150, 152, 0, 0, 0, 0, 0], [224, 15, 151, 0, 0, 0, 0, 0], [5]]

[ylish]

Thank you. I got it. I had considered this option before, but made two mistakes. First, there is indeed a vector there ( &Vec<u8> ), but not a slice &[u8]. bcs::to_bytes() will encode the slice incorrectly. Second, not only the second argument, but the third argument is also a vector. This is not displayed in the payload for some reason, but it can be found on the contract page. Thank you, you have helped me.