@aeternity/aepp-sdk 10.0.0 → 12.0.0

package/src/channel/internal.js

@@ -1,231 +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 { awaitingConnection, awaitingReconnection, channelOpen } from './handlers'
-
-// 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 Error('State Channels FSM entered unknown state')
-  }
-  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) {
-  const queue = messageQueue.get(channel)
-  if (messageQueueLocked.get(channel) || !queue.length) {
-    return
-  }
-  const [message, ...remaining] = queue
-  messageQueue.set(channel, remaining || [])
-  messageQueueLocked.set(channel, true)
-  await handleMessage(channel, message)
-  messageQueueLocked.set(channel, false)
-  dequeueMessage(channel)
-}
-
-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 Error('Server pong timed out'))
-    }, 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)
-    }
-  } else if (message.method === 'channels.message') {
-    emit(channel, 'message', message.params.data.message)
-  } else 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)
-    }
-  } else {
-    messageQueue.set(channel, [...(messageQueue.get(channel) || []), message])
-    dequeueMessage(channel)
-  }
-}
-
-function wrapCallErrorMessage (message) {
-  const [{ message: details } = {}] = message.error.data || []
-  if (details) {
-    return new Error(`${message.error.message}: ${details}`)
-  }
-  return new Error(message.error.message)
-}
-
-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) return reject(wrapCallErrorMessage(message))
-    })
-    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, { url, ...channelOptions }) {
-  options.set(channel, channelOptions)
-  fsm.set(channel, {
-    handler: channelOptions.existingFsmId ? awaitingReconnection : awaitingConnection
-  })
-  eventEmitters.set(channel, new EventEmitter())
-  sequence.set(channel, 0)
-  rpcCallbacks.set(channel, new Map())
-
-  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: channelOpen })
-        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/index.js

