@aeternity/aepp-sdk 10.0.0 → 12.0.0

package/src/account/Rpc.ts

@@ -0,0 +1,67 @@
+import AccountBase from './Base'
+import { METHODS } from '../aepp-wallet-communication/schema'
+import { NotImplementedError } from '../utils/errors'
+import { EncodedData } from '../utils/encoder'
+
+/**
+ * Account provided by wallet
+ * @param params - Params
+ * @param params.rpcClient - RpcClient instance
+ * @param params.address - RPC account address
+ * @returns AccountRpc instance
+ */
+export default class AccountRpc extends AccountBase {
+  _rpcClient: any
+  _address: EncodedData<'ak'>
+
+  constructor (
+    { rpcClient, address, ...options }:
+    { rpcClient: any, address: EncodedData<'ak'> } & ConstructorParameters<typeof AccountBase>[0]
+  ) {
+    super(options)
+    this._rpcClient = rpcClient
+    this._address = address
+  }
+
+  async sign (data: string | Uint8Array, options?: any): Promise<Uint8Array> {
+    throw new NotImplementedError('RAW signing using wallet')
+  }
+
+  async address (): Promise<EncodedData<'ak'>> {
+    return this._address
+  }
+
+  /**
+   * @returns Signed transaction
+   */
+  async signTransaction (
+    tx: EncodedData<'tx'>,
+    { innerTx, networkId }: Parameters<AccountBase['signTransaction']>[1] = {}
+  ): Promise<EncodedData<'tx'>> {
+    if (innerTx != null) throw new NotImplementedError('innerTx option in AccountRpc')
+    const res = await this._rpcClient.request(METHODS.sign, {
+      onAccount: this._address,
+      tx,
+      returnSigned: true,
+      /**
+       * @deprecated Wallet provided networkId will be used (current network)
+       * required to maintain backward compatibility with wallets using SDK v11.0.1 and below
+       * @see {@link https://github.com/aeternity/aepp-sdk-js/commit/153fd89a52c4eab39fcd659b356b36d32129c1ba}
+       */
+      networkId
+    })
+    return res.signedTransaction
+  }
+
+  /**
+   * @returns Signed message
+   */
+  async signMessage (
+    message: string, { returnHex = false }: Parameters<AccountBase['signMessage']>[1] = {}
+  ): Promise<string | Uint8Array> {
+    const { signature } = await this._rpcClient.request(
+      METHODS.signMessage, { onAccount: this._address, message }
+    )
+    return returnHex ? signature : Buffer.from(signature, 'hex')
+  }
+}

package/src/aens.ts

