carbon-js-sdk 0.2.14-dev.4 → 0.2.14-dev.6

package/lib/modules/cdp.js

@@ -23,12 +23,9 @@ const bignumber_js_1 = require("bignumber.js");
 const query_3 = require("./../codec/cdp/query");
 const base_1 = __importDefault(require("./base"));
 const constant_1 = require("../constant");
+const TokenClient_1 = __importDefault(require("../clients/TokenClient"));
+const address_1 = require("../util/address");
 class CDPModule extends base_1.default {
-    constructor() {
-        super(...arguments);
-        this.cdpModuleAddress = "";
-        this.collateralPoolAddress = "";
-    }
     supplyAsset(params, opts) {
         return __awaiter(this, void 0, void 0, function* () {
             const wallet = this.getWallet();
@@ -208,7 +205,6 @@ class CDPModule extends base_1.default {
                 minCollateralAmount: params.minCollateralAmount.toString(10),
                 debtDenom: params.debtDenom,
                 debtAmount: params.debtAmount.toString(10),
-                principalAmount: params.principalAmount.toString(10),
                 interestDenom: params.interestDenom,
                 interestAmount: params.interestAmount.toString(10),
             });
@@ -305,6 +301,26 @@ class CDPModule extends base_1.default {
             }, opts);
         });
     }
