npm - @ensdomains/ensjs - Versions diffs - 3.0.0-alpha.46 → 3.0.0-alpha.48 - Mend

@ensdomains/ensjs 3.0.0-alpha.46 → 3.0.0-alpha.48

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (28) hide show

package/dist/cjs/functions/deleteSubname.js +17 -7
package/dist/cjs/functions/getNames.js +1 -5
package/dist/cjs/functions/transferSubname.js +4 -9
package/dist/cjs/index.js +1 -1
package/dist/cjs/utils/registry.js +32 -0
package/dist/cjs/utils/wrapper.js +14 -9
package/dist/esm/functions/deleteSubname.mjs +17 -7
package/dist/esm/functions/getNames.mjs +1 -5
package/dist/esm/functions/transferSubname.mjs +5 -10
package/dist/esm/index.mjs +1 -1
package/dist/esm/utils/registry.mjs +13 -0
package/dist/esm/utils/wrapper.mjs +14 -9
package/dist/types/functions/deleteSubname.d.ts +8 -2
package/dist/types/functions/transferSubname.d.ts +1 -1
package/dist/types/utils/registry.d.ts +2 -0
package/dist/types/utils/wrapper.d.ts +1 -0
package/package.json +2 -2
package/src/functions/deleteSubname.test.ts +139 -6
package/src/functions/deleteSubname.ts +28 -11
package/src/functions/getNames.test.ts +11 -1
package/src/functions/getNames.ts +1 -5
package/src/functions/getSubnames.test.ts +1178 -324
package/src/functions/getWrapperData.test.ts +0 -1
package/src/functions/transferSubname.test.ts +120 -18
package/src/functions/transferSubname.ts +5 -10
package/src/index.ts +1 -1
package/src/utils/registry.ts +14 -0
package/src/utils/wrapper.ts +12 -9

package/src/functions/getSubnames.test.ts CHANGED Viewed

@@ -141,8 +141,8 @@ describe('getSubnames', () => {
       })
       expect(result).toBeTruthy()