@@ -0,0 +1,391 @@
+/*
+ * 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.
+ */
+
+/**
+ * Aens methods - routines to interact with the æternity naming system
+ *
+ * The high-level description of the naming system is
+ * https://github.com/aeternity/protocol/blob/master/AENS.md in the protocol
+ * repository.
+ */
+
+import { salt } from './utils/crypto'
+import { commitmentHash, isAuctionName, Pointer } from './tx/builder/helpers'
+import { CLIENT_TTL, NAME_TTL, TX_TYPE, AensName } from './tx/builder/schema'
+import { ArgumentError } from './utils/errors'
+import { EncodedData } from './utils/encoder'
+import BigNumber from 'bignumber.js'
+import { send, SendOptions } from './spend'
+import { getName, height } from './chain'
+import { _buildTx, BuildTxOptions } from './tx'
+import { TransformNodeType } from './Node'
+import { NameEntry } from './apis/node'
+import AccountBase from './account/Base'
+
+interface KeyPointers {
+  [key: string]: string | Buffer
+}
+
+/**
+ * Revoke a name
+ * @param name - Name hash
+ * @param options - Options
+ * @param options.onAccount - Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @returns Transaction result
+ * @example
+ * ```js
+ * const name = 'test.chain'
+ * const nameObject = await sdkInstance.aensQuery(name)
+ *
+ * await sdkInstance.aensRevoke(name, { fee, ttl , nonce })
+ * // or
+ * await nameObject.revoke({ fee, ttl, nonce })
+ * ```
+ */
+export async function aensRevoke (
+  name: AensName, options: AensRevokeOptions
+): ReturnType<typeof send> {
+  const nameRevokeTx = await _buildTx(TX_TYPE.nameRevoke, {
+    ...options,
+    nameId: name,
+    accountId: await options.onAccount.address(options)
+  })
+  return await send(nameRevokeTx, options)
+}
+
+interface AensRevokeOptions extends
+  BuildTxOptions<TX_TYPE.nameRevoke, 'nameId' | 'accountId'>,
+  SendOptions {}
+
+/**
+ * Update a name
+ * @param name - AENS name
+ * @param pointers - Map of pointer keys to corresponding addresses
+ * @param options - Options
+ * @param options.extendPointers - Get the pointers from the node and merge with provided
+ * ones. Pointers with the same type will be overwritten
+ * @param options.onAccount - Make operation on specific account from sdk (you
+ * pass publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @param options.nameTtl - Name ttl represented in number of
+ * blocks (Max value is 50000 blocks)
+ * @param options.clientTtl=84600 a suggestion as to how long any
+ * clients should cache this information
+ * @throws Invalid pointer array error
+ * @example
+ * ```js
+ * const name = 'test.chain'
+ * const pointersArray = ['ak_asd23dasdas...,' 'ct_asdf34fasdasd...']
+ * const nameObject = await sdkInstance.aensQuery(name)
+ *
+ * await sdkInstance.aensUpdate(name, pointersArray, { nameTtl, ttl, fee, nonce, clientTtl })
+ * // or
+ * await nameObject.update(pointers, { nameTtl, ttl, fee, nonce, clientTtl })
+ * ```
+ */
+export async function aensUpdate (
+  name: AensName, pointers: KeyPointers, { extendPointers, ...options }: AensUpdateOptions
+): ReturnType<typeof send> {
+  const allPointers = {
+    ...extendPointers === true && Object.fromEntries(
+      (await getName(name, options)).pointers
+        .map(({ key, id }: { key: string, id: string }) => [key, id])
+    ),
+    ...pointers
+  }
+
+  const nameUpdateTx = await _buildTx(TX_TYPE.nameUpdate, {
+    clientTtl: CLIENT_TTL,
+    nameTtl: NAME_TTL,
+    ...options,
+    nameId: name,
+    accountId: await options.onAccount.address(options),
+    pointers: Object.entries(allPointers).map(([key, id]) => ({ key, id: id.toString() }))
+  })
+
+  return await send(nameUpdateTx, options)
+}
+
+interface AensUpdateOptions extends
+  BuildTxOptions<TX_TYPE.nameUpdate, 'nameId' | 'accountId' | 'pointers' | 'clientTtl' | 'nameTtl'>,
+  SendOptions {
+  extendPointers?: boolean
+  clientTtl?: number
+  nameTtl?: number
+}
+
+/**
+ * Transfer a domain to another account
+ * @param name - AENS name
+ * @param account - Recipient account publick key
+ * @param options - Options
+ * @param options.onAccount - Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @returns Transaction result
+ * @example
+ * ```js
+ * const name = 'test.chain'
+ * const recipientPub = 'ak_asd23dasdas...'
+ * const nameObject = await sdkInstance.aensQuery(name)
+ *
+ * await sdkInstance.aensTransfer(name, recipientPub, { ttl, fee, nonce })
+ * // or
+ * await nameObject.transfer(recipientPub, { ttl, fee, nonce })
+ * ```
+ */
+export async function aensTransfer (
+  name: AensName, account: EncodedData<'ak'>, options: AensTransferOptions
+): ReturnType<typeof send> {
+  const nameTransferTx = await _buildTx(TX_TYPE.nameTransfer, {
+    ...options,
+    nameId: name,
+    accountId: await options.onAccount.address(options),
+    recipientId: account
+  })
+
+  return await send(nameTransferTx, options)
+}
+
+interface AensTransferOptions extends
+  BuildTxOptions<TX_TYPE.nameTransfer, 'nameId' | 'accountId' | 'recipientId'>,
+  SendOptions {}
+
+/**
+ * Query the AENS name info from the node
+ * and return the object with info and predefined functions for manipulating name
+ * @param name - AENS name
+ * @param opt - Options
+ * @returns
+ * @example
+ * ```js
+ * const nameObject = sdkInstance.aensQuery('test.chain')
+ * console.log(nameObject)
+ * {
+ *  id, // name hash
+ *  pointers, // array of pointers
+ *  update, // Update name function
+ *  extendTtl, // Extend Ttl name function
+ *  transfer, // Transfer name function
+ *  revoke // Revoke name function
+ * }
+ * ```
+ */
+export async function aensQuery (
+  name: AensName,
+  opt: Parameters<typeof getName>[1] & Parameters<typeof aensUpdate>[2]
+  & Parameters<typeof aensTransfer>[2]
+): Promise<Readonly<
+  TransformNodeType<NameEntry> & {
+    id: EncodedData<'nm'>
+    owner: EncodedData<'ak'>
+    pointers: KeyPointers | Pointer[]
+    ttl: number
+    update: (
+      pointers: KeyPointers,
+      options?: Omit<Parameters<typeof aensQuery>[1], 'onNode' | 'onCompiler' | 'onAccount'> & {
+        onAccount?: AccountBase
+      }
+    ) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>
+    transfer: (
+      account: EncodedData<'ak'>,
+      options?: Parameters<typeof aensQuery>[1]
+    ) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>
+    revoke: (options?: Omit<Parameters<typeof aensRevoke>[1], 'onNode' | 'onCompiler' | 'onAccount'> & {
+      onAccount?: AccountBase
+    }
+    ) => ReturnType<typeof aensRevoke>
+    extendTtl: (
+      nameTtl: number,
+      options?: Omit<Parameters<typeof aensQuery>[1], 'onNode' | 'onCompiler' | 'onAccount'>
+    ) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>
+  }
+  >> {
+  const nameEntry = await getName(name, opt)
+  return Object.freeze({
+    ...nameEntry,
+    id: nameEntry.id as EncodedData<'nm'>,
+    owner: nameEntry.owner as EncodedData<'ak'>,
+    async update (pointers, options) {
+      return {
+        ...await aensUpdate(name, pointers, { ...opt, ...options }),
+        ...await aensQuery(name, { ...opt, ...options })
+      }
+    },
+    async transfer (account, options) {
+      return {
+        ...await aensTransfer(name, account, { ...opt, ...options }),
+        ...await aensQuery(name, { ...opt, ...options })
+      }
+    },
+    async revoke (options) {
+      return await aensRevoke(name, { ...opt, ...options })
+    },
+    async extendTtl (nameTtl = NAME_TTL, options) {
+      if (nameTtl > NAME_TTL || nameTtl <= 0) {
+        throw new ArgumentError('nameTtl', `a number between 1 and ${NAME_TTL} blocks`, nameTtl)
+      }
+
+      return {
+        ...await aensUpdate(name, {}, { ...opt, ...options, nameTtl, extendPointers: true }),
+        ...await aensQuery(name, { ...opt, ...options })
+      }
+    }
+  })
+}
+
+/**
+ * Claim a previously preclaimed registration. This can only be done after the
+ * preclaim step
+ * @param name - AENS name
+ * @param salt - Salt from pre-claim, or 0 if it's a bid
+ * @param options - options
+ * @param options.onAccount - Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @param options.nameFee - Name Fee (By default calculated by sdk)
+ * @returns the result of the claim
+ * @example
+ * ```js
+ * const name = 'test.chain'
+ * const salt = preclaimResult.salt // salt from pre-claim transaction
+ *
+ * await sdkInstance.aensClaim(name, salt, { ttl, fee, nonce, nameFee })
+ * ```
+ */
+export async function aensClaim (
+  name: AensName, salt: number, options: AensClaimOptions
+): Promise<AensClaimReturnType> {
+  const claimTx = await _buildTx(TX_TYPE.nameClaim, {
+    ...options,
+    accountId: await options.onAccount.address(options),
+    nameSalt: salt,
+    name
+  })
+
+  const result = await send(claimTx, options)
+  if (!isAuctionName(name)) {
+    const nameInter = result.blockHeight != null && result.blockHeight > 0
+      ? await aensQuery(name, options)
+      : {}
+    return Object.assign(result, nameInter)
+  }
+  return result
+}
+
+type AensClaimOptionsType = BuildTxOptions<TX_TYPE.nameClaim, 'accountId' | 'nameSalt' | 'name'>
+& SendOptions & Parameters<typeof aensQuery>[1]
+interface AensClaimOptions extends AensClaimOptionsType {}
+interface AensClaimReturnType extends
+  Awaited<ReturnType<typeof send>>,
+  Partial<Awaited<ReturnType<typeof aensQuery>>> {}
+
+/**
+ * Preclaim a name. Sends a hash of the name and a random salt to the node
+ * @param name - AENS name
+ * @param options - Options
+ * @param options.onAccount - Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @example
+ * ```js
+ * const name = 'test.chain'
+ * const salt = preclaimResult.salt // salt from pre-claim transaction
+ *
+ * await sdkInstance.aensPreclaim(name, { ttl, fee, nonce })
+ * {
+ *   ...transactionResult,
+ *   claim, // Claim function (options={}) => claimTransactionResult
+ *   salt,
+ *   commitmentId
+ * }
+ * ```
+ */
+export async function aensPreclaim (
+  name: AensName, options: AensPreclaimOptions
+): Promise<Readonly<
+  Awaited<ReturnType<typeof send>> & {
+    height: number
+    salt: number
+    commitmentId: string
+    claim: (opts?: Parameters<typeof aensClaim>[2]) => ReturnType<typeof aensClaim>
+  }
+  >> {
+  const _salt = salt()
+  const currentHeight = await height(options)
+  const commitmentId = commitmentHash(name, _salt)
+
+  const preclaimTx = await _buildTx(TX_TYPE.namePreClaim, {
+    ...options,
+    accountId: await options.onAccount.address(options),
+    commitmentId
+  })
+
+  return Object.freeze({
+    ...await send(preclaimTx, options),
+    height: currentHeight,
+    salt: _salt,
+    commitmentId,
+    async claim (opts?: Parameters<typeof aensClaim>[2]) {
+      return await aensClaim(name, _salt, { ...options, ...opts })
+    }
+  })
+}
+
+interface AensPreclaimOptions extends
+  BuildTxOptions<TX_TYPE.namePreClaim, 'accountId' | 'commitmentId'>,
+  SendOptions,
+  AensClaimOptions {}
+
+/**
+ * Bid to name auction
+ * @param name - Domain name
+ * @param nameFee - Name fee (bid fee)
+ * @param options - Options
+ * @param options.onAccount - Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @returns Transaction result
+ * @example
+ * ```js
+ * const name = 'test.chain'
+ * const bidFee = computeBidFee(name, startFee, incrementPercentage)
+ *
+ * await sdkInstance.aensBid(name, 213109412839123, { ttl, fee, nonce })
+ * ```
+ */
+export async function aensBid (
+  name: AensName,
+  nameFee: number | string | BigNumber,
+  options: Omit<Parameters<typeof aensClaim>[2], 'nameFee'>
+): ReturnType<typeof aensClaim> {
+  return await aensClaim(name, 0, { ...options, nameFee })
+}

