Verifying signature does not work if struct contains an array

Smart Contracts
1

Normally if I don't add values array to Order struct, it works, I can handle correct address. But when I add an array to the struct, I handle incorrect address. Where am i doing wrong?

uint[] values;

const SIGNING_DOMAIN_NAME = "Test"
const SIGNING_DOMAIN_VERSION = "1"

class LazyMinter {
	constructor({ contract, signer }) {
		this.contract = contract
		this.signer = signer
	}
    /*
          Sample Inputs for the validation on the solidity side
          order: ["0xd8b934580fcE35a11B58C6D73aDeE468a2833fa8","40df6a67-b3df-4056-a4c9-32cb9874e1d5",1,"1000000000000000000",0,0,"asd",["10"]]
          signature: 0xa4120b1a4e438354ed80576ee75cef62375dcasd1231da16fd25f84f9db7759b6d525a915c5acc54ce894ce6e3b028249797431e0653dfc27a7e78b0b551c
    */
	async createVoucher(voucher) {
		const domain = await this._signingDomain()
		const types = {
			Order: [
				{ name: "nftContractAddress", type: "address" },
				{ name: "salt", type: "string" },
				{ name: "tokenId", type: "uint256" },
				{ name: "price", type: "uint256" },
				{ name: "start", type: "uint256" },
				{ name: "end", type: "uint256" },
				{ name: "tokenUri", type: "string" },
				{ name: "values", type: "uint256[]" }
			]
		}
		const signature = await this.signer._signTypedData(domain, types, voucher)
		return {
			voucher,
			signature,
		}
	}

	async _signingDomain() {
		if (this._domain != null) {
			return this._domain
		}
		const chainId = await this.contract.getChainId()
		this._domain = {
			name: SIGNING_DOMAIN_NAME,
			version: SIGNING_DOMAIN_VERSION,
			chainId: Number(chainId),
			verifyingContract: this.contract.address
		}
		return this._domain
	}
}

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/utils/math/SafeMath.sol";

library LibOrder {
    using SafeMath for uint;

    bytes32 constant ORDER_TYPEHASH = keccak256(
        "Order(address nftContractAddress,string salt,uint256 tokenId,uint256 price,uint256 start,uint256 end,string tokenUri,uint256[] values)"
    );

    struct Order {
        address nftContractAddress;
        string salt;
        uint tokenId;
        uint price;
        uint start;
        uint end;
        string tokenUri;
        uint[] values;
    }

    function hash(Order memory order) internal pure returns (bytes32) {
        return keccak256(abi.encode(
                ORDER_TYPEHASH,
                order.nftContractAddress,
                keccak256(bytes(order.salt)),
                order.tokenId,
                order.price,
                order.start,
                order.end,
                keccak256(bytes(order.tokenUri)),
                keccak256(abi.encodePacked(order.values))
            ));
    }
}```


![Screen Shot 2022-08-05 at 14.46.09|690x90](upload://yYorwuxLZUV5dKnybin2h1k2tCo.png)