carbon-js-sdk 0.2.11 → 0.2.13-dev.2

package/lib/modules/cdp.js

@@ -16,60 +16,189 @@ exports.CDPModule = void 0;
 const tx_1 = require("../codec/cdp/tx");
 const util_1 = require("../util");
 const base_1 = __importDefault(require("./base"));
-const long_1 = __importDefault(require("long"));
 class CDPModule extends base_1.default {
-    addCollateral(params, opts) {
+    supplyAsset(params, opts) {
         return __awaiter(this, void 0, void 0, function* () {
             const wallet = this.getWallet();
-            const value = tx_1.MsgAddCollateral.fromPartial({
+            const value = tx_1.MsgSupplyAsset.fromPartial({
                 creator: wallet.bech32Address,
-                vaultTypeId: new long_1.default(params.vaultTypeId),
+                denom: params.denom,
                 amount: params.amount.toString(10),
             });
             return yield wallet.sendTx({
-                typeUrl: util_1.CarbonTx.Types.MsgAddCollateral,
-                value,
+                typeUrl: util_1.CarbonTx.Types.MsgSupplyAsset,
+                value
             }, opts);
         });
     }
-    removeCollateral(params, opts) {
+    withdrawAsset(params, opts) {
         return __awaiter(this, void 0, void 0, function* () {
             const wallet = this.getWallet();
-            const value = tx_1.MsgRemoveCollateral.fromPartial({
+            const value = tx_1.MsgWithdrawAsset.fromPartial({
                 creator: wallet.bech32Address,
-                vaultTypeId: new long_1.default(params.vaultTypeId),
+                cdpDenom: params.cdpDenom,
                 amount: params.amount.toString(10),
             });
             return yield wallet.sendTx({
-                typeUrl: util_1.CarbonTx.Types.MsgRemoveCollateral,
-                value,
+                typeUrl: util_1.CarbonTx.Types.MsgWithdrawAsset,
+                value
             }, opts);
         });
     }
-    addDebt(params, opts) {
+    lockCollateral(params, opts) {
         return __awaiter(this, void 0, void 0, function* () {
             const wallet = this.getWallet();
-            const value = tx_1.MsgAddDebt.fromPartial({
+            const value = tx_1.MsgLockCollateral.fromPartial({
                 creator: wallet.bech32Address,
-                vaultTypeId: new long_1.default(params.vaultTypeId),
+                cdpDenom: params.cdpDenom,
                 amount: params.amount.toString(10),
             });
             return yield wallet.sendTx({
-                typeUrl: util_1.CarbonTx.Types.MsgAddDebt,
-                value,
+                typeUrl: util_1.CarbonTx.Types.MsgLockCollateral,
+                value
+            }, opts);
+        });
+    }
+    unlockCollateral(params, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getWallet();
+            const value = tx_1.MsgUnlockCollateral.fromPartial({
+                creator: wallet.bech32Address,
+                cdpDenom: params.cdpDenom,
+                amount: params.amount.toString(10),
+            });
+            return yield wallet.sendTx({
+                typeUrl: util_1.CarbonTx.Types.MsgUnlockCollateral,
+                value
+            }, opts);
+        });
+    }
+    borrowAsset(params, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getWallet();
+            const value = tx_1.MsgBorrowAsset.fromPartial({
+                creator: wallet.bech32Address,
+                denom: params.denom,
+                amount: params.amount.toString(10),
+            });
+            return yield wallet.sendTx({
+                typeUrl: util_1.CarbonTx.Types.MsgBorrowAsset,
+                value
             }, opts);
         });
     }
-    removeDebt(params, opts) {
+    repayAsset(params, opts) {
         return __awaiter(this, void 0, void 0, function* () {
             const wallet = this.getWallet();
-            const value = tx_1.MsgRemoveDebt.fromPartial({
+            const value = tx_1.MsgRepayAsset.fromPartial({
                 creator: wallet.bech32Address,
-                vaultTypeId: new long_1.default(params.vaultTypeId),
+                denom: params.denom,
                 amount: params.amount.toString(10),
             });
             return yield wallet.sendTx({
-                typeUrl: util_1.CarbonTx.Types.MsgRemoveDebt,
+                typeUrl: util_1.CarbonTx.Types.MsgRepayAsset,
+                value
+            }, opts);
+        });
+    }
+    supplyAssetAndLockCollateral(params, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getWallet();
+            const value = tx_1.MsgSupplyAssetAndLockCollateral.fromPartial({
+                creator: wallet.bech32Address,
+                denom: params.denom,
+                supplyAmount: params.supplyAmount.toString(10),
+                lockAmount: params.lockAmount.toString(10),
+            });
+            return yield wallet.sendTx({
+                typeUrl: util_1.CarbonTx.Types.MsgSupplyAssetAndLockCollateral,
+                value
+            }, opts);
+        });
+    }
+    unlockCollateralAndWithdrawAsset(params, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getWallet();
+            const value = tx_1.MsgUnlockCollateralAndWithdrawAsset.fromPartial({
+                creator: wallet.bech32Address,
+                cdpDenom: params.cdpDenom,
+                unlockAmount: params.unlockAmount.toString(10),
+                withdrawAmount: params.withdrawAmount.toString(10),
+            });
+            return yield wallet.sendTx({
+                typeUrl: util_1.CarbonTx.Types.MsgUnlockCollateralAndWithdrawAsset,
+                value
+            }, opts);
+        });
+    }
+    liquidateCollateral(params, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getWallet();
+            const value = tx_1.MsgLiquidateCollateral.fromPartial({
+                creator: wallet.bech32Address,
+                debtor: params.debtor,
+                collateralDenom: params.collateralDenom,
+                debtDenom: params.debtDenom,
+                debtAmount: params.debtAmount.toString(10),
+            });
+            return yield wallet.sendTx({
+                typeUrl: util_1.CarbonTx.Types.MsgLiquidateCollateral,
+                value
+            }, opts);
+        });
+    }
+    repayAssetWithCdpTokens(params, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getWallet();
+            const value = tx_1.MsgRepayAssetWithCdpTokens.fromPartial({
+                creator: wallet.bech32Address,
+                cdpDenom: params.cdpDenom,
+                amount: params.amount.toString(10),
+            });
+            return yield wallet.sendTx({
+                typeUrl: util_1.CarbonTx.Types.MsgRepayAssetWithCdpTokens,
+                value
+            }, opts);
+        });
+    }
+    repayAssetWithCollateral(params, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getWallet();
+            const value = tx_1.MsgRepayAssetWithCollateral.fromPartial({
+                creator: wallet.bech32Address,
+                cdpDenom: params.cdpDenom,
+                amount: params.amount.toString(10),
+            });
+            return yield wallet.sendTx({
+                typeUrl: util_1.CarbonTx.Types.MsgRepayAssetWithCollateral,
+                value
+            }, opts);
+        });
+    }
+    mintStablecoin(params, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getWallet();
+            const value = tx_1.MsgMintStablecoin.fromPartial({
+                creator: wallet.bech32Address,
+                amount: params.amount.toString(10),
+            });
+            return yield wallet.sendTx({
+                typeUrl: util_1.CarbonTx.Types.MsgMintStablecoin,
+                value,
+            }, opts);
+        });
+    }
+    returnStablecoin(params, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wallet = this.getWallet();
+            const value = tx_1.MsgReturnStablecoin.fromPartial({
+                creator: wallet.bech32Address,
+                principalAmount: params.principalAmount.toString(10),
+                interestDenom: params.interestDenom,
+                interestAmount: params.interestAmount.toString(10),
+            });
+            return yield wallet.sendTx({
+                typeUrl: util_1.CarbonTx.Types.MsgReturnStablecoin,
                 value,
             }, opts);
         });