package/src/aepp-wallet-communication/connection/Browser.ts

@@ -0,0 +1,68 @@
+/*
+ * 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 { AlreadyConnectedError, NoWalletConnectedError } from '../../utils/errors'
+
+/**
+ * Browser connection base interface
+ */
+export default abstract class BrowserConnection {
+  debug: boolean
+
+  protected constructor ({ debug = false }: { debug?: boolean }) {
+    this.debug = debug
+  }
+
+  /**
+   * Connect
+   * @param onMessage - Message handler
+   * @param onDisconnect - trigger when runtime connection in closed
+   */
+  connect (
+    onMessage: (message: any, origin: string, source: any) => void,
+    onDisconnect: () => void
+  ): void {
+    if (this.isConnected()) throw new AlreadyConnectedError('You already connected')
+  }
+
+  /**
+   * Disconnect
+   */
+  disconnect (): void {
+    if (!this.isConnected()) throw new NoWalletConnectedError('You dont have connection. Please connect before')
+  }
+
+  /**
+   * Send message
+   */
+  protected receiveMessage (message: any): void {
+    if (this.debug) console.log('Receive message:', message)
+  }
+
+  /**
+   * Send message
+   */
+  sendMessage (message: any): void {
+    if (this.debug) console.log('Send message:', message)
+  }
+
+  /**
+   * Check if connected
+   * @returns Is connected
+   */
+  abstract isConnected (): boolean
+}