-      expect(result.subnames.length).toBe(1)
-      expect(result.subnameCount).toBe(1)
+      expect(result.subnames.length).toBe(4)
+      expect(result.subnameCount).toBe(4)
       expect(result.subnames[0].fuses).toBeDefined()
     })
     it('should return expiry as undefined if 0', async () => {
@@ -186,15 +186,17 @@ describe('getSubnames', () => {
     it('should get paginated subnames for a name ordered by createdAt in desc order', async () => {
       const result = await ensInstance.getSubnames({
         name: 'with-subnames.eth',
-        pageSize: 2,
+        pageSize: 10,
         orderBy: 'createdAt',
         orderDirection: 'desc',
       })
       expect(result).toBeTruthy()
-      expect(result.subnames.length).toBe(2)
+      expect(result.subnames.length).toBe(4)
       expect(result.subnameCount).toBe(4)
       expect(result.subnames[0].name).toEqual('addr.with-subnames.eth')
       expect(result.subnames[1].name).toEqual('xyz.with-subnames.eth')
+      expect(result.subnames[2].name).toEqual('legacy.with-subnames.eth')
+      expect(result.subnames[3].name).toEqual('test.with-subnames.eth')
       expect(
         result.subnames.every((subname, i, arr) => {
           if (arr[i + 1]) {
@@ -213,50 +215,22 @@ describe('getSubnames', () => {
         'owner',
         'truncatedName',
       )
-      const result2 = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
-        pageSize: 2,
-        orderBy: 'createdAt',
-        orderDirection: 'desc',
-        lastSubnames: result.subnames,
-      })
-      expect(result2).toBeTruthy()
-      expect(result2.subnames.length).toBe(2)
-      expect(result2.subnameCount).toBe(4)
-      expect(result2.subnames[0].name).toEqual('legacy.with-subnames.eth')
-      expect(result2.subnames[1].name).toEqual('test.with-subnames.eth')
-      expect(
-        result2.subnames.every((subname, i, arr) => {
-          if (arr[i + 1]) {
-            return (subname as any).createdAt >= (arr[i + 1] as any).createdAt
-          }
-          return true
-        }),
-      ).toBe(true)
-      testProperties(
-        result2.subnames[0],
-        'id',
-        'labelName',
-        'labelhash',
-        'name',
-        'isMigrated',
-        'owner',
-        'truncatedName',
-      )
     })
-    it('should get paginated subnames for a name ordered by createdAt in asc order', async () => {
+    it('should get the subnames for a name ordered by createdAt in asc order', async () => {
       const result = await ensInstance.getSubnames({
         name: 'with-subnames.eth',
-        pageSize: 2,
+        pageSize: 10,
         orderBy: 'createdAt',
         orderDirection: 'asc',
       })
       expect(result).toBeTruthy()
-      expect(result.subnames.length).toBe(2)
+      expect(result.subnames.length).toBe(4)
       expect(result.subnameCount).toBe(4)
       expect(result.subnames[0].name).toEqual('test.with-subnames.eth')
       expect(result.subnames[1].name).toEqual('legacy.with-subnames.eth')
+      expect(result.subnames[2].name).toEqual('xyz.with-subnames.eth')
+      expect(result.subnames[3].name).toEqual('addr.with-subnames.eth')
       expect(
         result.subnames.every((subname, i, arr) => {
           if (arr[i + 1]) {
@@ -275,74 +249,22 @@ describe('getSubnames', () => {
         'owner',
         'truncatedName',
       )
-      const result2 = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
-        page: 0,
-        pageSize: 2,
-        orderBy: 'createdAt',
-        orderDirection: 'asc',
-        lastSubnames: result.subnames,
-      })
-      expect(result2).toBeTruthy()
-      expect(result2.subnames.length).toBe(2)
-      expect(result2.subnameCount).toBe(4)
-      expect(result2.subnames[0].name).toEqual('xyz.with-subnames.eth')
-      expect(result2.subnames[1].name).toEqual('addr.with-subnames.eth')
-      expect(
-        result2.subnames.every((subname, i, arr) => {
-          if (arr[i + 1]) {
-            return (subname as any).createdAt <= (arr[i + 1] as any).createdAt
-          }
-          return true
-        }),
-      ).toBe(true)
-      testProperties(
-        result2.subnames[0],
-        'id',
-        'labelName',
-        'labelhash',
-        'name',
-        'isMigrated',
-        'owner',
-        'truncatedName',
-      )
     })
-    it('should get paginated subnames for a name by labelName in desc order', async () => {
+    it('should get the subnames for a name by labelName in desc order', async () => {
       const result = await ensInstance.getSubnames({
         name: 'with-subnames.eth',
-        pageSize: 2,
+        pageSize: 10,
         orderBy: 'labelName',
         orderDirection: 'desc',
       })
       expect(result).toBeTruthy()
-      expect(result.subnames.length).toBe(2)
+      expect(result.subnames.length).toBe(4)
       expect(result.subnameCount).toBe(4)
       expect(result.subnames[0].name).toEqual('xyz.with-subnames.eth')
       expect(result.subnames[1].name).toEqual('test.with-subnames.eth')
-      testProperties(
-        result.subnames[0],
-        'id',
-        'labelName',
-        'labelhash',
-        'name',
-        'isMigrated',
-        'owner',
-        'truncatedName',
-      )
-      const result2 = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
-        pageSize: 2,
-        orderBy: 'labelName',
-        orderDirection: 'desc',
-        lastSubnames: result.subnames,
-      })
-      expect(result2).toBeTruthy()
-      expect(result2.subnames.length).toBe(2)
-      expect(result2.subnameCount).toBe(4)
-      expect(result2.subnames[0].name).toEqual('legacy.with-subnames.eth')
-      expect(result2.subnames[1].name).toEqual('addr.with-subnames.eth')
+      expect(result.subnames[2].name).toEqual('legacy.with-subnames.eth')
+      expect(result.subnames[3].name).toEqual('addr.with-subnames.eth')
       testProperties(
         result.subnames[0],
         'id',
@@ -355,19 +277,20 @@ describe('getSubnames', () => {
       )
     })
-    it('should get paginated subnames for a name by labelName in asc order', async () => {
+    it('should get the subnames for a name by labelName in asc order', async () => {
       const result = await ensInstance.getSubnames({
         name: 'with-subnames.eth',
-        pageSize: 2,
+        pageSize: 10,
         orderBy: 'labelName',
         orderDirection: 'asc',
       })
       expect(result).toBeTruthy()
-      expect(result.subnames.length).toBe(2)
+      expect(result.subnames.length).toBe(4)
       expect(result.subnameCount).toBe(4)
       expect(result.subnames[0].name).toEqual('addr.with-subnames.eth')
       expect(result.subnames[1].name).toEqual('legacy.with-subnames.eth')
+      expect(result.subnames[2].name).toEqual('test.with-subnames.eth')
+      expect(result.subnames[3].name).toEqual('xyz.with-subnames.eth')
       testProperties(
         result.subnames[0],
         'id',
@@ -378,47 +301,568 @@ describe('getSubnames', () => {
         'owner',
         'truncatedName',
       )
+    })
-      const result2 = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
-        pageSize: 2,
-        orderBy: 'labelName',
-        orderDirection: 'asc',
-        lastSubnames: result.subnames,
+    describe('with pagination', () => {
+      it('should get paginated subnames for a name ordered by createdAt in desc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 2,
+          orderBy: 'createdAt',
+          orderDirection: 'desc',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual('addr.with-subnames.eth')
+        expect(result.subnames[1].name).toEqual('xyz.with-subnames.eth')
+        expect(
+          result.subnames.every((subname, i, arr) => {
+            if (arr[i + 1]) {
+              return (subname as any).createdAt >= (arr[i + 1] as any).createdAt
+            }
+            return true
+          }),
+        ).toBe(true)
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 2,
+          orderBy: 'createdAt',
+          orderDirection: 'desc',
+          lastSubnames: result.subnames,
+        })
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(2)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual('legacy.with-subnames.eth')
+        expect(result2.subnames[1].name).toEqual('test.with-subnames.eth')
+        expect(
+          result2.subnames.every((subname, i, arr) => {
+            if (arr[i + 1]) {
+              return (subname as any).createdAt >= (arr[i + 1] as any).createdAt
+            }
+            return true
+          }),
+        ).toBe(true)
+        testProperties(
+          result2.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
       })
-      expect(result2).toBeTruthy()
-      expect(result2.subnames.length).toBe(2)
-      expect(result2.subnameCount).toBe(4)
-      expect(result2.subnames[0].name).toEqual('test.with-subnames.eth')
-      expect(result2.subnames[1].name).toEqual('xyz.with-subnames.eth')
-      testProperties(
-        result2.subnames[0],
-        'id',
-        'labelName',
-        'labelhash',
-        'name',
-        'isMigrated',
-        'owner',
-        'truncatedName',
-      )
+      it('should get paginated subnames for a name ordered by createdAt in asc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 2,
+          orderBy: 'createdAt',
+          orderDirection: 'asc',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual('test.with-subnames.eth')
+        expect(result.subnames[1].name).toEqual('legacy.with-subnames.eth')
+        expect(
+          result.subnames.every((subname, i, arr) => {
+            if (arr[i + 1]) {
+              return (subname as any).createdAt <= (arr[i + 1] as any).createdAt
+            }
+            return true
+          }),
+        ).toBe(true)
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          page: 0,
+          pageSize: 2,
+          orderBy: 'createdAt',
+          orderDirection: 'asc',
+          lastSubnames: result.subnames,
+        })
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(2)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual('xyz.with-subnames.eth')
+        expect(result2.subnames[1].name).toEqual('addr.with-subnames.eth')
+        expect(
+          result2.subnames.every((subname, i, arr) => {
+            if (arr[i + 1]) {
+              return (subname as any).createdAt <= (arr[i + 1] as any).createdAt
+            }
+            return true
+          }),
+        ).toBe(true)
+        testProperties(
+          result2.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
+      it('should get paginated subnames for a name by labelName in desc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 2,
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual('xyz.with-subnames.eth')
+        expect(result.subnames[1].name).toEqual('test.with-subnames.eth')
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 2,
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+          lastSubnames: result.subnames,
+        })
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(2)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual('legacy.with-subnames.eth')
+        expect(result2.subnames[1].name).toEqual('addr.with-subnames.eth')
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
+      it('should get paginated subnames for a name by labelName in asc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 2,
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual('addr.with-subnames.eth')
+        expect(result.subnames[1].name).toEqual('legacy.with-subnames.eth')
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 2,
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+          lastSubnames: result.subnames,
+        })
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(2)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual('test.with-subnames.eth')
+        expect(result2.subnames[1].name).toEqual('xyz.with-subnames.eth')
+        testProperties(
+          result2.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
+    })
+    describe('With search query', () => {
+      it('should get the searched subnames for a name ordered by createdAt in desc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 10,
+          orderBy: 'createdAt',
+          orderDirection: 'desc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual('addr.with-subnames.eth')
+        expect(result.subnames[1].name).toEqual('legacy.with-subnames.eth')
+        expect(
+          result.subnames.every((subname, i, arr) => {
+            if (arr[i + 1]) {
+              return (subname as any).createdAt >= (arr[i + 1] as any).createdAt
+            }
+            return true
+          }),
+        ).toBe(true)
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
+      it('should get the searched subnames for a name ordered by createdAt in asc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          page: 0,
+          pageSize: 10,
+          orderBy: 'createdAt',
+          orderDirection: 'asc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual('legacy.with-subnames.eth')
+        expect(result.subnames[1].name).toEqual('addr.with-subnames.eth')
+        expect(
+          result.subnames.every((subname, i, arr) => {
+            if (arr[i + 1]) {
+              return (subname as any).createdAt <= (arr[i + 1] as any).createdAt
+            }
+            return true
+          }),
+        ).toBe(true)
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
+      it('should get the subnames for a name by labelName in desc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 10,
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual('legacy.with-subnames.eth')
+        expect(result.subnames[1].name).toEqual('addr.with-subnames.eth')
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
+      it('should get the subnames for a name by labelName in asc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 10,
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual('addr.with-subnames.eth')
+        expect(result.subnames[1].name).toEqual('legacy.with-subnames.eth')
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
+    })
+    describe('with search query and pagination', () => {
+      it('should get paginated subnames for a name ordered by createdAt in desc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 1,
+          orderBy: 'createdAt',
+          orderDirection: 'desc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(1)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual('addr.with-subnames.eth')
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 1,
+          orderBy: 'createdAt',
+          orderDirection: 'desc',
+          lastSubnames: result.subnames,
+          search: 'a',
+        })
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(1)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual('legacy.with-subnames.eth')
+        testProperties(
+          result2.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
+      it('should get paginated subnames for a name ordered by createdAt in asc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 1,
+          orderBy: 'createdAt',
+          orderDirection: 'asc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(1)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual('legacy.with-subnames.eth')
+        expect(
+          result.subnames.every((subname, i, arr) => {
+            if (arr[i + 1]) {
+              return (subname as any).createdAt <= (arr[i + 1] as any).createdAt
+            }
+            return true
+          }),
+        ).toBe(true)
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          page: 0,
+          pageSize: 2,
+          orderBy: 'createdAt',
+          orderDirection: 'asc',
+          lastSubnames: result.subnames,
+          search: 'a',
+        })
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(1)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual('addr.with-subnames.eth')
+        testProperties(
+          result2.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
+      it('should get paginated subnames for a name by labelName in desc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 1,
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(1)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual('legacy.with-subnames.eth')
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 1,
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+          lastSubnames: result.subnames,
+          search: 'a',
+        })
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(1)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual('addr.with-subnames.eth')
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
+      it('should get paginated subnames for a name by labelName in asc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 1,
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(1)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual('addr.with-subnames.eth')
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'with-subnames.eth',
+          pageSize: 1,
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+          lastSubnames: result.subnames,
+          search: 'a',
+        })
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(1)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual('legacy.with-subnames.eth')
+        testProperties(
+          result2.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
     })
   })
-  describe('With search query', () => {
-    it('should get the searched subnames for a name ordered by createdAt in desc order', async () => {
+  describe('wrapped', () => {
+    it('should get the subnames for a name ordered by createdAt in desc order', async () => {
       const result = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
+        name: 'wrapped-with-subnames.eth',
         pageSize: 10,
         orderBy: 'createdAt',
         orderDirection: 'desc',
-        search: 'a',
       })
       expect(result).toBeTruthy()
-      expect(result.subnames.length).toBe(2)
+      expect(result.subnames.length).toBe(4)
       expect(result.subnameCount).toBe(4)
-      expect(result.subnames[0].name).toEqual('addr.with-subnames.eth')
-      expect(result.subnames[1].name).toEqual('legacy.with-subnames.eth')
+      expect(result.subnames[0].name).toEqual('addr.wrapped-with-subnames.eth')
+      expect(result.subnames[1].name).toEqual('xyz.wrapped-with-subnames.eth')
+      expect(result.subnames[2].name).toEqual(
+        'legacy.wrapped-with-subnames.eth',
+      )
+      expect(result.subnames[3].name).toEqual('test.wrapped-with-subnames.eth')
       expect(
         result.subnames.every((subname, i, arr) => {
           if (arr[i + 1]) {
@@ -439,20 +883,22 @@ describe('getSubnames', () => {
       )
     })
-    it('should get the searched subnames for a name ordered by createdAt in asc order', async () => {
+    it('should get the subnames for a name ordered by createdAt in asc order', async () => {
       const result = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
-        page: 0,
+        name: 'wrapped-with-subnames.eth',
         pageSize: 10,
         orderBy: 'createdAt',
         orderDirection: 'asc',
-        search: 'a',
       })
       expect(result).toBeTruthy()
-      expect(result.subnames.length).toBe(2)
+      expect(result.subnames.length).toBe(4)
       expect(result.subnameCount).toBe(4)
-      expect(result.subnames[0].name).toEqual('legacy.with-subnames.eth')
-      expect(result.subnames[1].name).toEqual('addr.with-subnames.eth')
+      expect(result.subnames[0].name).toEqual('test.wrapped-with-subnames.eth')
+      expect(result.subnames[1].name).toEqual(
+        'legacy.wrapped-with-subnames.eth',
+      )
+      expect(result.subnames[2].name).toEqual('xyz.wrapped-with-subnames.eth')
+      expect(result.subnames[3].name).toEqual('addr.wrapped-with-subnames.eth')
       expect(
         result.subnames.every((subname, i, arr) => {
           if (arr[i + 1]) {
@@ -475,17 +921,20 @@ describe('getSubnames', () => {
     it('should get the subnames for a name by labelName in desc order', async () => {
       const result = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
+        name: 'wrapped-with-subnames.eth',
         pageSize: 10,
         orderBy: 'labelName',
         orderDirection: 'desc',
-        search: 'a',
       })
       expect(result).toBeTruthy()
-      expect(result.subnames.length).toBe(2)
+      expect(result.subnames.length).toBe(4)
       expect(result.subnameCount).toBe(4)
-      expect(result.subnames[0].name).toEqual('legacy.with-subnames.eth')
-      expect(result.subnames[1].name).toEqual('addr.with-subnames.eth')
+      expect(result.subnames[0].name).toEqual('xyz.wrapped-with-subnames.eth')
+      expect(result.subnames[1].name).toEqual('test.wrapped-with-subnames.eth')
+      expect(result.subnames[2].name).toEqual(
+        'legacy.wrapped-with-subnames.eth',
+      )
+      expect(result.subnames[3].name).toEqual('addr.wrapped-with-subnames.eth')
       testProperties(
         result.subnames[0],
         'id',
@@ -500,17 +949,20 @@ describe('getSubnames', () => {
     it('should get the subnames for a name by labelName in asc order', async () => {
       const result = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
+        name: 'wrapped-with-subnames.eth',
         pageSize: 10,
         orderBy: 'labelName',
         orderDirection: 'asc',
-        search: 'a',
       })
       expect(result).toBeTruthy()
-      expect(result.subnames.length).toBe(2)
+      expect(result.subnames.length).toBe(4)
       expect(result.subnameCount).toBe(4)
-      expect(result.subnames[0].name).toEqual('addr.with-subnames.eth')
-      expect(result.subnames[1].name).toEqual('legacy.with-subnames.eth')
+      expect(result.subnames[0].name).toEqual('addr.wrapped-with-subnames.eth')
+      expect(result.subnames[1].name).toEqual(
+        'legacy.wrapped-with-subnames.eth',
+      )
+      expect(result.subnames[2].name).toEqual('test.wrapped-with-subnames.eth')
+      expect(result.subnames[3].name).toEqual('xyz.wrapped-with-subnames.eth')
       testProperties(
         result.subnames[0],
         'id',
@@ -522,205 +974,607 @@ describe('getSubnames', () => {
         'truncatedName',
       )
     })
-  })
-  describe('with search query and pagination', () => {
-    it('should get paginated subnames for a name ordered by createdAt in desc order', async () => {
-      const result = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
-        pageSize: 1,
-        orderBy: 'createdAt',
-        orderDirection: 'desc',
-        search: 'a',
-      })
-      expect(result).toBeTruthy()
-      expect(result.subnames.length).toBe(1)
-      expect(result.subnameCount).toBe(4)
-      expect(result.subnames[0].name).toEqual('addr.with-subnames.eth')
-      testProperties(
-        result.subnames[0],
-        'id',
-        'labelName',
-        'labelhash',
-        'name',
-        'isMigrated',
-        'owner',
-        'truncatedName',
-      )
-      const result2 = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
-        pageSize: 1,
-        orderBy: 'createdAt',
-        orderDirection: 'desc',
-        lastSubnames: result.subnames,
-        search: 'a',
+    describe('with pagination', () => {
+      it('should get paginated subnames for a name ordered by createdAt in desc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 2,
+          orderBy: 'createdAt',
+          orderDirection: 'desc',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual(
+          'addr.wrapped-with-subnames.eth',
+        )
+        expect(result.subnames[1].name).toEqual('xyz.wrapped-with-subnames.eth')
+        expect(
+          result.subnames.every((subname, i, arr) => {
+            if (arr[i + 1]) {
+              return (subname as any).createdAt >= (arr[i + 1] as any).createdAt
+            }
+            return true
+          }),
+        ).toBe(true)
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 2,
+          orderBy: 'createdAt',
+          orderDirection: 'desc',
+          lastSubnames: result.subnames,
+        })
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(2)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual(
+          'legacy.wrapped-with-subnames.eth',
+        )
+        expect(result2.subnames[1].name).toEqual(
+          'test.wrapped-with-subnames.eth',
+        )
+        expect(
+          result2.subnames.every((subname, i, arr) => {
+            if (arr[i + 1]) {
+              return (subname as any).createdAt >= (arr[i + 1] as any).createdAt
+            }
+            return true
+          }),
+        ).toBe(true)
+        testProperties(
+          result2.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
       })
-      expect(result2).toBeTruthy()
-      expect(result2.subnames.length).toBe(1)
-      expect(result2.subnameCount).toBe(4)
-      expect(result2.subnames[0].name).toEqual('legacy.with-subnames.eth')
-      testProperties(
-        result2.subnames[0],
-        'id',
-        'labelName',
-        'labelhash',
-        'name',
-        'isMigrated',
-        'owner',
-        'truncatedName',
-      )
-    })
-    it('should get paginated subnames for a name ordered by createdAt in asc order', async () => {
-      const result = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
-        pageSize: 1,
-        orderBy: 'createdAt',
-        orderDirection: 'asc',
-        search: 'a',
+      it('should get paginated subnames for a name ordered by createdAt in asc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 2,
+          orderBy: 'createdAt',
+          orderDirection: 'asc',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual(
+          'test.wrapped-with-subnames.eth',
+        )
+        expect(result.subnames[1].name).toEqual(
+          'legacy.wrapped-with-subnames.eth',
+        )
+        expect(
+          result.subnames.every((subname, i, arr) => {
+            if (arr[i + 1]) {
+              return (subname as any).createdAt <= (arr[i + 1] as any).createdAt
+            }
+            return true
+          }),
+        ).toBe(true)
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          page: 0,
+          pageSize: 2,
+          orderBy: 'createdAt',
+          orderDirection: 'asc',
+          lastSubnames: result.subnames,
+        })
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(2)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual(
+          'xyz.wrapped-with-subnames.eth',
+        )
+        expect(result2.subnames[1].name).toEqual(
+          'addr.wrapped-with-subnames.eth',
+        )
+        expect(
+          result2.subnames.every((subname, i, arr) => {
+            if (arr[i + 1]) {
+              return (subname as any).createdAt <= (arr[i + 1] as any).createdAt
+            }
+            return true
+          }),
+        ).toBe(true)
+        testProperties(
+          result2.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
       })
-      expect(result).toBeTruthy()
-      expect(result.subnames.length).toBe(1)
-      expect(result.subnameCount).toBe(4)
-      expect(result.subnames[0].name).toEqual('legacy.with-subnames.eth')
-      expect(
-        result.subnames.every((subname, i, arr) => {
-          if (arr[i + 1]) {
-            return (subname as any).createdAt <= (arr[i + 1] as any).createdAt
-          }
-          return true
-        }),
-      ).toBe(true)
-      testProperties(
-        result.subnames[0],
-        'id',
-        'labelName',
-        'labelhash',
-        'name',
-        'isMigrated',
-        'owner',
-        'truncatedName',
-      )
-      const result2 = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
-        page: 0,
-        pageSize: 2,
-        orderBy: 'createdAt',
-        orderDirection: 'asc',
-        lastSubnames: result.subnames,
-        search: 'a',
+      it('should get paginated subnames for a name by labelName in desc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 2,
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual('xyz.wrapped-with-subnames.eth')
+        expect(result.subnames[1].name).toEqual(
+          'test.wrapped-with-subnames.eth',
+        )
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 2,
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+          lastSubnames: result.subnames,
+        })
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(2)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual(
+          'legacy.wrapped-with-subnames.eth',
+        )
+        expect(result2.subnames[1].name).toEqual(
+          'addr.wrapped-with-subnames.eth',
+        )
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
       })
-      expect(result2).toBeTruthy()
-      expect(result2.subnames.length).toBe(1)
-      expect(result2.subnameCount).toBe(4)
-      expect(result2.subnames[0].name).toEqual('addr.with-subnames.eth')
+      it('should get paginated subnames for a name by labelName in asc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 2,
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual(
+          'addr.wrapped-with-subnames.eth',
+        )
+        expect(result.subnames[1].name).toEqual(
+          'legacy.wrapped-with-subnames.eth',
+        )
-      testProperties(
-        result2.subnames[0],
-        'id',
-        'labelName',
-        'labelhash',
-        'name',
-        'isMigrated',
-        'owner',
-        'truncatedName',
-      )
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 2,
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+          lastSubnames: result.subnames,
+        })
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(2)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual(
+          'test.wrapped-with-subnames.eth',
+        )
+        expect(result2.subnames[1].name).toEqual(
+          'xyz.wrapped-with-subnames.eth',
+        )
+        testProperties(
+          result2.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
     })
-    it('should get paginated subnames for a name by labelName in desc order', async () => {
-      const result = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
-        pageSize: 1,
-        orderBy: 'labelName',
-        orderDirection: 'desc',
-        search: 'a',
+    describe('With search query', () => {
+      it('should get the searched subnames for a name ordered by createdAt in desc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 10,
+          orderBy: 'createdAt',
+          orderDirection: 'desc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual(
+          'addr.wrapped-with-subnames.eth',
+        )
+        expect(result.subnames[1].name).toEqual(
+          'legacy.wrapped-with-subnames.eth',
+        )
+        expect(
+          result.subnames.every((subname, i, arr) => {
+            if (arr[i + 1]) {
+              return (subname as any).createdAt >= (arr[i + 1] as any).createdAt
+            }
+            return true
+          }),
+        ).toBe(true)
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
       })
-      expect(result).toBeTruthy()
-      expect(result.subnames.length).toBe(1)
-      expect(result.subnameCount).toBe(4)
-      expect(result.subnames[0].name).toEqual('legacy.with-subnames.eth')
-      testProperties(
-        result.subnames[0],
-        'id',
-        'labelName',
-        'labelhash',
-        'name',
-        'isMigrated',
-        'owner',
-        'truncatedName',
-      )
-      const result2 = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
-        pageSize: 1,
-        orderBy: 'labelName',
-        orderDirection: 'desc',
-        lastSubnames: result.subnames,
-        search: 'a',
+      it('should get the searched subnames for a name ordered by createdAt in asc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          page: 0,
+          pageSize: 10,
+          orderBy: 'createdAt',
+          orderDirection: 'asc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual(
+          'legacy.wrapped-with-subnames.eth',
+        )
+        expect(result.subnames[1].name).toEqual(
+          'addr.wrapped-with-subnames.eth',
+        )
+        expect(
+          result.subnames.every((subname, i, arr) => {
+            if (arr[i + 1]) {
+              return (subname as any).createdAt <= (arr[i + 1] as any).createdAt
+            }
+            return true
+          }),
+        ).toBe(true)
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
+      it('should get the subnames for a name by labelName in desc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 10,
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual(
+          'legacy.wrapped-with-subnames.eth',
+        )
+        expect(result.subnames[1].name).toEqual(
+          'addr.wrapped-with-subnames.eth',
+        )
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
+      it('should get the subnames for a name by labelName in asc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 10,
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(2)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual(
+          'addr.wrapped-with-subnames.eth',
+        )
+        expect(result.subnames[1].name).toEqual(
+          'legacy.wrapped-with-subnames.eth',
+        )
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
       })
-      expect(result2).toBeTruthy()
-      expect(result2.subnames.length).toBe(1)
-      expect(result2.subnameCount).toBe(4)
-      expect(result2.subnames[0].name).toEqual('addr.with-subnames.eth')
-      testProperties(
-        result.subnames[0],
-        'id',
-        'labelName',
-        'labelhash',
-        'name',
-        'isMigrated',
-        'owner',
-        'truncatedName',
-      )
     })
-    it('should get paginated subnames for a name by labelName in asc order', async () => {
-      const result = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
-        pageSize: 1,
-        orderBy: 'labelName',
-        orderDirection: 'asc',
-        search: 'a',
+    describe('with search query and pagination', () => {
+      it('should get paginated subnames for a name ordered by createdAt in desc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 1,
+          orderBy: 'createdAt',
+          orderDirection: 'desc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(1)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual(
+          'addr.wrapped-with-subnames.eth',
+        )
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 1,
+          orderBy: 'createdAt',
+          orderDirection: 'desc',
+          lastSubnames: result.subnames,
+          search: 'a',
+        })
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(1)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual(
+          'legacy.wrapped-with-subnames.eth',
+        )
+        testProperties(
+          result2.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
       })
-      expect(result).toBeTruthy()
-      expect(result.subnames.length).toBe(1)
-      expect(result.subnameCount).toBe(4)
-      expect(result.subnames[0].name).toEqual('addr.with-subnames.eth')
-      testProperties(
-        result.subnames[0],
-        'id',
-        'labelName',
-        'labelhash',
-        'name',
-        'isMigrated',
-        'owner',
-        'truncatedName',
-      )
+      it('should get paginated subnames for a name ordered by createdAt in asc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 1,
+          orderBy: 'createdAt',
+          orderDirection: 'asc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(1)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual(
+          'legacy.wrapped-with-subnames.eth',
+        )
+        expect(
+          result.subnames.every((subname, i, arr) => {
+            if (arr[i + 1]) {
+              return (subname as any).createdAt <= (arr[i + 1] as any).createdAt
+            }
+            return true
+          }),
+        ).toBe(true)
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          page: 0,
+          pageSize: 2,
+          orderBy: 'createdAt',
+          orderDirection: 'asc',
+          lastSubnames: result.subnames,
+          search: 'a',
+        })
-      const result2 = await ensInstance.getSubnames({
-        name: 'with-subnames.eth',
-        pageSize: 1,
-        orderBy: 'labelName',
-        orderDirection: 'asc',
-        lastSubnames: result.subnames,
-        search: 'a',
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(1)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual(
+          'addr.wrapped-with-subnames.eth',
+        )
+        testProperties(
+          result2.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
       })
-      expect(result2).toBeTruthy()
-      expect(result2.subnames.length).toBe(1)
-      expect(result2.subnameCount).toBe(4)
-      expect(result2.subnames[0].name).toEqual('legacy.with-subnames.eth')
-      testProperties(
-        result2.subnames[0],
-        'id',
-        'labelName',
-        'labelhash',
-        'name',
-        'isMigrated',
-        'owner',
-        'truncatedName',
-      )
+      it('should get paginated subnames for a name by labelName in desc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 1,
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(1)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual(
+          'legacy.wrapped-with-subnames.eth',
+        )
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 1,
+          orderBy: 'labelName',
+          orderDirection: 'desc',
+          lastSubnames: result.subnames,
+          search: 'a',
+        })
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(1)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual(
+          'addr.wrapped-with-subnames.eth',
+        )
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
+      it('should get paginated subnames for a name by labelName in asc order', async () => {
+        const result = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 1,
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+          search: 'a',
+        })
+        expect(result).toBeTruthy()
+        expect(result.subnames.length).toBe(1)
+        expect(result.subnameCount).toBe(4)
+        expect(result.subnames[0].name).toEqual(
+          'addr.wrapped-with-subnames.eth',
+        )
+        testProperties(
+          result.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+        const result2 = await ensInstance.getSubnames({
+          name: 'wrapped-with-subnames.eth',
+          pageSize: 1,
+          orderBy: 'labelName',
+          orderDirection: 'asc',
+          lastSubnames: result.subnames,
+          search: 'a',
+        })
+        expect(result2).toBeTruthy()
+        expect(result2.subnames.length).toBe(1)
+        expect(result2.subnameCount).toBe(4)
+        expect(result2.subnames[0].name).toEqual(
+          'legacy.wrapped-with-subnames.eth',
+        )
+        testProperties(
+          result2.subnames[0],
+          'id',
+          'labelName',
+          'labelhash',
+          'name',
+          'isMigrated',
+          'owner',
+          'truncatedName',
+        )
+      })
     })
   })
 })