feat: errors, add utils, signup

Refactoring of error handler and returning data format
Added: tokenApproval, isTokenTransferApproved, signup, renewToken

Author: kyzia551

README.md

@@ -54,9 +54,11 @@ For the functions that modify the marketplace state (like creating a new request
 
 All the features of the API will be available after initializing the Marketplace object, using a valid API secret Key.
 
-To get an API secret key, it's necessary to send to **https://ethdenver-api.aave.com/signup** a POST request with the body:
+To get an API secret key, it's necessary to send to **https://ethdenver-api.aave.com/auth/signup** a POST request with the body:
 ```
 {
+   "name": "my name",
+   "company": "company name", // optional
    "email": "[email protected]",
    "password": "my-secret-password"
 }
@@ -228,4 +230,4 @@ const await.marketplace.utils.refreshCollateralPrice(loanAddress);
 
 ## LICENSE 
 
-This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details.
+This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details.

src/aave-js.ts

@@ -1,16 +1,17 @@
 // Import here Polyfills if needed. Recommended core-js (npm i -D core-js)
 // import "core-js/fn/array.find"
 // ...
-// tslint:disable-next-line
-import Web3 from 'web3'
 
 import { LoanAPIInstance } from './types'
 import LoanRequest from './services/LoanRequest'
+import Utils from './services/Utils'
 
 export class Marketplace implements Marketplace {
   public requests: LoanAPIInstance
+  public utils: Utils
 
-  constructor(token: string, web3?: Web3, apiUrl?: string) {
-    this.requests = new LoanRequest(token, web3, apiUrl)
+  constructor(token: string, apiUrl?: string) {
+    this.requests = new LoanRequest(token, apiUrl)
+    this.utils = new Utils(token, apiUrl)
   }
 }

src/services/BaseService.ts

@@ -1,22 +1,22 @@
 import axios, { AxiosError, AxiosInstance } from 'axios'
 import { isValidChecksumAddress } from 'ethereumjs-util'
-// tslint:disable-next-line
-import Web3 from 'web3'
 
-import { BaseResponse } from '../types'
-import { Transaction } from 'web3/eth/types'
-import { TransactionReceipt } from 'web3-core/types'
+class ServiceError extends Error {
+  public code: number
+  constructor(message: string, code: number) {
+    super(message)
+    this.code = code
+  }
+}
 
 export default class BaseService {
   protected readonly api: AxiosInstance
-  protected readonly web3?: Web3
 
-  constructor(token: string, web3?: Web3, apiUrl?: string) {
+  constructor(token: string, apiUrl?: string) {
     this.api = axios.create({
       baseURL: apiUrl || 'https://api.aave.com',
       headers: { Authorization: `Bearer ${token}` }
     })
-    this.web3 = web3
   }
 
   protected static checkAddressChecksum(address: string): void {
@@ -25,18 +25,22 @@ export default class BaseService {
     }
   }
 
-  protected static errorHandler(e: AxiosError, resourceType: string, address: string = ''): BaseResponse {
+  protected static errorHandler(e: AxiosError, resourceType: string, address: string = ''): ServiceError {
     const status = e.response ? e.response.status : 504
 
     switch (status) {
-      case 404:
-        return { error: `${resourceType} ${address} doesn't exists`, code: 404 }
+      case 400: {
+        const errorText = e.response && e.response.data && e.response.data.error ? e.response.data.error : ''
+        return new ServiceError(`bad request: ${errorText}`, 400)
+      }
       case 401:
-        return { error: 'invalid access token', code: 401 }
+        return new ServiceError('invalid access token', 401)
+      case 404:
+        return new ServiceError(`${resourceType} ${address} doesn't exists`, 404)
       case 504:
-        return { error: 'probably some troubles with network connection', code: 504 }
+        return new ServiceError('probably some troubles with network connection', 504)
       default:
-        return { error: 'internal server error, please contact support', code: 500 }
+        return new ServiceError('internal server error, please contact support', 500)
     }
   }
 