+    createRewardScheme(params, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getWallet();
+            const value = tx_1.MsgCreateRewardScheme.fromPartial({
+                creator: wallet.bech32Address,
+                createRewardSchemeParams: {
+                    rewardDenom: params.rewardDenom,
+                    rewardType: params.rewardType,
+                    assetDenom: params.assetDenom,
+                    rewardAmountPerSecond: params.rewardAmountPerSecond.toString(10),
+                    startTime: params.startTime,
+                    endTime: params.endTime,
+                }
+            });
+            return yield wallet.sendTx({
+                typeUrl: util_1.CarbonTx.Types.MsgCreateRewardScheme,
+                value,
+            }, opts);
+        });
+    }
     // start of cdp calculations
     getAccountData(account) {
         var _a;
@@ -322,20 +338,20 @@ class CDPModule extends base_1.default {
             for (let i = 0; i < collaterals.length; i++) {
                 const amount = (0, number_1.bnOrZero)(collaterals[i].collateralAmount);
                 if (amount.isZero()) {
-                    continue;
+                    continue; // no collateral for denom
                 }
                 const denom = collaterals[i].denom;
                 const debtInfo = debtInfos.find(d => d.denom === denom);
                 if (!debtInfo) {
-                    return;
+                    continue; // no debt for denom
                 }
                 const collateralUsdVal = yield this.getCdpTokenUsdVal(collaterals[i].cdpDenom, amount);
                 if (!collateralUsdVal) {
-                    return;
+                    continue;
                 }
                 const assetParam = assetParams.find(a => a.denom === denom);
                 if (!assetParam) {
-                    return;
+                    continue;
                 }
                 const ltv = (0, number_1.bnOrZero)(assetParam.loanToValue).div(number_1.BN_10000);
                 const availableBorrowUsd = collateralUsdVal.times(ltv);
@@ -357,25 +373,25 @@ class CDPModule extends base_1.default {
                 }
                 const debtInfo = debtInfos.find(d => d.denom === denom);
                 if (!debtInfo) {
-                    return;
+                    continue;
                 }
                 const tokenDebtUsdVal = yield this.getTotalAccountTokenDebtUsdVal(account, denom, debts[i], debtInfo);
                 if (!tokenDebtUsdVal) {
-                    return;
+                    continue;
                 }
                 totalDebtsUsd = totalDebtsUsd.plus(tokenDebtUsdVal);
             }
             // add stablecoin debt
             const debtInfoRsp = yield sdk.query.cdp.StablecoinDebt(query_1.QueryStablecoinDebtRequest.fromPartial({}));
             const stablecoinDebtInfo = debtInfoRsp.stablecoinDebtInfo;
-            if (!stablecoinDebtInfo) {
-                return;
+            let stablecoinDebtUsd = number_1.BN_ZERO;
+            if (stablecoinDebtInfo) {
+                const accountStablecoin = yield sdk.query.cdp.AccountStablecoin({ address: account });
+                const stablecoinDecimals = (_a = yield this.sdkProvider.getTokenClient().getDecimals(stablecoinDebtInfo.denom)) !== null && _a !== void 0 ? _a : number_1.BN_ZERO;
+                const stablecoinDebtAmount = (0, number_1.bnOrZero)(accountStablecoin.principalDebt).plus((0, number_1.bnOrZero)(accountStablecoin.interestDebt));
+                stablecoinDebtUsd = stablecoinDebtAmount.shiftedBy(-stablecoinDecimals);
+                totalDebtsUsd = totalDebtsUsd.plus(stablecoinDebtUsd);
             }
-            const accountStablecoin = yield sdk.query.cdp.AccountStablecoin({ address: account });
-            const stablecoinDecimals = (_a = yield this.sdkProvider.getTokenClient().getDecimals(stablecoinDebtInfo.denom)) !== null && _a !== void 0 ? _a : number_1.BN_ZERO;
-            const stablecoinDebtAmount = (0, number_1.bnOrZero)(accountStablecoin.principalDebt).plus((0, number_1.bnOrZero)(accountStablecoin.interestDebt));
-            const stablecoinDebtUsd = stablecoinDebtAmount.shiftedBy(-stablecoinDecimals);
-            totalDebtsUsd = totalDebtsUsd.plus(stablecoinDebtUsd);
             const healthFactor = currLiquidationThreshold.div(totalDebtsUsd);
             return {
                 TotalCollateralsUsd: totalCollateralsUsd,
@@ -388,58 +404,38 @@ class CDPModule extends base_1.default {
         });
     }
     getAssetBorrowableSupply(denom) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const sdk = this.sdkProvider;
-            if (!this.cdpModuleAddress) {
-                const moduleAddressRsp = yield sdk.query.misc.ModuleAddress(codec_1.QueryModuleAddressRequest.fromPartial({ module: "cdp" }));
-                this.cdpModuleAddress = moduleAddressRsp.address;
-            }
-            const balanceRsp = yield sdk.query.bank.Balance(query_2.QueryBalanceRequest.fromPartial({ address: this.cdpModuleAddress, denom }));
-            if (!balanceRsp.balance) {
-                return;
-            }
-            return (0, number_1.bnOrZero)(balanceRsp.balance.amount);
+            const cdpAddress = this.getCdpModuleAddress();
+            const balanceRsp = yield sdk.query.bank.Balance(query_2.QueryBalanceRequest.fromPartial({ address: cdpAddress, denom }));
+            return (0, number_1.bnOrZero)((_a = balanceRsp.balance) === null || _a === void 0 ? void 0 : _a.amount);
         });
     }
     getCdpToActualRatio(cdpDenom) {
         return __awaiter(this, void 0, void 0, function* () {
             const sdk = this.sdkProvider;
             const denom = this.getUnderlyingDenom(cdpDenom);
-            if (!denom) {
-                return;
-            }
             const supplyRsp = yield sdk.query.bank.SupplyOf(query_2.QuerySupplyOfRequest.fromPartial({ denom: cdpDenom }));
             const cdpAmountRsp = supplyRsp.amount;
-            if (!cdpAmountRsp) {
-                return;
-            }
+            if (!cdpAmountRsp)
+                throw new Error("unable to retrieve cdp token supply");
             const cdpAmount = (0, number_1.bnOrZero)(cdpAmountRsp.amount);
-            if (!this.cdpModuleAddress) {
-                const moduleAddressRsp = yield sdk.query.misc.ModuleAddress(codec_1.QueryModuleAddressRequest.fromPartial({ module: "cdp" }));
-                this.cdpModuleAddress = moduleAddressRsp.address;
-            }
-            const balanceRsp = yield sdk.query.bank.Balance(query_2.QueryBalanceRequest.fromPartial({ address: this.cdpModuleAddress, denom }));
-            if (!balanceRsp.balance) {
-                return;
-            }
-            let actualAmount = (0, number_1.bnOrZero)(balanceRsp.balance.amount);
+            const cdpAddress = this.getCdpModuleAddress();
+            const balanceRsp = yield sdk.query.bank.Balance(query_2.QueryBalanceRequest.fromPartial({ address: cdpAddress, denom }));
+            if (!balanceRsp.balance)
+                throw new Error("unable to retrieve cdp module balance");
             const owedAmount = yield this.getTotalTokenDebt(denom);
-            if (!owedAmount) {
-                return;
-            }
-            actualAmount = actualAmount.plus(owedAmount);
-            const ratio = cdpAmount.div(actualAmount);
-            return ratio;
+            const actualAmount = (0, number_1.bnOrZero)(balanceRsp.balance.amount).plus(owedAmount);
+            if (!owedAmount)
+                throw new Error("unable to retrieve total token debt");
+            return cdpAmount.div(actualAmount);
         });
     }
     getTotalAccountTokenDebtUsdVal(account, denom, debt, debtInfo) {
         return __awaiter(this, void 0, void 0, function* () {
-            const amount = yield this.getTotalAccountTokenDebt(account, denom, debt, debtInfo).catch((err) => console.log(err));
-            if (!amount) {
-                return;
-            }
-            const tokenDebtUsdVal = yield this.getTokenUsdVal(denom, amount).catch((err) => console.log(err));
-            return tokenDebtUsdVal;
+            const amount = yield this.getTotalAccountTokenDebt(account, denom, debt, debtInfo);
+            return yield this.getTokenUsdVal(denom, amount);
         });
     }
     getModuleTotalDebtUsdVal() {
@@ -463,29 +459,28 @@ class CDPModule extends base_1.default {
             }
             // get stablecoin debt
             const stablecoinDebtRes = yield this.sdkProvider.query.cdp.StablecoinDebt({});
-            const stablecoinDebtInfo = stablecoinDebtRes.stablecoinDebtInfo;
-            if (!stablecoinDebtInfo) {
-                return;
+            if (stablecoinDebtRes.stablecoinDebtInfo) {
+                const debtInfo = stablecoinDebtRes.stablecoinDebtInfo;
+                const debtAmt = (0, number_1.bnOrZero)(debtInfo.totalPrincipal).plus((0, number_1.bnOrZero)(debtInfo.totalAccumulatedInterest));
+                const stablecoinDecimals = (_a = yield sdk.getTokenClient().getDecimals(debtInfo.denom)) !== null && _a !== void 0 ? _a : 0;
+                const debtUsdVal = (debtAmt).shiftedBy(-stablecoinDecimals);
+                totalDebt = totalDebt.plus(debtUsdVal);
             }
-            const debtAmt = (0, number_1.bnOrZero)(stablecoinDebtInfo.totalPrincipal).plus((0, number_1.bnOrZero)(stablecoinDebtInfo.totalAccumulatedInterest));
-            const stablecoinDecimals = (_a = yield sdk.getTokenClient().getDecimals(stablecoinDebtInfo.denom)) !== null && _a !== void 0 ? _a : number_1.BN_ZERO;
-            const debtUsdVal = (debtAmt).shiftedBy(-stablecoinDecimals);
-            totalDebt = totalDebt.plus(debtUsdVal);
             return totalDebt;
         });
     }
     getModuleTotalCollateralUsdVal() {
         return __awaiter(this, void 0, void 0, function* () {
-            const moduleAddressRsp = yield this.sdkProvider.query.misc.ModuleAddress(codec_1.QueryModuleAddressRequest.fromPartial({ module: "collateral_pool" }));
-            const cdpBalances = yield this.sdkProvider.query.bank.AllBalances({ address: moduleAddressRsp.address });
-            let allCollateralsUsdValue = new bignumber_js_1.BigNumber(0);
-            for (let i = 0; i < cdpBalances.balances.length; i++) {
-                const denom = cdpBalances.balances[i].denom;
-                const amount = new bignumber_js_1.BigNumber(cdpBalances.balances[i].amount);
-                const collateralUsdValue = yield this.getCdpTokenUsdVal(denom, amount);
-                if (!collateralUsdValue) {
-                    return;
+            const network = this.sdkProvider.getConfig().network;
+            const collateralPoolAddress = address_1.SWTHAddress.getModuleAddress("collateral_pool", network);
+            const cdpBalances = yield this.sdkProvider.query.bank.AllBalances({ address: collateralPoolAddress });
+            let allCollateralsUsdValue = number_1.BN_ZERO;
+            for (const balance of cdpBalances.balances) {
+                if (!TokenClient_1.default.isCdpToken(balance.denom)) {
+                    continue;
                 }
+                const amount = (0, number_1.bnOrZero)(balance.amount);
+                const collateralUsdValue = yield this.getCdpTokenUsdVal(balance.denom, amount);
                 allCollateralsUsdValue = allCollateralsUsdValue.plus(collateralUsdValue);
             }
             return allCollateralsUsdValue;
@@ -494,13 +489,7 @@ class CDPModule extends base_1.default {
     getCdpTokenUsdVal(cdpDenom, amount) {
         return __awaiter(this, void 0, void 0, function* () {
             const denom = this.getUnderlyingDenom(cdpDenom);
-            if (!denom) {
-                return;
-            }
             const ratio = yield this.getCdpToActualRatio(cdpDenom);
-            if (!ratio) {
-                return;
-            }
             const actualTokenAmount = amount.div(ratio);
             return yield this.getTokenUsdVal(denom, actualTokenAmount);
         });
@@ -509,39 +498,30 @@ class CDPModule extends base_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             const sdk = this.sdkProvider;
             const decimals = yield this.sdkProvider.getTokenClient().getDecimals(denom);
-            if (!decimals) {
-                return;
-            }
-            const price = yield sdk.query.pricing.TokenPrice(codec_1.QueryTokenPriceRequest.fromPartial({ denom }));
-            if (!price.tokenPrice) {
-                return;
-            }
-            const twap = (0, number_1.bnOrZero)(price.tokenPrice.twap).shiftedBy(18 * (-1));
-            return amount.times(twap).shiftedBy(decimals * (-1));
+            if (decimals === undefined)
+                throw new Error("unable to retrieve token decimals for " + denom);
+            const priceResult = yield sdk.query.pricing.TokenPrice(codec_1.QueryTokenPriceRequest.fromPartial({ denom }));
+            if (!priceResult.tokenPrice)
+                throw new Error("unable to retrieve token price for " + denom);
+            const twap = (0, number_1.bnOrZero)(priceResult.tokenPrice.twap).shiftedBy(-18);
+            return amount.multipliedBy(twap).shiftedBy(-decimals);
         });
     }
     getTotalTokenDebt(denom, debtInfo) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (!debtInfo) {
                 const debtInfoRsp = yield this.sdkProvider.query.cdp.TokenDebt(query_1.QueryTokenDebtRequest.fromPartial({ denom }));
                 debtInfo = debtInfoRsp.debtInfo;
             }
-            if (!debtInfo) {
-                return;
-            }
-            const cim = yield this.recalculateCIM(denom, debtInfo);
-            if (!cim) {
-                return;
-            }
+            if (!debtInfo)
+                throw new Error("unable to retrieve debt info");
             const principal = (0, number_1.bnOrZero)(debtInfo.totalPrincipal);
-            const interest = (0, number_1.bnOrZero)(debtInfo.totalAccumulatedInterest);
+            const accumInterest = (0, number_1.bnOrZero)(debtInfo.totalAccumulatedInterest);
             const cdpParamsRsp = yield this.sdkProvider.query.cdp.Params(query_1.QueryParamsRequest.fromPartial({}));
-            const cdpParams = cdpParamsRsp.params;
-            if (!cdpParams) {
-                return;
-            }
-            const interestFee = (0, number_1.bnOrZero)(cdpParams.interestFee).div(10000);
-            return principal.plus(interest.times((0, number_1.bnOrZero)(1).minus(interestFee)));
+            const interestFee = (0, number_1.bnOrZero)((_a = cdpParamsRsp.params) === null || _a === void 0 ? void 0 : _a.interestFee);
+            const interest = accumInterest.times(number_1.BN_10000.minus(interestFee)).dividedToIntegerBy(number_1.BN_10000);
+            return principal.plus(interest);
         });
     }
     getTotalAccountTokenDebt(account, denom, debt, debtInfo) {
@@ -551,22 +531,19 @@ class CDPModule extends base_1.default {
                 const debtInfoRsp = yield sdk.query.cdp.TokenDebt(query_1.QueryTokenDebtRequest.fromPartial({ denom }));
                 debtInfo = debtInfoRsp.debtInfo;
             }
-            if (!debtInfo) {
-                return;
-            }
+            if (!debtInfo)
+                return number_1.BN_ZERO;
             if (!debt) {
                 const debtRes = yield sdk.query.cdp.AccountDebt({ address: account, denom: denom });
                 debt = debtRes.debt;
             }
-            if (!debt) {
-                return;
-            }
-            const principalAmount = (0, number_1.bnOrZero)(debt.principalDebt);
-            const initialCIM = (0, number_1.bnOrZero)(debt.initialCumulativeInterestMultiplier);
+            const principalAmount = (0, number_1.bnOrZero)(debt === null || debt === void 0 ? void 0 : debt.principalDebt);
+            const initialCIM = (0, number_1.bnOrZero)(debt === null || debt === void 0 ? void 0 : debt.initialCumulativeInterestMultiplier);
+            if (principalAmount.isZero() || initialCIM.isZero())
+                return number_1.BN_ZERO;
             const cim = yield this.recalculateCIM(denom, debtInfo);
-            if (!cim) {
-                return;
-            }
+            if (!cim)
+                throw new Error("unable to retrieve account debt");
             // TODO: change to round up
             const totalAmountTokenDebt = principalAmount.times(cim).dividedToIntegerBy(initialCIM);
             return totalAmountTokenDebt;
@@ -580,24 +557,18 @@ class CDPModule extends base_1.default {
                 const debtInfoResponse = yield sdk.query.cdp.StablecoinDebt(query_1.QueryStablecoinDebtRequest.fromPartial({}));
                 debtInfo = debtInfoResponse.stablecoinDebtInfo;
             }
-            if (!debtInfo) {
+            if (!debtInfo)
                 return number_1.BN_ZERO;
-            }
             if (!debt) {
                 const debtResp = yield sdk.query.cdp.AccountStablecoin(query_1.QueryAccountStablecoinRequest.fromPartial({ address: account }));
                 debt = debtResp;
             }
-            if (!debt) {
-                return number_1.BN_ZERO;
-            }
             principalAmount = (0, number_1.bnOrZero)(debt.principalDebt);
             const initialCIM = (0, number_1.bnOrZero)(debt.initialCumulativeInterestMultiplier);
             const cim = yield this.recalculateStablecoinCIM(debtInfo);
-            if (!cim) {
-                return number_1.BN_ZERO;
-            }
-            const totalStablecoinDebtAmount = principalAmount.times(cim).dividedToIntegerBy(initialCIM);
-            return totalStablecoinDebtAmount;
+            if (!cim)
+                throw new Error("unable to retrieve account debt");
+            return principalAmount.times(cim).dividedToIntegerBy(initialCIM);
         });
     }
     calculateAPY(denom, debtInfo, assetParams, rateStrategyParams) {
@@ -606,15 +577,14 @@ class CDPModule extends base_1.default {
             if (!debtInfo) {
                 const debtInfoResponse = yield sdk.query.cdp.TokenDebt(query_1.QueryTokenDebtRequest.fromPartial({ denom }));
                 debtInfo = debtInfoResponse.debtInfo;
-                if (!debtInfo) {
-                    return;
-                }
+                if (!debtInfo)
+                    throw new Error("unable to retrieve debt info for " + denom);
             }
             if (!assetParams) {
                 const assetResponse = yield sdk.query.cdp.Asset(query_1.QueryAssetRequest.fromPartial({ denom }));
                 assetParams = assetResponse.assetParams;
                 if (!assetParams) {
-                    return;
+                    throw new Error("unable to retrieve asset param for " + denom);
                 }
             }
             if (!rateStrategyParams) {
@@ -623,7 +593,7 @@ class CDPModule extends base_1.default {
                 }));
                 rateStrategyParams = rateStrategyParamsResponse.rateStrategyParams;
                 if (!rateStrategyParams) {
-                    return;
+                    throw new Error("unable to retrieve rate strategy for " + denom);
                 }
             }
             const utilizationRate = (0, number_1.bnOrZero)(debtInfo.utilizationRate).shiftedBy(-18);
