type DomainType = {
  readonly name?: string;           // dApp name
  readonly version?: string;        // Domain version
  readonly chainId?: ChainIdType;   // EIP-155 chain ID
  readonly verifyingContract?: AddressType; // Contract address
  readonly salt?: HashType;         // Salt for disambiguation
};

import * as Domain from './primitives/Domain/index.js';

const domain = Domain.from({
  name: 'MyDApp',
  version: '1',
  chainId: 1,
  verifyingContract: '0x123...',
});

import { keccak256 } from './crypto/keccak256/index.js';

const domainSep = Domain.toHash(domain, { keccak256 });
console.log(DomainSeparator.toHex(domainSep));

// Name only
const domain = Domain.from({ name: 'MyDApp' });

// Contract only
const domain = Domain.from({
  verifyingContract: '0x123...'
});

{ name: 'Uniswap V3' }

{ version: '1' }

{ chainId: 1 }  // Ethereum mainnet
{ chainId: 137 }  // Polygon

{ verifyingContract: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48' }

{ salt: '0x1234...' }

const typeString = Domain.encodeType('EIP712Domain', {
  EIP712Domain: [
    { name: 'name', type: 'string' },
    { name: 'version', type: 'string' },
    { name: 'chainId', type: 'uint256' },
    { name: 'verifyingContract', type: 'address' },
  ],
});
// 'EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'

const encoded = Domain.encodeData(
  'EIP712Domain',
  domain,
  types,
  { keccak256 }
);

const domain = Domain.from({
  name: 'USD Coin',
  version: '2',
  chainId: 1,
  verifyingContract: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
});

const domain = Domain.from({
  name: 'Permit2',
  chainId: 1,
  verifyingContract: '0x000000000022D473030F116dDEE9F6B43aC78BA3',
});

const domain = Domain.from({
  name: 'MyDeFiProtocol',
  version: '1.0',
  chainId: 1,
  verifyingContract: '0x123...',
});

import * as Domain from './primitives/Domain/index.js';
import { InvalidDomainError } from './primitives/Domain/errors.js';

try {
  Domain.from({});
} catch (e) {
  if (e instanceof InvalidDomainError) {
    console.log(e.name);     // "InvalidDomainError"
    console.log(e.code);     // "INVALID_DOMAIN"
    console.log(e.value);    // The invalid domain object
    console.log(e.expected); // "valid EIP-712 domain"
  }
}

import { InvalidDomainTypeError } from './primitives/Domain/errors.js';

try {
  Domain.encodeData('NonExistent', data, types, { keccak256 });
} catch (e) {
  if (e instanceof InvalidDomainTypeError) {
    console.log(e.name); // "InvalidDomainTypeError"
    console.log(e.code); // "INVALID_DOMAIN_TYPE"
  }
}

import { InvalidEIP712ValueError } from './primitives/Domain/errors.js';

try {
  Domain.encodeValue('uint512', value, types, { keccak256 }); // Invalid size
} catch (e) {
  if (e instanceof InvalidEIP712ValueError) {
    console.log(e.name); // "InvalidEIP712ValueError"
    console.log(e.code); // "INVALID_EIP712_VALUE"
  }
}