package/src/aepp-wallet-communication/connection/BrowserRuntime.ts

@@ -0,0 +1,58 @@
+/*
+ * 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 { Runtime } from 'webextension-polyfill'
+import BrowserConnection from './Browser'
+
+/**
+ * BrowserRuntimeConnection
+ * Handle browser runtime communication
+ */
+export default class BrowserRuntimeConnection extends BrowserConnection {
+  port: Runtime.Port
+
+  constructor ({ port, ...options }: { port: Runtime.Port, debug: boolean }) {
+    super(options)
+    this.port = port
+  }
+
+  disconnect (): void {
+    super.disconnect()
+    this.port.disconnect()
+  }
+
+  connect (
+    onMessage: (message: any, origin: string, source: Runtime.Port) => void,
+    onDisconnect: () => void
+  ): void {
+    super.connect(onMessage, onDisconnect)
+    this.port.onMessage.addListener((message, port) => {
+      this.receiveMessage(message)
+      onMessage(message, port.name, port)
+    })
+    this.port.onDisconnect.addListener(onDisconnect)
+  }
+
+  sendMessage (message: any): void {
+    super.sendMessage(message)
+    this.port.postMessage(message)
+  }
+
+  isConnected (): boolean {
+    return this.port.onMessage.hasListeners()
+  }
+}

