test.ts

const { expect } = require("chai");
import { StarknetContract} from 'hardhat/types';
import { stark } from 'starknet';
import { starknet, ethers } from 'hardhat';

describe("Tuples and type aliases", function () {
  it("Should work with felt", async function () {
    const Greeter = await starknet.getContractFactory('./contracts/starknet/test.cairo');
    const greeter: StarknetContract = await Greeter.deploy();

    await greeter.invoke("normal", {bar: 10});
  });

  it("Should work with tuple", async function () {
    const Greeter = await starknet.getContractFactory('./contracts/starknet/test.cairo');
    const greeter: StarknetContract = await Greeter.deploy();

    await greeter.invoke("tuple", {bar: [10, 20]});
  });

  it("Should work with type alias", async function () {
    const Greeter = await starknet.getContractFactory('./contracts/starknet/test.cairo');
    const greeter: StarknetContract = await Greeter.deploy();
    
    // This doesn't work because type aliases are not supported
    await greeter.invoke("type_alias", {bar: [10]});
  });

  it("Should work with tuple type alias", async function () {
    const Greeter = await starknet.getContractFactory('./contracts/starknet/test.cairo');
    const greeter: StarknetContract = await Greeter.deploy();

    // This does work because it's not a type alias
    await greeter.invoke("tuple_type_alias", {bar: [10]});
  });
});

type_alias.cairo

%lang starknet

using TypeAlias = (address: felt)
using TupleTypeAlias = (felt)

@view
func normal(bar: felt):
    return ()
end

@view
func tuple(bar: (felt, felt)):
    return ()
end

@view
func type_alias(bar: TypeAlias):
    return ()
end

@view
func tuple_type_alias(bar: TupleTypeAlias):
    return ()
end

All tests work except from should work with type alias :)