@brightunion/sdk
Version:
Brightjs is a set of javascript tools to interact with the Bright Union's risk platform aggregator's protocol on Ethereum, Binance Smart Chain and Polygon blockchains.
350 lines (289 loc) • 13.9 kB
text/typescript
import NetConfig from "../config/NetConfig";
import CatalogHelper from "../helpers/catalogHelper"
import {
_getDistributorsContract,
_getInsuraceDistributor,
_getInsurAceCoverDataContract,
_getInsurAceProductContract,
_getBridgeV2RegistryContract,
_getBridgeV2PolicyBookContract,
_getBridgeV2PolicyRegistry,
_getNexusDistributor,
_getNexusV2CoverNFT,
_getNexusV2ProductsV1,
_getIERC20Contract,
_getEaseContract, _getNexusV2CoverViewer,
} from "../helpers/getContract";
import {hexToUtf8, asciiToHex, fromWei} from 'web3-utils';
import EaseApi from "@/service/distributorsApi/EaseApi";
import UnslashedAPI from "@/service/distributorsApi/UnslashedAPI";
import UnoReAPI from "@/service/distributorsApi/UnoReAPI";
import RiskCarriers from "@/service/config/RiskCarriers";
import axios from "axios";
/**
* Returns the total cover count owned by an address
*
* @remarks
* Function to get total number of owned covers from an address
*
* @param _distributorName - Name of distributor in lower case
* @param _owner
* @param _isActive
* @returns Number of total covers
*/
export async function getCoversCount(
_distributorName: string,
_ownerAddress: string,
_isActive: boolean
): Promise<number> {
if (global.user.ethNet.networkId == 1) {
//ToDO - finish the logic of fetching Count from Distributors
} else {
return await _getDistributorsContract(global.user.web3)
.methods
.getCoversCount(
_distributorName,
_ownerAddress,
_isActive)
.call().then((_data: any) => {
return _data;
});
}
}
/**
* Return Covers from owner's address of specified distributor.
*
* @remarks
* Get active/inactive cover from user address
*
* @param web3
* @param distributorName
* @returns Cover Object
*/
export async function getCovers(
_web3: any,
_distributorName: string,
): Promise<any[]> {
if (_distributorName == "insurace") {
return getCoversInsurace(_web3);
} else if (_distributorName == 'bridge') {
return getCoversBridgeV2();
} else if (_distributorName == 'nexus') {
return getCoversNexus();
} else if (_distributorName == 'ease') {
return getCoversEase();
} else if (_distributorName == 'unslashed') {
return getCoversUnslashed();
} else if (_distributorName == 'unore') {
return getCoversUnoRe();
}
}
export async function getCoversNexus(): Promise<any> {
const distributor = await _getNexusDistributor(NetConfig.netById(global.user.ethNet.networkId).nexusDistributor);
const coverNFT = await _getNexusV2CoverNFT(NetConfig.netById(global.user.ethNet.networkId).nexusV2CoverNFT);
//const productsV1 = await _getNexusV2ProductsV1(NetConfig.netById(global.user.ethNet.networkId).nexusV2ProductsV1);
//const countV1 = await distributor.methods.balanceOf(global.user.account).call();
const countV2 = await coverNFT.methods.balanceOf(global.user.account).call();
global.events.emit("covers", {itemsCount: Number(countV2)});
let covers: any = [];
//fetch covers bought from Nexus Distributor for V1
//DEPRECATED
/*for (let i = 0; i < Number(countV1); i++) {
await distributor.methods.tokenOfOwnerByIndex(global.user.account, i).call().then ((tokenId:any) => {
distributor.methods.getCover(global.user.account, tokenId, true, 5).call().then((cover:any) => {
productsV1.methods.getNewProductId(cover.contractAddress).call().then((productId:any) => {
cover = {
...cover,
'nexusProductId': productId,
'id': tokenId,
'source': 'distributor',
'risk_protocol': 'nexus',
'endTime': cover.validUntil,
'net': global.user.ethNet.networkId
}
global.events.emit("covers", {coverItem: cover});
covers.push(cover)
})
});
});
}*/
// V2
const coverViewer = await _getNexusV2CoverViewer(NetConfig.netById(global.user.ethNet.networkId).nexusV2CoverViewer);
await axios.get(`https://eth-mainnet.g.alchemy.com/nft/v2/${NetConfig.netById(global.user.ethNet.networkId).alchemyApiKey}
/getNFTs?contractAddresses[]=${coverNFT.options.address}&owner=${global.user.account}&withMetadata=true`)
.then(async (response) => {
const data:any = response.data;
let tokenIds = data.ownedNfts.map((a:any) =>
global.user.ethNet.web3Instance.utils.hexToNumber(a.id.tokenId));
let coverObjs = await coverViewer.methods.getCovers(tokenIds).call();
let i: number = 0;
let nexusAssetsIds = RiskCarriers.NEXUS.assetsIds;
for (let cover of coverObjs) {
let lastSegment = cover.segments[cover.segments.length - 1];
covers.push({
'id': tokenIds[i],
'nexusProductId': cover.productId,
'status': '0', //'active'
'coverAsset': Object.keys(nexusAssetsIds).find(key => nexusAssetsIds[key] === cover.coverAsset),
'coverAmount': lastSegment.amount,
'source': 'distributor',
'risk_protocol': 'nexus',
'coverPeriod': Number(lastSegment.period) / 3600 / 24,
'endTime': Number(lastSegment.start) + Number(lastSegment.period),
'net': global.user.ethNet.networkId
})
i++;
}
}).catch(error => {
console.error(error)
})
return covers;
}
export async function getCoversInsurace(_web3: any): Promise<any> {
let allCovers: any = [];
const insuraceCoverInstance = await _getInsuraceDistributor(NetConfig.netById(_web3.networkId).insuraceCover, _web3.web3Instance);
const coverDataAddress = await insuraceCoverInstance.methods.data().call()
const coverDataInstance = await _getInsurAceCoverDataContract(coverDataAddress, _web3.web3Instance);
const count = await coverDataInstance.methods.getCoverCount(_web3.account).call();
global.events.emit("covers", {itemsCount: count});
for (let coverId = 1; coverId <= Number(count); coverId++) {
const expirationP = coverDataInstance.methods.getCoverEndTimestamp(_web3.account, coverId.toString()).call();
const startTimeP = coverDataInstance.methods.getCoverBeginTimestamp(_web3.account, coverId.toString()).call();
const amountP = coverDataInstance.methods.getCoverAmount(_web3.account, coverId.toString()).call();
const currencyP = coverDataInstance.methods.getCoverCurrency(_web3.account, coverId.toString()).call();
const statusP = coverDataInstance.methods.getAdjustedCoverStatus(_web3.account, coverId.toString()).call();
const productId = await coverDataInstance.methods.getCoverProductId(_web3.account, coverId.toString()).call();
const productAddress = await insuraceCoverInstance.methods.product().call();
const product = await _getInsurAceProductContract(productAddress, _web3.web3Instance);
const prodDetailsP = product.methods.getProductDetails(productId).call();
let coverDataPromises = [expirationP, amountP, currencyP, statusP, prodDetailsP, startTimeP];
await Promise.all(coverDataPromises).then((_data: any) => {
const [expiration, amount, currency, status, prodDetails, startTime] = _data;
let coverNameUnified = CatalogHelper.unifyCoverName(hexToUtf8(prodDetails['0']), 'insurace');
let cover = {
risk_protocol: 'insurace',
contractName: coverNameUnified,
coverType: hexToUtf8(prodDetails['1']),
coverAmount: amount,
coverAsset: currency,
startTime: startTime,
validUntil: expiration,
endTime: expiration,
status: status,
net: _web3.networkId,
rawData: prodDetails,
}
global.events.emit("covers", {coverItem: cover});
allCovers.push(cover);
});
}
return allCovers;
}
export async function getCoversBridgeV2(): Promise<any> {
const policyRegistryAddr = await _getBridgeV2RegistryContract(NetConfig.netById(global.user.ethNet.networkId).bridgeV2Registry, global.user.ethNet.web3Instance).methods.getPolicyRegistryContract().call();
const policyRegistry = await _getBridgeV2PolicyRegistry(policyRegistryAddr, global.user.ethNet.web3Instance)
let trustWalletAssets: { [key: string]: any } = {};
trustWalletAssets = await CatalogHelper.getTrustWalletAssets();
const nPolicies = await policyRegistry.methods.getPoliciesLength(global.user.account).call();
const activeInfos = await policyRegistry.methods.getPoliciesInfo(global.user.account, true, 0, nPolicies).call();
const expiredInfos = await policyRegistry.methods.getPoliciesInfo(global.user.account, false, 0, nPolicies).call();
// merge the arrays from both sets
let mergedPolicyInfos = activeInfos._policiesArr.concat(expiredInfos._policies);
let mergedPolicyBooks = activeInfos._policyBooksArr.concat(expiredInfos._policyBooksArr);
let mergedPolicyStatuses = activeInfos._policyStatuses.concat(expiredInfos._policyStatuses);
let policies = []
let limit = parseInt(nPolicies);
global.events.emit("covers", {itemsCount: limit});
for (let i = 0; i < limit; i++) {
if (mergedPolicyBooks[i] === '0x0000000000000000000000000000000000000000') {
//Bridge BUG, means no actual policy info
limit++;
continue;
}
let policyBook = await _getBridgeV2PolicyBookContract(mergedPolicyBooks[i], global.user.ethNet.web3Instance);
let policyBookinfo = await policyBook.methods.info().call();
let claimStatus = mergedPolicyStatuses[i];
let asset = trustWalletAssets[Object.keys(trustWalletAssets)
.find(key => key.toLowerCase() === policyBookinfo._insuredContract.toLowerCase())];
let coverNameUnified = CatalogHelper.unifyCoverName(asset ? asset.name : policyBookinfo._symbol, 'bridge');
let cover = {
risk_protocol: 'bridge',
policyBookAddr: mergedPolicyBooks[i],
status: claimStatus,
coverAmount: mergedPolicyInfos[i].coverAmount,
validUntil: mergedPolicyInfos[i].endTime,
endTime: mergedPolicyInfos[i].endTime,
premium: mergedPolicyInfos[i].premium,
startTime: mergedPolicyInfos[i].startTime,
name: coverNameUnified,
net: global.user.ethNet.networkId
}
global.events.emit("covers", {coverItem: cover});
policies.push(cover)
}
return policies;
}
export async function getCoversCountBridge(): Promise<any> {
return [];
}
export async function getCoversEase(): Promise<any> {
return await EaseApi.fetchCoverables()
.then((data: any) => {
let policies: any = []
data.forEach(async (vault: any) => {
let protocol = await _getIERC20Contract(vault.address);
let instance = await _getEaseContract(vault.address);
protocol.methods.balanceOf(global.user.account).call().then(async (balance: any) => {
if (balance > 0) {
let rcaValue = await instance.methods.rcaValue(balance, vault.liquidation_amount).call()
let convertedAmount = await instance.methods.uValue(rcaValue, vault.liquidation_amount, vault.percent_reserved).call()
vault.tokenBalance = fromWei(balance);
let cover = {
risk_protocol: 'ease',
status: 0,
coverAmount: convertedAmount,
vaultCurrency: vault.symbol,
coverAsset: vault.display_name,
validUntil: Date.now(),
endTime: Date.now(),
startTime: Date.now(),
name: CatalogHelper.unifyCoverName(vault.top_protocol, 'ease'),
net: global.user.ethNet.networkId,
instance: instance
}
global.events.emit("covers", {coverItem: cover});
policies.push(cover)
}
})
});
return policies;
})
}
export async function getCoversUnslashed(): Promise<any> {
const activeCoversData = await UnslashedAPI.fetchCovers();
let policies: any = [];
for (var i = 0; i < activeCoversData.length; i++) {
let cover = {
risk_protocol: 'unslashed',
status: 0,
coverAmount: activeCoversData[i].coverage.userCoverBalance,
coverAsset: "ETH",
validUntil: activeCoversData[i].static.rolloverDate,
endTime: activeCoversData[i].static.rolloverDate,
startTime: false,
name: CatalogHelper.unifyCoverName(activeCoversData[i].static.name, 'unlashed'),
net: global.user.ethNet.networkId,
}
global.events.emit("covers", {coverItem: cover});
policies.push(cover)
}
return policies;
}
export async function getCoversUnoRe(): Promise<any> {
const activeCoversData = UnoReAPI.fetchCovers();
return activeCoversData;
}
export default {
getCovers,
getCoversCount,
}