package/src/aepp-wallet-communication/connection/BrowserWindowMessage.ts

@@ -0,0 +1,111 @@
+/*
+ * 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 BrowserConnection from './Browser'
+import { MESSAGE_DIRECTION } from '../schema'
+import { InternalError, RpcConnectionError } from '../../utils/errors'
+
+export type ImplPostMessage = Pick<Window, 'addEventListener' | 'removeEventListener' | 'postMessage'>
+
+/**
+ * Browser window Post Message connector module
+ */
+export default class BrowserWindowMessageConnection extends BrowserConnection {
+  origin?: string
+  sendDirection?: MESSAGE_DIRECTION
+  receiveDirection: MESSAGE_DIRECTION
+  listener?: (this: Window, ev: MessageEvent<any>) => void
+  #onDisconnect?: () => void
+  #target?: ImplPostMessage
+  #self: ImplPostMessage
+
+  /**
+   * @param options - Options
+   * @param options.target Target window for message
+   * @param options.self Host window for message
+   * @param options.origin Origin of receiver
+   * @param options.sendDirection Wrapping messages into additional struct
+   * `({ type: 'to_aepp' || 'to_waellet', data })`
+   * Used for handling messages between content script and page
+   * @param options.receiveDirection Unwrapping messages from additional struct
+   */
+  constructor ({
+    target,
+    self = window,
+    origin,
+    sendDirection,
+    receiveDirection = MESSAGE_DIRECTION.to_aepp,
+    ...options
+  }: {
+    target?: ImplPostMessage
+    self?: ImplPostMessage
+    origin?: string
+    sendDirection?: MESSAGE_DIRECTION
+    receiveDirection?: MESSAGE_DIRECTION
+    debug?: boolean
+  } = {}) {
+    super(options)
+    this.#target = target
+    this.#self = self
+    this.origin = origin
+    this.sendDirection = sendDirection
+    this.receiveDirection = receiveDirection
+  }
+
+  isConnected (): boolean {
+    return this.listener != null
+  }
+
+  connect (
+    onMessage: (message: any, origin: string, source: MessageEventSource | null) => void,
+    onDisconnect: () => void
+  ): void {
+    super.connect(onMessage, onDisconnect)
+    this.listener = (message: MessageEvent<any>) => {
+      if (typeof message.data !== 'object') return
+      if (this.origin != null && this.origin !== message.origin) return
+      if (this.#target != null && this.#target !== message.source) return
+      this.receiveMessage(message)
+      let { data } = message
+      if (data.type != null) {
+        if (message.data.type !== this.receiveDirection) return
+        data = data.data
+      }
+      onMessage(data, message.origin, message.source)
+    }
+    this.#self.addEventListener('message', this.listener)
+    this.#onDisconnect = onDisconnect
+  }
+
+  disconnect (): void {
+    super.disconnect()
+    if (this.listener == null || this.#onDisconnect == null) {
+      throw new InternalError('Expected to not happen, required for TS')
+    }
+    this.#self.removeEventListener('message', this.listener)
+    delete this.listener
+    this.#onDisconnect()
+    this.#onDisconnect = undefined
+  }
+
+  sendMessage (msg: any): void {
+    if (this.#target == null) throw new RpcConnectionError('Can\'t send messages without target')
+    const message = this.sendDirection != null ? { type: this.sendDirection, data: msg } : msg
+    super.sendMessage(message)
+    this.#target.postMessage(message, this.origin ?? '*')
+  }
+}