@aeternity/aepp-sdk 11.0.1 → 12.1.1

package/src/channel/internal.js

@@ -1,236 +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 { w3cwebsocket as W3CWebSocket } from 'websocket'
-import { EventEmitter } from 'events'
-import JsonBig from '../utils/json-big'
-import { pascalToSnake } from '../utils/string'
-import { ChannelCallError, ChannelPingTimedOutError, UnknownChannelStateError } from '../utils/errors'
-
-// Send ping message every 10 seconds
-const PING_TIMEOUT_MS = 10000
-// Close connection if pong message is not received within 5 seconds
-const PONG_TIMEOUT_MS = 5000
-
-export const options = new WeakMap()
-export const status = new WeakMap()
-export const state = new WeakMap()
-const fsm = new WeakMap()
-const websockets = new WeakMap()
-export const eventEmitters = new WeakMap()
-const messageQueue = new WeakMap()
-const messageQueueLocked = new WeakMap()
-const actionQueue = new WeakMap()
-const actionQueueLocked = new WeakMap()
-const sequence = new WeakMap()
-export const channelId = new WeakMap()
-const rpcCallbacks = new WeakMap()
-const pingTimeoutId = new WeakMap()
-const pongTimeoutId = new WeakMap()
-export const fsmId = new WeakMap()
-
-export function emit (channel, ...args) {
-  eventEmitters.get(channel).emit(...args)
-}
-
-function enterState (channel, nextState) {
-  if (!nextState) {
-    throw new UnknownChannelStateError()
-  }
-  fsm.set(channel, nextState)
-  if (nextState.handler.enter) {
-    nextState.handler.enter(channel)
-  }
-  dequeueAction(channel)
-}
-
-export function changeStatus (channel, newStatus) {
-  const prevStatus = status.get(channel)
-  if (newStatus !== prevStatus) {
-    status.set(channel, newStatus)
-    emit(channel, 'statusChanged', newStatus)
-  }
-}
-
-export function changeState (channel, newState) {
-  state.set(channel, newState)
-  emit(channel, 'stateChanged', newState)
-}
-
-export function send (channel, message) {
-  const { debug = false } = options.get(channel)
-  if (debug) console.log('Send message: ', message)
-  websockets.get(channel).send(JsonBig.stringify(message))
-}
-
-export function enqueueAction (channel, guard, action) {
-  actionQueue.set(channel, [
-    ...actionQueue.get(channel) || [],
-    { guard, action }
-  ])
-  dequeueAction(channel)
-}
-
-async function dequeueAction (channel) {
-  const locked = actionQueueLocked.get(channel)
-  const queue = actionQueue.get(channel) || []
-  if (locked || !queue.length) {
-    return
-  }
-  const state = fsm.get(channel)
-  const index = queue.findIndex(item => item.guard(channel, state))
-  if (index === -1) {
-    return
-  }
-  actionQueue.set(channel, queue.filter((_, i) => index !== i))
-  actionQueueLocked.set(channel, true)
-  const nextState = await Promise.resolve(queue[index].action(channel, state))
-  actionQueueLocked.set(channel, false)
-  enterState(channel, nextState)
-}
-
-async function handleMessage (channel, message) {
-  const { handler, state } = fsm.get(channel)
-  enterState(channel, await Promise.resolve(handler(channel, message, state)))
-}
-
-async function dequeueMessage (channel) {
-  if (messageQueueLocked.get(channel)) return
-  const messages = messageQueue.get(channel)
-  if (!messages.length) return
-  messageQueueLocked.set(channel, true)
-  while (messages.length) {
-    const message = messages.shift()
-    try {
-      await handleMessage(channel, message)
-    } catch (error) {
-      console.error('Error handling incoming message:')
-      console.error(message)
-      console.error(error)
-    }
-  }
-  messageQueueLocked.set(channel, false)
-}
-
-function ping (channel) {
-  clearTimeout(pingTimeoutId.get(channel))
-  clearTimeout(pongTimeoutId.get(channel))
-  pingTimeoutId.set(channel, setTimeout(() => {
-    send(channel, {
-      jsonrpc: '2.0',
-      method: 'channels.system',
-      params: {
-        action: 'ping'
-      }
-    })
-    pongTimeoutId.set(channel, setTimeout(() => {
-      disconnect(channel)
-      emit(channel, 'error', new ChannelPingTimedOutError())
-    }, PONG_TIMEOUT_MS))
-  }, PING_TIMEOUT_MS))
-}
-
-function onMessage (channel, data) {
-  const message = JsonBig.parse(data)
-  const { debug = false } = options.get(channel)
-  if (debug) console.log('Receive message: ', message)
-  if (message.id) {
-    const callback = rpcCallbacks.get(channel).get(message.id)
-    try {
-      callback(message)
-    } finally {
-      rpcCallbacks.get(channel).delete(message.id)
-    }
-    return
-  }
-  if (message.method === 'channels.message') {
-    emit(channel, 'message', message.params.data.message)
-    return
-  }
-  if (message.method === 'channels.system.pong') {
-    if (
-      (message.params.channel_id === channelId.get(channel)) ||
-      // Skip channelId check if channelId is not known yet
-      (channelId.get(channel) == null)
-    ) {
-      ping(channel)
-    }
-    return
-  }
-  messageQueue.get(channel).push(message)
-  dequeueMessage(channel)
-}
-
-export function call (channel, method, params) {
-  return new Promise((resolve, reject) => {
-    const id = sequence.set(channel, sequence.get(channel) + 1).get(channel)
-    rpcCallbacks.get(channel).set(id, (message) => {
-      if (message.result) return resolve(message.result)
-      if (message.error) {
-        const [{ message: details } = {}] = message.error.data || []
-        return reject(new ChannelCallError(message.error.message + (details ? `: ${details}` : '')))
-      }
-    })
-    send(channel, { jsonrpc: '2.0', method, id, params })
-  })
-}
-
-export function disconnect (channel) {
-  websockets.get(channel).close()
-  clearTimeout(pingTimeoutId.get(channel))
-  clearTimeout(pongTimeoutId.get(channel))
-}
-
-export async function initialize (
-  channel, connectionHandler, openHandler, { url, ...channelOptions }
-) {
-  options.set(channel, channelOptions)
-  fsm.set(channel, { handler: connectionHandler })
-  eventEmitters.set(channel, new EventEmitter())
-  sequence.set(channel, 0)
-  rpcCallbacks.set(channel, new Map())
-  messageQueue.set(channel, [])
-
-  const wsUrl = new URL(url)
-  Object.entries(channelOptions)
-    .filter(([key]) => !['sign', 'debug'].includes(key))
-    .forEach(([key, value]) => wsUrl.searchParams.set(pascalToSnake(key), value))
-  wsUrl.searchParams.set('protocol', 'json-rpc')
-  changeStatus(channel, 'connecting')
-  const ws = new W3CWebSocket(wsUrl.toString())
-  await new Promise((resolve, reject) => Object.assign(ws, {
-    onerror: reject,
-    onopen: () => {
-      resolve()
-      changeStatus(channel, 'connected')
-      if (channelOptions.reconnectTx) {
-        enterState(channel, { handler: openHandler })
-        setTimeout(async () => changeState(channel,
-          (await call(channel, 'channels.get.offchain_state', {})).signed_tx
-        ))
-      }
-      ping(channel)
-    },
-    onclose: () => {
-      changeStatus(channel, 'disconnected')
-      clearTimeout(pingTimeoutId.get(channel))
-      clearTimeout(pongTimeoutId.get(channel))
-    },
-    onmessage: ({ data }) => onMessage(channel, data)
-  }))
-  websockets.set(channel, ws)
-}