@@ -46,26 +50,14 @@ export default class BaseService {
     errorParam: string = '',
     method: 'get' | 'post' = 'get',
     params?: object
-  ): Promise<BaseResponse> {
+  ): Promise<any> {
     const api = method === 'post' ? this.api.post : this.api.get
 
     try {
       const { data } = await api(endpoint, params)
-
-      return { data, code: 200 }
+      return data
     } catch (e) {
-      return BaseService.errorHandler(e, resourceType, errorParam)
-    }
-  }
-
-  private async sendTransaction(tx: Transaction): Promise<TransactionReceipt> {
-    if (this.web3) {
-      const currentNetwork = await this.web3.eth.net.getNetworkType()
-      if (currentNetwork === 'kovan') {
-        return await this.web3.eth.sendTransaction(tx)
-      }
-      throw `this version of API allows transactions only on kovan network, but ${currentNetwork} chosen`
+      throw BaseService.errorHandler(e, resourceType, errorParam)
     }
-    throw 'web3 provider is not specified'
   }
 }

src/services/LoanRequest.ts

@@ -1,24 +1,20 @@
-// tslint:disable-next-line
-import Web3 from 'web3'
-
-import {
-  LoanTransactionResponse,
-  LoanMetadataResponse,
-  LoanRequestResponse,
-  LoanAddressesByBorrowerResponse,
-  LoansAddressesResponse,
-  LoanAPIInstance,
-  BaseLoanModel,
-  MaxLoanAmountResponse
-} from '../types'
+import { Transaction } from 'web3/eth/types'
+
+import { LoanAPIInstance, BaseLoanModel, LoanRequestModel, LoanMetadata } from '../types'
 import BaseService from './BaseService'
 
 export default class LoanRequest extends BaseService implements LoanAPIInstance {
-  constructor(token: string, web3?: Web3, apiUrl?: string) {
-    super(token, web3, apiUrl)
+  constructor(token: string, apiUrl?: string) {
+    super(token, apiUrl)
+  }
+  public async approve(amount: number, tokenSymbol: string): Promise<Transaction> {
+    return await this.apiRequest('/request/approveTransfer', 'token approval', tokenSymbol, 'post', {
+      amount,
+      tokenSymbol
+    })
   }
 
-  public async create(borrowerWalletAddress: string, params: BaseLoanModel): Promise<LoanTransactionResponse> {
+  public async create(borrowerWalletAddress: string, params: BaseLoanModel): Promise<Transaction> {
     BaseService.checkAddressChecksum(borrowerWalletAddress)
 
     return await this.apiRequest('/request', 'loan requests creation', '', 'post', {
@@ -27,7 +23,7 @@ export default class LoanRequest extends BaseService implements LoanAPIInstance
     })
   }
 
-  public async placeCollateral(loanAddress: string, borrowerAddress: string): Promise<LoanTransactionResponse> {
+  public async placeCollateral(loanAddress: string, borrowerAddress: string): Promise<Transaction> {
     BaseService.checkAddressChecksum(loanAddress)
     BaseService.checkAddressChecksum(borrowerAddress)
 
@@ -39,7 +35,7 @@ export default class LoanRequest extends BaseService implements LoanAPIInstance
     )
   }
 
-  public async fund(loanAddress: string, lenderAddress: string, amount: number): Promise<LoanTransactionResponse> {
+  public async fund(loanAddress: string, lenderAddress: string, amount: number): Promise<Transaction> {
     BaseService.checkAddressChecksum(loanAddress)
     BaseService.checkAddressChecksum(lenderAddress)
 
@@ -51,7 +47,7 @@ export default class LoanRequest extends BaseService implements LoanAPIInstance
     )
   }
 
-  public async payback(loanAddress: string, borrowerAddress: string): Promise<LoanTransactionResponse> {
+  public async payback(loanAddress: string, borrowerAddress: string): Promise<Transaction> {
     BaseService.checkAddressChecksum(loanAddress)
     BaseService.checkAddressChecksum(borrowerAddress)
 
@@ -65,28 +61,26 @@ export default class LoanRequest extends BaseService implements LoanAPIInstance
   public async getMaxLoanAmountFromCollateral(
     collateralAmount: number,
     collateralType: string,
-    moe: string,
-    ltv?: number
-  ): Promise<MaxLoanAmountResponse> {
+    moe: string
+  ): Promise<number> {
     return await this.apiRequest('/request/maxamount/', 'getting max loan amount', collateralType, 'post', {
       collateralAmount,
       collateralType,
-      moe,
-      ltv
+      moe
     })
   }
 
-  public async getLoanData(loanAddress: string): Promise<LoanRequestResponse> {
+  public async getLoanData(loanAddress: string): Promise<LoanRequestModel> {
     BaseService.checkAddressChecksum(loanAddress)
 
     return await this.apiRequest(`/request/getone/${loanAddress}`, 'loan requests', loanAddress)
   }
 
-  public async getAllAddresses(): Promise<LoansAddressesResponse> {
+  public async getAllAddresses(): Promise<string[]> {
     return await this.apiRequest('/request', 'loan requests addresses')
   }
 
-  public async getLoansByBorrower(borrowerAddress: string): Promise<LoanAddressesByBorrowerResponse> {
+  public async getLoansByBorrower(borrowerAddress: string): Promise<string[]> {
     BaseService.checkAddressChecksum(borrowerAddress)
 
     return await this.apiRequest(
@@ -96,7 +90,13 @@ export default class LoanRequest extends BaseService implements LoanAPIInstance
     )
   }
 
-  public async getMetadata(): Promise<LoanMetadataResponse> {
+  public async getLoansByLender(lenderAddress: string): Promise<string[]> {
+    BaseService.checkAddressChecksum(lenderAddress)
+
+    return await this.apiRequest(`/request/getlistbylender/${lenderAddress}`, 'loan addresses by lender', lenderAddress)
+  }
+
+  public async getMetadata(): Promise<LoanMetadata> {
     return await this.apiRequest('/request/metadata', 'loan requests metadata')
   }
 }

src/services/Utils.ts

@@ -0,0 +1,30 @@
+import { Transaction } from 'web3/eth/types'
+
+import BaseService from './BaseService'
+
+export default class Utils extends BaseService {
+  constructor(token: string, apiUrl?: string) {
+    super(token, apiUrl)
+  }
+  public async approveTransfer(address: string, tokenSymbol: string): Promise<Transaction> {
+    return await this.apiRequest('/common/approvetransfer/', 'token approval', tokenSymbol, 'post', {
+      address,
+      token: tokenSymbol
+    })
+  }
+
+  public async isTransferApproved(address: string, tokenSymbol: string, amount: number): Promise<boolean> {
+    return await this.apiRequest(
+      `/common/istransferapproved/${address}/${tokenSymbol}/${amount}`,
+      'is token transfer approved'
+    )
+  }
+
+  public async signup(email: string, name: string, password: string, organisation?: string): Promise<string> {
+    return await this.apiRequest('/auth/signup', 'signup', '', 'post', { email, name, password, organisation })
+  }
+
+  public async renewToken(email: string, password: string): Promise<string> {
+    return await this.apiRequest('/auth/renewtoken', 'token renewal', '', 'post', { email, password })
+  }
+}

src/types.ts

@@ -34,57 +34,22 @@ export interface LoanRequestModel extends BaseLoanModel {
   isCrowdLendingLoan: boolean
   peggedCurrency?: string
   peggedMedium?: string
+  nextInstalmentAmount?: number
   type: string
 }
 
-export interface BaseResponse {
-  data?: any
-  error?: string
-  code: ResponseCodes
-}
-
-export interface MaxLoanAmountResponse extends BaseResponse {
-  data?: number
-}
-
-export interface LoanTransactionResponse extends BaseResponse {
-  data?: Transaction
-}
-
-export interface LoanRequestResponse extends BaseResponse {
-  data?: LoanRequestModel
-}
-
-export interface LoanMetadataResponse extends BaseResponse {
-  data?: LoanMetadata
-}
-
-export interface LoansAddressesResponse extends BaseResponse {
-  data?: string[]
-}
-
-export interface LoanAddressesByBorrowerResponse extends BaseResponse {
-  data?: {
-    requestsAsBorrower: string[]
-    requestsAsLender: string[]
-  }
-}
-
 export interface LoanAPIInstance {
-  create(creatorWalletAddress: string, params: BaseLoanModel): Promise<LoanTransactionResponse>
-  placeCollateral(loanAddress: string, borrowerAddress: string): Promise<LoanTransactionResponse>
-  fund(loanAddress: string, lenderAddress: string, amount: number): Promise<LoanTransactionResponse>
-  payback(loanAddress: string, borrowerAddress: string): Promise<LoanTransactionResponse>
-  getMaxLoanAmountFromCollateral(
-    collateralAmount: number,
-    collateralType: string,
-    moe: string,
-    ltv?: number
-  ): Promise<MaxLoanAmountResponse>
-  getLoanData(loanAddress: string): Promise<LoanRequestResponse>
-  getAllAddresses(): Promise<LoansAddressesResponse>
-  getLoansByBorrower(borrowerAddress: string): Promise<LoanAddressesByBorrowerResponse>
-  getMetadata(): Promise<LoanMetadataResponse>
+  approve(amount: number, tokenSymbol: string): Promise<Transaction>
+  create(creatorWalletAddress: string, params: BaseLoanModel): Promise<Transaction>
+  placeCollateral(loanAddress: string, borrowerAddress: string): Promise<Transaction>
+  fund(loanAddress: string, lenderAddress: string, amount: number): Promise<Transaction>
+  payback(loanAddress: string, borrowerAddress: string): Promise<Transaction>
+  getMaxLoanAmountFromCollateral(collateralAmount: number, collateralType: string, moe: string): Promise<number>
+  getLoanData(loanAddress: string): Promise<LoanRequestModel>
+  getAllAddresses(): Promise<string[]>
+  getLoansByBorrower(borrowerAddress: string): Promise<string[]>
+  getLoansByLender(lenderAddress: string): Promise<string[]>
+  getMetadata(): Promise<LoanMetadata>
 }
 
 export interface MarketplaceInstance {

test/BaseService.test.ts

@@ -27,7 +27,7 @@ describe('BaseService tests', () => {
       response: { status, data: null, headers: null, statusText: '', config: {} }
     })
     it('should return correct error codes', () => {
-      for (const status of [401, 404, 500, 504]) {
+      for (const status of [400, 401, 404, 500, 504]) {
         expect(BaseService['errorHandler'](axiosErrorMock(status), 'type').code).toBe(status)
       }
     })
@@ -42,28 +42,4 @@ describe('BaseService tests', () => {
       )
     })
   })
-
-  describe('sendTransaction method', () => {
-    it('should send transaction', async () => {
-      const tx = { some: 1 }
-      const web3Mock = <any>{
-        eth: {
-          sendTransaction: async (tx: any) => Promise.resolve(tx),
-          net: { getNetworkType: async () => Promise.resolve('kovan') }
-        }
-      }
-      const service = new BaseService('token', web3Mock)
-      await expect(service['sendTransaction'](<any>tx)).resolves.toEqual(tx)
-    })
-
-    it('should raise exception if now web3 specified', async () => {
-      await expect(defaultService['sendTransaction'](<any>{})).rejects.toBe('web3 provider is not specified')
-    })
-
-    it('should raise exception on incorrect network', async () => {
-      const web3Mock = <any>{ eth: { net: { getNetworkType: async () => Promise.resolve('main') } } }
-      const service = new BaseService('86C019FF04C4', web3Mock)
-      await expect(service['sendTransaction'](<any>{})).rejects.toBeTruthy()
-    })
-  })
 })