@aeternity/aepp-sdk 10.0.0 → 12.0.0

package/src/channel/internal.ts

@@ -0,0 +1,345 @@
+/*
+ * 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 BigNumber from 'bignumber.js'
+import Channel from '.'
+import JsonBig from '../utils/json-big'
+import { pascalToSnake } from '../utils/string'
+import { EncodedData } from '../utils/encoder'
+import { ChannelCallError, ChannelPingTimedOutError, UnknownChannelStateError } from '../utils/errors'
+
+interface ChannelAction {
+  guard: (channel: Channel, state?: ChannelFsm) => boolean
+  action: (channel: Channel, state?: ChannelFsm) => ChannelFsm
+}
+
+export type SignTxWithTag = (tag: string, tx: EncodedData<'tx'>, options?: object) => Promise<EncodedData<'tx'>>
+// TODO: SignTx shouldn't return number or null
+export type SignTx = (tx: EncodedData<'tx'>, options?: object) => Promise<EncodedData<'tx'> | number | null>
+
+export interface ChannelOptions {
+  existingFsmId?: string
+  url: string
+  role: 'initiator' | 'responder'
+  initiatorId: EncodedData<'ak'>
+  responderId: EncodedData<'ak'>
+  pushAmount: number
+  initiatorAmount: BigNumber
+  responderAmount: BigNumber
+  channelReserve?: BigNumber | number
+  signedTx?: string
+  ttl?: number
+  host: string
+  port: number
+  lockPeriod: number
+  existingChannelId?: string
+  offChainTx?: string
+  reconnectTx?: string
+  timeoutIdle?: number
+  timeoutFundingCreate?: number
+  timeoutFundingSign?: number
+  timeoutFundingLock?: number
+  timeoutSign?: number
+  timeoutAccept?: number
+  timeoutInitialized?: number
+  timeoutAwaitingOpen?: number
+  statePassword?: string
+  debug: boolean
+  sign: SignTxWithTag
+  offchainTx?: string
+}
+
+export interface ChannelHandler extends Function {
+  enter?: Function
+}
+
+export interface ChannelState {
+  signedTx: any
+  resolve: Function
+  reject: Function
+  sign: SignTx
+  handler?: ChannelHandler
+  onOnChainTx?: Function
+  onOwnWithdrawLocked?: Function
+  onWithdrawLocked?: Function
+  onOwnDepositLocked?: Function
+  onDepositLocked?: Function
+  closeTx?: string
+}
+
+export interface ChannelFsm {
+  handler: ChannelHandler
+  state?: ChannelState | {
+    resolve: Function
+    reject: Function
+  }
+}
+
+export interface ChannelMessage {
+  id?: number
+  jsonrpc: string
+  method: string
+  params: any
+  payload?: any
+  data?: any
+  error?: ChannelMessageError
+}
+
+interface ChannelMessageError {
+  code: number
+  message: string
+  data: [{
+    message: string
+    code: number
+  }]
+  request: ChannelMessage
+}
+
+// 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
+
+// TODO: move to Channel instance to avoid is-null checks and for easier debugging
+export const options = new WeakMap<Channel, ChannelOptions>()
+export const status = new WeakMap<Channel, string>()
+export const state = new WeakMap<Channel, EncodedData<'tx'>>()
+const fsm = new WeakMap<Channel, ChannelFsm>()
+const websockets = new WeakMap<Channel, W3CWebSocket>()
+export const eventEmitters = new WeakMap<Channel, EventEmitter>()
+const messageQueue = new WeakMap<Channel, string[]>()
+const messageQueueLocked = new WeakMap<Channel, boolean>()
+const actionQueue = new WeakMap<Channel, ChannelAction[]>()
+const actionQueueLocked = new WeakMap<Channel, boolean>()
+const sequence = new WeakMap<Channel, number>()
+export const channelId = new WeakMap<Channel, string>()
+const rpcCallbacks = new WeakMap<Channel, Map<number, Function>>()
+const pingTimeoutId = new WeakMap<Channel, NodeJS.Timeout>()
+const pongTimeoutId = new WeakMap<Channel, NodeJS.Timeout>()
+export const fsmId = new WeakMap<Channel, string>()
+
+export function emit (channel: Channel, ...args: any[]): void {
+  const [eventName, ...rest] = args
+  eventEmitters.get(channel)?.emit(eventName, ...rest)
+}
+
+function enterState (channel: Channel, nextState: ChannelFsm): void {
+  if (nextState == null) {
+    throw new UnknownChannelStateError()
+  }
+  fsm.set(channel, nextState)
+  if (nextState?.handler?.enter != null) {
+    nextState.handler.enter(channel)
+  }
+  void dequeueAction(channel)
+}
+
+export function changeStatus (channel: Channel, newStatus: string): void {
+  const prevStatus = status.get(channel)
+  if (newStatus !== prevStatus) {
+    status.set(channel, newStatus)
+    emit(channel, 'statusChanged', newStatus)
+  }
+}
+
+export function changeState (channel: Channel, newState: EncodedData<'tx'>): void {
+  state.set(channel, newState)
+  emit(channel, 'stateChanged', newState)
+}
+
+export function send (channel: Channel, message: ChannelMessage): void {
+  const debug: boolean = options.get(channel)?.debug ?? false
+  if (debug) console.log('Send message: ', message)
+
+  websockets.get(channel)?.send(JsonBig.stringify(message))
+}
+
+export function enqueueAction (channel: Channel, guard: ChannelAction['guard'], action: ChannelAction['action']): void {
+  const queue = actionQueue.get(channel) ?? []
+  actionQueue.set(channel, [
+    ...queue,
+    { guard, action }
+  ])
+  void dequeueAction(channel)
+}
+
+async function dequeueAction (channel: Channel): Promise<void> {
+  const locked = actionQueueLocked.get(channel)
+  const queue = actionQueue.get(channel) ?? []
+  if (Boolean(locked) || queue.length === 0) {
+    return
+  }
+  const state = fsm.get(channel)
+  if (state == null) return
+  const index = queue.findIndex((action: ChannelAction) => action.guard(channel, state))
+  if (index === -1) {
+    return
+  }
+  actionQueue.set(channel, queue.filter((_: ChannelAction, i: number) => index !== i))
+  actionQueueLocked.set(channel, true)
+  const nextState: ChannelFsm = await Promise.resolve(queue[index].action(channel, state))
+  actionQueueLocked.set(channel, false)
+  enterState(channel, nextState)
+}
+
+async function handleMessage (channel: Channel, message: string): Promise<void> {
+  const fsmState = fsm.get(channel)
+  if (fsmState == null) throw new UnknownChannelStateError()
+  const { handler, state } = fsmState
+  enterState(channel, await Promise.resolve(handler(channel, message, state)))
+}
+
+async function dequeueMessage (channel: Channel): Promise<void> {
+  const locked: boolean = messageQueueLocked.get(channel) ?? false
+  if (locked) return
+  const messages: string[] = messageQueue.get(channel) ?? []
+  if (messages.length === 0) return
+  messageQueueLocked.set(channel, true)
+  while (messages.length > 0) {
+    const message: string = 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: Channel): void {
+  const pingTimeoutIdValue = pingTimeoutId.get(channel)
+  const pongTimeoutIdValue = pongTimeoutId.get(channel)
+  if (pingTimeoutIdValue != null) clearTimeout(pingTimeoutIdValue)
+  if (pongTimeoutIdValue != null) clearTimeout(pongTimeoutIdValue)
+  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: Channel, data: string): void {
+  const message = JsonBig.parse(data)
+  const debug: boolean = options.get(channel)?.debug ?? false
+  if (debug) console.log('Receive message: ', message)
+  if (message.id != null) {
+    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)
+  void dequeueMessage(channel)
+}
+
+export async function call (channel: Channel, method: string, params: any): Promise<any> {
+  return await new Promise((resolve, reject) => {
+    const currentSequence: number = sequence.get(channel) ?? 0
+    const id = sequence.set(channel, currentSequence + 1).get(channel) ?? 1
+    rpcCallbacks.get(channel)?.set(id, (message: {
+      result: PromiseLike<any>
+      error?: ChannelMessageError }) => {
+      if (message.result != null) return resolve(message.result)
+      if (message.error != null) {
+        const [{ message: details } = { message: '' }] = message.error.data ?? []
+        return reject(new ChannelCallError(message.error.message + details))
+      }
+    })
+    send(channel, { jsonrpc: '2.0', method, id, params })
+  })
+}
+
+export function disconnect (channel: Channel): void {
+  websockets.get(channel)?.close()
+  const pingTimeoutIdValue = pingTimeoutId.get(channel)
+  const pongTimeoutIdValue = pongTimeoutId.get(channel)
+  if (pingTimeoutIdValue != null) clearTimeout(pingTimeoutIdValue)
+  if (pongTimeoutIdValue != null) clearTimeout(pongTimeoutIdValue)
+}
+
+export async function initialize (
+  channel: Channel,
+  connectionHandler: Function,
+  openHandler: Function,
+  { url, ...channelOptions }: ChannelOptions
+): Promise<void> {
+  options.set(channel, { url, ...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<void>((resolve, reject) => Object.assign(ws, {
+    onerror: reject,
+    onopen: async () => {
+      resolve()
+      changeStatus(channel, 'connected')
+      if (channelOptions.reconnectTx != null) {
+        enterState(channel, { handler: openHandler })
+        const signedTx = (await call(channel, 'channels.get.offchain_state', {})).signed_tx
+        changeState(channel, signedTx)
+      }
+      ping(channel)
+    },
+    onclose: () => {
+      changeStatus(channel, 'disconnected')
+      const pingTimeoutIdValue = pingTimeoutId.get(channel)
+      const pongTimeoutIdValue = pongTimeoutId.get(channel)
+      if (pingTimeoutIdValue != null) clearTimeout(pingTimeoutIdValue)
+      if (pongTimeoutIdValue != null) clearTimeout(pongTimeoutIdValue)
+    },
+    onmessage: ({ data }: {data: string}) => onMessage(channel, data)
+  }))
+  websockets.set(channel, ws)
+}

package/src/contract/Compiler.ts

@@ -0,0 +1,66 @@
+/*
+ * ISC License (ISC)
+ * Copyright (c) 2022 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 { Compiler as CompilerApi, ErrorModel, CompilerError } from '../apis/compiler'
+import { genErrorFormatterPolicy, genVersionCheckPolicy } from '../utils/autorest'
+
+type GeneralCompilerError = ErrorModel & {
+  info?: object
+  parameter?: string
+}
+
+/**
+ * Contract Compiler
+ *
+ * This class include api call's related to contract compiler functionality.
+ * @example Compiler('COMPILER_URL')
+ */
+export default class Compiler extends CompilerApi {
+  /**
+   * @param compilerUrl - Url for compiler API
+   * @param options - Options
+   * @param options.ignoreVersion - Don't check compiler version
+   */
+  constructor (compilerUrl: string, { ignoreVersion }: { ignoreVersion?: boolean } = {}) {
+    super(compilerUrl, {
+      allowInsecureConnection: true,
+      additionalPolicies: [
+        genErrorFormatterPolicy((body: GeneralCompilerError | CompilerError[]) => {
+          let message = ''
+          if ('reason' in body) {
+            message += ' ' + body.reason +
+              (body.parameter != null ? ` in ${body.parameter}` : '') +
+              // TODO: revising after improving documentation https://github.com/aeternity/aesophia_http/issues/78
+              (body.info != null ? ` (${JSON.stringify(body.info)})` : '')
+          }
+          if (Array.isArray(body)) {
+            message += '\n' + body
+              .map(e => `${e.type}:${e.pos.line}:${e.pos.col}: ${e.message}${e.context != null ? `(${e.context})` : ''}`)
+              .map(e => e.trim()) // TODO: remove after fixing https://github.com/aeternity/aesophia_http/issues/80
+              .join('\n')
+          }
+          return message
+        })
+      ]
+    })
+    if (ignoreVersion !== true) {
+      const versionPromise = this.aPIVersion().then(({ apiVersion }) => apiVersion)
+      this.pipeline.addPolicy(
+        genVersionCheckPolicy('compiler', '/api-version', versionPromise, '6.1.0', '7.0.0')
+      )
+    }
+  }
+}