package/src/contract/aci.js

@@ -1,376 +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.
- */
-
-/**
- * ContractACI module
- *
- * @module @aeternity/aepp-sdk/es/contract/aci
- * @export getContractInstance
- */
-
-import { Encoder as Calldata } from '@aeternity/aepp-calldata'
-import { DRY_RUN_ACCOUNT, GAS_MAX } from '../tx/builder/schema'
-import TxObject from '../tx/tx-object'
-import { decode } from '../tx/builder/helpers'
-import {
-  MissingContractDefError,
-  MissingContractAddressError,
-  InactiveContractError,
-  BytecodeMismatchError,
-  InternalError,
-  DuplicateContractError,
-  MissingFunctionNameError,
-  InvalidMethodInvocationError,
-  NotPayableFunctionError,
-  TypeError,
-  NodeInvocationError,
-  IllegalArgumentError,
-  NoSuchContractFunctionError,
-  MissingEventDefinitionError,
-  AmbiguousEventDefinitionError
-} from '../utils/errors'
-import { hash } from '../utils/crypto-ts'
-
-/**
- * Generate contract ACI object with predefined js methods for contract usage - can be used for
- * creating a reference to already deployed contracts
- * @alias module:@aeternity/aepp-sdk/es/contract/aci
- * @param {Object} [options={}] Options object
- * @param {String} [options.source] Contract source code
- * @param {String} [options.bytecode] Contract bytecode
- * @param {Object} [options.aci] Contract ACI
- * @param {String} [options.contractAddress] Contract address
- * @param {Object} [options.filesystem] Contact source external namespaces map
- * @param {Boolean} [options.validateBytecode] Compare source code with on-chain version
- * @return {ContractInstance} JS Contract API
- * @example
- * const contractIns = await aeSdk.getContractInstance({ source })
- * await contractIns.deploy([321]) or await contractIns.methods.init(321)
- * const callResult = await contractIns.call('setState', [123]) or
- * await contractIns.methods.setState.send(123, options)
- * const staticCallResult = await contractIns.call('setState', [123], { callStatic: true }) or
- * await contractIns.methods.setState.get(123, options)
- * Also you can call contract like: await contractIns.methods.setState(123, options)
- * Then sdk decide to make on-chain or static call(dry-run API) transaction based on function is
- * stateful or not
- */
-export default async function getContractInstance ({
-  source,
-  bytecode,
-  aci: _aci,
-  contractAddress,
-  filesystem = {},
-  validateBytecode,
-  ...otherOptions
-} = {}) {
-  if (!_aci && source) {
-    _aci = await this.compilerApi.generateACI({ code: source, options: { filesystem } })
-  }
-  if (!_aci) throw new MissingContractDefError()
-  contractAddress = contractAddress && await this.resolveName(
-    contractAddress, 'contract_pubkey', { resolveByNode: true }
-  )
-  if (!contractAddress && !source && !bytecode) {
-    throw new MissingContractAddressError('Can\'t create instance by ACI without address')
-  }
-
-  if (contractAddress) {
-    const contract = await this.getContract(contractAddress)
-    if (!contract.active) throw new InactiveContractError(contractAddress)
-  }
-
-  const instance = {
-    _aci,
-    _name: _aci.encoded_aci.contract.name,
-    calldata: new Calldata([_aci.encoded_aci, ..._aci.external_encoded_aci]),
-    source,
-    bytecode,
-    deployInfo: { address: contractAddress },
-    options: {
-      ...this.Ae.defaults,
-      callStatic: false,
-      filesystem,
-      ...otherOptions
-    },
-    compilerVersion: this.compilerVersion
-  }
-
-  if (validateBytecode) {
-    if (!contractAddress) throw new MissingContractAddressError('Can\'t validate bytecode without contract address')
-    const onChanBytecode = (await this.getContractByteCode(contractAddress)).bytecode
-    const isValid = source
-      ? await this.compilerApi.validateByteCode(
-        { bytecode: onChanBytecode, source, options: instance.options }
-      ).then((res) => Object.entries(res).length === 0, () => false)
-      : bytecode === onChanBytecode
-    if (!isValid) throw new BytecodeMismatchError(source ? 'source' : 'bytecode')
-  }
-
-  /**
-   * Compile contract
-   * @alias module:@aeternity/aepp-sdk/es/contract/aci
-   * @rtype () => ContractInstance: Object
-   * @return {String} bytecode bytecode
-   */
-  instance.compile = async (options = {}) => {
-    if (instance.bytecode) throw new IllegalArgumentError('Contract already compiled')
-    if (!instance.source) throw new IllegalArgumentError('Can\'t compile without source code')
-    const { bytecode } = await this.compilerApi.compileContract({
-      code: instance.source, options: { ...instance.options, ...options }
-    })
-    instance.bytecode = bytecode
-    return instance.bytecode
-  }
-
-  const sendAndProcess = async (tx, options) => {
-    const txData = await this.send(tx, options)
-    const result = {
-      hash: txData.hash, tx: TxObject({ tx: txData.rawTx }), txData, rawTx: txData.rawTx
-    }
-    if (options.waitMined === false) return result
-    const { callInfo } = await this.api.getTransactionInfoByHash(txData.hash)
-    Object.assign(result.txData, callInfo) // TODO: don't duplicate data in result
-    await handleCallError(callInfo)
-    return { ...result, result: callInfo }
-  }
-
-  const handleCallError = ({ returnType, returnValue }) => {
-    let message
-    // TODO: ensure that it works correctly https://github.com/aeternity/aepp-calldata-js/issues/88
-    switch (returnType) {
-      case 'ok': return
-      case 'revert':
-        message = instance.calldata.decodeFateString(returnValue)
-        break
-      case 'error':
-        message = decode(returnValue).toString()
-        break
-      default: throw new InternalError(`Unknown returnType: ${returnType}`)
-    }
-    throw new NodeInvocationError(message)
-  }
-
-  instance._estimateGas = async (name, params, options) => {
-    const { result: { gasUsed } } =
-      await instance.call(name, params, { ...options, callStatic: true })
-    // taken from https://github.com/aeternity/aepp-sdk-js/issues/1286#issuecomment-977814771
-    return Math.floor(gasUsed * 1.25)
-  }
-
-  /**
-   * Deploy contract
-   * @alias module:@aeternity/aepp-sdk/es/contract/aci
-   * @rtype (init: Array, options: Object) => ContractInstance: Object
-   * @param {Array} params Contract init function arguments array
-   * @param {Object} [options] options
-   * @return {Object} deploy info
-   */
-  instance.deploy = async (params = [], options) => {
-    const opt = { ...instance.options, ...options }
-    if (!instance.bytecode) await instance.compile(opt)
-    if (opt.callStatic) return instance.call('init', params, opt)
-    if (instance.deployInfo.address) throw new DuplicateContractError()
-
-    const ownerId = await this.address(opt)
-    const { tx, contractId } = await this.contractCreateTx({
-      ...opt,
-      gas: opt.gas ?? await instance._estimateGas('init', params, opt),
-      callData: instance.calldata.encode(instance._name, 'init', params),
-      code: instance.bytecode,
-      ownerId
-    })
-    const { hash, rawTx, result, txData } = await sendAndProcess(tx, opt)
-    instance.deployInfo = Object.freeze({
-      result,
-      owner: ownerId,
-      transaction: hash,
-      rawTx,
-      txData,
-      address: contractId
-    })
-    return instance.deployInfo
-  }
-
-  /**
-   * Get function schema from contract ACI object
-   * @param {String} name Function name
-   * @return {Object} function ACI
-   */
-  function getFunctionACI (name) {
-    const fn = instance._aci.encoded_aci.contract.functions.find(f => f.name === name)
-    if (fn) return fn
-    if (name === 'init') return { payable: false }
-    throw new NoSuchContractFunctionError(`Function ${name} doesn't exist in contract`)
-  }
-
-  /**
-   * Call contract function
-   * @alias module:@aeternity/aepp-sdk/es/contract/aci
-   * @rtype (init: Array, options: Object = { callStatic: false }) => CallResult: Object
-   * @param {String} fn Function name
-   * @param {Array} params Array of function arguments
-   * @param {Object} [options={}] Array of function arguments
-   * @param {Boolean} [options.callStatic=false] Static function call
-   * @return {Object} CallResult
-   */
-  instance.call = async (fn, params = [], options = {}) => {
-    const opt = { ...instance.options, ...options }
-    const fnACI = getFunctionACI(fn)
-    const contractId = instance.deployInfo.address
-
-    if (!fn) throw new MissingFunctionNameError()
-    if (fn === 'init' && !opt.callStatic) throw new InvalidMethodInvocationError('"init" can be called only via dryRun')
-    if (!contractId && fn !== 'init') throw new InvalidMethodInvocationError('You need to deploy contract before calling!')
-    if (fn !== 'init' && opt.amount > 0 && fnACI.payable === false) throw new NotPayableFunctionError(`You try to pay "${opt.amount}" to function "${fn}" which is not payable. Only payable function can accept coins`)
-
-    const callerId = await this.address(opt).catch(error => {
-      if (opt.callStatic) return DRY_RUN_ACCOUNT.pub
-      else throw error
-    })
-    const callData = instance.calldata.encode(instance._name, fn, params)
-
-    let res
-    if (opt.callStatic) {
-      if (typeof opt.top === 'number') {
-        opt.top = (await this.getKeyBlock(opt.top)).hash
-      }
-      const txOpt = {
-        ...opt,
-        gas: opt.gas ?? GAS_MAX,
-        callData,
-        nonce: opt.nonce ??
-          (opt.top && (await this.getAccount(callerId, { hash: opt.top })).nonce + 1)
-      }
-      const tx = fn === 'init'
-        ? (await this.contractCreateTx({ ...txOpt, code: instance.bytecode, ownerId: callerId })).tx
-        : await this.contractCallTx({ ...txOpt, callerId, contractId })
-
-      const { callObj, ...dryRunOther } = await this.txDryRun(tx, callerId, opt)
-      await handleCallError(callObj)
-      res = { ...dryRunOther, tx: TxObject({ tx }), result: callObj }
-    } else {
-      const tx = await this.contractCallTx({
-        ...opt,
-        gas: opt.gas ?? await instance._estimateGas(fn, params, opt),
-        callerId,
-        contractId,
-        callData
-      })
-      res = await sendAndProcess(tx, opt)
-    }
-    if (opt.waitMined || opt.callStatic) {
-      res.decodedResult = fnACI.returns && fnACI.returns !== 'unit' && fn !== 'init' &&
-        instance.calldata.decode(instance._name, fn, res.result.returnValue)
-      res.decodedEvents = instance.decodeEvents(res.result.log, opt)
-    }
-    return res
-  }
-
-  /**
-   * @param {String} address Contract address that emitted event
-   * @param {BigInt} nameHash Hash of emitted event name
-   * @param {Object} [options]
-   * @param {Object} [options.contractAddressToName] Map of contract addresses to their names
-   * @return {String} Contract name
-   * @throws {MissingEventDefinitionError}
-   * @throws {AmbiguousEventDefinitionError}
-   */
-  function getContractNameByEvent (address, nameHash, { contractAddressToName }) {
-    const addressToName = { ...instance.options.contractAddressToName, ...contractAddressToName }
-    if (addressToName[address]) return addressToName[address]
-
-    const matchedEvents = [
-      instance._aci.encoded_aci,
-      ...instance._aci.external_encoded_aci
-    ]
-      .filter(({ contract }) => contract?.event)
-      .map(({ contract }) => [contract.name, contract.event.variant])
-      .map(([name, events]) => events.map(event => [name, Object.keys(event)[0]]))
-      .flat()
-      .filter(([, eventName]) => BigInt('0x' + hash(eventName).toString('hex')) === nameHash)
-    switch (matchedEvents.length) {
-      case 0: throw new MissingEventDefinitionError(nameHash, address)
-      case 1: return matchedEvents[0][0]
-      default: throw new AmbiguousEventDefinitionError(address, matchedEvents)
-    }
-  }
-
-  /**
-   * Decode Events
-   * @alias module:@aeternity/aepp-sdk/es/contract/aci
-   * @rtype (events: Array) => DecodedEvents: Array
-   * @param {Array} events Array of encoded events (callRes.result.log)
-   * @param {Object} [options]
-   * @param {Boolean} [options.omitUnknown] Omit events that can't be decoded in case ACI is not
-   * complete
-   * @return {Object} DecodedEvents
-   */
-  instance.decodeEvents = (events, { omitUnknown, ...opt } = {}) => events
-    .map(event => {
-      const topics = event.topics.map(t => BigInt(t))
-      let contractName
-      try {
-        contractName = getContractNameByEvent(event.address, topics[0], opt)
-      } catch (error) {
-        if (omitUnknown && error instanceof MissingEventDefinitionError) return null
-        throw error
-      }
-      const decoded = instance.calldata.decodeEvent(contractName, event.data, topics)
-      const [name, args] = Object.entries(decoded)[0]
-      return {
-        name,
-        args,
-        contract: {
-          name: contractName,
-          address: event.address
-        }
-      }
-    })
-    .filter(e => e)
-
-  /**
-   * Generate proto function based on contract function using Contract ACI schema
-   * All function can be called like:
-   * 'await contract.methods.testFunction()' -> then sdk will decide to use dry-run or send tx
-   * on-chain base on if function stateful or not.
-   * Also you can manually do that:
-   * `await contract.methods.testFunction.get()` -> use call-static(dry-run)
-   * `await contract.methods.testFunction.send()` -> send tx on-chain
-   */
-  instance.methods = Object.fromEntries(instance._aci.encoded_aci.contract.functions
-    .map(({ name, arguments: aciArgs, stateful }) => {
-      const genHandler = callStatic => (...args) => {
-        const options = args.length === aciArgs.length + 1 ? args.pop() : {}
-        if (typeof options !== 'object') throw new TypeError(`Options should be an object: ${options}`)
-        if (name === 'init') return instance.deploy(args, { callStatic, ...options })
-        return instance.call(name, args, { callStatic, ...options })
-      }
-      return [
-        name,
-        Object.assign(
-          genHandler(name === 'init' ? false : !stateful),
-          {
-            get: genHandler(true),
-            send: genHandler(false)
-          }
-        )
-      ]
-    })
-  )
-
-  return instance
-}