called `Result::unwrap()` on an `Err` value: Other("expected `Unit`, got `Tuple([Unit])`")

git clone [email protected]:compolabs/orderbook-contract.git 

cd orderbook-contract/  

git checkout testnet

forc build -v --release

echo "ADMIN=<YOUR PK WITH SOME TEST ETH>" >> .env 

cargo run --bin match_in_pairs_multicall

called `Result::unwrap()` on an `Err` value: Other("expected `Unit`, got `Tuple([Unit])`")

 pub async fn match_in_pairs_multicall(
        &self,
        orders: Vec<(Bits256, Bits256)>,
    ) -> Result<FuelCallResponse<()>, fuels::types::errors::Error> {
        let wallet = self.instance.account();
        let mut multi_call_handler = MultiContractCallHandler::new(wallet.clone());

        for (sell_order_id, buy_order_id) in orders {
            let call_handler = self
                .instance
                .methods()
                .match_orders(sell_order_id.clone(), buy_order_id.clone())
                .append_variable_outputs(2)
                .with_tx_policies(TxPolicies::default().with_script_gas_limit(3500000));
            multi_call_handler.add_call(call_handler);
        }

        multi_call_handler
            .with_tx_policies(
                TxPolicies::default()
                    .with_tip(1)
                    .with_script_gas_limit(9_999_000),
            )
            .call()
            .await
    }

#[tokio::main]
async fn main() {
    print_title("Match in pairs multicall");
    dotenv().ok();
    let provider = Provider::connect(RPC).await.unwrap();
    let secret = std::env::var("ADMIN").unwrap();
    let wallet =
        WalletUnlocked::new_from_private_key(secret.parse().unwrap(), Some(provider.clone()));
    println!("wallet.address() = {:?}", wallet.address());
    let token_contract = TokenContract::new(
        &ContractId::from_str(TOKEN_CONTRACT_ID).unwrap().into(),
        wallet.clone(),
    );

    let token_contract_id = token_contract.contract_id().into();
    let base_asset = Asset::new(wallet.clone(), token_contract_id, MARKET_SYMBOL);
    let quote_asset = Asset::new(wallet.clone(), token_contract_id, "USDC");

    let orderbook = Orderbook::new(&wallet, ORDERBOOK_CONTRACT_ID).await;
    let price = (BASE_PRICE * 10f64.powf(orderbook.price_decimals as f64)) as u64;

    //mint base asset to sell
    let base_size = base_asset.parse_units(BASE_SIZE as f64) as u64;
    base_asset
        .mint(wallet.address().into(), base_size)
        .await
        .unwrap();

    // sell
    let sell_order_id = orderbook
        .open_order(base_asset.asset_id, -1 * base_size as i64, price - 1)
        .await
        .unwrap()
        .value;
    println!(
        "sell_order = {:?}",
        orderbook.order_by_id(&sell_order_id).await.unwrap().value
    );

    //mint quote asset to buy
    let quote_size = quote_asset.parse_units(BASE_SIZE as f64 * BASE_PRICE as f64);
    quote_asset
        .mint(wallet.address().into(), quote_size as u64)
        .await
        .unwrap();

    //buy
    let buy_order_id = orderbook
        .open_order(base_asset.asset_id, base_size as i64, price)
        .await
        .unwrap()
        .value;

    println!(
        "buy_order = {:?}\n",
        orderbook.order_by_id(&buy_order_id).await.unwrap().value
    );

    orderbook
        .match_in_pairs_multicall(vec![(sell_order_id, buy_order_id)])
        .await
        .unwrap();
}