@aeternity/aepp-sdk 10.0.0 → 12.0.0

package/src/chain/index.js

@@ -1,250 +0,0 @@
-/*
- * ISC License (ISC)
- * Copyright (c) 2018 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
- *  copyright notice and this permission notice appear in all copies.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
- *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
- *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
- *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
- *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
- *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- *  PERFORMANCE OF THIS SOFTWARE.
- */
-
-/**
- * Chain module
- * @module @aeternity/aepp-sdk/es/chain
- * @export Chain
- * @example import { Chain } from '@aeternity/aepp-sdk'
- */
-
-import stampit from '@stamp/it'
-import { required } from '@stamp/required'
-
-/**
- * Basic Chain Stamp
- *
- * Attempting to create instances from the Stamp without overwriting all
- * abstract methods using composition will result in an exception.
- * @function
- * @alias module:@aeternity/aepp-sdk/es/chain
- * @rtype Stamp
- * @param {Object} [options={}] - Initializer object
- * @return {Object} Chain instance
- */
-const Chain = stampit({
-  deepProps: { Ae: { defaults: { waitMined: true, verify: true } } }
-}, required({
-  methods: {
-    sendTransaction: required,
-    height: required,
-    awaitHeight: required,
-    topBlock: required,
-    poll: required,
-    balance: required,
-    getBalance: required,
-    tx: required,
-    getTxInfo: required,
-    mempool: required,
-    txDryRun: required,
-    getAccount: required
-  }
-}))
-
-/**
- * Submit a signed transaction for mining
- * @function sendTransaction
- * @instance
- * @abstract
- * @category async
- * @rtype (tx: String, options?: Object) => tx: Promise[Object]|txHash: Promise[String]
- * @param {String} tx - Transaction to submit
- * @param {String} [options={}] - Options to pass to the implementation
- * @param {String} [options.verify=true] - Verify transaction before broadcast.
- * @return {Object} Transaction
- */
-
-/**
- * Obtain current height of the chain
- * @function height
- * @instance
- * @abstract
- * @category async
- * @rtype () => height: Number
- * @return {Number} Current chain height
- */
-
-/**
- * Wait for the chain to reach a specific height
- * @function awaitHeight
- * @instance
- * @abstract
- * @category async
- * @rtype (height: Number, options?: Object) => height: Number
- * @param {Object} [options={}] - Options
- * @param {Number} options.interval - Interval (in ms) at which to poll the chain
- * @param {Number} options.attempts - Number of polling attempts after which to fail
- * @return {Number} Current chain height
- */
-
-/**
- * Wait for a transaction to be mined
- * @function poll
- * @instance
- * @abstract
- * @category async
- * @rtype (th: String, options?: Object) => tx: Object
- * @param {Object} [options={}] - Options
- * @param {Number} options.interval - Interval (in ms) at which to poll the chain
- * @param {Number} options.blocks - Number of blocks mined after which to fail
- * @return {Object} The transaction as it was mined
- */
-
-/**
- * Request the balance of specified account
- * @function balance
- * @instance
- * @abstract
- * @category async
- * @rtype (address: String, options?: Object) => balance: Number
- * @param {String} address - The public account address to obtain the balance for
- * @param {Object} [options={}] - Options
- * @param {Number} options.height - The chain height at which to obtain the balance for (default:
- * top of chain)
- * @param {String} options.hash - The block hash on which to obtain the balance for (default: top
- * of chain)
- * @return {Object} The transaction as it was mined
- */
-
-/**
- * Obtain a transaction based on its hash
- * @function tx
- * @instance
- * @abstract
- * @category async
- * @rtype (hash: String, info = false) => tx: Object
- * @param {String} hash - Transaction hash
- * @param {Boolean} info - Retrieve additional transaction date. Works only for (ContractCreate and
- * ContractCall transaction's)
- * @return {Object} Transaction
- */
-
-/**
- * Obtain a transaction info based on its hash
- * @function getTxInfo
- * @instance
- * @abstract
- * @category async
- * @rtype (hash: String) => tx: Object
- * @param {String} hash - Transaction hash
- * @return {Object} Transaction
- */
-
-/**
- * Obtain transaction's from mempool
- * @function mempool
- * @instance
- * @abstract
- * @category async
- * @rtype () => txs: [...Object]
- * @return {Object[]} Transactions
- */
-
-/**
- * Obtain current generation
- * @function getCurrentGeneration
- * @instance
- * @abstract
- * @category async
- * @rtype () => generation: Object
- * @return {Object} Current Generation
- */
-
-/**
- * Get generation by hash or height
- * @function getGeneration
- * @instance
- * @abstract
- * @category async
- * @rtype (hashOrHeight) => generation: Object
- * @param {String|Number} hashOrHeight - Generation hash or height
- * @return {Object} Generation
- */
-
-/**
- * Wait for transaction confirmation
- * @function waitForTxConfirm
- * @instance
- * @abstract
- * @category async
- * @rtype (txHash: String, { confirm: Number | Boolean } = { confirm: 3 }) => Promise<Number>
- * @param {String} txHash - Transaction hash
- * @param {Object} [options] - options
- * @param {Number} [options.confirm=3] - Number of blocks to wait for transaction confirmation
- * @return {Promise<Number>} Current Height
- */
-
-/**
- * Get micro block transactions
- * @function getMicroBlockTransactions
- * @instance
- * @abstract
- * @category async
- * @rtype (hash) => txs: [...Object]
- * @return {Object[]} Transactions
- */
-
-/**
- * Get key block
- * @function getKeyBlock
- * @instance
- * @abstract
- * @category async
- * @rtype (hashOrHeight) => keyBlock: Object
- * @return {Object} Key Block
- */
-
-/**
- * Get micro block header
- * @function getMicroBlockHeader
- * @instance
- * @abstract
- * @category async
- * @rtype (hash) => header: Object
- * @return {Object} Micro block header
- */
-
-/**
- * Get account by account public key
- * @function getAccount
- * @instance
- * @abstract
- * @category async
- * @rtype (address, { hash, height }) => account: Object
- * @param {String} address - Account public key
- * @param {Object} [options={}] - Options
- * @param {Number} [options.height] - Get account on specific block by block height
- * @param {String} [options.hash] - Get account on specific block by block hash
- * @return {Object} Account
- */
-
-/**
- * Transaction dry-run
- * @function txDryRun
- * @instance
- * @abstract
- * @category async
- * @rtype (tx, accountAddress, options) => result: Object
- * @param {String} tx - transaction to execute
- * @param {String} accountAddress - address that will be used to execute transaction
- * @param {String|Number} [options.top] - hash of block on which to make dry-run
- * @param {Boolean} [options.txEvents] - collect and return on-chain tx events that would result
- * from the call
- * @return {Object} Result
- */
-
-export default Chain

