@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.
375 lines (337 loc) • 13.9 kB
text/typescript
import GoogleEvents from '../config/GoogleEvents';
import BuyReceipt from "../domain/BuyReceipt";
import {
_getDistributorsContract,
_getInsuraceDistributor,
_getInsuraceDistributorsContract,
_getNexusDistributorsContract,
_getBridgeV2Distributor,
_getBridgeV2PolicyBookContract,
_getBridgeV2PolicyBookFacade,
_getEaseContract,
_getEaseDistributorContract, _getNexusV2CoverContract
} from "../helpers/getContract";
import ERC20Helper from '../helpers/ERC20Helper';
import NetConfig from '../config/NetConfig';
import {fromWei, toBN, toWei} from 'web3-utils'
import axios from 'axios'
import RiskCarriers from "@/service/config/RiskCarriers";
/**
* Returns a transaction receipt.
* (Emits a boughtCover event at contract level)
*
* @remarks At the moment this function is only supported
* when intended distributor is Bridge & Nexus, for Insurace please
* refer to buyCoverDecode function.2
*
* @param _distributorName
* @param _contractAddress
* @param _coverAsset
* @param _sumAssured
* @param _coverPeriod
* @param _coverType
* @param _maxPriceWithFee
* @param _data
* @returns BuyReceipt Object
*/
export async function buyCoverBridge(
_ownerAddress: string,
_distributorName: string,
_contractAddress: string,
_coverAsset: string,
_sumAssured: number,
_coverPeriod: number,
_coverType: any,
_maxPriceWithFee: number,
_data: any,
buyingWithNetworkCurrency: boolean,
_quoteProtocol: any,
): Promise<any> {
let tx: any;
tx = {
'hash': null,
'distributor': "bridge",
'premium': fromWei(_quoteProtocol.price),
'name': _quoteProtocol.name,
'amount': fromWei(_quoteProtocol.amount),
'currency': _quoteProtocol.currency,
'period': _quoteProtocol.period,
}
const brightRewardsAddress = NetConfig.netById(global.user.ethNet.networkId).brightTreasury;
const policyBook = await _getBridgeV2PolicyBookContract(_contractAddress, global.user.web3);
const policyBookFacadeAddress = await policyBook.methods.policyBookFacade().call();
const policyBookFacade = _getBridgeV2PolicyBookFacade(policyBookFacadeAddress, global.user.web3);
// convert period from days to bridge epochs (weeks)
let epochs = Math.min(52, Math.ceil(_coverPeriod / 7));
return await new Promise((resolve, reject) => {
policyBookFacade.methods.buyPolicyFromDistributorFor(global.user.account, epochs, _sumAssured, brightRewardsAddress)
.send({from: global.user.account})
.on('transactionHash', (transactionHash: any) => {
tx.hash = transactionHash;
global.events.emit("buy", {status: "TX_GENERATED", data: tx});
GoogleEvents.onTxHash(tx);
resolve({success: transactionHash});
})
.on('error', (err: any, receipt: any) => {
global.events.emit("buy", {status: "REJECTED"});
GoogleEvents.onTxRejected(tx);
reject({error: err, receipt: receipt})
})
.on('confirmation', (confirmationNumber: any) => {
if (confirmationNumber === 0) {
GoogleEvents.onTxConfirmation(tx);
global.events.emit("buy", {status: "TX_CONFIRMED"});
}
});
});
}
export async function buyCoverEase(
_ownerAddress: string,
_contractAddress: string,
_coverAsset: string,
_sumAssured: number,
_coverPeriod: number,
_coverType: any,
_maxPriceWithFee: number,
_data: any,
_quoteProtocol: any,
): Promise<any> {
let tx: any;
tx = {
'hash': null,
'distributor': "ease",
'name': _quoteProtocol.name,
'amount': _data.amount,
'currency': _quoteProtocol.asset,
}
return await new Promise(async (resolve, reject) => {
await _getEaseDistributorContract(NetConfig.netById(1).easeDistributor).methods.buyCover(
_contractAddress,
_coverAsset,
_data.amount,
_data.user,
_data.expiry,
_data.vInt,
_data.r,
_data.s,
_quoteProtocol.vault.liquidation_amount,
_quoteProtocol.vault.liquidation_proof
).send({from: _data.user})
.on('transactionHash', (res: any) => {
tx.hash = res
global.events.emit("buy", {status: "TX_GENERATED", data: tx});
GoogleEvents.onTxHash(tx);
resolve({success: res});
})
.on('error', (err: any, receipt: any) => {
global.events.emit("buy", {status: "REJECTED"});
GoogleEvents.onTxRejected(tx);
reject({error: err, receipt: receipt})
})
.on('confirmation', (confirmationNumber: any) => {
if (confirmationNumber === 0) {
GoogleEvents.onTxConfirmation(tx);
global.events.emit("buy", {status: "TX_CONFIRMED"});
}
});
});
}
export async function buyCoverNexus(
_ownerAddress: string,
_distributorName: string,
_paymentAsset: string,
_sumAssured: number,
_amountOut: number,
_priceWithSlippage: number,
_coverPeriod: number,
_maxPriceWithFee: number,
buyingWithNetworkCurrency: boolean,
_quoteProtocol: any,
) {
let tx: any = {
'hash': null,
'distributor': _quoteProtocol.distributorName,
'premium': fromWei(_quoteProtocol.price),
'name': _quoteProtocol.name,
'amount': fromWei(_quoteProtocol.amount),
'currency': _quoteProtocol.currency,
'period': _quoteProtocol.period,
}
const sendValue = buyingWithNetworkCurrency ? _maxPriceWithFee : 0;
return await new Promise(async (resolve, reject) => {
const buyCoverParams:any = [
0, // coverId
_ownerAddress, // owner
_quoteProtocol.nexusProductId.toString(), // productId
RiskCarriers.NEXUS.assetsIds[_quoteProtocol.currency], // coverAsset
_sumAssured.toString(), // amount
Number(_coverPeriod) * 24 * 3600, // period
_quoteProtocol.priceInNXM, // maxPremiumInAsset, NXM amount we buy
'255', // paymentAsset, NXM
'1000', // commissionRatio, 10% we got in NXM as a kickback fee
'0xac0734c62b316041d190438d5d3e5d1359614407', // commissionDestination, treasury
'' // ipfsData
];
const poolAllocationRequest: any = _quoteProtocol.rawData.quote.poolAllocationRequests;
//buying directly on Nexus for NXM?
if (_quoteProtocol.paymentCurrency === 'NXM') {
const nexusV2CoverAddr = NetConfig.netById(global.user.ethNet.networkId).nexusV2Cover;
const NexusV2CoverContract = await _getNexusV2CoverContract(nexusV2CoverAddr, global.user.ethNet.web3Instance);
NexusV2CoverContract.methods.buyCover(
buyCoverParams,
poolAllocationRequest
).send({from: _ownerAddress, value: sendValue})
.on('transactionHash', (res: any) => {
tx.hash = res
global.events.emit("buy", {status: "TX_GENERATED", data: tx});
GoogleEvents.onTxHash(tx);
resolve({success: res});
})
.on('error', (err: any, receipt: any) => {
global.events.emit("buy", {status: "REJECTED"});
GoogleEvents.onTxRejected(tx);
reject({error: err, receipt: receipt})
})
.on('confirmation', (confirmationNumber: any) => {
if (confirmationNumber === 0) {
GoogleEvents.onTxConfirmation(tx);
global.events.emit("buy", {status: "TX_CONFIRMED"});
}
});
}
else if (_quoteProtocol.uniSwapRouteData.protocol) {
const nexusAddress = await _getDistributorsContract(global.user.web3).methods.getDistributorAddress('nexus2').call();
const swapData = global.user.web3.eth.abi.encodeParameters(
[
'address[]', 'uint24[]', 'string',
'uint256', 'address', 'uint256',
'uint256', 'uint256'
],
[
_quoteProtocol.uniSwapRouteData.swapVia,
_quoteProtocol.uniSwapRouteData.poolFees,
_quoteProtocol.uniSwapRouteData.protocol,
_amountOut,
_paymentAsset,
_amountOut,
_priceWithSlippage,
_maxPriceWithFee
]
);
_getNexusDistributorsContract(nexusAddress).methods.buyCover(
buyCoverParams,
poolAllocationRequest,
swapData
).send({from: _ownerAddress, value: sendValue})
.on('transactionHash', (res: any) => {
tx.hash = res
global.events.emit("buy", {status: "TX_GENERATED", data: tx});
GoogleEvents.onTxHash(tx);
resolve({success: res});
})
.on('error', (err: any, receipt: any) => {
global.events.emit("buy", {status: "REJECTED"});
GoogleEvents.onTxRejected(tx);
reject({error: err, receipt: receipt})
})
.on('confirmation', (confirmationNumber: any) => {
if (confirmationNumber === 0) {
GoogleEvents.onTxConfirmation(tx);
global.events.emit("buy", {status: "TX_CONFIRMED"});
}
});
} else {
// Warning! TODO - can't find a route for NXM buy on Uni!
}
});
}
/**
* Returns a transaction receipt.
* (Emits a boughtCover event at contract level)
*
* @remarks Buy coverages for Insurance
*
* @param _distributorName
* @param _products
* @param _durationInDays
* @param _amounts
* @param _currency
* @param _premiumAmount
* @param _helperParameters
* @param _securityParameters
* @param _v
* @param _r
* @param _s
* @returns BuyReceipt Object
*/
export async function buyCoverInsurace(buyingObj: any, buyingWithNetworkCurrency: boolean, _quotes: any) {
let insuraceAddress: any;
const sendValue = buyingWithNetworkCurrency ? buyingObj.premium : 0;
let tx: any = {
'hash': null,
'distributor': 'insurace',
'premium': _quotes.price,
'name': _quotes.name,
'amount': _quotes.amount,
'currency': _quotes.currency,
'period': _quotes.period,
}
insuraceAddress = await _getDistributorsContract(global.user.web3).methods.getDistributorAddress('insurace').call();
const contractInstance = _getInsuraceDistributorsContract(insuraceAddress);
let gasEstimationCost: any = null;
let estimatedGasPrice: any = null;
let buyTransactionData: any = {
from: global.user.account,
value: sendValue,
}
if (global.user.networkId == 137) {
let gasPriceNow = await axios.get("https://gasstation-mainnet.matic.network/")
.then((response: any) => {
return response.data.standard;
},
(error) => {
console.error('gasstation-mainnet.matic.network error - ', error);
return 50;
});
let gasPrice = Math.round(Number(gasPriceNow));
estimatedGasPrice = toWei(toBN(Number(gasPrice)), "gwei").toString();
await contractInstance.methods.buyCoverInsurace(buyingObj).estimateGas({
from: global.user.account,
gas: estimatedGasPrice,
value: _quotes.price
}).then(function (gasAmount: any) {
gasEstimationCost = gasAmount && gasAmount.toString()
})
.catch(function (error: any) {
console.info("Simulated transaction to estimate gas costs", error)
});
buyTransactionData.gas = gasEstimationCost;
buyTransactionData.gasLimit = 2500000;
buyTransactionData.gasPrice = estimatedGasPrice;
}
return await new Promise((resolve, reject) => {
contractInstance.methods
.buyCoverInsurace(buyingObj)
.send(buyTransactionData)
.on('transactionHash', (res: any) => {
tx.hash = res;
global.events.emit("buy", {status: "TX_GENERATED", data: tx});
GoogleEvents.onTxHash(tx);
resolve({success: res});
})
.on('error', (err: any, receipt: any) => {
global.events.emit("buy", {status: "REJECTED"});
GoogleEvents.onTxRejected(tx);
reject({error: err, receipt: receipt})
})
.on('confirmation', (confirmationNumber: any) => {
if (confirmationNumber === 0) {
global.events.emit("buy", {status: "TX_CONFIRMED"});
GoogleEvents.onTxConfirmation(tx);
}
});
});
}
export default {
buyCoverBridge, buyCoverInsurace, buyCoverNexus, buyCoverEase
}