package/lib/modules/fee.d.ts

@@ -1,5 +1,5 @@
-import { FeeResult } from "../util/transferfees";
+import { GetFeeQuoteResponse } from "../hydrogen/feeQuote";
 import BaseModule from "./base";
 export declare class FeeModule extends BaseModule {
-    getDepositWithdrawalFees(denom: string): Promise<FeeResult>;
+    getDepositWithdrawalFees(denom: string): Promise<GetFeeQuoteResponse>;
 }

package/lib/modules/fee.js

@@ -13,15 +13,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FeeModule = void 0;
-const util_1 = require("../util");
 const base_1 = __importDefault(require("./base"));
 class FeeModule extends base_1.default {
     getDepositWithdrawalFees(denom) {
         return __awaiter(this, void 0, void 0, function* () {
-            const networkConfig = this.sdkProvider.getConfig();
-            const url = `${networkConfig.feeURL}/fees?denom=${denom}`;
-            const result = (yield util_1.FetchUtils.fetch(url).then((res) => res.json()));
-            return result;
+            const feeInfo = yield this.sdkProvider.hydrogen.getFeeQuote({
+                token_denom: denom,
+            });
+            return feeInfo;
         });
     }
 }

package/lib/provider/amino/types/admin.js

@@ -43,6 +43,14 @@ const TxTypes = {
     RemoveMinGasPrice: "fee/RemoveMinGasPrice",
     CreateValidator: "cosmos-sdk/MsgCreateValidator",
     EditValidator: "cosmos-sdk/MsgEditValidator",
+    AddRateStrategy: "cdp/AddRateStrategy",
+    UpdateRateStrategy: "cdp/UpdateRateStrategy",
+    RemoveRateStrategy: "cdp/RemoveRateStrategy",
+    AddAsset: "cdp/AddAsset",
+    UpdateAsset: "cdp/UpdateAsset",
+    SetLiquidationFee: "cdp/SetLiquidationFee",
+    SetInterestFee: "cdp/SetInterestFee",
+    SetStableCoinInterestRate: "cdp/SetStableCoinInterestRate",
 };
 const MsgCreateOracle = {
     aminoType: TxTypes.CreateOracle,
@@ -84,12 +92,6 @@ const MsgCreateMarket = {
         currentQuotePriceUsd: utils_1.ConvertEncType.Dec,
     },
 };
