@aeternity/aepp-sdk 9.0.1 → 11.0.0

package/package.json

@@ -1,31 +1,27 @@
 {
   "name": "@aeternity/aepp-sdk",
-  "version": "9.0.1",
+  "version": "11.0.0",
   "description": "SDK for the æternity blockchain",
   "main": "dist/aepp-sdk.js",
   "types": "es/index.d.ts",
-  "module": "es/index.js",
+  "module": "es/index.mjs",
   "browser": {
     "dist/aepp-sdk.js": "./dist/aepp-sdk.browser.js"
   },
   "sideEffects": false,
   "scripts": {
-    "build:es": "tsc && babel src --config-file ./babel.esm.config.js --out-dir es --extensions '.js,.ts' --source-maps true",
+    "build:es": "tsc && babel src --config-file ./babel.esm.config.js --out-dir es --extensions .js,.ts --out-file-extension .mjs --source-maps true",
     "build": "webpack --mode=production && npm run build:es",
     "build:dev": "webpack --mode=development && npm run build:es",
     "docs:examples": "node tooling/docs/examples-to-md.js examples/node/*.js",
     "docs:api": "node apidoc.js",
-    "docs:changelog": "cp CHANGELOG.md docs/CHANGELOG.md",
-    "lint": "commitlint --from develop --verbose && ts-standard",
-    "test": "nyc --require @babel/register --require ts-node/register mocha --recursive --exit --timeout 10m",
-    "report-coverage": "nyc report --reporter=text-lcov > coverage.lcov && codecov",
-    "test:integration:channel,accounts": "nyc --require @babel/register --require ts-node/register mocha './test/integration/@(channel|accounts).js' --exit --timeout 10m",
-    "test:integration:contract,chain": "nyc --require @babel/register --require ts-node/register mocha './test/integration/@(contract|chain).js' --timeout 10m",
-    "test:integration:else": "nyc --require @babel/register --require ts-node/register mocha './test/integration/!(channel|accounts|contract|chain).js' --timeout 10m",
-    "test:unit": "nyc --require @babel/register --require ts-node/register mocha './test/unit/*'",
-    "test:watch": "mocha --recursive --require @babel/register --require ts-node/register --watch --timeout 10m",
+    "lint": "eslint .",
+    "test": "nyc mocha './test/unit/' './test/integration/'",
+    "test:integration": "nyc mocha './test/integration/'",
+    "test:unit": "nyc mocha './test/unit/'",
+    "test:watch": "mocha './test/unit/' './test/integration/' --watch",
     "prepare": "npm run build",
-    "prepublishOnly": "npm run docs:examples && npm run docs:changelog",
+    "prepublishOnly": "npm run docs:examples",
     "release": "standard-version --skip.tag"
   },
   "license": "ISC",
@@ -36,33 +32,27 @@
     "SDK"
   ],
   "dependencies": {
-    "@aeternity/bip39": "^0.1.0",
+    "@aeternity/aepp-calldata": "^1.1.1",
+    "@aeternity/argon2-browser": "^0.1.2",
+    "@aeternity/blakejs": "^1.1.2",
     "@aeternity/json-bigint": "^0.3.1",
-    "@babel/runtime-corejs3": "^7.14.0",
+    "@aeternity/uuid": "^0.0.1",
+    "@babel/runtime-corejs3": "^7.17.2",
     "@stamp/it": "^1.1.0",
     "@stamp/required": "^1.0.1",
     "aes-js": "^3.1.2",
-    "bignumber.js": "^9.0.1",
+    "bignumber.js": "^9.0.2",
     "bip32-path": "^0.4.2",
-    "blakejs": "^1.1.0",
-    "bs58check": "^2.1.2",
+    "bs58": "^4.0.1",
     "buffer": "^6.0.3",
-    "cross-fetch": "^3.1.4",
-    "crypto-browserify": "^3.12.0",
-    "ed2curve": "^0.3.0",
+    "cross-fetch": "^3.1.5",
     "events": "^3.3.0",
-    "joi-browser": "^13.4.0",
-    "libsodium-wrappers-sumo": "0.7.9",
-    "path-browserify": "^1.0.1",
     "process": "^0.11.10",
-    "ramda": "^0.27.1",
-    "rlp": "2.2.6",
+    "rlp": "^3.0.0",
     "sha.js": "^2.4.11",
-    "stream-browserify": "^3.0.0",
-    "swagger-client": "^3.13.5",
+    "swagger-client": "^3.18.4",
     "tweetnacl": "^1.0.3",
     "tweetnacl-auth": "^1.0.1",
-    "uuid": "^8.3.2",
     "websocket": "^1.0.34"
   },
   "repository": {
@@ -70,47 +60,50 @@
     "url": "https://github.com/aeternity/aepp-sdk-js"
   },
   "devDependencies": {
-    "@babel/cli": "7.14.3",
-    "@babel/core": "7.14.3",
-    "@babel/node": "7.14.2",
-    "@babel/plugin-proposal-export-default-from": "7.12.13",
-    "@babel/plugin-proposal-object-rest-spread": "7.14.4",
-    "@babel/plugin-transform-runtime": "7.14.3",
-    "@babel/preset-env": "7.14.4",
-    "@babel/preset-typescript": "^7.13.0",
-    "@babel/register": "7.13.16",
-    "@commitlint/cli": "^12.1.4",
-    "@commitlint/config-conventional": "^12.1.4",
+    "@babel/cli": "^7.17.0",
+    "@babel/core": "^7.17.2",
+    "@babel/node": "^7.16.8",
+    "@babel/plugin-transform-runtime": "^7.17.0",
+    "@babel/preset-env": "^7.16.11",
+    "@babel/preset-typescript": "^7.16.7",
+    "@babel/register": "^7.17.0",
+    "@commitlint/cli": "^16.1.0",
+    "@commitlint/config-conventional": "^16.0.0",
     "@types/bn.js": "^5.1.0",
-    "@types/chai": "^4.2.18",
-    "@types/mocha": "^8.2.2",
-    "@types/node": "^15.6.1",
-    "babel-loader": "^8.2.2",
-    "babel-plugin-ramda": "^2.0.0",
-    "chai": "^4.3.4",
+    "@types/chai": "^4.3.0",
+    "@types/mocha": "^9.1.0",
+    "@types/node": "^17.0.17",
+    "@typescript-eslint/eslint-plugin": "^5.11.0",
+    "@typescript-eslint/parser": "^5.11.0",
+    "babel-loader": "^8.2.3",
+    "babel-plugin-add-import-extension": "^1.6.0",
+    "babel-plugin-import-globals": "^2.0.0",
+    "babel-plugin-transform-default-named-imports": "^1.2.2",
+    "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
-    "codecov": "^3.8.2",
-    "jsdoc-to-markdown": "^7.0.1",
-    "mocha": "^8.4.0",
+    "eslint": "^8.8.0",
+    "eslint-config-standard": "^17.0.0-1",
+    "jsdoc-to-markdown": "^7.1.1",
+    "mocha": "^9.2.0",
     "nyc": "^15.1.0",
-    "sinon": "^11.1.1",
+    "sinon": "^13.0.1",
     "source-map": "^0.7.3",
-    "standard-version": "^9.3.0",
-    "ts-node": "^10.0.0",
-    "ts-standard": "^10.0.0",
-    "typescript": "4.2.4",
-    "webpack": "^5.38.1",
-    "webpack-bundle-analyzer": "^4.4.2",
-    "webpack-cli": "4.7.0"
+    "standard-version": "^9.3.2",
+    "ts-node": "^10.5.0",
+    "typescript": "^4.5.5",
+    "webpack": "^5.68.0",
+    "webpack-bundle-analyzer": "^4.5.0",
+    "webpack-cli": "^4.9.2"
   },
   "files": [
     "dist",
     "src",
     "es"
   ],
