carbon-js-sdk 0.3.14 → 0.3.16-beta.1

package/lib/clients/CarbonTendermintClient.d.ts

@@ -0,0 +1,117 @@
+import { Stream } from "xstream";
+import { JsonRpcSuccessResponse } from "@cosmjs/json-rpc/build/types";
+import * as requests from "@cosmjs/tendermint-rpc/build/tendermint34/requests";
+import * as responses from "@cosmjs/tendermint-rpc/build/tendermint34/responses";
+export interface SubscriptionEvent {
+    readonly query: string;
+    readonly data: {
+        readonly type: string;
+        readonly value: any;
+    };
+}
+export declare type JsonRpcId = number | string;
+export interface JsonRpcRequest {
+    readonly jsonrpc: "2.0";
+    readonly id: JsonRpcId;
+    readonly method: string;
+    readonly params: JsonCompatibleArray | JsonCompatibleDictionary;
+}
+export interface JsonCompatibleArray extends ReadonlyArray<JsonCompatibleValue> {
+}
+export interface JsonCompatibleDictionary {
+    readonly [key: string]: JsonCompatibleValue | readonly JsonCompatibleValue[];
+}
+export declare type JsonCompatibleValue = JsonCompatibleDictionary | JsonCompatibleArray | string | number | boolean | null;
+export interface RpcClient {
+    readonly execute: (request: JsonRpcRequest) => Promise<JsonRpcSuccessResponse>;
+    readonly disconnect: () => void;
+}
+export declare function instanceOfRpcStreamingClient(client: RpcClient): client is RpcStreamingClient;
+export interface RpcStreamingClient extends RpcClient {
+    readonly listen: (request: JsonRpcRequest) => Stream<SubscriptionEvent>;
+}
+export default class CarbonTendermintClient {
+    /**
+     * Creates a new Tendermint client for the given endpoint.
+     *
+     * Uses HTTP when the URL schema is http or https. Uses WebSockets otherwise.
+     */
+    static connect(endpoint: string): Promise<CarbonTendermintClient>;
+    /**
+     * Creates a new Tendermint client given an RPC client.
+     */
+    static create(rpcClient: RpcClient): Promise<CarbonTendermintClient>;
+    private static detectVersion;
+    private readonly client;
+    private readonly p;
+    private readonly r;
+    /**
+     * Use `CarbonTendermintClient.connect` or `CarbonTendermintClient.create` to create an instance.
+     */
+    private constructor();
+    disconnect(): void;
+    abciInfo(): Promise<responses.AbciInfoResponse>;
+    abciQuery(params: requests.AbciQueryParams): Promise<responses.AbciQueryResponse>;
+    block(height?: number): Promise<responses.BlockResponse>;
+    blockResults(height?: number): Promise<responses.BlockResultsResponse>;
+    /**
+     * Search for events that are in a block.
+     *
+     * NOTE
+     * This method will error on any node that is running a Tendermint version lower than 0.34.9.
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/block_search
+     */
+    blockSearch(params: requests.BlockSearchParams): Promise<responses.BlockSearchResponse>;
+    blockSearchAll(params: requests.BlockSearchParams): Promise<responses.BlockSearchResponse>;
+    /**
+     * Queries block headers filtered by minHeight <= height <= maxHeight.
+     *
+     * @param minHeight The minimum height to be included in the result. Defaults to 0.
+     * @param maxHeight The maximum height to be included in the result. Defaults to infinity.
+     */
+    blockchain(minHeight?: number, maxHeight?: number): Promise<responses.BlockchainResponse>;
+    /**
+     * Broadcast transaction to mempool and wait for response
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_sync
+     */
+    broadcastTxSync(params: requests.BroadcastTxParams): Promise<responses.BroadcastTxSyncResponse>;
+    /**
+     * Broadcast transaction to mempool and do not wait for result
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_async
+     */
+    broadcastTxAsync(params: requests.BroadcastTxParams): Promise<responses.BroadcastTxAsyncResponse>;
+    /**
+     * Broadcast transaction to mempool and wait for block
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_commit
+     */
+    broadcastTxCommit(params: requests.BroadcastTxParams): Promise<responses.BroadcastTxCommitResponse>;
+    commit(height?: number): Promise<responses.CommitResponse>;
+    genesis(): Promise<responses.GenesisResponse>;
+    health(): Promise<responses.HealthResponse>;
+    numUnconfirmedTxs(): Promise<responses.NumUnconfirmedTxsResponse>;
+    status(): Promise<responses.StatusResponse>;
+    subscribeNewBlock(): Stream<responses.NewBlockEvent>;
+    subscribeNewBlockHeader(): Stream<responses.NewBlockHeaderEvent>;
+    subscribeTx(query?: string): Stream<responses.TxEvent>;
+    /**
+     * Get a single transaction by hash
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/tx
+     */
+    tx(params: requests.TxParams): Promise<responses.TxResponse>;
+    /**
+     * Search for transactions that are in a block
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/tx_search
+     */
+    txSearch(params: requests.TxSearchParams): Promise<responses.TxSearchResponse>;
+    txSearchAll(params: requests.TxSearchParams): Promise<responses.TxSearchResponse>;
+    validators(params: requests.ValidatorsParams): Promise<responses.ValidatorsResponse>;
+    validatorsAll(height?: number): Promise<responses.ValidatorsResponse>;
+    private doCall;
+    private subscribe;
+}

