feat: add getMaxLoanAmountFromCollateral and sendTransaction methods

Also update routes to new structure

Author: kyzia551

package.json

@@ -1,8 +1,8 @@
 {
   "name": "aave-js",
   "version": "0.0.0",
-  "description": "",
-  "keywords": [],
+  "description": "js wrapper for Aave ETHLend marketplace",
+  "keywords": ["aave", "loans", "crypto", "marketplace", "js"],
   "main": "dist/aave-js.umd.js",
   "module": "dist/aave-js.es5.js",
   "typings": "dist/types/aave-js.d.ts",
@@ -71,8 +71,7 @@
       }
     },
     "collectCoverageFrom": [
-      "src/*.{js,ts}",
-      "src/services/*.{js,ts}"
+      "src/**/*.{js,ts}"
     ]
   },
   "prettier": {

src/aave-js.ts

@@ -1,13 +1,16 @@
 // 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'
 
 export class Marketplace implements Marketplace {
-  public request: LoanAPIInstance
+  public requests: LoanAPIInstance
 
-  constructor(token: string, apiUrl?: string) {
-    this.request = new LoanRequest(token, apiUrl)
+  constructor(token: string, web3?: Web3, apiUrl?: string) {
+    this.requests = new LoanRequest(token, web3, apiUrl)
   }
 }

src/services/BaseService.ts

@@ -1,16 +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'
 
 export default class BaseService {
   protected readonly api: AxiosInstance
+  protected readonly web3?: Web3
 
-  constructor(token: string, apiUrl?: string) {
+  constructor(token: string, web3?: Web3, 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 {
@@ -33,4 +39,33 @@ export default class BaseService {
         return { error: 'internal server error, please contact support', code: 500 }
     }
   }
+
+  protected async apiRequest(
+    endpoint: string,
+    resourceType: string,
+    errorParam: string = '',
+    method: 'get' | 'post' = 'get',
+    params?: object
+  ): Promise<BaseResponse> {
+    const api = method === 'post' ? this.api.post : this.api.get
+
+    try {
+      const { data } = await api(endpoint, params)
+
+      return { data, code: 200 }
+    } 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 'web3 provider is not specified'
+  }
 }

src/services/LoanRequest.ts

@@ -1,43 +1,30 @@
+// tslint:disable-next-line
+import Web3 from 'web3'
+
 import {
   LoanTransactionResponse,
   LoanMetadataResponse,
   LoanRequestResponse,
   LoanAddressesByBorrowerResponse,
   LoansAddressesResponse,
   LoanAPIInstance,
-  BaseResponse,
-  BaseLoanModel
+  BaseLoanModel,
+  MaxLoanAmountResponse
 } from '../types'
-
 import BaseService from './BaseService'
 
 export default class LoanRequest extends BaseService implements LoanAPIInstance {
-  constructor(token: string, apiUrl?: string) {
-    super(token, apiUrl)
-  }
-
-  private async apiRequest(
-    endpoint: string,
-    resourceType: string,
-    errorParam: string = '',
-    method: 'get' | 'post' = 'get',
-    params?: object
-  ): Promise<BaseResponse> {
-    const api = method === 'post' ? this.api.post : this.api.get
-
-    try {
-      const { data } = await api(endpoint, params)
-
-      return { data, code: 200 }
-    } catch (e) {
-      return LoanRequest.errorHandler(e, resourceType, errorParam)
-    }
+  constructor(token: string, web3?: Web3, apiUrl?: string) {
+    super(token, web3, apiUrl)
   }
 
-  public async create(creatorWalletAddress: string, params: BaseLoanModel): Promise<LoanTransactionResponse> {
-    BaseService.checkAddressChecksum(creatorWalletAddress)
+  public async create(borrowerWalletAddress: string, params: BaseLoanModel): Promise<LoanTransactionResponse> {
+    BaseService.checkAddressChecksum(borrowerWalletAddress)
 
-    return await this.apiRequest(`/request/create/${creatorWalletAddress}`, 'loan request creation', '', 'post', params)
+    return await this.apiRequest('/request', 'loan requests creation', '', 'post', {
+      borrower: borrowerWalletAddress,
+      ...params
+    })
   }
 
   public async placeCollateral(loanAddress: string, borrowerAddress: string): Promise<LoanTransactionResponse> {
@@ -46,7 +33,7 @@ export default class LoanRequest extends BaseService implements LoanAPIInstance
 
     return await this.apiRequest(
       `/request/placecollateral/${loanAddress}/${borrowerAddress}`,
-      'placing loan request collateral',
+      'placing loan requests collateral',
       loanAddress,
       'post'
     )
@@ -58,7 +45,7 @@ export default class LoanRequest extends BaseService implements LoanAPIInstance
 
     return await this.apiRequest(
       `/request/fund/${loanAddress}/${lenderAddress}/${amount}`,
-      'funding loan request',
+      'funding loan requests',
       loanAddress,
       'post'
     )
@@ -70,29 +57,46 @@ export default class LoanRequest extends BaseService implements LoanAPIInstance
 
     return await this.apiRequest(
       `/request/payback/${loanAddress}/${borrowerAddress}`,
-      'placing loan request payback',
+      'placing loan requests payback',
       loanAddress,
       'post'
     )
   }
+  public async getMaxLoanAmountFromCollateral(
+    collateralAmount: number,
+    collateralType: string,
+    moe: string,
+    ltv?: number
+  ): Promise<MaxLoanAmountResponse> {
+    return await this.apiRequest('/request/maxamount/', 'getting max loan amount', collateralType, 'post', {
+      collateralAmount,
+      collateralType,
+      moe,
+      ltv
+    })
+  }
 
   public async getLoanData(loanAddress: string): Promise<LoanRequestResponse> {
     BaseService.checkAddressChecksum(loanAddress)
 
-    return await this.apiRequest(`/request/${loanAddress}`, 'loan request', loanAddress)
+    return await this.apiRequest(`/request/getone/${loanAddress}`, 'loan requests', loanAddress)
   }
 
   public async getAllAddresses(): Promise<LoansAddressesResponse> {
-    return await this.apiRequest('/requests', 'loan request addresses')
+    return await this.apiRequest('/request', 'loan requests addresses')
   }
 
   public async getLoansByBorrower(borrowerAddress: string): Promise<LoanAddressesByBorrowerResponse> {
     BaseService.checkAddressChecksum(borrowerAddress)
 
-    return await this.apiRequest(`/requests/${borrowerAddress}`, 'loan addresses by borrower', borrowerAddress)
+    return await this.apiRequest(
+      `/request/getlistbyborrower/${borrowerAddress}`,
+      'loan addresses by borrower',
+      borrowerAddress
+    )
   }
 
   public async getMetadata(): Promise<LoanMetadataResponse> {
-    return await this.apiRequest('/requests/metadata', 'loan requests metadata')
+    return await this.apiRequest('/request/metadata', 'loan requests metadata')
   }
 }

src/types.ts

@@ -1,4 +1,4 @@
-import { TransactionObject } from 'web3/eth/types'
+import { Transaction } from 'web3/eth/types'
 
 export type ResponseCodes = 200 | 401 | 404 | 500 | 504
 
@@ -43,8 +43,12 @@ export interface BaseResponse {
   code: ResponseCodes
 }
 
+export interface MaxLoanAmountResponse extends BaseResponse {
+  data?: number
+}
+
 export interface LoanTransactionResponse extends BaseResponse {
-  data?: TransactionObject<any>
+  data?: Transaction
 }
 
 export interface LoanRequestResponse extends BaseResponse {
@@ -71,6 +75,12 @@ export interface LoanAPIInstance {
   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>

test/BaseService.test.ts

@@ -2,39 +2,68 @@ import BaseService from '../src/services/BaseService'
 /**
  * BaseService test
  */
-describe('LoanRequest test', () => {
-  const service = new BaseService('86C019FF04C4')
+describe('BaseService tests', () => {
+  const defaultService = new BaseService('86C019FF04C4')
 
-  it('LoanRequest is instantiable', () => {
-    expect(service).toBeInstanceOf(BaseService)
+  it('BaseService is instantiable', () => {
+    expect(defaultService).toBeInstanceOf(BaseService)
   })
 
-  it('should check valid eth addresses without errors', () => {
-    expect(BaseService['checkAddressChecksum']('0x71f4CF5Cfb74a9D3c9060aC4c25070F989cFC39C')).toBeUndefined()
-  })
+  describe('checkAddressChecksum method', () => {
+    it('should check valid eth addresses without errors', () => {
+      expect(BaseService['checkAddressChecksum']('0x71f4CF5Cfb74a9D3c9060aC4c25070F989cFC39C')).toBeUndefined()
+    })
 
-  it('should throw error on checking invalid eth address', () => {
-    expect(() => BaseService['checkAddressChecksum']('0x71f4CF5Cfb74a9D3c9060aC4c25070F989cFC39c')).toThrow()
-  })
-  const axiosErrorMock = (status: number) => ({
-    message: '',
-    name: '',
-    config: {},
-    response: { status, data: null, headers: null, statusText: '', config: {} }
-  })
-  it('should return correct error codes', () => {
-    for (const status of [401, 404, 500, 504]) {
-      expect(BaseService['errorHandler'](axiosErrorMock(status), 'type').code).toBe(status)
-    }
+    it('should throw error on checking invalid eth address', () => {
+      expect(() => BaseService['checkAddressChecksum']('0x71f4CF5Cfb74a9D3c9060aC4c25070F989cFC39c')).toThrow()
+    })
   })
 
-  it('should return 500 code on unknown status', () => {
-    expect(BaseService['errorHandler'](axiosErrorMock(343), 'type').code).toBe(500)
+  describe('errorHandler method', () => {
+    const axiosErrorMock = (status: number) => ({
+      message: '',
+      name: '',
+      config: {},
+      response: { status, data: null, headers: null, statusText: '', config: {} }
+    })
+    it('should return correct error codes', () => {
+      for (const status of [401, 404, 500, 504]) {
+        expect(BaseService['errorHandler'](axiosErrorMock(status), 'type').code).toBe(status)
+      }
+    })
+
+    it('should return 500 code on unknown status', () => {
+      expect(BaseService['errorHandler'](axiosErrorMock(343), 'type').code).toBe(500)
+    })
+
+    it('should return 504 code if no response', () => {
+      expect(BaseService['errorHandler']({ message: '', name: '', config: {}, response: undefined }, 'type').code).toBe(
+        504
+      )
+    })
   })
 
-  it('should return 504 code if no response', () => {
-    expect(BaseService['errorHandler']({ message: '', name: '', config: {}, response: undefined }, 'type').code).toBe(
-      504
-    )
+  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()
+    })
   })
 })

test/LoanRequest.test.ts

@@ -3,7 +3,7 @@ import LoanRequest from '../src/services/LoanRequest'
  * LoanRequest test
  */
 describe('LoanRequest test', () => {
-  const request = new LoanRequest('86C019FF04C4', 'http://localhost:3333')
+  const request = new LoanRequest('86C019FF04C4', undefined, 'http://localhost:3333')
 
   it('LoanRequest is instantiable', () => {
     expect(request).toBeInstanceOf(LoanRequest)
@@ -19,6 +19,11 @@ describe('LoanRequest test', () => {
     expect(data.code).toBe(200)
   })
 
+  it('Should load requests metadata from api', async () => {
+    const data = await request.getMaxLoanAmountFromCollateral(2312, 'LEND', 'ETH')
+    expect(data.code).toBe(200)
+  })
+
   it('Should get single loan data from api', async () => {
     const data = await request.getLoanData('0x71f4CF5Cfb74a9D3c9060aC4c25070F989cFC39C')
     expect(data.code).toBe(200)

test/aave-js.test.ts

@@ -5,6 +5,6 @@ import { Marketplace } from '../src/aave-js'
  */
 describe('Marketplace test', () => {
   it('Marketplace is instantiable', () => {
-    expect(new Marketplace('token')).toBeInstanceOf(Marketplace)
+    expect(new Marketplace('token', undefined, undefined)).toBeInstanceOf(Marketplace)
   })
 })