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

package/lib/codec/pricing/legacy.d.ts

@@ -0,0 +1,22 @@
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+import { Duration } from "../google/protobuf/duration";
+export declare const protobufPackage = "Switcheo.carbon.pricing";
+/** Legacy Params from v.2.13.0. */
+export interface ParamsV2130 {
+    smoothenBand: number;
+    impactBand: number;
+    staleIndexAllowance?: Duration;
+}
+export declare const ParamsV2130: {
+    encode(message: ParamsV2130, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): ParamsV2130;
+    fromJSON(object: any): ParamsV2130;
+    toJSON(message: ParamsV2130): unknown;
+    fromPartial(object: DeepPartial<ParamsV2130>): ParamsV2130;
+};
+declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+export {};

package/lib/codec/pricing/legacy.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParamsV2130 = exports.protobufPackage = void 0;
+/* eslint-disable */
+const long_1 = __importDefault(require("long"));
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const duration_1 = require("../google/protobuf/duration");
+exports.protobufPackage = "Switcheo.carbon.pricing";
+const baseParamsV2130 = { smoothenBand: 0, impactBand: 0 };
+exports.ParamsV2130 = {
+    encode(message, writer = minimal_1.default.Writer.create()) {
+        if (message.smoothenBand !== 0) {
+            writer.uint32(8).uint32(message.smoothenBand);
+        }
+        if (message.impactBand !== 0) {
+            writer.uint32(16).uint32(message.impactBand);
+        }
+        if (message.staleIndexAllowance !== undefined) {
+            duration_1.Duration.encode(message.staleIndexAllowance, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = Object.assign({}, baseParamsV2130);
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.smoothenBand = reader.uint32();
+                    break;
+                case 2:
+                    message.impactBand = reader.uint32();
+                    break;
+                case 3:
+                    message.staleIndexAllowance = duration_1.Duration.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        const message = Object.assign({}, baseParamsV2130);
+        message.smoothenBand =
+            object.smoothenBand !== undefined && object.smoothenBand !== null
+                ? Number(object.smoothenBand)
+                : 0;
+        message.impactBand =
+            object.impactBand !== undefined && object.impactBand !== null
+                ? Number(object.impactBand)
+                : 0;
+        message.staleIndexAllowance =
+            object.staleIndexAllowance !== undefined &&
+                object.staleIndexAllowance !== null
+                ? duration_1.Duration.fromJSON(object.staleIndexAllowance)
+                : undefined;
+        return message;
+    },
+    toJSON(message) {
+        const obj = {};
+        message.smoothenBand !== undefined &&
+            (obj.smoothenBand = message.smoothenBand);
+        message.impactBand !== undefined && (obj.impactBand = message.impactBand);
+        message.staleIndexAllowance !== undefined &&
+            (obj.staleIndexAllowance = message.staleIndexAllowance
+                ? duration_1.Duration.toJSON(message.staleIndexAllowance)
+                : undefined);
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = Object.assign({}, baseParamsV2130);
+        message.smoothenBand = (_a = object.smoothenBand) !== null && _a !== void 0 ? _a : 0;
+        message.impactBand = (_b = object.impactBand) !== null && _b !== void 0 ? _b : 0;
+        message.staleIndexAllowance =
+            object.staleIndexAllowance !== undefined &&
+                object.staleIndexAllowance !== null
+                ? duration_1.Duration.fromPartial(object.staleIndexAllowance)
+                : undefined;
+        return message;
+    },
+};
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}

package/lib/modules/admin.d.ts

@@ -256,7 +256,6 @@ export declare namespace AdminModule {
         rewardAmountPerSecond: BigNumber;
         startTime?: Date;
         endTime?: Date;
-        reservesAmount: BigNumber;
     }
     interface UpdateRewardSchemeParams {
         rewardSchemeId: number;
@@ -354,7 +353,6 @@ export declare function transformCreateRewardScheme(msg: AdminModule.CreateRewar
     rewardAmountPerSecond: string;
     startTime: Date | undefined;
     endTime: Date | undefined;
-    reservesAmount: string;
 };
 export declare function transformUpdateRewardScheme(msg: AdminModule.UpdateRewardSchemeParams): {
     rewardSchemeId: Long.Long;

package/lib/modules/admin.js

@@ -737,7 +737,6 @@ function transformCreateRewardScheme(msg) {
         rewardAmountPerSecond: msg.rewardAmountPerSecond.toString(10),
         startTime: msg.startTime,
         endTime: msg.endTime,
-        reservesAmount: msg.reservesAmount.toString(10),
     };
 }
 exports.transformCreateRewardScheme = transformCreateRewardScheme;

package/lib/modules/cdp.d.ts

@@ -5,7 +5,6 @@ import { Debt } from './../codec/cdp/query';
 import BaseModule from "./base";
 export declare class CDPModule extends BaseModule {
     private cdpModuleAddress;
-    private collateralPoolAddress;
     supplyAsset(params: CDPModule.SupplyAssetParams, opts?: CarbonTx.SignTxOpts): Promise<import("@cosmjs/stargate").DeliverTxResponse>;
     withdrawAsset(params: CDPModule.WithdrawAssetParams, opts?: CarbonTx.SignTxOpts): Promise<import("@cosmjs/stargate").DeliverTxResponse>;
     lockCollateral(params: CDPModule.LockCollateralParams, opts?: CarbonTx.SignTxOpts): Promise<import("@cosmjs/stargate").DeliverTxResponse>;
@@ -31,24 +30,26 @@ export declare class CDPModule extends BaseModule {
         TotalDebtsUsd: BigNumber;
         TotalStablecoinDebtsUsd: BigNumber;
         HealthFactor: BigNumber;
-    } | undefined>;
-    getAssetBorrowableSupply(denom: string): Promise<BigNumber | undefined>;
-    getCdpToActualRatio(cdpDenom: string): Promise<BigNumber | undefined>;
-    getTotalAccountTokenDebtUsdVal(account: string, denom: string, debt?: Debt, debtInfo?: DebtInfo): Promise<void | BigNumber>;
+    }>;
+    getAssetBorrowableSupply(denom: string): Promise<BigNumber>;
+    getCdpToActualRatio(cdpDenom: string): Promise<BigNumber>;
+    getTotalAccountTokenDebtUsdVal(account: string, denom: string, debt?: Debt, debtInfo?: DebtInfo): Promise<BigNumber>;
     getModuleTotalDebtUsdVal(): Promise<BigNumber | undefined>;
-    getModuleTotalCollateralUsdVal(): Promise<BigNumber | undefined>;
-    getCdpTokenUsdVal(cdpDenom: string, amount: BigNumber): Promise<BigNumber | undefined>;
-    getTokenUsdVal(denom: string, amount: BigNumber): Promise<BigNumber | undefined>;
-    getTotalTokenDebt(denom: string, debtInfo?: DebtInfo): Promise<BigNumber | undefined>;
-    getTotalAccountTokenDebt(account: string, denom: string, debt?: Debt, debtInfo?: DebtInfo): Promise<BigNumber | undefined>;
+    getModuleTotalCollateralUsdVal(): Promise<BigNumber>;
+    getCdpTokenUsdVal(cdpDenom: string, amount: BigNumber): Promise<BigNumber>;
+    getTokenUsdVal(denom: string, amount: BigNumber): Promise<BigNumber>;
+    getTotalTokenDebt(denom: string, debtInfo?: DebtInfo): Promise<BigNumber>;
+    getTotalAccountTokenDebt(account: string, denom: string, debt?: Debt, debtInfo?: DebtInfo): Promise<BigNumber>;
     getTotalAccountStablecoinDebt(account: string, debt?: CDPModule.StablecoinDebt, debtInfo?: StablecoinDebtInfo): Promise<BigNumber>;
-    calculateAPY(denom: string, debtInfo?: DebtInfo, assetParams?: AssetParams, rateStrategyParams?: RateStrategyParams): Promise<BigNumber | undefined>;
+    calculateAPY(denom: string, debtInfo?: DebtInfo, assetParams?: AssetParams, rateStrategyParams?: RateStrategyParams): Promise<BigNumber>;
     calculateInterestForTimePeriod(apy: BigNumber, start: Date, end: Date): BigNumber;
     recalculateCIM(denom: string, debtInfo?: DebtInfo): Promise<BigNumber>;
     recalculateStablecoinCIM(debtInfo?: StablecoinDebtInfo): Promise<BigNumber>;
     getMaxCollateralForUnlock(account: string, cdpDenom: string): Promise<BigNumber | undefined>;
-    getCdpTokenPrice(cdpDenom: string): Promise<BigNumber | undefined>;
-    getUnderlyingDenom(cdpDenom: string): string | undefined;
+    getCdpModuleAddress(): string;
+    getCdpTokenPrice(cdpDenom: string): Promise<BigNumber>;
+    getUnderlyingDenom(cdpDenom: string): string;
+    getCollateralReceivableForLiquidation(debtDenom: string, debtAmount: BigNumber, cdpDenom: string): Promise<BigNumber>;
 }
 export declare namespace CDPModule {
     interface SupplyAssetParams {

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();
@@ -322,20 +319,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 +354,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 +385,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 +440,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 +470,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 +479,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.times(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 +512,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 +538,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 +558,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 +574,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 +597,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 +643,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 +655,82 @@ 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 asset = yield sdk.query.cdp.Asset({
+                denom: debtDenom
+            });
+            if (!asset.assetParams)
+                throw new Error("unable to retrieve asset param for " + debtDenom);
+            const bonus = (0, number_1.bnOrZero)(asset.assetParams.liquidationBonus).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 = yield 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);
+        });
     }
 }
 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: () => {

package/lib/websocket/channel.js

@@ -93,8 +93,8 @@ const generateChannelId = (params) => {
             return [channel, denom].join(':');
         }
         case types_1.WSChannel.cdp_reward_schemes: {
-            const { channel, address } = params;
-            return [channel, address].join(':');
+            const { channel } = params;
+            return [channel].join(':');
         }
         case types_1.WSChannel.cdp_reward_debts: {
             const { channel, address } = params;
@@ -106,50 +106,50 @@ const generateChannelId = (params) => {
 };
 exports.generateChannelId = generateChannelId;
 const parseChannelId = (rawChannelId) => {
-    const [channel, market, resolution, address, id] = rawChannelId.split(':');
+    const [channel, param0, param1] = rawChannelId.split(':');
     switch (channel) {
         case types_1.WSChannel.candlesticks:
             return {
                 channel,
-                market,
-                resolution,
+                market: param0,
+                resolution: param1,
             };
         case types_1.WSChannel.books:
             return {
                 channel,
-                market,
+                market: param0,
             };
         case types_1.WSChannel.recent_trades:
             return {
                 channel,
-                market,
+                market: param0,
             };
         case types_1.WSChannel.orders:
             return {
                 channel,
-                address,
+                address: param0,
             };
         case types_1.WSChannel.orders_by_market:
             return {
                 channel,
-                market,
-                address,
+                market: param0,
+                address: param1,
             };
         case types_1.WSChannel.balances:
             return {
                 channel,
-                address,
+                address: param0,
             };
         case types_1.WSChannel.account_trades:
             return {
                 channel,
-                address,
+                address: param0,
             };
         case types_1.WSChannel.account_trades_by_market:
             return {
                 channel,
-                market,
-                address,
+                market: param0,
+                address: param1,
             };
         case types_1.WSChannel.market_stats:
             return {
@@ -158,29 +158,29 @@ const parseChannelId = (rawChannelId) => {
         case types_1.WSChannel.market_stats_by_market:
             return {
                 channel,
-                market,
+                market: param0,
             };
         case types_1.WSChannel.leverages:
             return {
                 channel,
-                address,
+                address: param0,
             };
         case types_1.WSChannel.leverages_by_market:
             return {
                 channel,
-                market,
-                address,
+                market: param0,
+                address: param1,
             };
         case types_1.WSChannel.positions:
             return {
                 channel,
-                address,
+                address: param0,
             };
         case types_1.WSChannel.positions_by_market:
             return {
                 channel,
-                market,
-                address,
+                market: param0,
+                address: param1,
             };
         case types_1.WSChannel.pools:
             return {
@@ -189,22 +189,22 @@ const parseChannelId = (rawChannelId) => {
         case types_1.WSChannel.pools_by_id:
             return {
                 channel,
-                id,
+                id: param0,
             };
         case types_1.WSChannel.commitments:
             return {
                 channel,
-                address,
+                address: param0,
             };
         case types_1.WSChannel.cdp_borrows:
             return {
                 channel,
-                address,
+                address: param0,
             };
         case types_1.WSChannel.cdp_collaterals:
             return {
                 channel,
-                address,
+                address: param0,
             };
         case types_1.WSChannel.cdp_liquidate_collaterals:
             return {
@@ -215,18 +215,18 @@ const parseChannelId = (rawChannelId) => {
                 channel,
             };
         case types_1.WSChannel.cdp_token_debt:
-            const denom = market;
             return {
                 channel,
-                denom,
+                denom: param0,
             };
         case types_1.WSChannel.cdp_reward_schemes:
             return {
-                address,
+                channel,
             };
         case types_1.WSChannel.cdp_reward_debts:
             return {
-                address,
+                channel,
+                address: param0,
             };
         default:
             throw new Error('Error parsing channelId');

package/lib/websocket/types.d.ts

@@ -203,7 +203,6 @@ export interface WsSubscribeTokenDebt extends WsSubscribeParams {
     denom: string;
 }
 export interface WsSubscribeRewardSchemes extends WsSubscribeParams {
-    address?: string;
 }
 export interface WsSubscribeRewardDebts extends WsSubscribeParams {
     address?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carbon-js-sdk",
-  "version": "0.2.14-dev.4+b00fe13d8bb3",
+  "version": "0.2.14-dev.5+de5603ab13a1",
   "description": "TypeScript SDK for Carbon blockchain",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",