package/lib/clients/CarbonTendermintClient.js

@@ -0,0 +1,376 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfRpcStreamingClient = void 0;
+const jsonrpc_1 = require("@cosmjs/tendermint-rpc/build/jsonrpc");
+const httpclient_1 = require("@cosmjs/tendermint-rpc/build/rpcclients/httpclient");
+const adaptor_1 = require("@cosmjs/tendermint-rpc/build/tendermint34/adaptor");
+const requests = __importStar(require("@cosmjs/tendermint-rpc/build/tendermint34/requests"));
+function instanceOfRpcStreamingClient(client) {
+    return typeof client.listen === "function";
+}
+exports.instanceOfRpcStreamingClient = instanceOfRpcStreamingClient;
+class CarbonTendermintClient {
+    /**
+     * Use `CarbonTendermintClient.connect` or `CarbonTendermintClient.create` to create an instance.
+     */
+    constructor(client) {
+        this.client = client;
+        this.p = adaptor_1.adaptor34.params;
+        this.r = adaptor_1.adaptor34.responses;
+    }
+    /**
+     * Creates a new Tendermint client for the given endpoint.
+     *
+     * Uses HTTP when the URL schema is http or https. Uses WebSockets otherwise.
+     */
+    static connect(endpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const useHttp = endpoint.startsWith("http://") || endpoint.startsWith("https://");
+            if (!useHttp) {
+                throw new Error('this client only uses httpClient.');
+            }
+            const rpcClient = new httpclient_1.HttpClient(endpoint);
+            return CarbonTendermintClient.create(rpcClient);
+        });
+    }
+    /**
+     * Creates a new Tendermint client given an RPC client.
+     */
+    static create(rpcClient) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // For some very strange reason I don't understand, tests start to fail on some systems
+            // (our CI) when skipping the status call before doing other queries. Sleeping a little
+            // while did not help. Thus we query the version as a way to say "hi" to the backend,
+            // even in cases where we don't use the result.
+            const _version = yield this.detectVersion(rpcClient);
+            return new CarbonTendermintClient(rpcClient);
+        });
+    }
+    static detectVersion(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const req = (0, jsonrpc_1.createJsonRpcRequest)(requests.Method.Status);
+            const response = yield client.execute(req);
+            const result = response.result;
+            if (!result || !result.node_info) {
+                throw new Error("Unrecognized format for status response");
+            }
+            const version = result.node_info.version;
+            if (typeof version !== "string") {
+                throw new Error("Unrecognized version format: must be string");
+            }
+            return version;
+        });
+    }
+    disconnect() {
+        this.client.disconnect();
+    }
+    abciInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.AbciInfo };
+            return this.doCall(query, this.p.encodeAbciInfo, this.r.decodeAbciInfo);
+        });
+    }
+    abciQuery(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.AbciQuery };
+            return this.doCall(query, this.p.encodeAbciQuery, this.r.decodeAbciQuery);
+        });
+    }
+    block(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Block, params: { height: height } };
+            return this.doCall(query, this.p.encodeBlock, this.r.decodeBlock);
+        });
+    }
+    blockResults(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = {
+                method: requests.Method.BlockResults,
+                params: { height: height },
+            };
+            return this.doCall(query, this.p.encodeBlockResults, this.r.decodeBlockResults);
+        });
+    }
+    /**
+     * Search for events that are in a block.
+     *
+     * NOTE
+     * This method will error on any node that is running a Tendermint version lower than 0.34.9.
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/block_search
+     */
+    blockSearch(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BlockSearch };
+            const resp = yield this.doCall(query, this.p.encodeBlockSearch, this.r.decodeBlockSearch);
+            return Object.assign(Object.assign({}, resp), { 
+                // make sure we sort by height, as tendermint may be sorting by string value of the height
+                blocks: [...resp.blocks].sort((a, b) => a.block.header.height - b.block.header.height) });
+        });
+    }
+    // this should paginate through all blockSearch options to ensure it returns all results.
+    // starts with page 1 or whatever was provided (eg. to start on page 7)
+    //
+    // NOTE
+    // This method will error on any node that is running a Tendermint version lower than 0.34.9.
+    blockSearchAll(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let page = params.page || 1;
+            const blocks = [];
+            let done = false;
+            while (!done) {
+                const resp = yield this.blockSearch(Object.assign(Object.assign({}, params), { page: page }));
+                blocks.push(...resp.blocks);
+                if (blocks.length < resp.totalCount) {
+                    page++;
+                }
+                else {
+                    done = true;
+                }
+            }
+            // make sure we sort by height, as tendermint may be sorting by string value of the height
+            // and the earlier items may be in a higher page than the later items
+            blocks.sort((a, b) => a.block.header.height - b.block.header.height);
+            return {
+                totalCount: blocks.length,
+                blocks: blocks,
+            };
+        });
+    }
+    /**
+     * Queries block headers filtered by minHeight <= height <= maxHeight.
+     *
+     * @param minHeight The minimum height to be included in the result. Defaults to 0.
+     * @param maxHeight The maximum height to be included in the result. Defaults to infinity.
+     */
+    blockchain(minHeight, maxHeight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = {
+                method: requests.Method.Blockchain,
+                params: {
+                    minHeight: minHeight,
+                    maxHeight: maxHeight,
+                },
+            };
+            return this.doCall(query, this.p.encodeBlockchain, this.r.decodeBlockchain);
+        });
+    }
+    /**
+     * Broadcast transaction to mempool and wait for response
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_sync
+     */
+    broadcastTxSync(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BroadcastTxSync };
+            return this.doCall(query, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxSync);
+        });
+    }
+    /**
+     * Broadcast transaction to mempool and do not wait for result
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_async
+     */
+    broadcastTxAsync(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BroadcastTxAsync };
+            return this.doCall(query, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxAsync);
+        });
+    }
+    /**
+     * Broadcast transaction to mempool and wait for block
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_commit
+     */
+    broadcastTxCommit(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BroadcastTxCommit };
+            return this.doCall(query, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxCommit);
+        });
+    }
+    commit(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Commit, params: { height: height } };
+            return this.doCall(query, this.p.encodeCommit, this.r.decodeCommit);
+        });
+    }
+    genesis() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Genesis };
+            return this.doCall(query, this.p.encodeGenesis, this.r.decodeGenesis);
+        });
+    }
+    health() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Health };
+            return this.doCall(query, this.p.encodeHealth, this.r.decodeHealth);
+        });
+    }
+    numUnconfirmedTxs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.NumUnconfirmedTxs };
+            return this.doCall(query, this.p.encodeNumUnconfirmedTxs, this.r.decodeNumUnconfirmedTxs);
+        });
+    }
+    status() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Status };
+            return this.doCall(query, this.p.encodeStatus, this.r.decodeStatus);
+        });
+    }
+    subscribeNewBlock() {
+        const request = {
+            method: requests.Method.Subscribe,
+            query: { type: requests.SubscriptionEventType.NewBlock },
+        };
+        return this.subscribe(request, this.r.decodeNewBlockEvent);
+    }
+    subscribeNewBlockHeader() {
+        const request = {
+            method: requests.Method.Subscribe,
+            query: { type: requests.SubscriptionEventType.NewBlockHeader },
+        };
+        return this.subscribe(request, this.r.decodeNewBlockHeaderEvent);
+    }
+    subscribeTx(query) {
+        const request = {
+            method: requests.Method.Subscribe,
+            query: {
+                type: requests.SubscriptionEventType.Tx,
+                raw: query,
+            },
+        };
+        return this.subscribe(request, this.r.decodeTxEvent);
+    }
+    /**
+     * Get a single transaction by hash
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/tx
+     */
+    tx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.Tx };
+            return this.doCall(query, this.p.encodeTx, this.r.decodeTx);
+        });
+    }
+    /**
+     * Search for transactions that are in a block
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/tx_search
+     */
+    txSearch(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.TxSearch };
+            return this.doCall(query, this.p.encodeTxSearch, this.r.decodeTxSearch);
+        });
+    }
+    // this should paginate through all txSearch options to ensure it returns all results.
+    // starts with page 1 or whatever was provided (eg. to start on page 7)
+    txSearchAll(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let page = params.page || 1;
+            const txs = [];
+            let done = false;
+            while (!done) {
+                const resp = yield this.txSearch(Object.assign(Object.assign({}, params), { page: page }));
+                txs.push(...resp.txs);
+                if (txs.length < resp.totalCount) {
+                    page++;
+                }
+                else {
+                    done = true;
+                }
+            }
+            return {
+                totalCount: txs.length,
+                txs: txs,
+            };
+        });
+    }
+    validators(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = {
+                method: requests.Method.Validators,
+                params: params,
+            };
+            return this.doCall(query, this.p.encodeValidators, this.r.decodeValidators);
+        });
+    }
+    validatorsAll(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validators = [];
+            let page = 1;
+            let done = false;
+            let blockHeight = height;
+            while (!done) {
+                const response = yield this.validators({
+                    per_page: 50,
+                    height: blockHeight,
+                    page: page,
+                });
+                validators.push(...response.validators);
+                blockHeight = blockHeight || response.blockHeight;
+                if (validators.length < response.total) {
+                    page++;
+                }
+                else {
+                    done = true;
+                }
+            }
+            return {
+                // NOTE: Default value is for type safety but this should always be set
+                blockHeight: blockHeight !== null && blockHeight !== void 0 ? blockHeight : 0,
+                count: validators.length,
+                total: validators.length,
+                validators: validators,
+            };
+        });
+    }
+    // doCall is a helper to handle the encode/call/decode logic
+    doCall(request, encode, decode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const req = encode(request);
+            const result = yield this.client.execute(req);
+            return decode(result);
+        });
+    }
+    subscribe(request, decode) {
+        if (!instanceOfRpcStreamingClient(this.client)) {
+            throw new Error("This RPC client type cannot subscribe to events");
+        }
+        const req = this.p.encodeSubscribe(request);
+        const eventStream = this.client.listen(req);
+        return eventStream.map((event) => {
+            return decode(event);
+        });
+    }
+}
+exports.default = CarbonTendermintClient;