@@ -646,8 +616,7 @@ class CDPModule extends base_1.default {
         }
         const duration = (0, number_1.bnOrZero)(end.valueOf() - start.valueOf());
         const millisecondsAYear = (0, number_1.bnOrZero)(31536000000);
-        const interest = duration.div(millisecondsAYear).times(apy);
-        return interest;
+        return duration.div(millisecondsAYear).times(apy);
     }
     recalculateCIM(denom, debtInfo) {
         var _a;
@@ -693,12 +662,10 @@ class CDPModule extends base_1.default {
         });
     }
     getMaxCollateralForUnlock(account, cdpDenom) {
-        var _a;
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
             const sdk = this.sdkProvider;
-            const denom = yield this.getUnderlyingDenom(cdpDenom);
-            if (!denom)
-                return;
+            const denom = this.getUnderlyingDenom(cdpDenom);
             const assetParams = yield sdk.query.cdp.Asset({ denom: denom });
             if (!assetParams.assetParams)
                 return;
@@ -707,54 +674,122 @@ class CDPModule extends base_1.default {
                 unlockRatio = new bignumber_js_1.BigNumber(assetParams.assetParams.liquidationThreshold);
             }
             const accountData = yield this.getAccountData(account);
-            if (!accountData)
-                return;
-            const tokenDecimals = yield sdk.getTokenClient().getDecimals(denom);
-            if (!tokenDecimals)
-                return;
+            const tokenDecimals = (_a = yield sdk.getTokenClient().getDecimals(denom)) !== null && _a !== void 0 ? _a : 0;
             const availableBorrowsUsd = accountData.AvailableBorrowsUsd.minus(accountData.TotalDebtsUsd);
-            const unlockableUsd = availableBorrowsUsd.multipliedBy(10000).div(unlockRatio);
-            const tokenPrice = yield sdk.query.pricing.TokenPrice({ denom: denom });
-            if (!tokenPrice.tokenPrice)
-                return;
-            const tokenTwap = new bignumber_js_1.BigNumber(tokenPrice.tokenPrice.twap);
+            const unlockableUsd = availableBorrowsUsd.multipliedBy(number_1.BN_10000).div(unlockRatio);
+            const tokenPrice = yield sdk.query.pricing.TokenPrice({ denom });
+            const tokenTwap = (0, number_1.bnOrZero)((_b = tokenPrice.tokenPrice) === null || _b === void 0 ? void 0 : _b.twap);
+            if (tokenTwap.isZero())
+                throw new Error("unable to retrieve token price for " + denom);
             const tokenAmt = unlockableUsd.div(tokenTwap.shiftedBy(-18)).shiftedBy(tokenDecimals);
-            const cdpToActualRatio = (_a = yield this.getCdpToActualRatio(cdpDenom)) !== null && _a !== void 0 ? _a : number_1.BN_ZERO;
+            const cdpToActualRatio = (_c = yield this.getCdpToActualRatio(cdpDenom)) !== null && _c !== void 0 ? _c : number_1.BN_ZERO;
             const cdpTokenAmt = tokenAmt.multipliedBy(cdpToActualRatio);
             // take the min of cdpTokensUnlockableAmt and locked tokens
             const accountCollateral = yield sdk.query.cdp.AccountCollateral({
                 address: account,
                 cdpDenom: cdpDenom
             });
-            if (!accountCollateral.collateral)
-                return;
-            const lockedAmount = new bignumber_js_1.BigNumber(accountCollateral.collateral.collateralAmount);
-            if (lockedAmount.lt(cdpTokenAmt)) {
-                return lockedAmount;
-            }
-            return cdpTokenAmt;
+            const lockedAmount = (0, number_1.bnOrZero)((_e = (_d = accountCollateral.collateral) === null || _d === void 0 ? void 0 : _d.collateralAmount) !== null && _e !== void 0 ? _e : "0");
+            return lockedAmount.lt(cdpTokenAmt) ? lockedAmount : cdpTokenAmt;
         });
     }