package/src/chain/node.js

@@ -1,293 +0,0 @@
-/*
- * ISC License (ISC)
- * Copyright (c) 2018 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
- *  copyright notice and this permission notice appear in all copies.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
- *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
- *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
- *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
- *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
- *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- *  PERFORMANCE OF THIS SOFTWARE.
- */
-import Chain from './'
-import { AE_AMOUNT_FORMATS, formatAmount } from '../utils/amount-formatter'
-import verifyTransaction from '../tx/validator'
-import NodePool from '../node-pool'
-import { pause } from '../utils/other'
-import { isNameValid, produceNameId, decode } from '../tx/builder/helpers'
-import { DRY_RUN_ACCOUNT } from '../tx/builder/schema'
-
-/**
- * ChainNode module
- *
- * This is the complement to {@link module:@aeternity/aepp-sdk/es/chain}.
- * @module @aeternity/aepp-sdk/es/chain/node
- * @export ChainNode
- * @example import { ChainNode } from '@aeternity/aepp-sdk'
- */
-
-async function sendTransaction (tx, options = {}) {
-  const { waitMined, verify } = { ...this.Ae.defaults, ...options }
-  if (verify) {
-    const validation = await verifyTransaction(tx, this.selectedNode.instance)
-    if (validation.length) {
-      const message = 'Transaction verification errors: ' +
-        validation.map(v => v.message).join(', ')
-      throw Object.assign(new Error(message), {
-        code: 'TX_VERIFICATION_ERROR',
-        validation,
-        transaction: tx
-      })
-    }
-  }
-
-  try {
-    const { txHash } = await this.api.postTransaction({ tx })
-
-    if (waitMined) {
-      const txData = { ...await this.poll(txHash, options), rawTx: tx }
-      // wait for transaction confirmation
-      if (options.confirm) {
-        return { ...txData, confirmationHeight: await this.waitForTxConfirm(txHash, options) }
-      }
-      return txData
-    }
-    return { hash: txHash, rawTx: tx }
-  } catch (error) {
-    throw Object.assign(error, {
-      rawTx: tx,
-      verifyTx: () => verifyTransaction(tx, this.selectedNode.instance)
-    })
-  }
-}
-
-async function waitForTxConfirm (txHash, options = { confirm: 3 }) {
-  options.confirm = options.confirm === true ? 3 : options.confirm
-  const { blockHeight } = await this.tx(txHash)
-  const height = await this.awaitHeight(blockHeight + options.confirm, options)
-  const { blockHeight: newBlockHeight } = await this.tx(txHash)
-  switch (newBlockHeight) {
-    case -1:
-      throw new Error(`Transaction ${txHash} is removed from chain`)
-    case blockHeight:
-      return height
-    default:
-      return waitForTxConfirm(txHash, options)
-  }
-}
-
-async function getAccount (address, { height, hash } = {}) {
-  if (height) return this.api.getAccountByPubkeyAndHeight(address, height)
-  if (hash) return this.api.getAccountByPubkeyAndHash(address, hash)
-  return this.api.getAccountByPubkey(address)
-}
-
-/**
- * @function
- * @deprecated
- */
-async function balance (address, { height, hash, format = AE_AMOUNT_FORMATS.AETTOS } = {}) {
-  const { balance } = await this.getAccount(address, { hash, height })
-
-  return formatAmount(balance, { targetDenomination: format }).toString()
-}
-
-async function getBalance (address, { height, hash, format = AE_AMOUNT_FORMATS.AETTOS } = {}) {
-  const { balance } = await this.getAccount(address, { hash, height }).catch(_ => ({ balance: 0 }))
-
-  return formatAmount(balance, { targetDenomination: format }).toString()
-}
-
-async function tx (hash, info = true) {
-  const tx = await this.api.getTransactionByHash(hash)
-  if (['ContractCreateTx', 'ContractCallTx', 'ChannelForceProgressTx'].includes(tx.tx.type) && info && tx.blockHeight !== -1) {
-    try {
-      return { ...tx, ...await this.getTxInfo(hash) }
-    } catch (e) {}
-  }
-  return tx
-}
-
-async function height () {
-  try {
-    if (!this._heightPromise) {
-      this._heightPromise = this.api.getCurrentKeyBlockHeight()
-    }
-    return (await this._heightPromise).height
-  } finally {
-    delete this._heightPromise
-  }
-}
-
-async function awaitHeight (height, { interval = 5000, attempts = 20 } = {}) {
-  let currentHeight
-  for (let i = 0; i < attempts; i++) {
-    if (i) await pause(interval)
-    currentHeight = await this.height()
-    if (currentHeight >= height) return currentHeight
-  }
-  throw new Error(`Giving up after ${(attempts - 1) * interval}ms, current height: ${currentHeight}, desired height: ${height}`)
-}
-
-/**
- * @deprecated
- */
-async function topBlock () {
-  return this.api.getTopHeader()
-}
-
-async function poll (th, { blocks = 10, interval = 500, allowUnsynced = false } = {}) {
-  const max = await this.height() + blocks
-  do {
-    const tx = await this.tx(th).catch(_ => null)
-    if (tx && (tx.blockHeight !== -1 || (allowUnsynced && tx.height))) {
-      return tx
-    }
-    await pause(interval)
-  } while (await this.height() < max)
-  throw new Error(`Giving up after ${blocks} blocks mined, transaction hash: ${th}`)
-}
-
-async function getTxInfo (hash) {
-  const result = await this.api.getTransactionInfoByHash(hash)
-  return result.callInfo || result
-}
-
-async function mempool () {
-  return this.api.getPendingTransactions()
-}
-
-async function getCurrentGeneration () {
-  return this.api.getCurrentGeneration()
-}
-
-async function getGeneration (hashOrHeight) {
-  if (typeof hashOrHeight === 'string') return this.api.getGenerationByHash(hashOrHeight)
-  if (typeof hashOrHeight === 'number') return this.api.getGenerationByHeight(hashOrHeight)
-  throw new Error('Invalid param, param must be hash or height')
-}
-
-async function getMicroBlockTransactions (hash) {
-  return (await this.api.getMicroBlockTransactionsByHash(hash)).transactions
-}
-
-async function getKeyBlock (hashOrHeight) {
-  if (typeof hashOrHeight === 'string') return this.api.getKeyBlockByHash(hashOrHeight)
-  if (typeof hashOrHeight === 'number') return this.api.getKeyBlockByHeight(hashOrHeight)
-  throw new Error('Invalid param, param must be hash or height')
-}
-
-async function getMicroBlockHeader (hash) {
-  return this.api.getMicroBlockHeaderByHash(hash)
-}
-
-async function txDryRun (tx, accountAddress, options) {
-  const { results: [{ result, reason, ...resultPayload }], ...other } =
-    await this.api.protectedDryRunTxs({
-      ...options,
-      txs: [{ tx }],
-      accounts: [{
-        pubKey: accountAddress,
-        amount: DRY_RUN_ACCOUNT.amount
-      }]
-    })
-
-  if (result === 'ok') return { ...resultPayload, ...other }
-
-  throw Object.assign(
-    new Error('Dry run error, ' + reason),
-    { tx, accountAddress, options }
-  )
-}
-
-async function getContractByteCode (contractId) {
-  return this.api.getContractCode(contractId)
-}
-
-async function getContract (contractId) {
-  return this.api.getContract(contractId)
-}
-
-async function getName (name) {
-  return this.api.getNameEntryByName(name)
-}
-
-/**
- * Resolve AENS name and return name hash
- * @param {String} nameOrId
- * @param {String} key in AENS pointers record
- * @param {Object} [options]
- * @param {Boolean} [options.verify] To ensure that name exist and have a corresponding pointer
- * // TODO: avoid that to don't trust to current api gateway
- * @param {Boolean} [options.resolveByNode] Enables pointer resolving using node
- * @return {String} Address or AENS name hash
- */
-async function resolveName (nameOrId, key, { verify, resolveByNode } = {}) {
-  if (!nameOrId || typeof nameOrId !== 'string') {
-    throw new Error(`Name or address should be a string: ${nameOrId}`)
-  }
-  try {
-    decode(nameOrId)
-    return nameOrId
-  } catch (error) {}
-  if (isNameValid(nameOrId)) {
-    if (verify || resolveByNode) {
-      const name = await this.api.getNameEntryByName(nameOrId).catch(_ => null)
-      if (!name) throw new Error(`Name not found: ${nameOrId}`)
-      const pointer = name.pointers.find(pointer => pointer.key === key)
-      if (!pointer) {
-        throw new Error(`Name ${nameOrId} don't have pointers for ${key}`)
-      }
-      if (resolveByNode) return pointer.id
-    }
-    return produceNameId(nameOrId)
-  }
-  throw new Error(`Invalid name or address: ${nameOrId}`)
-}
-
-/**
- * ChainNode Stamp
- *
- * This is implementation of {@link module:@aeternity/aepp-sdk/es/chain--Chain}
- * composed with {@link module:@aeternity/aepp-sdk/es/contract/node--ContractNodeAPI} and
- * {@link module:@aeternity/aepp-sdk/es/oracle/node--OracleNodeAPI}
- * @function
- * @alias module:@aeternity/aepp-sdk/es/chain/node
- * @rtype Stamp
- * @param {Object} [options={}] - Initializer object
- * @return {Object} ChainNode instance
- * @example ChainNode({url: 'https://testnet.aeternity.io/'})
- */
-const ChainNode = Chain.compose(NodePool, {
-  methods: {
-    sendTransaction,
-    balance,
-    getBalance,
-    getAccount,
-    topBlock,
-    tx,
-    height,
-    awaitHeight,
-    poll,
-    getTxInfo,
-    mempool,
-    getCurrentGeneration,
-    getGeneration,
-    getMicroBlockHeader,
-    getMicroBlockTransactions,
-    getKeyBlock,
-    txDryRun,
-    getContractByteCode,
-    getContract,
-    getName,
-    waitForTxConfirm,
-    resolveName
-  }
-})
-
-export default ChainNode