package/lib/clients/NEOClient.js

@@ -112,9 +112,10 @@ class NEOClient {
             const toAssetHash = Neon.u.str2hexstring(token.id);
             const addressBytes = address_1.SWTHAddress.getAddressBytes(swthAddress, networkConfig.network);
             const toAddress = (0, generic_1.stripHexPrefix)(ethers_1.ethers.utils.hexlify(addressBytes));
+            const zeroAddressHex = (0, generic_1.stripHexPrefix)(ethers_1.ethers.utils.hexlify(constant_1.ZeroAddress));
             const amount = ethers_1.ethers.BigNumber.from(token.externalBalance);
             const feeAmount = ethers_1.ethers.BigNumber.from(feeAmountInput !== null && feeAmountInput !== void 0 ? feeAmountInput : "100000000");
-            const feeAddress = feeAmount.isZero() ? constant_1.ZeroAddress : networkConfig.feeAddress;
+            const feeAddress = feeAmount.isZero() ? zeroAddressHex : networkConfig.feeAddress;
             const nonce = Math.floor(Math.random() * 1000000);
             if (amount.lt(feeAmount)) {
                 return false;

package/lib/codec/cdp/tx.d.ts

@@ -266,6 +266,30 @@ export interface MsgReturnStablecoinWithInterestInCdpTokens {
 }
 export interface MsgReturnStablecoinWithInterestInCdpTokensResponse {
 }
+export interface MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokens {
+    creator: string;
+    debtor: string;
+    collateralDenom: string;
+    minCollateralAmount: string;
+    debtDenom: string;
+    debtAmount: string;
+    interestCdpDenom: string;
+    interestCdpAmount: string;
+}
+export interface MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokensResponse {
+}
+export interface MsgLiquidateCollateralWithStablecoinAndInterestInCollateral {
+    creator: string;
+    debtor: string;
+    collateralDenom: string;
+    minCollateralAmount: string;
+    debtDenom: string;
+    debtAmount: string;
+    interestCdpDenom: string;
+    interestCdpAmount: string;
+}
+export interface MsgLiquidateCollateralWithStablecoinAndInterestInCollateralResponse {
+}
 export declare const MsgAddRateStrategy: {
     encode(message: MsgAddRateStrategy, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number | undefined): MsgAddRateStrategy;
@@ -756,6 +780,34 @@ export declare const MsgReturnStablecoinWithInterestInCdpTokensResponse: {
     toJSON(_: MsgReturnStablecoinWithInterestInCdpTokensResponse): unknown;
     fromPartial(_: DeepPartial<MsgReturnStablecoinWithInterestInCdpTokensResponse>): MsgReturnStablecoinWithInterestInCdpTokensResponse;
 };
+export declare const MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokens: {
+    encode(message: MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokens, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokens;
+    fromJSON(object: any): MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokens;
+    toJSON(message: MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokens): unknown;
+    fromPartial(object: DeepPartial<MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokens>): MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokens;
+};
+export declare const MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokensResponse: {
+    encode(_: MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokensResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokensResponse;
+    fromJSON(_: any): MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokensResponse;
+    toJSON(_: MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokensResponse): unknown;
+    fromPartial(_: DeepPartial<MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokensResponse>): MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokensResponse;
+};
+export declare const MsgLiquidateCollateralWithStablecoinAndInterestInCollateral: {
+    encode(message: MsgLiquidateCollateralWithStablecoinAndInterestInCollateral, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): MsgLiquidateCollateralWithStablecoinAndInterestInCollateral;
+    fromJSON(object: any): MsgLiquidateCollateralWithStablecoinAndInterestInCollateral;
+    toJSON(message: MsgLiquidateCollateralWithStablecoinAndInterestInCollateral): unknown;
+    fromPartial(object: DeepPartial<MsgLiquidateCollateralWithStablecoinAndInterestInCollateral>): MsgLiquidateCollateralWithStablecoinAndInterestInCollateral;
+};
+export declare const MsgLiquidateCollateralWithStablecoinAndInterestInCollateralResponse: {
+    encode(_: MsgLiquidateCollateralWithStablecoinAndInterestInCollateralResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number | undefined): MsgLiquidateCollateralWithStablecoinAndInterestInCollateralResponse;
+    fromJSON(_: any): MsgLiquidateCollateralWithStablecoinAndInterestInCollateralResponse;
+    toJSON(_: MsgLiquidateCollateralWithStablecoinAndInterestInCollateralResponse): unknown;
+    fromPartial(_: DeepPartial<MsgLiquidateCollateralWithStablecoinAndInterestInCollateralResponse>): MsgLiquidateCollateralWithStablecoinAndInterestInCollateralResponse;
+};
 /** Msg defines the Msg service. */
 export interface Msg {
     AddRateStrategy(request: MsgAddRateStrategy): Promise<MsgAddRateStrategyResponse>;
@@ -792,8 +844,10 @@ export interface Msg {
     SetStalePriceGracePeriod(request: MsgSetStalePriceGracePeriod): Promise<MsgSetStalePriceGracePeriodResponse>;
     SetCdpPaused(request: MsgSetCdpPaused): Promise<MsgSetCdpPausedResponse>;
     ReturnStablecoinWithInterestInCdpTokens(request: MsgReturnStablecoinWithInterestInCdpTokens): Promise<MsgReturnStablecoinWithInterestInCdpTokensResponse>;
-    /** this line is used by starport scaffolding # proto/tx/rpc */
     ReturnStablecoinWithInterestInCollateral(request: MsgReturnStablecoinWithInterestInCollateral): Promise<MsgReturnStablecoinWithInterestInCollateralResponse>;
+    LiquidateCollateralWithStablecoinAndInterestInCdpTokens(request: MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokens): Promise<MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokensResponse>;
+    /** this line is used by starport scaffolding # proto/tx/rpc */
+    LiquidateCollateralWithStablecoinAndInterestInCollateral(request: MsgLiquidateCollateralWithStablecoinAndInterestInCollateral): Promise<MsgLiquidateCollateralWithStablecoinAndInterestInCollateralResponse>;
 }
 export declare class MsgClientImpl implements Msg {
     private readonly rpc;
@@ -833,6 +887,8 @@ export declare class MsgClientImpl implements Msg {
     SetCdpPaused(request: MsgSetCdpPaused): Promise<MsgSetCdpPausedResponse>;
     ReturnStablecoinWithInterestInCdpTokens(request: MsgReturnStablecoinWithInterestInCdpTokens): Promise<MsgReturnStablecoinWithInterestInCdpTokensResponse>;
     ReturnStablecoinWithInterestInCollateral(request: MsgReturnStablecoinWithInterestInCollateral): Promise<MsgReturnStablecoinWithInterestInCollateralResponse>;
+    LiquidateCollateralWithStablecoinAndInterestInCdpTokens(request: MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokens): Promise<MsgLiquidateCollateralWithStablecoinAndInterestInCdpTokensResponse>;
+    LiquidateCollateralWithStablecoinAndInterestInCollateral(request: MsgLiquidateCollateralWithStablecoinAndInterestInCollateral): Promise<MsgLiquidateCollateralWithStablecoinAndInterestInCollateralResponse>;
 }
 interface Rpc {
     request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;