+    getCdpModuleAddress() {
+        if (!this.cdpModuleAddress) {
+            const network = this.sdkProvider.getConfig().network;
+            this.cdpModuleAddress = address_1.SWTHAddress.getModuleAddress("cdp", network);
+        }
+        return this.cdpModuleAddress;
+    }
     getCdpTokenPrice(cdpDenom) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const sdk = this.sdkProvider;
-            const denom = yield this.getUnderlyingDenom(cdpDenom);
-            if (!denom) {
-                return;
-            }
+            const denom = this.getUnderlyingDenom(cdpDenom);
             const cdpToActualRatio = (_a = yield this.getCdpToActualRatio(cdpDenom)) !== null && _a !== void 0 ? _a : number_1.BN_ZERO;
             const tokenPrice = yield sdk.query.pricing.TokenPrice({ denom: denom });
-            if (!tokenPrice.tokenPrice) {
-                return;
-            }
-            const tokenTwap = new bignumber_js_1.BigNumber(tokenPrice.tokenPrice.twap);
-            return tokenTwap.multipliedBy(cdpToActualRatio).shiftedBy(-18);
+            const tokenTwap = (0, number_1.bnOrZero)((_b = tokenPrice.tokenPrice) === null || _b === void 0 ? void 0 : _b.twap).shiftedBy(-18);
+            return tokenTwap.multipliedBy(cdpToActualRatio);
         });
     }
     getUnderlyingDenom(cdpDenom) {
         var _a;
-        return (_a = this.sdkProvider.getTokenClient().getCdpUnderlyingToken(cdpDenom)) === null || _a === void 0 ? void 0 : _a.denom;
+        const denom = (_a = this.sdkProvider.getTokenClient().getCdpUnderlyingToken(cdpDenom)) === null || _a === void 0 ? void 0 : _a.denom;
+        if (!denom)
+            throw new Error("underlying denom not found for " + cdpDenom);
+        return denom;
+    }
+    // given a debt repayment amount, we get the max collateral that a liquidator can receive
+    // this takes into account the liquidation bonus and fees that will be deducted from his profit
+    getCollateralReceivableForLiquidation(debtDenom, debtAmount, cdpDenom) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const sdk = this.sdkProvider;
+            // get the discounted price for the cdp token
+            const cdpActualDenom = this.getUnderlyingDenom(cdpDenom);
+            const asset = yield sdk.query.cdp.Asset({
+                denom: cdpActualDenom
+            });
+            if (!asset.assetParams)
+                throw new Error("unable to retrieve asset param for " + debtDenom);
+            const bonus = (0, number_1.bnOrZero)(asset.assetParams.liquidationDiscount).div(number_1.BN_10000);
+            const cdpTokenPrice = yield this.getCdpTokenPrice(cdpDenom);
+            const cdpTokenDiscountedPrice = cdpTokenPrice.multipliedBy(number_1.BN_ONE.minus(bonus));
+            // get cdp tokens (discounted) that can be gained from the debt amount
+            const debtValue = (_a = yield this.getTokenUsdVal(debtDenom, debtAmount)) !== null && _a !== void 0 ? _a : number_1.BN_ZERO;
+            const underlyingDenom = this.getUnderlyingDenom(cdpDenom);
+            const cdpTokenDecimals = (_b = yield sdk.getTokenClient().getDecimals(underlyingDenom)) !== null && _b !== void 0 ? _b : 0;
+            const cdpAmountWithDiscount = debtValue.div(cdpTokenDiscountedPrice).shiftedBy(cdpTokenDecimals);
+            // get cdp tokens (not discounted) that can be gained from the debt amount
+            const cdpAmountWithoutDiscount = debtValue.div(cdpTokenPrice).shiftedBy(cdpTokenDecimals);
+            // get fee amount
+            const cdpAmountProfit = cdpAmountWithDiscount.minus(cdpAmountWithoutDiscount);
+            const params = yield sdk.query.cdp.Params({});
+            if (!params.params)
+                throw new Error("unable to retrieve cdp params");
+            const feePercentage = (0, number_1.bnOrZero)(params.params.liquidationFee).div(number_1.BN_10000);
+            const feeAmount = cdpAmountProfit.multipliedBy(feePercentage);
+            // return collateral that can be received by liquidator
+            return cdpAmountWithDiscount.minus(feeAmount);
+        });
+    }
+    getCollateralReceivableForStablecoinLiq(cdpDenom, stablecoinRepayAmt, interestDenom, interestRepayAmt) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            const sdk = this.sdkProvider;
+            // get the discounted price for the cdp token
+            const cdpActualDenom = this.getUnderlyingDenom(cdpDenom);
+            const asset = yield sdk.query.cdp.Asset({
+                denom: cdpActualDenom
+            });
+            if (!asset.assetParams)
+                throw new Error("unable to retrieve asset param for " + cdpActualDenom);
+            const bonus = (0, number_1.bnOrZero)(asset.assetParams.liquidationDiscount).div(number_1.BN_10000);
+            const cdpTokenPrice = yield this.getCdpTokenPrice(cdpDenom);
+            const cdpTokenDiscountedPrice = cdpTokenPrice.multipliedBy(number_1.BN_ONE.minus(bonus));
+            // get value of stablecoin repayment + interest repayment
+            const debtInfoRsp = (_a = yield sdk.query.cdp.StablecoinDebt({})) !== null && _a !== void 0 ? _a : {};
+            if (!debtInfoRsp.stablecoinDebtInfo)
+                throw new Error("unable to retrieve stablecoin debt info");
+            const stablecoinDebtInfo = debtInfoRsp.stablecoinDebtInfo;
+            const stablecoinDecimals = (_b = yield this.sdkProvider.getTokenClient().getDecimals(stablecoinDebtInfo.denom)) !== null && _b !== void 0 ? _b : number_1.BN_ZERO;
+            const stablecoinRepaymentValue = stablecoinRepayAmt.shiftedBy(-stablecoinDecimals);
+            const interestRepaymentValue = (_c = yield this.getTokenUsdVal(interestDenom, interestRepayAmt)) !== null && _c !== void 0 ? _c : number_1.BN_ZERO;
+            const totalRepaymentValue = stablecoinRepaymentValue.plus(interestRepaymentValue);
+            // get cdp tokens (discounted) that can be gained from the debt amount
+            const cdpTokenDecimals = (_d = yield sdk.getTokenClient().getDecimals(cdpActualDenom)) !== null && _d !== void 0 ? _d : 0;
+            const cdpAmountWithDiscount = totalRepaymentValue.div(cdpTokenDiscountedPrice).shiftedBy(cdpTokenDecimals);
+            // get cdp tokens (not discounted) that can be gained from the debt amount
+            const cdpAmountWithoutDiscount = totalRepaymentValue.div(cdpTokenPrice).shiftedBy(cdpTokenDecimals);
+            // get fee amount
+            const cdpAmountProfit = cdpAmountWithDiscount.minus(cdpAmountWithoutDiscount);
+            const params = yield sdk.query.cdp.Params({});
+            if (!params.params)
+                throw new Error("unable to retrieve cdp params");
+            const feePercentage = (0, number_1.bnOrZero)(params.params.liquidationFee).div(number_1.BN_10000);
+            const feeAmount = cdpAmountProfit.multipliedBy(feePercentage);
+            // return collateral that can be received by liquidator
+            return cdpAmountWithDiscount.minus(feeAmount);
+        });
     }
 }
 exports.CDPModule = CDPModule;

