Validate client's Ethereum address options (#223)

If user overrides some Ethereum address option in StreamrClientOptions, we validate that value already in the constructor. Using the option is therefore easier in the code, as we know that the value is always valid.

Author: teogeb

package-lock.json

@@ -74,6 +74,9 @@
     "@types/debug": "^4.1.5",
     "@types/express": "^4.17.11",
     "@types/jest": "^26.0.20",
+    "@types/lodash.get": "^4.4.6",
+    "@types/lodash.has": "^4.5.6",
+    "@types/lodash.set": "^4.3.6",
     "@types/lodash.uniqueid": "^4.0.6",
     "@types/node": "^14.14.31",
     "@types/node-fetch": "^2.5.8",
@@ -136,6 +139,9 @@
     "debug": "^4.3.2",
     "eventemitter3": "^4.0.7",
     "lodash.uniqueid": "^4.0.1",
+    "lodash.has": "^4.0.1",
+    "lodash.get": "^4.0.1",
+    "lodash.set": "^4.0.1",
     "mem": "^8.0.0",
     "node-abort-controller": "^1.1.0",
     "node-fetch": "^2.6.1",

package.json

@@ -10,6 +10,9 @@ import { getVersionString } from './utils'
 import { ConnectionInfo } from '@ethersproject/web'
 import { EthereumAddress, Todo } from './types'
 import { BytesLike } from '@ethersproject/bytes'
+import { isAddress } from '@ethersproject/address'
+import has from 'lodash.has'
+import get from 'lodash.get'
 
 export type EthereumConfig = ExternalProvider|JsonRpcFetchFunc
 
@@ -79,6 +82,17 @@ export type StreamrClientOptions = Partial<Omit<StrictStreamrClientOptions, 'dat
 const { ControlMessage } = ControlLayer
 const { StreamMessage } = MessageLayer
 
+const validateOverridedEthereumAddresses = (opts: any, propertyPaths: string[]) => {
+    for (const propertyPath of propertyPaths) {
+        if (has(opts, propertyPath)) {
+            const value = get(opts, propertyPath)
+            if (!isAddress(value)) {
+                throw new Error(`${propertyPath} is not a valid Ethereum address`)
+            }
+        }
+    }
+}
+
 /**
  * @category Important
  */
