refactor(wallet-rpc)!: rewrite to TypeScript

BREAKING CHANGE: `txObject` parameter of `onSign` callback is removed
Use `unpackTx(tx)` on wallet side instead.

src/account/multiple.ts

@@ -28,7 +28,7 @@ import AccountResolver, { _AccountResolver, Account } from './resolver'
 import { UnavailableAccountError } from '../utils/errors'
 import type stampit from '@stamp/it' // eslint-disable-line @typescript-eslint/no-unused-vars
 
-class _AccountMultiple extends _AccountResolver {
+export class _AccountMultiple extends _AccountResolver {
   accounts: { [key: EncodedData<'ak'>]: _AccountBase }
   selectedAddress?: EncodedData<'ak'>
 
@@ -60,8 +60,8 @@ class _AccountMultiple extends _AccountResolver {
    * @return {String[]}
    * @example addresses()
    */
-  addresses (): string[] {
-    return Object.keys(this.accounts)
+  addresses (): Array<EncodedData<'ak'>> {
+    return Object.keys(this.accounts) as Array<EncodedData<'ak'>>
   }
 
   /**

src/node-pool/index.ts

@@ -31,7 +31,7 @@ interface NodePool {
   readonly api: Node['api']
 }
 
-class _NodePool implements NodePool {
+export class _NodePool implements NodePool {
   readonly api: Node['api']
   pool: Map<string, Node>
   selectedNode?: Node
@@ -159,7 +159,7 @@ export default stampit<NodePool>({
     selectNode: _NodePool.prototype.selectNode,
     getNodeInfo: _NodePool.prototype.getNodeInfo,
     isNodeConnected: _NodePool.prototype.isNodeConnected,
-    getNetworkId: _NodePool.prototype.getNetworkId,
+    getNetworkId,
     getNodesInPool: _NodePool.prototype.getNodesInPool
   }
 })

src/utils/aepp-wallet-communication/rpc/RpcClient.ts

@@ -21,8 +21,11 @@ interface JsonRpcResponse {
   }
 }
 
-type RpcApiHandler = (p?: any, origin?: string) => any | undefined
-type RpcApi<Keys> = { [k in keyof Keys]: RpcApiHandler }
+type RpcApiHandler = (p?: any) => any | undefined
+type RpcApi<Api> = { [k in keyof Api]: RpcApiHandler }
+type WithOrigin<Api extends RpcApi<Api>> = {
+  [k in keyof Api]: (p: Parameters<Api[k]>[0], origin: string) => ReturnType<Api[k]>
+}
 
 /**
  * Contain functionality for using RPC conection
@@ -36,12 +39,12 @@ export default class RpcClient <
   connection: BrowserConnection
   #callbacks = new Map<number, { resolve: (v: any) => void, reject: (e: Error) => void }>()
   #messageId = 0
-  #methods: LocalApi
+  #methods: WithOrigin<LocalApi>
 
   constructor (
     connection: BrowserConnection,
     onDisconnect: () => void,
-    methods: LocalApi
+    methods: WithOrigin<LocalApi>
   ) {
     this.connection = connection
     this.#methods = methods

src/utils/aepp-wallet-communication/rpc/aepp-rpc.ts

@@ -13,7 +13,7 @@ import AccountRpc from '../../../account/rpc'
 import { decode, EncodedData } from '../../encoder'
 import { Accounts, WalletInfo, Network, WalletApi, AeppApi } from './types'
 import RpcClient from './RpcClient'
-import { METHODS, VERSION } from '../schema'
+import { METHODS, VERSION, SUBSCRIPTION_TYPES } from '../schema'
 import {
   AlreadyConnectedError,
   NoWalletConnectedError,
@@ -155,12 +155,12 @@ abstract class _AeppRpc extends _AccountResolver {
 
   /**
    * Subscribe for addresses from wallet
-   * @param type Should be one of 'current' (the selected account), 'connected' (all)
-   * @param value Subscription action
+   * @param type Subscription type
+   * @param value Should be one of 'current' (the selected account), 'connected' (all)
    * @return Accounts from wallet
    */
   async subscribeAddress (
-    type: 'current' | 'connected', value: 'subscribe' | 'unsubscribe'
+    type: SUBSCRIPTION_TYPES, value: 'current' | 'connected'
   ): Promise<ReturnType<WalletApi[METHODS.subscribeAddress]>> {
     this._ensureConnected()
     const result = await this.rpcClient.request(METHODS.subscribeAddress, { type, value })

src/utils/aepp-wallet-communication/rpc/types.ts

@@ -1,5 +1,5 @@
 import { EncodedData } from '../../encoder'
-import { METHODS, WALLET_TYPE } from '../schema'
+import { METHODS, SUBSCRIPTION_TYPES, WALLET_TYPE } from '../schema'
 
 export interface WalletInfo {
   id: string
@@ -29,25 +29,23 @@ type Icons = Array<{ src: string, sizes?: string, type?: string, purpose?: strin
 export interface WalletApi {
   [METHODS.connect]: (
     p: { name: string, icons?: Icons, version: 1, connectNode: boolean }
-  ) => WalletInfo & { node?: Node }
+  ) => Promise<WalletInfo & { node?: Node }>
 
   [METHODS.closeConnection]: (p: any) => void
 
   [METHODS.subscribeAddress]: (
-    p: { type: 'connected' | 'current', value: 'subscribe' | 'unsubscribe' }
-  ) => { subscription: Array<'subscribe' | 'unsubscribe'>, address: Accounts }
+    p: { type: SUBSCRIPTION_TYPES, value: 'connected' | 'current' }
+  ) => Promise<{ subscription: Array<'connected' | 'current'>, address: Accounts }>
 
-  [METHODS.address]: () => Array<EncodedData<'ak'>>
+  [METHODS.address]: () => Promise<Array<EncodedData<'ak'>>>
 
   [METHODS.sign]: ((
-    p: { tx: EncodedData<'tx'>, onAccount: EncodedData<'ak'>, returnSigned: false }
-  ) => { transactionHash: EncodedData<'th'> }) & ((
-    p: { tx: EncodedData<'tx'>, onAccount: EncodedData<'ak'>, returnSigned: true }
-  ) => { signedTransaction: EncodedData<'tx'> })
+    p: { tx: EncodedData<'tx'>, onAccount: EncodedData<'ak'>, returnSigned: boolean }
+  ) => Promise<{ transactionHash?: EncodedData<'th'>, signedTransaction?: EncodedData<'tx'> }>)
 
   [METHODS.signMessage]: (
     p: { message: string, onAccount: EncodedData<'ak'> }
-  ) => { signature: string }
+  ) => Promise<{ signature: string }>
 }
 
 export interface AeppApi {