Drop old names support, split ensureNameValid and isNameValid

src/ae/aens.js

@@ -30,7 +30,7 @@ import * as R from 'ramda'
 import { salt } from '../utils/crypto'
 import {
   commitmentHash,
-  isNameValid,
+  ensureNameValid,
   getMinimumNameFee,
   classify,
   isAuctionName,
@@ -62,7 +62,7 @@ import { CLIENT_TTL, NAME_FEE, NAME_TTL } from '../tx/builder/schema'
  * await nameObject.revoke({ fee, ttl, nonce })
  */
 async function revoke (name, options = {}) {
-  isNameValid(name)
+  ensureNameValid(name)
   const opt = R.merge(this.Ae.defaults, options)
 
   const nameRevokeTx = await this.nameRevokeTx(R.merge(opt, {
@@ -102,7 +102,7 @@ async function revoke (name, options = {}) {
  * await nameObject.update(pointersArray, { nameTtl, ttl, fee, nonce, clientTtl })
  */
 async function update (name, pointers = [], options = { extendPointers: false }) {
-  isNameValid(name)
+  ensureNameValid(name)
   const opt = R.merge(this.Ae.defaults, options)
   if (!validatePointers(pointers)) throw new Error('Invalid pointers array')
 
@@ -144,7 +144,7 @@ async function update (name, pointers = [], options = { extendPointers: false })
  * await nameObject.transfer(recipientPub, { ttl, fee, nonce })
  */
 async function transfer (name, account, options = {}) {
-  isNameValid(name)
+  ensureNameValid(name)
   const opt = R.merge(this.Ae.defaults, options)
 
   const nameTransferTx = await this.nameTransferTx(R.merge(opt, {
@@ -179,7 +179,7 @@ async function transfer (name, account, options = {}) {
  * }
  */
 async function query (name, opt = {}) {
-  isNameValid(name)
+  ensureNameValid(name)
   const o = await this.getName(name)
 
   return Object.freeze(Object.assign(o, {
@@ -233,7 +233,7 @@ async function query (name, opt = {}) {
  * await sdkInstance.aensClaim(name, salt, { ttl, fee, nonce, nameFee })
  */
 async function claim (name, salt, options = { vsn: 2 }) {
-  isNameValid(name)
+  ensureNameValid(name)
   const opt = R.merge(this.Ae.defaults, options)
 
   const minNameFee = getMinimumNameFee(name)
@@ -283,7 +283,7 @@ async function claim (name, salt, options = { vsn: 2 }) {
  * }
  */
 async function preclaim (name, options = {}) {
-  isNameValid(name)
+  ensureNameValid(name)
   const opt = R.merge(this.Ae.defaults, options)
   const _salt = salt()
   const height = await this.height()

src/tx/builder/helpers.js

@@ -13,7 +13,6 @@ import { toBytes } from '../../utils/bytes'
 import {
   ID_TAG_PREFIX,
   PREFIX_ID_TAG,
-  AENS_NAME_DOMAINS,
   NAME_BID_RANGES,
   NAME_BID_MAX_LENGTH,
   NAME_FEE,
@@ -93,26 +92,6 @@ export function formatSalt (salt) {
   return Buffer.from(salt.toString(16).padStart(64, '0'), 'hex')
 }
 
-/**
- * Calculate 256bits Blake2b nameId of `input`
- * as defined in https://github.com/aeternity/protocol/blob/master/AENS.md#hashing
- * @rtype (input: String) => hash: String
- * @param {String} input - Data to hash
- * @return {Buffer} Hash
- */
-export function nameHash (input) {
-  let buf = Buffer.allocUnsafe(32).fill(0)
-  if (!input) {
-    return buf
-  } else {
-    const labels = input.split('.')
-    for (let i = 0; i < labels.length; i++) {
-      buf = hash(Buffer.concat([buf, hash(labels[i])]))
-    }
-    return buf
-  }
-}
-
 /**
  * Encode a domain name
  * @function
@@ -121,9 +100,8 @@ export function nameHash (input) {
  * @return {String} `nm_` prefixed encoded domain name
  */
 export function produceNameId (name) {
-  const namespace = R.last(name.split('.'))
-  if (namespace === 'chain') return encode(hash(name.toLowerCase()), 'nm')
-  return encode(nameHash(name), 'nm')
+  ensureNameValid(name)
+  return encode(hash(name.toLowerCase()), 'nm')
 }
 
 /**
@@ -139,9 +117,8 @@ export function produceNameId (name) {
  * @return {String} Commitment hash
  */
 export function commitmentHash (name, salt = createSalt()) {
-  const namespace = R.last(name.split('.'))
-  if (namespace === 'chain') return `cm_${encodeBase58Check(hash(Buffer.concat([Buffer.from(name.toLowerCase()), formatSalt(salt)])))}`
-  return `cm_${encodeBase58Check(hash(Buffer.concat([nameHash(name.toLowerCase()), formatSalt(salt)])))}`
+  ensureNameValid(name)
+  return `cm_${encodeBase58Check(hash(Buffer.concat([Buffer.from(name.toLowerCase()), formatSalt(salt)])))}`
 }
 
 /**
@@ -255,22 +232,33 @@ export function readPointers (pointers) {
   )
 }
 
+/**
+ * Ensure that name is valid
+ * @function
+ * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
+ * @param {string} name
+ * @return void
+ * @throws Error
+ */
+export function ensureNameValid (name) {
+  if (!name || typeof name !== 'string') throw new Error('Name must be a string')
+  if (!name.endsWith('.chain')) throw new Error(`Name should end with .chain: ${name}`)
+}
+
 /**
  * Is name valid
  * @function
  * @alias module:@aeternity/aepp-sdk/es/tx/builder/helpers
  * @param {string} name
- * @param {boolean} [throwError=true] Throw error on invalid
  * @return Boolean
- * @throws Error
  */
-export function isNameValid (name, throwError = true) {
-  if ((!name || typeof name !== 'string') && throwError) throw new Error('AENS: Name must be a string')
-  if (!AENS_NAME_DOMAINS.includes(R.last(name.split('.')))) {
-    if (throwError) throw new Error(`AENS: Invalid name domain. Possible domains [${AENS_NAME_DOMAINS}]`)
+export function isNameValid (name) {
+  try {
+    ensureNameValid(name)
+    return true
+  } catch (error) {
     return false
   }
-  return true
 }
 
 /**
@@ -374,26 +362,3 @@ export function getContractBackendFromTx ({ abiVersion } = {}) {
 export function isAuctionName (name) {
   return name.replace('.chain', '').length < 13
 }
-
-export default {
-  readPointers,
-  buildPointers,
-  buildContractId,
-  readId,
-  writeId,
-  readInt,
-  writeInt,
-  encode,
-  decode,
-  commitmentHash,
-  formatSalt,
-  oracleQueryId,
-  getContractBackendFromTx,
-  createSalt,
-  buildHash,
-  isNameValid,
-  produceNameId,
-  classify,
-  isAuctionName,
-  validatePointers
-}

src/tx/builder/schema.js

@@ -27,7 +27,6 @@ export const MIN_GAS_PRICE = 1000000000 // min gasPrice 1e9
 export const MAX_AUTH_FUN_GAS = 50000
 export const DRY_RUN_ACCOUNT = { pub: 'ak_11111111111111111111111111111111273Yts', amount: '100000000000000000000000000000000000' }
 // # AENS
-export const AENS_NAME_DOMAINS = ['chain']
 export const NAME_TTL = 50000
 // # max number of block into the future that the name is going to be available
 // # https://github.com/aeternity/protocol/blob/epoch-v0.22.0/AENS.md#update

test/integration/transaction.js

@@ -18,7 +18,7 @@
 import { describe, it, before } from 'mocha'
 import { encodeBase58Check, encodeBase64Check, generateKeyPair, salt } from '../../src/utils/crypto'
 import { getSdk } from './index'
-import { commitmentHash, isNameValid, oracleQueryId } from '../../src/tx/builder/helpers'
+import { commitmentHash, oracleQueryId } from '../../src/tx/builder/helpers'
 import { MemoryAccount } from '../../src'
 import { AE_AMOUNT_FORMATS } from '../../src/utils/amount-formatter'
 import { unpackTx } from '../../src/tx/builder'
@@ -29,7 +29,7 @@ const clientTtl = 1
 const amount = 0
 const senderId = 'ak_2iBPH7HUz3cSDVEUWiHg76MZJ6tZooVNBmmxcgVK6VV8KAE688'
 const recipientId = 'ak_2iBPH7HUz3cSDVEUWiHg76MZJ6tZooVNBmmxcgVK6VV8KAE688'
-const name = 'test123test.test'
+const name = 'test123test.chain'
 const nameHash = `nm_${encodeBase58Check(Buffer.from(name))}`
 const nameId = 'nm_2sFnPHi5ziAqhdApSpRBsYdomCahtmk3YGNZKYUTtUNpVSMccC'
 const nameFee = '1000000000000000000000'
@@ -258,13 +258,6 @@ describe('Native Transaction', function () {
     const nonceCustom = await client.getAccountNonce(await client.address(), 1)
     nonceCustom.should.be.equal(1)
   })
-  it('Is name valid', () => {
-    try {
-      isNameValid('asdasdasd.testDomain')
-    } catch (e) {
-      e.message.indexOf('AENS: Invalid name domain').should.not.be.equal(-1)
-    }
-  })
   it('Destroy instance', () => {
     client.destroyInstance()
     console.log('Finish without error')

test/unit/tx.js

@@ -18,7 +18,7 @@
 import '../'
 import { describe, it } from 'mocha'
 import { salt, rlp } from '../../src/utils/crypto'
-import { classify, commitmentHash, isNameValid, nameHash, produceNameId } from '../../src/tx/builder/helpers'
+import { classify, commitmentHash, ensureNameValid, isNameValid, produceNameId } from '../../src/tx/builder/helpers'
 import BigNumber from 'bignumber.js'
 import { toBytes } from '../../src/utils/bytes'
 import { parseBigNumber } from '../../src/utils/bignumber'
@@ -27,9 +27,9 @@ import { buildTx, unpackTx } from '../../src/tx/builder'
 describe('Tx', function () {
   it('reproducible commitment hashes can be generated', async () => {
     const _salt = salt()
-    const hash = await commitmentHash('foobar.aet', _salt)
+    const hash = await commitmentHash('foobar.chain', _salt)
     hash.should.be.a('string')
-    return hash.should.be.equal(await commitmentHash('foobar.aet', _salt))
+    return hash.should.be.equal(await commitmentHash('foobar.chain', _salt))
   })
   it('Parse big number', async () => {
     parseBigNumber('123123123123').should.be.a('string')
@@ -54,15 +54,36 @@ describe('Tx', function () {
       n.toString(10).should.be.equal(bnFromBytes(n))
     })
   })
-  it('nameHash: Invalid input', () => {
-    nameHash(undefined).equals(Buffer.allocUnsafe(32).fill(0)).should.be.equal(true)
+  it('Produce name id for `.chain`', () => {
+    produceNameId('asdas.chain').should.be.equal('nm_2DMazuJNrGkQYve9eMttgdteaigeeuBk3fmRYSThJZ2NpX3r8R')
   })
-  it('Produce name if for `.test`', () => {
-    produceNameId('asdas.test').should.be.equal('nm_KhRggXqN4siPYQtacAncf9v4B4fBrcu4qrDkDi6PhsGpFxS7y')
+
+  describe('ensureNameValid', () => {
+    it('validates type', () => {
+      try {
+        ensureNameValid({})
+      } catch ({ message }) {
+        message.should.be.equal('Name must be a string')
+      }
+    })
+
+    it('validates domain', () => {
+      try {
+        ensureNameValid('asdasdasd.unknown')
+      } catch ({ message }) {
+        message.should.have.string('Name should end with .chain:')
+      }
+    })
+
+    it('don\'t throws exception', () => ensureNameValid('asdasdasd.chain'))
   })
-  it('isNameValid: invalid namespace', () => {
-    isNameValid('asdas.eth', false).should.be.equal(false)
+
+  describe('isNameValid', () => {
+    it('validates type', () => isNameValid({}).should.be.equal(false))
+    it('validates domain', () => isNameValid('asdasdasd.unknown').should.be.equal(false))
+    it('don\'t throws exception', () => isNameValid('asdasdasd.chain').should.be.equal(true))
   })
+
   it('classify: invalid hash', () => {
     try {
       classify('aaaaa')