@@ -131,6 +145,22 @@ export const STREAM_CLIENT_DEFAULTS: StrictStreamrClientOptions = {
 
 /** @internal */
 export default function ClientConfig(opts: StreamrClientOptions = {}) {
+
+    // validate all Ethereum addresses which are required in StrictStreamrClientOptions: if user
+    // overrides a setting, which has a default value, it must be a non-null valid Ethereum address
+    // TODO could also validate
+    // - other optional Ethereum address (if there will be some)
+    // - other overriden options (e.g. regexp check that "restUrl" is a valid url)
+    validateOverridedEthereumAddresses(opts, [
+        'streamrNodeAddress',
+        'tokenAddress',
+        'tokenSidechainAddress',
+        'dataUnion.factoryMainnetAddress',
+        'dataUnion.factorySidechainAddress',
+        'dataUnion.templateMainnetAddress',
+        'dataUnion.templateSidechainAddress'
+    ])
+
     const options: StrictStreamrClientOptions = {
         ...STREAM_CLIENT_DEFAULTS,
         ...opts,

src/Config.ts

@@ -434,12 +434,8 @@ export class StreamrClient extends EventEmitter { // eslint-disable-line no-rede
      */
     async getTokenBalance(address: EthereumAddress): Promise<BigNumber> {
         const { tokenAddress } = this.options
-        if (!tokenAddress) {
-            throw new Error('StreamrClient has no tokenAddress configuration.')
-        }
         const addr = getAddress(address)
         const provider = this.ethereum.getMainnetProvider()
-
         const token = new Contract(tokenAddress, balanceOfAbi, provider)
         return token.balanceOf(addr)
     }
@@ -449,12 +445,8 @@ export class StreamrClient extends EventEmitter { // eslint-disable-line no-rede
      */
     async getSidechainTokenBalance(address: EthereumAddress): Promise<BigNumber> {
         const { tokenSidechainAddress } = this.options
-        if (!tokenSidechainAddress) {
-            throw new Error('StreamrClient has no sidechainTokenAddress configuration.')
-        }
         const addr = getAddress(address)
         const provider = this.ethereum.getSidechainProvider()
-
         const token = new Contract(tokenSidechainAddress, balanceOfAbi, provider)
         return token.balanceOf(addr)
     }

src/StreamrClient.ts

@@ -47,8 +47,6 @@ export class Contracts {
     }
 
     getDataUnionMainnetAddress(dataUnionName: string, deployerAddress: EthereumAddress) {
-        validateAddress('StreamrClient factoryMainnetAddress', this.factoryMainnetAddress)
-        validateAddress('StreamrClient templateMainnetAddress', this.templateMainnetAddress)
         // This magic hex comes from https://github.com/streamr-dev/data-union-solidity/blob/master/contracts/CloneLib.sol#L19
         const codeHash = keccak256(`0x3d602d80600a3d3981f3363d3d373d3d3d363d73${this.templateMainnetAddress.slice(2)}5af43d82803e903d91602b57fd5bf3`)
         const salt = keccak256(defaultAbiCoder.encode(['string', 'address'], [dataUnionName, deployerAddress]))
@@ -62,8 +60,6 @@ export class Contracts {
     }
 
     getDataUnionSidechainAddress(mainnetAddress: EthereumAddress) {
-        validateAddress('StreamrClient factorySidechainAddress', this.factorySidechainAddress)
-        validateAddress('StreamrClient templateSidechainAddress', this.templateSidechainAddress)
         // This magic hex comes from https://github.com/streamr-dev/data-union-solidity/blob/master/contracts/CloneLib.sol#L19
         const code = `0x3d602d80600a3d3981f3363d3d373d3d3d363d73${this.templateSidechainAddress.slice(2)}5af43d82803e903d91602b57fd5bf3`
         const codeHash = keccak256(code)
@@ -293,15 +289,13 @@ export class Contracts {
             throw new Error(`Mainnet data union "${duName}" contract ${duMainnetAddress} already exists!`)
         }
 
-        validateAddress('StreamrClient factoryMainnetAddress', this.factoryMainnetAddress)
-
         if (await mainnetProvider.getCode(this.factoryMainnetAddress) === '0x') {
             throw new Error(
                 `Data union factory contract not found at ${this.factoryMainnetAddress}, check StreamrClient.options.dataUnion.factoryMainnetAddress!`
             )
         }
 
-        const factoryMainnet = new Contract(this.factoryMainnetAddress!, factoryMainnetABI, mainnetWallet)
+        const factoryMainnet = new Contract(this.factoryMainnetAddress, factoryMainnetABI, mainnetWallet)
         const ethersOptions: any = {}
         if (gasPrice) {
             ethersOptions.gasPrice = gasPrice

src/dataunion/Contracts.ts

@@ -491,9 +491,7 @@ export class DataUnion {
         } else {
             // streamrNode needs to be joinPartAgent so that EE join with secret works (and join approvals from Marketplace UI)
             agentAddressList = [ownerAddress]
-            if (client.options.streamrNodeAddress) {
-                agentAddressList.push(getAddress(client.options.streamrNodeAddress))
-            }
+            agentAddressList.push(getAddress(client.options.streamrNodeAddress))
         }
 
         const contract = await new Contracts(client).deployDataUnion({

src/dataunion/DataUnion.ts

@@ -1,22 +1,49 @@
 import { arrayify, BytesLike } from '@ethersproject/bytes'
 import { StreamrClient } from '../../src/StreamrClient'
+import set from 'lodash.set'
 
-const createClient = (privateKey: BytesLike) => {
-    return new StreamrClient({
-        auth: {
-            privateKey
+describe('Config', () => {
+
+    describe('validate ethereum addresses', () => {
+        const createClient = (propertyPaths: string, value: string|undefined|null) => {
+            const opts: any = {}
+            set(opts, propertyPaths, value)
+            return new StreamrClient(opts)
+        }
+        const propertyPaths: string[] = [
+            'streamrNodeAddress',
+            'tokenAddress',
+            'tokenSidechainAddress',
+            'dataUnion.factoryMainnetAddress',
+            'dataUnion.factorySidechainAddress',
+            'dataUnion.templateMainnetAddress',
+            'dataUnion.templateSidechainAddress'
+        ]
+        for (const propertyPath of propertyPaths) {
+            it(propertyPath, () => {
+                const errorMessage = `${propertyPath} is not a valid Ethereum address`
+                expect(() => createClient(propertyPath, 'invalid-address')).toThrow(errorMessage)
+                expect(() => createClient(propertyPath, undefined)).toThrow(errorMessage)
+                expect(() => createClient(propertyPath, null)).toThrow(errorMessage)
+                expect(() => createClient(propertyPath, '0x1234567890123456789012345678901234567890')).not.toThrow()
+            })
         }
     })
-}
 
-describe('Config', () => {
     describe('private key', () => {
+        const createAuthenticatedClient = (privateKey: BytesLike) => {
+            return new StreamrClient({
+                auth: {
+                    privateKey
+                }
+            })
+        }
         it('string', async () => {
-            const client = createClient('0x0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF')
+            const client = createAuthenticatedClient('0x0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF')
             expect(await client.getAddress()).toBe('0xFCAd0B19bB29D4674531d6f115237E16AfCE377c')
         })
         it('byteslike', async () => {
-            const client = createClient(arrayify('0x0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF'))
+            const client = createAuthenticatedClient(arrayify('0x0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF'))
             expect(await client.getAddress()).toBe('0xFCAd0B19bB29D4674531d6f115237E16AfCE377c')
         })
     })