Type definitions

Author: teogeb

src/Config.js renamed to src/Config.ts

@@ -1,16 +1,18 @@
 import qs from 'qs'
+// @ts-expect-error
 import { ControlLayer, MessageLayer } from 'streamr-client-protocol'
 import Debug from 'debug'
 
 import { getVersionString, counterId } from './utils'
+import { StreamrClientOptions } from './StreamrClient'
 
 const { ControlMessage } = ControlLayer
 const { StreamMessage } = MessageLayer
 
-export default function ClientConfig(opts = {}) {
+export default function ClientConfig(opts: StreamrClientOptions = {}) {
     const { id = counterId('StreamrClient') } = opts
 
-    const options = {
+    const options: StreamrClientOptions = {
         debug: Debug(id),
         // Authentication: identity used by this StreamrClient instance
         auth: {}, // can contain member privateKey or (window.)ethereum
@@ -39,15 +41,20 @@ export default function ClientConfig(opts = {}) {
         // For ethers.js provider params, see https://docs.ethers.io/ethers.js/v5-beta/api-providers.html#provider
         mainnet: null, // Default to ethers.js default provider settings
         sidechain: {
+            // @ts-expect-error
             url: null, // TODO: add our default public service sidechain node, also find good PoA params below
             // timeout:
             // pollingInterval:
         },
+        // @ts-expect-error
         dataUnion: null, // Give a "default target" of all data union endpoint operations (no need to pass argument every time)
         tokenAddress: '0x0Cf0Ee63788A0849fE5297F3407f701E122cC023',
         minimumWithdrawTokenWei: '1000000', // Threshold value set in AMB configs, smallest token amount to pass over the bridge
+        // @ts-expect-error
         sidechainTokenAddress: null, // TODO // sidechain token
+        // @ts-expect-error
         factoryMainnetAddress: null, // TODO // Data Union factory that creates a new Data Union
+        // @ts-expect-error
         sidechainAmbAddress: null, // Arbitrary Message-passing Bridge (AMB), see https://github.com/poanetwork/tokenbridge
         payForSignatureTransport: true, // someone must pay for transporting the withdraw tx to mainnet, either us or bridge operator
         ...opts,
@@ -58,7 +65,7 @@ export default function ClientConfig(opts = {}) {
         }
     }
 
-    const parts = options.url.split('?')
+    const parts = options.url!.split('?')
     if (parts.length === 1) { // there is no query string
         const controlLayer = `controlLayerVersion=${ControlMessage.LATEST_VERSION}`
         const messageLayer = `messageLayerVersion=${StreamMessage.LATEST_VERSION}`
@@ -78,16 +85,20 @@ export default function ClientConfig(opts = {}) {
     options.url = `${options.url}&streamrClient=${getVersionString()}`
 
     // Backwards compatibility for option 'authKey' => 'apiKey'
+    // @ts-expect-error
     if (options.authKey && !options.apiKey) {
+        // @ts-expect-error
         options.apiKey = options.authKey
     }
 
+    // @ts-expect-error
     if (options.apiKey) {
+        // @ts-expect-error
         options.auth.apiKey = options.apiKey
     }
 
-    if (options.auth.privateKey && !options.auth.privateKey.startsWith('0x')) {
-        options.auth.privateKey = `0x${options.auth.privateKey}`
+    if (options.auth!.privateKey && !options.auth!.privateKey.startsWith('0x')) {
+        options.auth!.privateKey = `0x${options.auth!.privateKey}`
     }
 
     return options

src/Session.js renamed to src/Session.ts

@@ -1,29 +1,58 @@
 import EventEmitter from 'eventemitter3'
 import { Wallet } from '@ethersproject/wallet'
-import { Web3Provider } from '@ethersproject/providers'
+import { ExternalProvider, JsonRpcFetchFunc, Web3Provider } from '@ethersproject/providers'
+import StreamrClient from './StreamrClient'
+
+enum State {
+    LOGGING_OUT = 'logging out',
+    LOGGED_OUT = 'logged out',
+    LOGGING_IN ='logging in',
+    LOGGED_IN = 'logged in',
+}
+
+export interface SessionOptions {
+    privateKey?: string
+    ethereum?: ExternalProvider|JsonRpcFetchFunc
+    apiKey?: string
+    username?: string
+    password?: string
+    sessionToken?: string
+    unauthenticated?: boolean
+}
+
+export interface TokenObject {
+    token: string
+}
 
 export default class Session extends EventEmitter {
-    constructor(client, options = {}) {
+
+    _client: StreamrClient
+    options: SessionOptions
+    state: State
+    loginFunction: () => Promise<TokenObject>
+    sessionTokenPromise?: Promise<string|undefined>
+
+    constructor(client: StreamrClient, options: SessionOptions = {}) {
         super()
         this._client = client
         this.options = {
             ...options
         }
 
-        this.state = Session.State.LOGGED_OUT
+        this.state = State.LOGGED_OUT
 
         // TODO: move loginFunction to StreamrClient constructor where "auth type" is checked
         if (typeof this.options.privateKey !== 'undefined') {
             const wallet = new Wallet(this.options.privateKey)
-            this.loginFunction = async () => this._client.loginWithChallengeResponse((d) => wallet.signMessage(d), wallet.address)
+            this.loginFunction = async () => this._client.loginEndpoints.loginWithChallengeResponse((d: string) => wallet.signMessage(d), wallet.address)
         } else if (typeof this.options.ethereum !== 'undefined') {
             const provider = new Web3Provider(this.options.ethereum)
             const signer = provider.getSigner()
-            this.loginFunction = async () => this._client.loginWithChallengeResponse((d) => signer.signMessage(d), await signer.getAddress())
+            this.loginFunction = async () => this._client.loginEndpoints.loginWithChallengeResponse((d: string) => signer.signMessage(d), await signer.getAddress())
         } else if (typeof this.options.apiKey !== 'undefined') {
-            this.loginFunction = async () => this._client.loginWithApiKey(this.options.apiKey)
+            this.loginFunction = async () => this._client.loginEndpoints.loginWithApiKey(this.options.apiKey!)
         } else if (typeof this.options.username !== 'undefined' && typeof this.options.password !== 'undefined') {
-            this.loginFunction = async () => this._client.loginWithUsernamePassword(this.options.username, this.options.password)
+            this.loginFunction = async () => this._client.loginEndpoints.loginWithUsernamePassword(this.options.username!, this.options.password!)
         } else {
             if (!this.options.sessionToken) {
                 this.options.unauthenticated = true
@@ -38,7 +67,7 @@ export default class Session extends EventEmitter {
         return this.options.unauthenticated
     }
 
-    updateState(newState) {
+    updateState(newState: State) {
         this.state = newState
         this.emit(newState)
     }
@@ -52,19 +81,19 @@ export default class Session extends EventEmitter {
             return undefined
         }
 
-        if (this.state !== Session.State.LOGGING_IN) {
-            if (this.state === Session.State.LOGGING_OUT) {
+        if (this.state !== State.LOGGING_IN) {
+            if (this.state === State.LOGGING_OUT) {
                 this.sessionTokenPromise = new Promise((resolve) => {
-                    this.once(Session.State.LOGGED_OUT, () => resolve(this.getSessionToken(requireNewToken)))
+                    this.once(State.LOGGED_OUT, () => resolve(this.getSessionToken(requireNewToken)))
                 })
             } else {
-                this.updateState(Session.State.LOGGING_IN)
-                this.sessionTokenPromise = this.loginFunction().then((tokenObj) => {
+                this.updateState(State.LOGGING_IN)
+                this.sessionTokenPromise = this.loginFunction().then((tokenObj: TokenObject) => {
                     this.options.sessionToken = tokenObj.token
-                    this.updateState(Session.State.LOGGED_IN)
+                    this.updateState(State.LOGGED_IN)
                     return tokenObj.token
-                }, (err) => {
-                    this.updateState(Session.State.LOGGED_OUT)
+                }, (err: Error) => {
+                    this.updateState(State.LOGGED_OUT)
                     throw err
                 })
             }
@@ -73,31 +102,24 @@ export default class Session extends EventEmitter {
     }
 
     async logout() {
-        if (this.state === Session.State.LOGGED_OUT) {
+        if (this.state === State.LOGGED_OUT) {
             throw new Error('Already logged out!')
         }
 
-        if (this.state === Session.State.LOGGING_OUT) {
+        if (this.state === State.LOGGING_OUT) {
             throw new Error('Already logging out!')
         }
 
-        if (this.state === Session.State.LOGGING_IN) {
+        if (this.state === State.LOGGING_IN) {
             await new Promise((resolve) => {
-                this.once(Session.State.LOGGED_IN, () => resolve(this.logout()))
+                this.once(State.LOGGED_IN, () => resolve(this.logout()))
             })
             return
         }
 
-        this.updateState(Session.State.LOGGING_OUT)
-        await this._client.logoutEndpoint()
+        this.updateState(State.LOGGING_OUT)
+        await this._client.loginEndpoints.logoutEndpoint()
         this.options.sessionToken = undefined
-        this.updateState(Session.State.LOGGED_OUT)
+        this.updateState(State.LOGGED_OUT)
     }
 }
-
-Session.State = {
-    LOGGING_OUT: 'logging out',
-    LOGGED_OUT: 'logged out',
-    LOGGING_IN: 'logging in',
-    LOGGED_IN: 'logged in',
-}