@@ -1,317 +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 * as R from 'ramda'
-import BigNumber from 'bignumber.js'
-import { Encoder as Calldata } from '@aeternity/aepp-calldata'
-import { decodeEvents } from './transformation'
-import { DRY_RUN_ACCOUNT, DEPOSIT } from '../../tx/builder/schema'
-import TxObject from '../../tx/tx-object'
-import { decode } from '../../tx/builder/helpers'
-
-/**
- * Get function schema from contract ACI object
- * @param {Object} aci Contract ACI object
- * @param {String} name Function name
- * @param external
- * @return {Object} function ACI
- */
-function getFunctionACI (aci, name, external) {
-  const fn = aci.functions.find(f => f.name === name)
-  if (!fn && name !== 'init') throw new Error(`Function ${name} doesn't exist in contract`)
-
-  return {
-    ...fn,
-    bindings: [
-      {
-        state: aci.state,
-        type_defs: aci.type_defs,
-        name: aci.name
-      },
-      ...external.map(R.pick(['state', 'type_defs', 'name']))
-    ],
-    event: aci.event ? aci.event.variant : []
-  }
-}
-
-/**
- * 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 client.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,
-  contractAddress,
-  filesystem = {},
-  validateBytecode,
-  ...otherOptions
-} = {}) {
-  aci = aci || (source && await this.contractGetACI(source, { filesystem }))
-  if (!aci) throw new Error('Either ACI or source code is required')
-  contractAddress = contractAddress && await this.resolveName(
-    contractAddress, 'contract_pubkey', { resolveByNode: true }
-  )
-  if (!contractAddress && !source && !bytecode) throw new Error('Can\'t create instance by ACI without address')
-
-  if (contractAddress) {
-    const contract = await this.getContract(contractAddress).catch(() => null)
-    if (!contract) throw new Error(`Contract with address ${contractAddress} not found on-chain`)
-    if (!contract.active) throw new Error(`Contract with address ${contractAddress} not active`)
-  }
-
-  const instance = {
-    interface: R.defaultTo(null, R.prop('interface', aci)),
-    aci: R.defaultTo(null, R.path(['encoded_aci', 'contract'], aci)),
-    calldata: new Calldata([aci.encoded_aci, ...aci.external_encoded_aci]),
-    externalAci: (aci.external_encoded_aci ?? []).map(a => a.contract || a.namespace),
-    source,
-    bytecode,
-    deployInfo: { address: contractAddress },
-    options: {
-      ...this.Ae.defaults,
-      callStatic: false,
-      filesystem,
-      ...otherOptions
-    },
-    compilerVersion: this.compilerVersion
-  }
-
-  if (validateBytecode) {
-    if (!contractAddress) throw new Error('Can\'t validate bytecode without contract address')
-    const onChanBytecode = (await this.getContractByteCode(contractAddress)).bytecode
-    const isValid = (source && await this
-      .validateByteCodeAPI(onChanBytecode, source, instance.options).catch(() => false)) ||
-      bytecode === onChanBytecode
-    if (!isValid) throw new Error(`Contract ${source ? 'source' : 'bytecode'} do not correspond to the bytecode deployed on the chain`)
-  }
-
-  /**
-   * 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 Error('Contract already compiled')
-    if (!instance.source) throw new Error('Can\'t compile without source code')
-    const { bytecode } = await this.contractCompile(
-      instance.source, { ...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 txInfo = await this.getTxInfo(txData.hash)
-    await handleCallError(txInfo)
-    return { ...result, result: txInfo }
-  }
-
-  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 Error(`Unknown returnType: ${returnType}`)
-    }
-    throw new Error(`Invocation failed${message ? `: "${message}"` : ''}`)
-  }
-
-  /**
-   * 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, deposit: DEPOSIT }
-    if (!instance.bytecode) await instance.compile(opt)
-    if (opt.callStatic) return instance.call('init', params, opt)
-    if (instance.deployInfo.address) throw new Error('Contract already deployed')
-
-    const ownerId = await this.address(opt)
-    const { tx, contractId } = await this.contractCreateTx({
-      ...opt,
-      callData: instance.calldata.encode(instance.aci.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,
-      call: (name, args, options) =>
-        this.contractCall(instance.source, contractId, name, args, { ...opt, ...options }),
-      callStatic: (name, args, options) =>
-        this.contractCallStatic(instance.source, contractId, name, args, { ...opt, ...options }),
-      createdAt: new Date()
-    })
-    return instance.deployInfo
-  }
-
-  /**
-   * 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(instance.aci, fn, instance.externalAci)
-    const contractId = instance.deployInfo.address
-
-    if (!fn) throw new Error('Function name is required')
-    if (fn === 'init' && !opt.callStatic) throw new Error('"init" can be called only via dryRun')
-    if (!contractId && fn !== 'init') throw new Error('You need to deploy contract before calling!')
-    if (
-      BigNumber(opt.amount).gt(0) &&
-      (Object.prototype.hasOwnProperty.call(fnACI, 'payable') && !fnACI.payable)
-    ) throw new Error(`You try to pay "${opt.amount}" to function "${fn}" which is not payable. Only payable function can accept tokens`)
-
-    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.aci.name, fn, params)
-
-    let res
-    if (opt.callStatic) {
-      if (typeof opt.top === 'number') {
-        opt.top = (await this.getKeyBlock(opt.top)).hash
-      }
-      const txOpt = {
-        ...opt,
-        callData,
-        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, 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.aci.name, fn, res.result.returnValue)
-      res.decodedEvents = instance.decodeEvents(res.result.log)
-    }
-    return res
-  }
-
-  /**
-   * 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)
-   * @return {Object} DecodedEvents
-   */
-  instance.decodeEvents = (events) => {
-    const eventsACI = instance.aci.event ? instance.aci.event.variant : []
-    const eventsSchema = eventsACI.map(e => {
-      const name = Object.keys(e)[0]
-      return { name, types: e[name] }
-    })
-
-    return decodeEvents(events, eventsSchema)
-  }
-
-  /**
-   * 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.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 Error(`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),
-            decodeEvents: events => instance.decodeEvents(events)
-          }
-        )
-      ]
-    })
-  )
-
-  return instance
-}

package/src/contract/aci/transformation.js

@@ -1,72 +0,0 @@
-import { toBytes } from '../../utils/bytes'
-import { decode } from '../../tx/builder/helpers'
-import { parseBigNumber } from '../../utils/bignumber'
-import { addressFromDecimal, hash } from '../../utils/crypto'
-
-export const SOPHIA_TYPES = [
-  'int',
-  'string',
-  'tuple',
-  'address',
-  'bool',
-  'list',
-  'map',
-  'record',
-  'option',
-  'oracle',
-  'oracleQuery',
-  'hash',
-  'signature',
-  'bytes',
-  'variant'
-].reduce((acc, type) => ({ ...acc, [type]: type }), { ChainTtl: 'Chain.ttl' })
-
-/**
- * Decode events fields
- * @param {Object[]} events Array of events with encoded fields
- * @param {Array} schemas Smart contract event ACI schemas
- * @return {Object}
- */
-export const decodeEvents = (events, schemas = []) => events.reduce((acc, event) => {
-  const [nameHash, ...params] = event.topics
-  const schema = schemas.find((s) => hash(s.name).equals(toBytes(nameHash, true)))
-  if (!schema) return acc
-  const stringCount = schema.types.filter(t => t === SOPHIA_TYPES.string).length
-  if (stringCount > 1) throw new Error(`Event schema contains more than one string: ${schema.types}`)
-  const topicsCount = schema.types.length - stringCount
-  if (topicsCount !== params.length) {
-    throw new Error(`Schema defines ${topicsCount} types, but ${params.length} topics present`)
-  }
-
-  acc.push({
-    ...event,
-    name: schema.name,
-    decoded: schema.types.map((type) =>
-      decodeEventField(type === SOPHIA_TYPES.string ? event.data : params.shift(), type))
-  })
-
-  return acc
-}, [])
-
-/**
- * Transform Event based on type
- * @param {String|Number} field Event data
- * @param {String} type Event type from schema
- * @return {*}
- */
-function decodeEventField (field, type) {
-  switch (type) {
-    case SOPHIA_TYPES.int:
-      return parseBigNumber(field)
-    case SOPHIA_TYPES.bool:
-      return !!field
-    case SOPHIA_TYPES.hash:
-      return toBytes(field, true).toString('hex')
-    case SOPHIA_TYPES.address:
-      return addressFromDecimal(field)
-    case SOPHIA_TYPES.string:
-      return decode(field).toString('utf-8')
-    default:
-      return toBytes(field, true)
-  }
-}