@lombardini.io/dapp

Breaking change v0.0.26

chainId parameter is now mandatory

loginWithKeeper({ chainId: 'R' })

Interaction with Reserves (write sample)

import { loginWithKeeper, dappWrite } from '@lombardini.io/dapp'
import config from './config.json'

const loginWithKeeperAndDeposit = async () => {
  const { address, keeper } = await loginWithKeeper({ chainId: 'R' })
  const { deposit } = dappWrite(config, keeper)

  const assetId = 'WAVES'
  const resultFromKeeper = await deposit({ assetId, paymentAmount: 100000000, useAsCollateral: true })
}

DappWrite Interface

type DappWrite = {
    deposit: ({ assetId, paymentAmount, useAsCollateral }: depositParams) => Promise<string>
    withdraw: ({ assetId, amount }: withdrawParams) => Promise<string>
    borrow: ({ assetId, amount }: borrowParams) => Promise<string>
    repay: ({ assetId, paymentAmount }: repayParams) => Promise<string>
    redeemAtokens: ({ assetId, aTokensAmount }: redeemAtokensParams) => Promise<string>;
    replenishWithAtoken: ({ assetId, aTokensAmount }: replenishWithAtokenParams) => Promise<string>
    collapseDebt: ({ assetId }: collapseDebtParams) => Promise<string>
    mintAtoken: ({ assetId, aTokensAmount }: replenishWithAtokenParams) => Promise<string>
    enableUseAsCollateral: ({ assetId }: AssetIdParam) => Promise<string>
    disableUseAsCollateral: ({ assetId }: AssetIdParam) => Promise<string>
}

Read state from dapp (read sample)

import { dappRead } from '@lombardini.io/dapp'
import config from './config.json'

const readDAppState = async () => {
  const { getConfig, getState, getUserState } = dappRead(config)

  //all reserves configs map (assetId => Config)
  const reservesConfigs = await getConfig()

  //all reserves states map (assetId => ReserveState)
  const reservesStates = await getState()

  //get state for particular reserves (assetId => ReserveState)
  const wavesState = await getState(['WAVES'])

  //user reserve state map (assetId => UserState)
  const userState = await getUserState('3MJtoDCxYdW69Scpp4qDvM2kVkhvcuRXgFS')

  //user state for particular reserves
  const userStateWavesReserve = await getUserState('3MJtoDCxYdW69Scpp4qDvM2kVkhvcuRXgFS', ['WAVES'])
}

return types

type Config = {
  ABCD: string[]
  reserveFactor: string
  collateralFactor: string
}

type ReserveState = {
  id: string
  currentTotalDeposit: string
  storedTotalDeposit: string
  currentTotalDebt: string
  storedTotalDebt: string
  currentTotalReserve: string
  storedTotalReserve: string
  currentIndex: string
  storedIndex: string
  lastUpdateHeight: string
  utilization: string
  aTokenCirculation: string
  aTokenPrice: string
}

type UserState = {
  id: string
  currentDebt: string
  storedDebt: string 
  currentDeposit: string
  aTokenContractBalance: string
  aTokenWalletBalance: string
  walletStake: string
  assetWalletBalance: string
  useAsCollateral: boolean
  storedIndex: string
}

login error handling example

import { loginWithKeeper, keeperErrors, dappWrite, dappRead } from '@lombardini.io/dapp'

function loginWithKeeperAndDeposit() {
  const assetId = 'WAVES'
  const paymentAmount = 100000000 // 1 waves
  loginWithKeeper({ chainId: 'R' }).then(({ address, keeper }) => {
    const { deposit } = dappWrite(config, keeper)
    return deposit({
      assetId,
      paymentAmount,
      useAsCollateral: true,
    }).then(x => {
      console.log(x)
    })
  }).catch(e => {
    if (e === keeperErrors.wrongNetwork) {
      console.log("Oops wrong network")
    }
    if (e === keeperErrors.rejectedByUser) {
      console.log("User rejected")
    }
    if (e === keeperErrors.noKeeper) {
      console.log("Please install keeper")
    }

    //handle deposit errors
  })
}

handling keeper events example

import { onKeeperUserChanged, onKeeperLockedChanged, onKeeperNetworkChanged } from '@lombardini.io/dapp'

onKeeperUserChanged(x => {
  console.log(x) // { oldUser: undefined, newUser: "3MMrvig4ecUF2w4ts7hVpYb65LDdbge5YBH" }
})

onKeeperNetworkChanged(x => {
  console.log(x) // { network: undefined | 'W' | 'R' }
})

onKeeperLockedChanged(x => {
  console.log(x) // { locked: undefined | true | false }
})