@ensdomains/ensjs 3.0.0-alpha.41 → 3.0.0-alpha.42

package/dist/types/utils/subgraph-types.d.ts

@@ -0,0 +1,284 @@
+export declare type Maybe<T> = T | null;
+export declare type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export declare type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    Bytes: string;
+    BigInt: string;
+};
+export declare type Domain = {
+    __typename?: 'Domain';
+    id: Scalars['ID'];
+    name?: Maybe<Scalars['String']>;
+    labelName?: Maybe<Scalars['String']>;
+    labelhash?: Maybe<Scalars['Bytes']>;
+    parent?: Maybe<Domain>;
+    subdomains: Array<Domain>;
+    subdomainCount: Scalars['Int'];
+    resolvedAddress?: Maybe<Account>;
+    owner: Account;
+    resolver?: Maybe<Resolver>;
+    ttl?: Maybe<Scalars['BigInt']>;
+    isMigrated: Scalars['Boolean'];
+    createdAt: Scalars['BigInt'];
+    events: Array<DomainEvent>;
+    registration?: Maybe<Registration>;
+    wrappedDomain?: Maybe<WrappedDomain>;
+};
+export declare type DomainEvent = {
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+};
+export declare type Transfer = DomainEvent & {
+    __typename?: 'Transfer';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type NewOwner = DomainEvent & {
+    __typename?: 'NewOwner';
+    id: Scalars['ID'];
+    parentDomain: Domain;
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type NewResolver = DomainEvent & {
+    __typename?: 'NewResolver';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    resolver: Resolver;
+};
+export declare type NewTtl = DomainEvent & {
+    __typename?: 'NewTTL';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    ttl: Scalars['BigInt'];
+};
+export declare type WrappedTransfer = DomainEvent & {
+    __typename?: 'WrappedTransfer';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type NameWrapped = DomainEvent & {
+    __typename?: 'NameWrapped';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    name: Scalars['String'];
+    fuses: Scalars['Int'];
+    owner: Account;
+    expiryDate: Scalars['BigInt'];
+};
+export declare type NameUnwrapped = DomainEvent & {
+    __typename?: 'NameUnwrapped';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Account;
+};
+export declare type FusesSet = DomainEvent & {
+    __typename?: 'FusesSet';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    fuses: Scalars['Int'];
+};
+export declare type ExpiryExtended = DomainEvent & {
+    __typename?: 'ExpiryExtended';
+    id: Scalars['ID'];
+    domain: Domain;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    expiryDate: Scalars['BigInt'];
+};
+export declare type Registration = {
+    __typename?: 'Registration';
+    id: Scalars['ID'];
+    domain: Domain;
+    registrationDate: Scalars['BigInt'];
+    expiryDate: Scalars['BigInt'];
+    cost?: Maybe<Scalars['BigInt']>;
+    registrant: Account;
+    labelName?: Maybe<Scalars['String']>;
+    events: Array<RegistrationEvent>;
+};
+export declare type RegistrationEvent = {
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+};
+export declare type NameRegistered = RegistrationEvent & {
+    __typename?: 'NameRegistered';
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    registrant: Account;
+    expiryDate: Scalars['BigInt'];
+};
+export declare type NameRenewed = RegistrationEvent & {
+    __typename?: 'NameRenewed';
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    expiryDate: Scalars['BigInt'];
+};
+export declare type NameTransferred = RegistrationEvent & {
+    __typename?: 'NameTransferred';
+    id: Scalars['ID'];
+    registration: Registration;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    newOwner: Account;
+};
+export declare type WrappedDomain = {
+    __typename?: 'WrappedDomain';
+    id: Scalars['ID'];
+    domain: Domain;
+    expiryDate: Scalars['BigInt'];
+    fuses: Scalars['Int'];
+    owner: Account;
+    name?: Maybe<Scalars['String']>;
+};
+export declare type Account = {
+    __typename?: 'Account';
+    id: Scalars['ID'];
+    domains: Array<Domain>;
+    wrappedDomains?: Maybe<Array<WrappedDomain>>;
+    registrations?: Maybe<Array<Registration>>;
+};
+export declare type Resolver = {
+    __typename?: 'Resolver';
+    id: Scalars['ID'];
+    domain?: Maybe<Domain>;
+    address: Scalars['Bytes'];
+    addr?: Maybe<Account>;
+    contentHash?: Maybe<Scalars['Bytes']>;
+    texts?: Maybe<Array<Scalars['String']>>;
+    coinTypes?: Maybe<Array<Scalars['BigInt']>>;
+    events: Array<ResolverEvent>;
+};
+export declare type ResolverEvent = {
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+};
+export declare type AddrChanged = ResolverEvent & {
+    __typename?: 'AddrChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    addr: Account;
+};
+export declare type MulticoinAddrChanged = ResolverEvent & {
+    __typename?: 'MulticoinAddrChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    coinType: Scalars['BigInt'];
+    addr: Scalars['Bytes'];
+};
+export declare type NameChanged = ResolverEvent & {
+    __typename?: 'NameChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    name: Scalars['String'];
+};
+export declare type AbiChanged = ResolverEvent & {
+    __typename?: 'AbiChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    contentType: Scalars['BigInt'];
+};
+export declare type PubkeyChanged = ResolverEvent & {
+    __typename?: 'PubkeyChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    x: Scalars['Bytes'];
+    y: Scalars['Bytes'];
+};
+export declare type TextChanged = ResolverEvent & {
+    __typename?: 'TextChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    key: Scalars['String'];
+    value?: Maybe<Scalars['String']>;
+};
+export declare type ContenthashChanged = ResolverEvent & {
+    __typename?: 'ContenthashChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    hash: Scalars['Bytes'];
+};
+export declare type InterfaceChanged = ResolverEvent & {
+    __typename?: 'InterfaceChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    interfaceID: Scalars['Bytes'];
+    implementer: Scalars['Bytes'];
+};
+export declare type AuthorisationChanged = ResolverEvent & {
+    __typename?: 'AuthorisationChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    owner: Scalars['Bytes'];
+    target: Scalars['Bytes'];
+    isAuthorized: Scalars['Boolean'];
+};
+export declare type VersionChanged = ResolverEvent & {
+    __typename?: 'VersionChanged';
+    id: Scalars['ID'];
+    resolver: Resolver;
+    blockNumber: Scalars['Int'];
+    transactionID: Scalars['Bytes'];
+    version: Scalars['BigInt'];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ensdomains/ensjs",
-  "version": "3.0.0-alpha.41",
+  "version": "3.0.0-alpha.42",
   "description": "ENS javascript library for contract interaction",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.mjs",
@@ -68,10 +68,9 @@
     "traverse": "^0.6.6"
   },
   "devDependencies": {
-    "ethers": "^5.7.2",
     "@ensdomains/buffer": "^0.0.13",
-    "@ensdomains/ens-contracts": "^0.0.15",
-    "@ensdomains/ens-test-env": "0.3.6",
+    "@ensdomains/ens-contracts": "^0.0.16",
+    "@ensdomains/ens-test-env": "0.3.7",
     "@ethersproject/abi": "^5.6.4",
     "@ethersproject/abstract-provider": "^5.7.0",
     "@ethersproject/abstract-signer": "^5.7.0",
@@ -98,6 +97,7 @@
     "dotenv": "^16.0.0",
     "esbuild": "^0.15.6",
     "eslint-plugin-jest": "^27.0.1",
+    "ethers": "^5.7.2",
     "ganache": "^7.4.0",
     "glob": "^8.0.3",
     "hardhat": "2.10.2",
@@ -133,7 +133,7 @@
   },
   "scripts": {
     "tenv": "ens-test-env -a",
-    "denv": "pnpm tenv start -ns -nb --extra-time 11368000",
+    "denv": "pnpm tenv start -ns -nb --extra-time 11368000 --verbosity 1",
     "generate-types": "ts-node scripts/runTypechain.ts",
     "generate-abis": "hardhat export-abi",
     "start": "ts-node --files src/index.test.ts",

package/src/contracts/getContractAddress.ts

@@ -20,19 +20,19 @@ const addresses: Record<
     '1': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
     '3': '0xa5627AB7Ae47063B533622C34FEBDb52d3281dF8',
     '4': '0x283af0b28c62c092c9727f1ee09c02ca627eb7f5',
-    '5': '0x9C51161bA2FB02Cc0a403332B607117685f34831',
+    '5': '0xb7A1f9e633fdeaAa2ec44bE00a61a7Db9a733D70',
   },
   Multicall: '0xcA11bde05977b3631167028862bE2a173976CA11',
   NameWrapper: {
     '1': '0x0000000000000000000000000000000000000000',
     '3': '0xF82155e2a43Be0871821E9654Fc8Ae894FB8307C',
     '4': '0x0000000000000000000000000000000000000000',
-    '5': '0x582224b8d4534F4749EFA4f22eF7241E0C56D4B8',
+    '5': '0xEe1F756aCde7E81B2D8cC6aB3c8A1E2cE6db0F39',
   },
   PublicResolver: {
     '1': '0x4976fb03C32e5B8cfe2b6cCB31c09Ba78EBaBa41',
     '3': '0x13F0659Ee6bb7484C884FEeFb7F75C93951ef837',
-    '5': '0xE264d5bb84bA3b8061ADC38D3D76e6674aB91852',
+    '5': '0x2800Ec5BAB9CE9226d19E0ad5BC607e3cfC4347E',
   },
   ENSRegistry: {
     '1': '0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e',
@@ -43,7 +43,7 @@ const addresses: Record<
   ReverseRegistrar: {
     '1': '0x084b1c3C81545d370f3634392De611CaaBFf8148',
     '3': '0x806246b52f8cB61655d3038c58D2f63Aa55d4edE',
-    '5': '0xD5610A08E370051a01fdfe4bB3ddf5270af1aA48',
+    '5': '0x9a879320A9F7ad2BBb02063d67baF5551D6BD8B0',
   },
   UniversalResolver: {
     '1': '0x74E20Bd2A1fE0cdbe45b9A1d89cb7e0a45b36376',

package/src/functions/commitName.test.ts

@@ -31,7 +31,6 @@ describe('commitName', () => {
     expect(popTx).toBeTruthy()
     expect(customData).toHaveProperty('secret')
     expect(customData).toHaveProperty('commitment')
-    expect(customData).toHaveProperty('wrapperExpiry')
 
     const tx = await provider.getSigner().sendTransaction(popTx)
     await tx.wait()
@@ -47,11 +46,9 @@ describe('commitName', () => {
       owner: accounts[1],
       addressOrIndex: accounts[1],
       secret,
-      wrapperExpiry: 100000,
     })
     await tx.wait()
     expect(tx.customData).toBeTruthy()
-    expect(tx.customData!.wrapperExpiry).toBe(100000)
     expect(tx.customData!.secret).toBe(secret)
 
     const controller = await ensInstance.contracts!.getEthRegistrarController()!

package/src/functions/commitName.ts

@@ -22,7 +22,7 @@ export default async function (
     undefined,
     resolverAddress,
   )
-  const { secret, commitment, wrapperExpiry } = makeCommitment({
+  const { secret, commitment } = makeCommitment({
     name,
     resolver,
     ...params,
@@ -33,7 +33,6 @@ export default async function (
     customData: {
       secret,
       commitment,
-      wrapperExpiry,
     },
   }
 }

package/src/functions/createSubname.ts

@@ -1,8 +1,7 @@
 import { BigNumber } from '@ethersproject/bignumber/lib/bignumber'
 import { keccak256 as solidityKeccak256 } from '@ethersproject/solidity'
 import { ENSArgs } from '..'
-import { FuseOptions } from '../utils/fuses'
-import generateFuseInput from '../utils/generateFuseInput'
+import { CombinedFuseInput, encodeFuses } from '../utils/fuses'
 import { namehash } from '../utils/normalise'
 import { Expiry, makeExpiry, wrappedLabelLengthCheck } from '../utils/wrapper'
 
@@ -14,7 +13,7 @@ type BaseArgs = {
 
 type NameWrapperArgs = {
   contract: 'nameWrapper'
-  fuses?: FuseOptions
+  fuses?: CombinedFuseInput
   expiry?: Expiry
 } & BaseArgs
 
@@ -70,8 +69,8 @@ export default async function (
 
       const generatedFuses =
         'fuses' in wrapperArgs && wrapperArgs.fuses
-          ? generateFuseInput(wrapperArgs.fuses)
-          : '0'
+          ? encodeFuses(wrapperArgs.fuses)
+          : 0
 
       return nameWrapper.populateTransaction.setSubnodeRecord(
         parentNodehash,

package/src/functions/getHistory.ts

@@ -4,6 +4,30 @@ import { ENSArgs } from '..'
 import { decodeContenthash } from '../utils/contentHash'
 import { labelhash } from '../utils/labels'
 import { namehash } from '../utils/normalise'
+import {
+  AbiChanged,
+  AddrChanged,
+  AuthorisationChanged,
+  ContenthashChanged,
+  ExpiryExtended,
+  FusesSet,
+  InterfaceChanged,
+  MulticoinAddrChanged,
+  NameChanged,
+  NameRegistered,
+  NameRenewed,
+  NameTransferred,
+  NameUnwrapped,
+  NameWrapped,
+  NewOwner,
+  NewResolver,
+  NewTtl,
+  PubkeyChanged,
+  TextChanged,
+  Transfer,
+  VersionChanged,
+  WrappedTransfer,
+} from '../utils/subgraph-types'
 
 type DomainEvent =
   | 'NewOwner'
@@ -14,6 +38,7 @@ type DomainEvent =
   | 'NameWrapped'
   | 'NameUnwrapped'
   | 'FusesSet'
+  | 'ExpiryExtended'
 type RegistrationEvent = 'NameRegistered' | 'NameRenewed' | 'NameTransferred'
 type ResolverEvent =
   | 'AddrChanged'
@@ -38,30 +63,35 @@ const eventFormat: {
   [key in EventTypes]: { [n in EventFormat[key]]: (args: any) => object }
 } = {
   Domain: {
-    NewOwner: (args: any) => ({ owner: args.owner.id }),
-    NewResolver: (args: any) => ({ resolver: args.resolver.id.split('-')[0] }),
-    Transfer: (args: any) => ({ owner: args.owner.id }),
-    NewTTL: (args: any) => ({ ttl: args.ttl }),
-    WrappedTransfer: (args: any) => ({ owner: args.owner.id }),
-    NameWrapped: (args: any) => ({
+    NewOwner: (args: NewOwner) => ({ owner: args.owner.id }),
+    NewResolver: (args: NewResolver) => ({
+      resolver: args.resolver.id.split('-')[0],
+    }),
+    Transfer: (args: Transfer) => ({ owner: args.owner.id }),
+    NewTTL: (args: NewTtl) => ({ ttl: args.ttl }),
+    WrappedTransfer: (args: WrappedTransfer) => ({ owner: args.owner.id }),
+    NameWrapped: (args: NameWrapped) => ({
       fuses: args.fuses,
       owner: args.owner.id,
-      expiry: args.expiry,
+      expiryDate: args.expiryDate,
     }),
-    NameUnwrapped: (args: any) => ({ owner: args.owner.id }),
-    FusesSet: (args: any) => ({ fuses: args.fuses, expiry: args.expiry }),
+    NameUnwrapped: (args: NameUnwrapped) => ({ owner: args.owner.id }),
+    FusesSet: (args: FusesSet) => ({ fuses: args.fuses }),
+    ExpiryExtended: (args: ExpiryExtended) => ({ expiryDate: args.expiryDate }),
   },
   Registration: {
-    NameRegistered: (args: any) => ({
+    NameRegistered: (args: NameRegistered) => ({
       registrant: args.registrant.id,
       expiryDate: args.expiryDate,
     }),
-    NameRenewed: (args: any) => ({ expiryDate: args.expiryDate }),
-    NameTransferred: (args: any) => ({ owner: args.newOwner.id }),
+    NameRenewed: (args: NameRenewed) => ({ expiryDate: args.expiryDate }),
+    NameTransferred: (args: NameTransferred) => ({ owner: args.newOwner.id }),
   },
   Resolver: {
-    AddrChanged: (args: any) => ({ addr: args.addr.id }),
-    MulticoinAddrChanged: (args: any) => {
+    AddrChanged: (args: AddrChanged) => ({ addr: args.addr.id }),
+    MulticoinAddrChanged: (
+      args: Omit<MulticoinAddrChanged, 'addr'> & { multiaddr: string },
+    ) => {
       const format = formatsByCoinType[parseInt(args.coinType)]
       if (!format) {
         return {
@@ -82,21 +112,23 @@ const eventFormat: {
         addr: format.encoder(Buffer.from(args.multiaddr.slice(2), 'hex')),
       }
     },
-    NameChanged: (args: any) => ({ name: args.name }),
-    AbiChanged: (args: any) => ({ contentType: args.contentType }),
-    PubkeyChanged: (args: any) => ({ x: args.x, y: args.y }),
-    TextChanged: (args: any) => ({ key: args.key, value: args.value }),
-    ContenthashChanged: (args: any) => ({ hash: decodeContenthash(args.hash) }),
-    InterfaceChanged: (args: any) => ({
-      interfaceId: args.interfaceId,
+    NameChanged: (args: NameChanged) => ({ name: args.name }),
+    AbiChanged: (args: AbiChanged) => ({ contentType: args.contentType }),
+    PubkeyChanged: (args: PubkeyChanged) => ({ x: args.x, y: args.y }),
+    TextChanged: (args: TextChanged) => ({ key: args.key, value: args.value }),
+    ContenthashChanged: (args: ContenthashChanged) => ({
+      hash: decodeContenthash(args.hash),
+    }),
+    InterfaceChanged: (args: InterfaceChanged) => ({
+      interfaceId: args.interfaceID,
       implementer: args.implementer,
     }),
-    AuthorisationChanged: (args: any) => ({
+    AuthorisationChanged: (args: AuthorisationChanged) => ({
       owner: args.owner,
       target: args.target,
       isAuthorized: args.isAuthorized,
     }),
-    VersionChanged: (args: any) => ({ version: args.version }),
+    VersionChanged: (args: VersionChanged) => ({ version: args.version }),
   },
 }
 
@@ -154,7 +186,7 @@ export async function getHistory(
             }
             ...on NameWrapped {
               fuses
-              expiry
+              expiryDate
               owner {
                 id
               }
@@ -166,7 +198,9 @@ export async function getHistory(
             }
             ...on FusesSet {
               fuses
-              expiry
+            }
+            ...on ExpiryExtended {
+              expiryDate
             }
           }
           registration {

package/src/functions/getNames.test.ts

@@ -172,7 +172,7 @@ describe('getNames', () => {
       type: 'wrappedOwner',
       page: 0,
     })
-    expect(pageOne).toHaveLength(1)
+    expect(pageOne).toHaveLength(2)
   })
   describe('orderBy', () => {
     describe('registrations', () => {

package/src/functions/getNames.ts

@@ -1,7 +1,8 @@
 import { ENSArgs } from '..'
 import { truncateFormat } from '../utils/format'
-import { CurrentFuses, decodeFuses } from '../utils/fuses'
+import { AllCurrentFuses, decodeFuses } from '../utils/fuses'
 import { decryptName } from '../utils/labels'
+import { Domain, Registration, WrappedDomain } from '../utils/subgraph-types'
 
 export type Name = {
   id: string
@@ -16,7 +17,7 @@ export type Name = {
   createdAt?: Date
   registrationDate?: Date
   expiryDate?: Date
-  fuses?: CurrentFuses
+  fuses?: AllCurrentFuses
   registration?: {
     expiryDate: Date
     registrationDate: Date
@@ -44,7 +45,7 @@ type OwnerParams = {
 
 type WrappedOwnerParams = {
   type: 'wrappedOwner'
-  orderBy?: 'expiryDate' | 'labelName'
+  orderBy?: 'expiryDate' | 'name'
 }
 
 type AllParams = {
@@ -57,23 +58,35 @@ type AllParams = {
 type Params = BaseParams &
   (RegistrantParams | OwnerParams | WrappedOwnerParams | AllParams)
 
-const mapDomain = (domain: any) => {
-  const decrypted = decryptName(domain.name)
+const mapDomain = ({ name, ...domain }: Domain) => {
+  const decrypted = name ? decryptName(name) : undefined
   return {
     ...domain,
     name: decrypted,
-    truncatedName: truncateFormat(decrypted),
+    truncatedName: decrypted ? truncateFormat(decrypted) : undefined,
     createdAt: new Date(parseInt(domain.createdAt) * 1000),
     type: 'domain',
   }
 }
 
-const mapWrappedDomain = (wrappedDomain: any) => {
-  const domain = mapDomain(wrappedDomain.domain)
+const mapWrappedDomain = (wrappedDomain: WrappedDomain) => {
+  const domain = mapDomain(wrappedDomain.domain) as Omit<
+    ReturnType<typeof mapDomain>,
+    'registration'
+  > & {
+    registration?: {
+      expiryDate: string | Date
+      registrationDate: string | Date
+    }
+  }
   if (domain.registration) {
     domain.registration = {
-      expiryDate: new Date(parseInt(domain.registration.expiryDate) * 1000),
-      registrationDate: new Date(domain.registration.registrationDate * 1000),
+      expiryDate: new Date(
+        parseInt(domain.registration.expiryDate as string) * 1000,
+      ),
+      registrationDate: new Date(
+        parseInt(domain.registration.registrationDate as string) * 1000,
+      ),
     }
   }
   return {
@@ -84,8 +97,8 @@ const mapWrappedDomain = (wrappedDomain: any) => {
   }
 }
 
-const mapRegistration = (registration: any) => {
-  const decrypted = decryptName(registration.domain.name)
+const mapRegistration = (registration: Registration) => {
+  const decrypted = decryptName(registration.domain.name!)
   return {
     expiryDate: new Date(parseInt(registration.expiryDate) * 1000),
     registrationDate: new Date(parseInt(registration.registrationDate) * 1000),
@@ -275,7 +288,7 @@ const getNames = async (
         id: address,
         first: pageSize,
         skip: (page || 0) * pageSize,
-        orderBy,
+        orderBy: orderBy === 'labelName' ? 'name' : orderBy,
         orderDirection,
       }
     }