-  "ts-standard": {
-    "ignore": [
-      "examples/**/*.js"
-    ]
-  }
+  "browserslist": [
+    "> 1%",
+    "last 2 versions",
+    "not dead",
+    "not ie 11"
+  ]
 }

package/src/account/base.js

@@ -85,7 +85,9 @@ async function signMessage (message, opt = { returnHex: false }) {
  * Verify message
  * @instance
  * @category async
- * @rtype (msg: String, signature: String, publicKey: String) => signature: Promise[String], throws: Error
+ * @rtype (
+ *   msg: String, signature: String, publicKey: String
+ * ) => signature: Promise[String], throws: Error
  * @param {String} message - Message to verify
  * @param {String} signature - Signature
  * @param {Object} opt - Options

package/src/account/memory.js

@@ -23,9 +23,10 @@
  */
 
 import AccountBase from './base'
-import { sign, isAddressValid, isValidKeypair } from '../utils/crypto'
+import { sign, isValidKeypair } from '../utils/crypto'
 import { isHex } from '../utils/string'
 import { decode } from '../tx/builder/helpers'
+import { InvalidKeypairError } from '../utils/errors'
 
 const secrets = new WeakMap()
 
@@ -44,21 +45,25 @@ export default AccountBase.compose({
   init ({ keypair, gaId }) {
     this.isGa = !!gaId
     if (gaId) {
-      if (!isAddressValid(gaId)) throw new Error('Invalid GA address')
+      decode(gaId)
       secrets.set(this, { publicKey: gaId })
       return
     }
 
-    if (!keypair || typeof keypair !== 'object') throw new Error('KeyPair must be an object')
-    if (!keypair.secretKey || !keypair.publicKey) throw new Error('KeyPair must must have "secretKey", "publicKey" properties')
-    if (typeof keypair.publicKey !== 'string' || keypair.publicKey.indexOf('ak_') === -1) throw new Error('Public Key must be a base58c string with "ak_" prefix')
+    if (!keypair || typeof keypair !== 'object') throw new InvalidKeypairError('KeyPair must be an object')
+    if (!keypair.secretKey || !keypair.publicKey) {
+      throw new InvalidKeypairError('KeyPair must must have "secretKey", "publicKey" properties')
+    }
+    if (typeof keypair.publicKey !== 'string' || keypair.publicKey.indexOf('ak_') === -1) {
+      throw new InvalidKeypairError('Public Key must be a base58c string with "ak_" prefix')
+    }
     if (
       !Buffer.isBuffer(keypair.secretKey) &&
       (typeof keypair.secretKey === 'string' && !isHex(keypair.secretKey))
-    ) throw new Error('Secret key must be hex string or Buffer')
+    ) throw new InvalidKeypairError('Secret key must be hex string or Buffer')
 
     const pubBuffer = Buffer.from(decode(keypair.publicKey, 'ak'))
-    if (!isValidKeypair(Buffer.from(keypair.secretKey, 'hex'), pubBuffer)) throw new Error('Invalid Key Pair')
+    if (!isValidKeypair(Buffer.from(keypair.secretKey, 'hex'), pubBuffer)) throw new InvalidKeypairError('Invalid Key Pair')
 
     secrets.set(this, {
       secretKey: Buffer.isBuffer(keypair.secretKey) ? keypair.secretKey : Buffer.from(keypair.secretKey, 'hex'),
@@ -68,7 +73,7 @@ export default AccountBase.compose({
   props: { isGa: false },
   methods: {
     sign (data) {
-      if (this.isGa) throw new Error('You are trying to sign data using GA account without keypair')
+      if (this.isGa) throw new InvalidKeypairError('You are trying to sign data using generalized account without keypair')
       return Promise.resolve(sign(data, secrets.get(this).secretKey))
     },
     address () {

package/src/account/multiple.js

@@ -21,11 +21,14 @@
  * @export AccountMultiple
  */
 
-import * as R from 'ramda'
 import AsyncInit from '../utils/async-init'
 import MemoryAccount from './memory'
 import { decode } from '../tx/builder/helpers'
 import AccountBase, { isAccountBase } from './base'
+import {
+  UnavailableAccountError,
+  TypeError
+} from '../utils/errors'
 
 /**
  * AccountMultiple stamp
@@ -42,7 +45,9 @@ import AccountBase, { isAccountBase } from './base'
  * @param {String} [options.address] - Address of account to select
  * @return {Object} AccountMultiple instance
  * @example
- * const accounts = await AccountMultiple({ accounts: [ MemmoryAccount({ keypair: 'keypair_object' }) ] })
+ * const accounts = await AccountMultiple({
+ *   accounts: [MemoryAccount({ keypair: 'keypair_object' })]
+ * })
  * await accounts.addAccount(account, { select: true }) // Add account and make it selected
  * accounts.removeAccount(address) // Remove account
  * accounts.selectAccount(address) // Select account
@@ -50,15 +55,11 @@ import AccountBase, { isAccountBase } from './base'
  */
 export default AccountBase.compose(AsyncInit, {
   async init ({ accounts = [], address }) {
-    /* An Account maynot be required for the Node/Chain methods */
-    if (Array.isArray(accounts) && accounts.length) {
-      this.accounts = R.fromPairs(await Promise.all(accounts.map(async a => [await a.address(), a])))
-      if (!address) address = Object.keys(this.accounts)[0]
-      decode(address, 'ak')
-      this.selectedAddress = address
-    } else {
-      console.warn('No account/accounts supplied')
-    }
+    this.accounts = Object.fromEntries(await Promise.all(
+      accounts.map(async a => [await a.address(), a])
+    ))
+    address = address || Object.keys(this.accounts)[0]
+    if (address) this.selectAccount(address)
   },
   props: {
     accounts: {}
@@ -128,25 +129,33 @@ export default AccountBase.compose(AsyncInit, {
      */
     selectAccount (address) {
       decode(address, 'ak')
-      if (!this.accounts[address]) throw new Error(`Account for ${address} not available`)
+      if (!this.accounts[address]) throw new UnavailableAccountError(address)
       this.selectedAddress = address
     },
     /**
      * Resolves an account
-     * @param account can be account address (should exist in sdk instance), MemoryAccount or keypair
+     * @param account account address (should exist in sdk instance), MemoryAccount or keypair
      * @returns {AccountBase}
      * @private
      */
     _resolveAccount (account) {
-      switch (typeof account) {
-        case 'string':
-          decode(account, 'ak')
-          if (!this.accounts[account]) throw new Error(`Account for ${account} not available`)
-          return this.accounts[account]
-        case 'object':
-          return isAccountBase(account) ? account : MemoryAccount({ keypair: account })
-        default:
-          throw new Error(`Unknown account type: ${typeof account} (account: ${account})`)
+      if (account === null) {
+        throw new TypeError(
+          'Account should be an address (ak-prefixed string), ' +
+          'keypair, or instance of account base, got null instead')
+      } else {
+        switch (typeof account) {
+          case 'string':
+            decode(account, 'ak')
+            if (!this.accounts[account]) throw new UnavailableAccountError(account)
+            return this.accounts[account]
+          case 'object':
+            return isAccountBase(account) ? account : MemoryAccount({ keypair: account })
+          default:
+            throw new TypeError(
+              'Account should be an address (ak-prefixed string), ' +
+              `keypair, or instance of account base, got ${account} instead`)
+        }
       }
     }
   }

package/src/ae/aens.js

@@ -26,18 +26,11 @@
  * @example import { Aens } from '@aeternity/aepp-sdk'
  */
 
-import * as R from 'ramda'
 import { salt } from '../utils/crypto'
-import {
-  commitmentHash,
-  ensureNameValid,
-  getMinimumNameFee,
-  classify,
-  isAuctionName,
-  validatePointers, encode, produceNameId
-} from '../tx/builder/helpers'
+import { commitmentHash, ensureNameValid, isAuctionName } from '../tx/builder/helpers'
 import Ae from './'
-import { CLIENT_TTL, NAME_FEE, NAME_TTL } from '../tx/builder/schema'
+import { CLIENT_TTL, NAME_TTL } from '../tx/builder/schema'
+import { ArgumentError } from '../utils/errors'
 
 /**
  * Revoke a name
@@ -47,11 +40,11 @@ import { CLIENT_TTL, NAME_FEE, NAME_TTL } from '../tx/builder/schema'
  * @category async
  * @param {String} name Name hash
  * @param {Object} [options={}] options
- * @param {(String|Object)} [options.onAccount] onAccount Make operation on specific account from sdk(you pass publickKey) or
- * using provided KeyPair(Can be keypair object or MemoryAccount)
- * @param {(Number|String|BigNumber)} [options.fee] fee
- * @param {(Number|String|BigNumber)} [options.ttl] ttl
- * @param {(Number|String|BigNumber)} [options.nonce] nonce
+ * @param {String|Object} [options.onAccount] Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param {Number|String|BigNumber} [options.fee] fee
+ * @param {Number|String|BigNumber} [options.ttl] ttl
+ * @param {Number|String|BigNumber} [options.nonce] nonce
  * @return {Promise<Object>} Transaction result
  * @example
  * const name = 'test.chain'
@@ -63,12 +56,13 @@ import { CLIENT_TTL, NAME_FEE, NAME_TTL } from '../tx/builder/schema'
  */
 async function revoke (name, options = {}) {
   ensureNameValid(name)
-  const opt = R.merge(this.Ae.defaults, options)
+  const opt = { ...this.Ae.defaults, ...options }
 
-  const nameRevokeTx = await this.nameRevokeTx(R.merge(opt, {
-    nameId: produceNameId(name),
+  const nameRevokeTx = await this.nameRevokeTx({
+    ...opt,
+    nameId: name,
     accountId: await this.address(opt)
-  }))
+  })
 
   return this.send(nameRevokeTx, opt)
 }
@@ -80,16 +74,19 @@ async function revoke (name, options = {}) {
  * @category async
  * @alias module:@aeternity/aepp-sdk/es/ae/aens
  * @param {String} name AENS name
- * @param {String[]} pointers Array of name pointers. Can be oracle|account|contract|channel public key
+ * @param {Object.<string, string>} pointers Map of pointer keys to corresponding addresses
  * @param {Object} [options={}]
- * @param {Boolean} [options.extendPointers=false] extendPointers Get the pointers from the node and merge with provided one. Pointers with the same type will be overwrited
- * @param {(String|Object)} [options.onAccount] onAccount Make operation on specific account from sdk(you pass publickKey) or
- * using provided KeyPair(Can be keypair object or MemoryAccount)
- * @param {(Number|String|BigNumber)} [options.fee] fee
- * @param {(Number|String|BigNumber)} [options.ttl] ttl
- * @param {(Number|String|BigNumber)} [options.nonce] nonce
- * @param {(Number|String|BigNumber)} [options.nameTtl=50000] nameTtl Name ttl represented in number of blocks (Max value is 50000 blocks)
- * @param {(Number|String|BigNumber)} [options.clientTtl=84600] clientTtl a suggestion as to how long any clients should cache this information
+ * @param {Boolean} [options.extendPointers] Get the pointers from the node and merge with provided
+ * ones. Pointers with the same type will be overwritten
+ * @param {String|Object} [options.onAccount] Make operation on specific account from sdk (you
+ * pass publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param {Number|String|BigNumber} [options.fee] fee
+ * @param {Number|String|BigNumber} [options.ttl] ttl
+ * @param {Number|String|BigNumber} [options.nonce] nonce
+ * @param {Number|String|BigNumber} [options.nameTtl=50000] Name ttl represented in number of
+ * blocks (Max value is 50000 blocks)
+ * @param {Number|String|BigNumber} [options.clientTtl=84600] a suggestion as to how long any
+ * clients should cache this information
  * @return {Promise<Object>}
  * @throws Invalid pointer array error
  * @example
@@ -99,22 +96,24 @@ async function revoke (name, options = {}) {
  *
  * await sdkInstance.aensUpdate(name, pointersArray, { nameTtl, ttl, fee, nonce, clientTtl })
  * // or
- * await nameObject.update(pointersArray, { nameTtl, ttl, fee, nonce, clientTtl })
+ * await nameObject.update(pointers, { nameTtl, ttl, fee, nonce, clientTtl })
  */
-async function update (name, pointers = [], options = { extendPointers: false }) {
+async function update (name, pointers = {}, options = {}) {
   ensureNameValid(name)
-  const opt = R.merge(this.Ae.defaults, options)
-  if (!validatePointers(pointers)) throw new Error('Invalid pointers array')
+  const opt = { ...this.Ae.defaults, ...options }
+  const allPointers = {
+    ...options.extendPointers && Object.fromEntries(
+      (await this.getName(name)).pointers.map(({ key, id }) => [key, id])
+    ),
+    ...pointers
+  }
 
-  pointers = [
-    ...options.extendPointers ? (await this.getName(name)).pointers : [],
-    ...pointers.map(p => R.fromPairs([['id', p], ['key', classify(p)]]))
-  ].reduce((acc, el) => [...acc.filter(p => p.key !== el.key), el], [])
-  const nameUpdateTx = await this.nameUpdateTx(R.merge(opt, {
-    nameId: produceNameId(name),
+  const nameUpdateTx = await this.nameUpdateTx({
+    ...opt,
+    nameId: name,
     accountId: await this.address(opt),
-    pointers
-  }))
+    pointers: Object.entries(allPointers).map(([key, id]) => ({ key, id }))
+  })
 
   return this.send(nameUpdateTx, opt)
 }
@@ -128,11 +127,11 @@ async function update (name, pointers = [], options = { extendPointers: false })
  * @param {String} name AENS name
  * @param {String} account Recipient account publick key
  * @param {Object} [options={}]
- * @param {(String|Object)} [options.onAccount] onAccount Make operation on specific account from sdk(you pass publickKey) or
- * using provided KeyPair(Can be keypair object or MemoryAccount)
- * @param {(Number|String|BigNumber)} [options.fee] fee
- * @param {(Number|String|BigNumber)} [options.ttl] ttl
- * @param {(Number|String|BigNumber)} [options.nonce] nonce
+ * @param {String|Object} [options.onAccount] Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param {Number|String|BigNumber} [options.fee] fee
+ * @param {Number|String|BigNumber} [options.ttl] ttl
+ * @param {Number|String|BigNumber} [options.nonce] nonce
  * @return {Promise<Object>} Transaction result
  * @example
  * const name = 'test.chain'
@@ -145,13 +144,14 @@ async function update (name, pointers = [], options = { extendPointers: false })
  */
 async function transfer (name, account, options = {}) {
   ensureNameValid(name)
-  const opt = R.merge(this.Ae.defaults, options)
+  const opt = { ...this.Ae.defaults, ...options }
 
-  const nameTransferTx = await this.nameTransferTx(R.merge(opt, {
-    nameId: produceNameId(name),
+  const nameTransferTx = await this.nameTransferTx({
+    ...opt,
+    nameId: name,
     accountId: await this.address(opt),
     recipientId: account
-  }))
+  })
 
   return this.send(nameTransferTx, opt)
 }
@@ -184,25 +184,27 @@ async function query (name, opt = {}) {
 
   return Object.freeze(Object.assign(o, {
     pointers: o.pointers || [],
-    update: async (pointers = [], options = {}) => {
+    update: async (pointers, options = {}) => {
       return {
-        ...(await this.aensUpdate(name, pointers, R.merge(opt, options))),
+        ...(await this.aensUpdate(name, pointers, { ...opt, ...options })),
         ...(await this.aensQuery(name))
       }
     },
     transfer: async (account, options = {}) => {
       return {
-        ...(await this.aensTransfer(name, account, R.merge(opt, options))),
+        ...(await this.aensTransfer(name, account, { ...opt, ...options })),
         ...(await this.aensQuery(name))
       }
     },
-    revoke: async (options = {}) => this.aensRevoke(name, R.merge(opt, options)),
+    revoke: async (options = {}) => this.aensRevoke(name, { ...opt, ...options }),
     extendTtl: async (nameTtl = NAME_TTL, options = {}) => {
-      if (!nameTtl || typeof nameTtl !== 'number' || nameTtl > NAME_TTL) throw new Error('Ttl must be an number and less then 180000 blocks')
+      if (typeof nameTtl !== 'number' || nameTtl > NAME_TTL || nameTtl <= 0) {
+        throw new ArgumentError('nameTtl', `a number between 1 and ${NAME_TTL} blocks`, nameTtl)
+      }
 
       return {
-        ...(await this.aensUpdate(name, o.pointers.map(p => p.id), { ...R.merge(opt, options), nameTtl })),
-        ...(await this.aensQuery(name))
+        ...await this.aensUpdate(name, {}, { ...opt, ...options, nameTtl, extendPointers: true }),
+        ...await this.aensQuery(name)
       }
     }
   }))
@@ -218,8 +220,8 @@ async function query (name, opt = {}) {
  * @param {String} name
  * @param {Number} salt Salt from pre-claim, or 0 if it's a bid
  * @param {Object} [options] options
- * @param {String|Object} [options.onAccount] onAccount Make operation on specific account from sdk(you pass publickKey) or
- * using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param {String|Object} [options.onAccount] Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
  * @param {Number|String|BigNumber} [options.fee] fee
  * @param {Number|String|BigNumber} [options.ttl] ttl
  * @param {Number|String|BigNumber} [options.nonce] nonce
@@ -233,18 +235,14 @@ async function query (name, opt = {}) {
  */
 async function claim (name, salt, options) {
   ensureNameValid(name)
-  const opt = R.merge(this.Ae.defaults, options)
+  const opt = { ...this.Ae.defaults, ...options }
 
-  const minNameFee = getMinimumNameFee(name)
-  if (opt.nameFee !== this.Ae.defaults.nameFee && minNameFee.gt(opt.nameFee)) {
-    throw new Error(`the provided fee ${opt.nameFee} is not enough to execute the claim, required: ${minNameFee}`)
-  }
-  opt.nameFee = opt.nameFee !== this.Ae.defaults.nameFee ? opt.nameFee : minNameFee
-  const claimTx = await this.nameClaimTx(R.merge(opt, {
+  const claimTx = await this.nameClaimTx({
+    ...opt,
     accountId: await this.address(opt),
     nameSalt: salt,
-    name: encode(name, 'nm')
-  }))
+    name
+  })
 
   const result = await this.send(claimTx, opt)
   if (!isAuctionName(name)) {
@@ -262,8 +260,8 @@ async function claim (name, salt, options) {
  * @alias module:@aeternity/aepp-sdk/es/ae/aens
  * @param {String} name
  * @param {Object} [options={}]
- * @param {String|Object} [options.onAccount] onAccount Make operation on specific account from sdk(you pass publickKey) or
- * using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param {String|Object} [options.onAccount] Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
  * @param {Number|String|BigNumber} [options.fee] fee
  * @param {Number|String|BigNumber} [options.ttl] ttl
  * @param {Number|String|BigNumber} [options.nonce] nonce
@@ -282,15 +280,16 @@ async function claim (name, salt, options) {
  */
 async function preclaim (name, options = {}) {
   ensureNameValid(name)
-  const opt = R.merge(this.Ae.defaults, options)
+  const opt = { ...this.Ae.defaults, ...options }
   const _salt = salt()
   const height = await this.height()
   const commitmentId = commitmentHash(name, _salt)
 
-  const preclaimTx = await this.namePreclaimTx(R.merge(opt, {
+  const preclaimTx = await this.namePreclaimTx({
+    ...opt,
     accountId: await this.address(opt),
     commitmentId
-  }))
+  })
 
   const result = await this.send(preclaimTx, opt)
 
@@ -312,8 +311,8 @@ async function preclaim (name, options = {}) {
  * @param {String} name Domain name
  * @param {String|Number} nameFee Name fee (bid fee)
  * @param {Object} [options={}]
- * @param {String|Object} [options.onAccount] onAccount Make operation on specific account from sdk(you pass publickKey) or
- * using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param {String|Object} [options.onAccount] Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
  * @param {Number|String|BigNumber} [options.fee] fee
  * @param {Number|String|BigNumber} [options.ttl] ttl
  * @param {Number|String|BigNumber} [options.nonce] nonce
@@ -324,7 +323,7 @@ async function preclaim (name, options = {}) {
  *
  * await sdkInstance.aensBid(name, 213109412839123, { ttl, fee, nonce })
  */
-async function bid (name, nameFee = NAME_FEE, options = {}) {
+async function bid (name, nameFee, options = {}) {
   return this.aensClaim(name, 0, { ...options, nameFee, vsn: 2 })
 }
 
@@ -353,8 +352,7 @@ const Aens = Ae.compose({
     Ae: {
       defaults: {
         clientTtl: CLIENT_TTL,
-        nameTtl: NAME_TTL, // aec_governance:name_claim_max_expiration() => 50000
-        nameFee: NAME_FEE
+        nameTtl: NAME_TTL // aec_governance:name_claim_max_expiration() => 50000
       }
     }
   }

package/src/ae/aepp.js

@@ -1,6 +1,6 @@
 /*
  * ISC License (ISC)
- * Copyright (c) 2018 aeternity developers
+ * Copyright (c) 2021 aeternity developers
  *
  *  Permission to use, copy, modify, and/or distribute this software for any
  *  purpose with or without fee is hereby granted, provided that the above
@@ -24,7 +24,7 @@
 
 import Ae from './'
 import Aens from './aens'
-import { ContractWithCompiler as Contract } from './contract'
+import Contract from './contract'
 import AeppRpc from '../utils/aepp-wallet-communication/rpc/aepp-rpc'
 import Chain from '../chain/node'
 import Tx from '../tx/tx'