package/lib/util/address.d.ts

@@ -62,6 +62,7 @@ declare type SWTHAddressType = AddressBuilder<SWTHAddressOptions> & {
     getAddressBytes(bech32Address: string, networkConfig: Network): Uint8Array;
     keyDerivationPath(index?: number, change?: number, account?: number): number[];
     encode(hash: string | Buffer, opts?: SWTHAddressOptions): string;
+    getModuleAddress(moduleKey: string, network?: Network): string;
 };
 export declare const SWTHAddress: SWTHAddressType;
 declare type NEOAddressType = AddressBuilder<AddressOptions> & {

package/lib/util/address.js

@@ -18,6 +18,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ETHAddress = exports.N3Address = exports.NEOAddress = exports.SWTHAddress = exports.wifEncodePrivateKey = exports.randomMnemonic = exports.BIP44Path = exports.stringOrBufferToBuffer = void 0;
 const constant_1 = require("../constant");
@@ -26,6 +29,7 @@ const Base58Check = __importStar(require("base58check"));
 const bech32 = __importStar(require("bech32"));
 const BIP32 = __importStar(require("bip32"));
 const BIP39 = __importStar(require("bip39"));
+const crypto_js_1 = __importDefault(require("crypto-js"));
 const ethers_1 = require("ethers");
 const secp256k1 = __importStar(require("secp256k1"));
 const secp256r1 = __importStar(require("secp256r1"));
@@ -189,6 +193,10 @@ exports.SWTHAddress = {
         }
         return new Uint8Array(bech32.fromWords(words));
     },
+    getModuleAddress: (moduleKey, network = constant_1.Network.MainNet) => {
+        const addressHash = crypto_js_1.default.SHA256(moduleKey).toString(crypto_js_1.default.enc.Hex);
+        return exports.SWTHAddress.encode(addressHash, { network });
+    },
 };
 exports.NEOAddress = {
     coinType: () => {