-const MsgCreateVaultType = {
-    aminoType: TxTypes.CreateVaultType,
-    valueMap: {
-        collateralizationRatio: utils_1.ConvertEncType.Dec,
-    },
-};
 const MsgLinkPool = {
     aminoType: TxTypes.LinkPool,
     valueMap: {
@@ -177,6 +179,38 @@ const MsgEditValidator = {
         commissionRate: utils_1.ConvertEncType.Dec,
     },
 };
+const MsgAddRateStrategy = {
+    aminoType: TxTypes.AddRateStrategy,
+    valueMap: {}
+};
+const MsgUpdateRateStrategy = {
+    aminoType: TxTypes.UpdateRateStrategy,
+    valueMap: {}
+};
+const MsgRemoveRateStrategy = {
+    aminoType: TxTypes.RemoveRateStrategy,
+    valueMap: {}
+};
+const MsgAddAsset = {
+    aminoType: TxTypes.AddAsset,
+    valueMap: {}
+};
+const MsgUpdateAsset = {
+    aminoType: TxTypes.UpdateAsset,
+    valueMap: {}
+};
+const MsgSetLiquidationFee = {
+    aminoType: TxTypes.SetLiquidationFee,
+    valueMap: {}
+};
+const MsgSetInterestFee = {
+    aminoType: TxTypes.SetInterestFee,
+    valueMap: {}
+};
+const MsgSetStableCoinInterestRate = {
+    aminoType: TxTypes.SetStableCoinInterestRate,
+    valueMap: {}
+};
 const AdminAmino = {
     [CarbonTx.Types.MsgCreateOracle]: (0, utils_1.generateAminoType)(MsgCreateOracle),
     [CarbonTx.Types.MsgBindToken]: (0, utils_1.generateAminoType)(MsgBindToken),
@@ -184,7 +218,6 @@ const AdminAmino = {
     [CarbonTx.Types.MsgLinkToken]: (0, utils_1.generateAminoType)(MsgLinkToken),
     [CarbonTx.Types.MsgSyncToken]: (0, utils_1.generateAminoType)(MsgSyncToken),
     [CarbonTx.Types.MsgCreateMarket]: (0, utils_1.generateAminoType)(MsgCreateMarket),
-    [CarbonTx.Types.MsgCreateVaultType]: (0, utils_1.generateAminoType)(MsgCreateVaultType),
     [CarbonTx.Types.MsgLinkPool]: (0, utils_1.generateAminoType)(MsgLinkPool),
     [CarbonTx.Types.MsgUnlinkPool]: (0, utils_1.generateAminoType)(MsgUnlinkPool),
     [CarbonTx.Types.MsgUpdatePool]: (0, utils_1.generateAminoType)(MsgUpdatePool),
@@ -198,5 +231,13 @@ const AdminAmino = {
     [CarbonTx.Types.MsgRemoveMinGasPrice]: (0, utils_1.generateAminoType)(MsgRemoveMinGasPrice),
     [CarbonTx.Types.MsgCreateValidator]: (0, utils_1.generateAminoType)(MsgCreateValidator),
     [CarbonTx.Types.MsgEditValidator]: (0, utils_1.generateAminoType)(MsgEditValidator),
+    [CarbonTx.Types.MsgAddRateStrategy]: (0, utils_1.generateAminoType)(MsgAddRateStrategy),
+    [CarbonTx.Types.MsgUpdateRateStrategy]: (0, utils_1.generateAminoType)(MsgUpdateRateStrategy),
+    [CarbonTx.Types.MsgRemoveRateStrategy]: (0, utils_1.generateAminoType)(MsgRemoveRateStrategy),
+    [CarbonTx.Types.MsgAddAsset]: (0, utils_1.generateAminoType)(MsgAddAsset),
+    [CarbonTx.Types.MsgUpdateAsset]: (0, utils_1.generateAminoType)(MsgUpdateAsset),
+    [CarbonTx.Types.MsgSetLiquidationFee]: (0, utils_1.generateAminoType)(MsgSetLiquidationFee),
+    [CarbonTx.Types.MsgSetInterestFee]: (0, utils_1.generateAminoType)(MsgSetInterestFee),
+    [CarbonTx.Types.MsgSetStablecoinInterestRate]: (0, utils_1.generateAminoType)(MsgSetStableCoinInterestRate),
 };
 exports.default = AdminAmino;

package/lib/provider/amino/types/cdp.js

@@ -22,39 +22,79 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const CarbonTx = __importStar(require("../../../util/tx"));
 const utils_1 = require("../utils");
 const TxTypes = {
-    AddCollateral: "cdp/AddCollateral",
-    RemoveCollateral: "cdp/removeCollateral",
-    AddDebt: "cdp/AddDebt",
-    RemoveDebt: "cdp/RemoveDebt",
-};
-const MsgAddCollateral = {
-    aminoType: TxTypes.AddCollateral,
-    valueMap: {
-        vaultTypeId: utils_1.ConvertEncType.Long,
-    },
-};
-const MsgRemoveCollateral = {
-    aminoType: TxTypes.RemoveCollateral,
-    valueMap: {
-        vaultTypeId: utils_1.ConvertEncType.Long,
-    },
-};
-const MsgAddDebt = {
-    aminoType: TxTypes.AddDebt,
-    valueMap: {
-        vaultTypeId: utils_1.ConvertEncType.Long,
-    },
-};
-const MsgRemoveDebt = {
-    aminoType: TxTypes.RemoveDebt,
-    valueMap: {
-        vaultTypeId: utils_1.ConvertEncType.Long,
-    },
+    SupplyAsset: "cdp/SupplyAsset",
+    WithdrawAsset: "cdp/WithdrawAsset",
+    LockCollateral: "cdp/LockCollateral",
+    UnlockCollateral: "cdp/UnlockCollateral",
+    BorrowAsset: "cdp/BorrowAsset",
+    RepayAsset: "cdp/RepayAsset",
+    SupplyAssetAndLockCollateral: "cdp/SupplyAssetAndLockCollateral",
+    UnlockCollateralAndWithdrawAsset: "cdp/UnlockCollateralAndWithdrawAsset",
+    LiquidateCollateral: "cdp/LiquidateCollateral",
+    RepayAssetWithCdpTokens: "cdp/RepayAssetWithCdpTokens",
+    RepayAssetWithCollateral: "cdp/RepayAssetWithCollateral",
+    MintStablecoin: "cdp/MintStablecoin",
+};
+const MsgSupplyAsset = {
+    aminoType: TxTypes.SupplyAsset,
+    valueMap: {},
+};
+const MsgWithdrawAsset = {
+    aminoType: TxTypes.WithdrawAsset,
+    valueMap: {},
+};
+const MsgLockCollateral = {
+    aminoType: TxTypes.LockCollateral,
+    valueMap: {},
+};
+const MsgUnlockCollateral = {
+    aminoType: TxTypes.UnlockCollateral,
+    valueMap: {},
+};
+const MsgBorrowAsset = {
+    aminoType: TxTypes.BorrowAsset,
+    valueMap: {},
+};
+const MsgRepayAsset = {
+    aminoType: TxTypes.RepayAsset,
+    valueMap: {},
+};
+const MsgSupplyAssetAndLockCollateral = {
+    aminoType: TxTypes.SupplyAssetAndLockCollateral,
+    valueMap: {},
+};
+const MsgUnlockCollateralAndWithdrawAsset = {
+    aminoType: TxTypes.UnlockCollateralAndWithdrawAsset,
+    valueMap: {},
+};
+const MsgLiquidateCollateral = {
+    aminoType: TxTypes.LiquidateCollateral,
+    valueMap: {},
+};
+const MsgRepayAssetWithCdpTokens = {
+    aminoType: TxTypes.RepayAssetWithCdpTokens,
+    valueMap: {},
+};
+const MsgRepayAssetWithCollateral = {
+    aminoType: TxTypes.RepayAssetWithCollateral,
+    valueMap: {},
+};
+const MsgMintStablecoin = {
+    aminoType: TxTypes.MintStablecoin,
+    valueMap: {},
 };
 const CdpAmino = {
-    [CarbonTx.Types.MsgAddCollateral]: (0, utils_1.generateAminoType)(MsgAddCollateral),
-    [CarbonTx.Types.MsgRemoveCollateral]: (0, utils_1.generateAminoType)(MsgRemoveCollateral),
-    [CarbonTx.Types.MsgAddDebt]: (0, utils_1.generateAminoType)(MsgAddDebt),
-    [CarbonTx.Types.MsgRemoveDebt]: (0, utils_1.generateAminoType)(MsgRemoveDebt),
+    [CarbonTx.Types.MsgSupplyAsset]: (0, utils_1.generateAminoType)(MsgSupplyAsset),
+    [CarbonTx.Types.MsgWithdrawAsset]: (0, utils_1.generateAminoType)(MsgWithdrawAsset),
+    [CarbonTx.Types.MsgLockCollateral]: (0, utils_1.generateAminoType)(MsgLockCollateral),
+    [CarbonTx.Types.MsgUnlockCollateral]: (0, utils_1.generateAminoType)(MsgUnlockCollateral),
+    [CarbonTx.Types.MsgBorrowAsset]: (0, utils_1.generateAminoType)(MsgBorrowAsset),
+    [CarbonTx.Types.MsgRepayAsset]: (0, utils_1.generateAminoType)(MsgRepayAsset),
+    [CarbonTx.Types.MsgSupplyAssetAndLockCollateral]: (0, utils_1.generateAminoType)(MsgSupplyAssetAndLockCollateral),
+    [CarbonTx.Types.MsgUnlockCollateralAndWithdrawAsset]: (0, utils_1.generateAminoType)(MsgUnlockCollateralAndWithdrawAsset),
+    [CarbonTx.Types.MsgLiquidateCollateral]: (0, utils_1.generateAminoType)(MsgLiquidateCollateral),
+    [CarbonTx.Types.MsgRepayAssetWithCdpTokens]: (0, utils_1.generateAminoType)(MsgRepayAssetWithCdpTokens),
+    [CarbonTx.Types.MsgRepayAssetWithCollateral]: (0, utils_1.generateAminoType)(MsgRepayAssetWithCollateral),
+    [CarbonTx.Types.MsgMintStablecoin]: (0, utils_1.generateAminoType)(MsgMintStablecoin),
 };
 exports.default = CdpAmino;

package/lib/provider/sdk/SDKProvider.d.ts

@@ -1,7 +1,8 @@
-import { CarbonQueryClient, TokenClient } from "../../clients";
+import { CarbonQueryClient, HydrogenClient, TokenClient } from "../../clients";
 import { NetworkConfig } from "../../constant/network";
 import { CarbonWallet } from "../../wallet/CarbonWallet";
 interface SDKProvider {
+    hydrogen: HydrogenClient;
     query: CarbonQueryClient;
     getTokenClient(): TokenClient;
     log: (...args: any[]) => void;

package/lib/util/tx.d.ts

@@ -57,16 +57,48 @@ export declare const Types: {
     MsgCancelOrderResponse: string;
     MsgCancelAll: string;
     MsgCancelAllResponse: string;
-    MsgAddCollateral: string;
-    MsgAddCollateralResponse: string;
-    MsgRemoveCollateral: string;
-    MsgRemoveCollateralResponse: string;
-    MsgAddDebt: string;
-    MsgAddDebtResponse: string;
-    MsgRemoveDebt: string;
-    MsgRemoveDebtResponse: string;
-    MsgCreateVaultType: string;
-    MsgCreateVaultTypeResponse: string;
+    MsgAddRateStrategy: string;
+    MsgAddRateStrategyResponse: string;
+    MsgUpdateRateStrategy: string;
+    MsgUpdateRateStrategyResponse: string;
+    MsgRemoveRateStrategy: string;
+    MsgRemoveRateStrategyResponse: string;
+    MsgAddAsset: string;
+    MsgAddAssetResponse: string;
+    MsgUpdateAsset: string;
+    MsgUpdateAssetResponse: string;
+    MsgSupplyAsset: string;
+    MsgSupplyAssetResponse: string;
+    MsgWithdrawAsset: string;
+    MsgWithdrawAssetResponse: string;
+    MsgLockCollateral: string;
+    MsgLockCollateralResponse: string;
+    MsgUnlockCollateral: string;
+    MsgUnlockCollateralResponse: string;
+    MsgBorrowAsset: string;
+    MsgBorrowAssetResponse: string;
+    MsgRepayAsset: string;
+    MsgRepayAssetResponse: string;
+    MsgSupplyAssetAndLockCollateral: string;
+    MsgSupplyAssetAndLockCollateralResponse: string;
+    MsgUnlockCollateralAndWithdrawAsset: string;
+    MsgUnlockCollateralAndWithdrawAssetResponse: string;
+    MsgLiquidateCollateral: string;
+    MsgLiquidateCollateralResponse: string;
+    MsgSetLiquidationFee: string;
+    MsgSetLiquidationFeeResponse: string;
+    MsgSetInterestFee: string;
+    MsgSetInterestFeeResponse: string;
+    MsgRepayAssetWithCdpTokens: string;
+    MsgRepayAssetWithCdpTokensResponse: string;
+    MsgRepayAssetWithCollateral: string;
+    MsgRepayAssetWithCollateralResponse: string;
+    MsgSetStablecoinInterestRate: string;
+    MsgSetStablecoinInterestRateResponse: string;
+    MsgMintStablecoin: string;
+    MsgMintStablecoinResponse: string;
+    MsgReturnStablecoin: string;
+    MsgReturnStablecoinResponse: string;
     MsgSyncGenesis: string;
     MsgSyncGenesisResponse: string;
     MsgSyncHeaders: string;
@@ -85,10 +117,6 @@ export declare const Types: {
     SetMinGasPriceProposal: string;
     RemoveMsgGasCostProposal: string;
     RemoveMinGasPriceProposal: string;
-    MsgEnableSend: string;
-    MsgEnableSendResponse: string;
-    MsgDisableSend: string;
-    MsgDisableSendResponse: string;
     MsgCreate: string;
     MsgCreateResponse: string;
     MsgBind: string;

package/lib/websocket/channel.js

@@ -72,6 +72,26 @@ const generateChannelId = (params) => {
             const { channel, address } = params;
             return [channel, address].join(':');
         }
+        case types_1.WSChannel.cdp_borrows: {
+            const { channel, address } = params;
+            return [channel, address].join(':');
+        }
+        case types_1.WSChannel.cdp_collaterals: {
+            const { channel, address } = params;
+            return [channel, address].join(':');
+        }
+        case types_1.WSChannel.cdp_liquidate_collaterals: {
+            const { channel } = params;
+            return [channel].join(':');
+        }
+        case types_1.WSChannel.cdp_all_token_debts: {
+            const { channel } = params;
+            return [channel].join(':');
+        }
+        case types_1.WSChannel.cdp_token_debt: {
+            const { channel, denom } = params;
+            return [channel, denom].join(':');
+        }
         default:
             throw new Error(`invalid subscription channel: ${params.channel}`);
     }
@@ -168,6 +188,30 @@ const parseChannelId = (rawChannelId) => {
                 channel,
                 address,
             };
+        case types_1.WSChannel.cdp_borrows:
+            return {
+                channel,
+                address,
+            };
+        case types_1.WSChannel.cdp_collaterals:
+            return {
+                channel,
+                address,
+            };
+        case types_1.WSChannel.cdp_liquidate_collaterals:
+            return {
+                channel,
+            };
+        case types_1.WSChannel.cdp_all_token_debts:
+            return {
+                channel,
+            };
+        case types_1.WSChannel.cdp_token_debt:
+            const denom = market;
+            return {
+                channel,
+                denom,
+            };
         default:
             throw new Error('Error parsing channelId');
     }