@aeternity/aepp-sdk 8.2.1 → 10.0.0

package/src/account/multiple.js

@@ -21,10 +21,9 @@
  * @export AccountMultiple
  */
 
-import * as R from 'ramda'
 import AsyncInit from '../utils/async-init'
 import MemoryAccount from './memory'
-import { assertedType } from '../utils/crypto'
+import { decode } from '../tx/builder/helpers'
 import AccountBase, { isAccountBase } from './base'
 
 /**
@@ -42,7 +41,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,10 +51,11 @@ import AccountBase, { isAccountBase } from './base'
  */
 export default AccountBase.compose(AsyncInit, {
   async init ({ accounts = [], address }) {
-    this.accounts = R.fromPairs(await Promise.all(accounts.map(async a => [await a.address(), a])))
-    if (!address) address = Object.keys(this.accounts)[0]
-    assertedType(address, 'ak')
-    this.selectedAddress = address
+    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: {}
@@ -122,26 +124,30 @@ export default AccountBase.compose(AsyncInit, {
      * @example selectAccount('ak_xxxxxxxx')
      */
     selectAccount (address) {
-      assertedType(address, 'ak')
+      decode(address, 'ak')
       if (!this.accounts[address]) throw new Error(`Account for ${address} not available`)
       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':
-          assertedType(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 Error('No account or wallet configured')
+      } else {
+        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})`)
+        }
       }
     }
   }

package/src/ae/aens.js

@@ -26,15 +26,9 @@
  * @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
+  commitmentHash, ensureNameValid, getMinimumNameFee, isAuctionName, encode, produceNameId
 } from '../tx/builder/helpers'
 import Ae from './'
 import { CLIENT_TTL, NAME_FEE, NAME_TTL } from '../tx/builder/schema'
@@ -47,11 +41,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 +57,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, {
+  const nameRevokeTx = await this.nameRevokeTx({
+    ...opt,
     nameId: produceNameId(name),
     accountId: await this.address(opt)
-  }))
+  })
 
   return this.send(nameRevokeTx, opt)
 }
@@ -80,16 +75,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 +97,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, {
+  const nameUpdateTx = await this.nameUpdateTx({
+    ...opt,
     nameId: produceNameId(name),
     accountId: await this.address(opt),
-    pointers
-  }))
+    pointers: Object.entries(allPointers).map(([key, id]) => ({ key, id }))
+  })
 
   return this.send(nameUpdateTx, opt)
 }
@@ -128,11 +128,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 +145,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, {
+  const nameTransferTx = await this.nameTransferTx({
+    ...opt,
     nameId: produceNameId(name),
     accountId: await this.address(opt),
     recipientId: account
-  }))
+  })
 
   return this.send(nameTransferTx, opt)
 }
@@ -184,25 +185,25 @@ 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')
 
       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 +219,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 +234,19 @@ 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')
-  }))
+  })
 
   const result = await this.send(claimTx, opt)
   if (!isAuctionName(name)) {
@@ -262,8 +264,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 +284,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 +315,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