@kimafinance/kima-transaction-api 1.4.1 → 1.4.3

package/README.md

@@ -17,12 +17,13 @@ yarn add @kimafinance/kima-transaction-api
 
 ```ts
 import {
-  submitKimaTransaction,
+  submitKimaTransferTransaction,
+  submitKimaSwapTransaction,
   SupportNetworks,
   CurrencyOptions,
 } from "@kimafinance/kima-transaction-api";
 
-const txResult = await submitKimaTransaction({
+const txResult = await submitKimaTransferTransaction({
   originAddress: "0x1234123412341234123412341234123412341234",
   originChain: "ETH",
   originSymbol: "USDK",
@@ -44,11 +45,30 @@ const txResult = await submitKimaTransaction({
     transactionIdSignature: "", // optional: used to validate transaction idempotency
   }
 });
+
+
+const txResult = await submitKimaSwapTransaction({
+  originAddress: "0x1234123412341234123412341234123412341234",
+  originChain: "ETH",
+  originSymbol: "USDK",
+  targetAddress: "0x1234123412341234123412341234123412341234",
+  targetChain: "POL",
+  targetSymbol: "USDK",
+  amountIn: "100",
+  amountOut: "100",
+  fee: "0.3",
+  dex: "uniswap", // required to send empty strings for now
+  slippage: "0.05",
+  options: {
+    signature: "", // required: generated signature from the approval message
+    feeId: "", // required: id returned from calculated fee in fcs
+  }
+});
 ```
 
 ## Available Functions
 
-`submitKimaTransaction` : Submit a transaction to transfer liquidity from one change to another.
+`submitKimaTransferTransaction` : Submit a transaction to transfer liquidity from one change to another.
 
     - `originAddress`: sending address
     - `originChain`: sending chain
@@ -59,6 +79,20 @@ const txResult = await submitKimaTransaction({
     - `amount`: amount of token to transfer
     - `fee`: amount of token that kima consumes to pay gas fee for pulling & releasing token transactions
 
+`submitKimaSwapTransaction` : Submit a transaction to swap token from one chain to another.
+
+    - `originAddress`: sending address
+    - `originChain`: sending chain
+    - `originSymbol`: sending token symbol
+    - `targetAddress`: receiving address
+    - `targetChain`: receiving chain
+    - `targetSymbol`: receiving token symbol
+    - `amountIn`: amount of token to swap
+    - `amountOut`: expected amount of token to receive
+    - `fee`: amount of token that kima consumes to pay gas fee for pulling & swapping token transactions
+    - `dex`: the name of the dex that user wants to interact with (optional)
+    - `slippage`: maximum acceptable slippage parameter
+
 ## Environment Variables
 
 `KIMA_BACKEND_MNEMONIC` : Seed phrase of developer wallet. This wallet must have KIMA token to submit a transaction to kima chain.

package/build/index.d.ts

@@ -1,3 +1,6 @@
-export * from "./api/htlc-reclaim";
-export * from "./api/htlc-lock";
-export * from "./api/submit";
+import { RequestHtlcReclaimProps, RequestHtlcLockProps, RequestTransferTxProps, RequestSwapTxProps } from "./types";
+export declare function HtlcReclaim({ senderAddress, txHash, }: RequestHtlcReclaimProps): Promise<import("@cosmjs/stargate").DeliverTxResponse>;
+export declare function submitHtlcLock({ fromAddress, senderPubkey, amount, htlcTimeout, txHash, htlcAddress, }: RequestHtlcLockProps): Promise<import("@cosmjs/stargate").DeliverTxResponse>;
+export declare function getCreatorAddress(): Promise<import("@cosmjs/proto-signing").AccountData>;
+export declare function submitKimaTransferTransaction({ originChain, originAddress, targetChain, targetAddress, originSymbol, targetSymbol, amount, fee, htlcCreationHash, htlcCreationVout, htlcExpirationTimestamp, htlcVersion, senderPubKey, options, }: RequestTransferTxProps): Promise<import("@cosmjs/stargate").DeliverTxResponse>;
+export declare function submitKimaSwapTransaction({ originChain, originAddress, targetChain, targetAddress, originSymbol, targetSymbol, amountIn, amountOut, fee, dex, slippage, options, }: RequestSwapTxProps): Promise<import("@cosmjs/stargate").DeliverTxResponse>;

package/build/index.js

@@ -1,19 +1,93 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./api/htlc-reclaim"), exports);
-__exportStar(require("./api/htlc-lock"), exports);
-__exportStar(require("./api/submit"), exports);
+exports.submitKimaSwapTransaction = exports.submitKimaTransferTransaction = exports.getCreatorAddress = exports.submitHtlcLock = exports.HtlcReclaim = void 0;
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const common_1 = require("./kima/common");
+async function HtlcReclaim({ senderAddress, txHash, }) {
+    const wallet = await proto_signing_1.DirectSecp256k1HdWallet.fromMnemonic(process.env.KIMA_BACKEND_MNEMONIC, { prefix: "kima" });
+    const client = await (0, common_1.TxClient)(wallet);
+    const [firstAccount] = await wallet.getAccounts();
+    const params = {
+        creator: firstAccount.address,
+        senderAddress,
+        txHash,
+    };
+    let msg = await client.msgHtlcReclaim(params);
+    const result = await client.signAndBroadcast([msg]);
+    return result;
+}
+exports.HtlcReclaim = HtlcReclaim;
+async function submitHtlcLock({ fromAddress, senderPubkey, amount, htlcTimeout, txHash, htlcAddress, }) {
+    const wallet = await proto_signing_1.DirectSecp256k1HdWallet.fromMnemonic(process.env.KIMA_BACKEND_MNEMONIC, { prefix: "kima" });
+    const client = await (0, common_1.TxClient)(wallet);
+    const [firstAccount] = await wallet.getAccounts();
+    const params = {
+        creator: firstAccount.address,
+        fromAddress,
+        senderPubkey,
+        amount,
+        htlcTimeout,
+        htlcAddress,
+        txHash,
+    };
+    let msg = await client.msgRequestHtlcLock(params);
+    const result = await client.signAndBroadcast([msg]);
+    return result;
+}
+exports.submitHtlcLock = submitHtlcLock;
+async function getCreatorAddress() {
+    const wallet = await proto_signing_1.DirectSecp256k1HdWallet.fromMnemonic(process.env.KIMA_BACKEND_MNEMONIC, { prefix: "kima" });
+    const [firstAccount] = await wallet.getAccounts();
+    return firstAccount;
+}
+exports.getCreatorAddress = getCreatorAddress;
+async function submitKimaTransferTransaction({ originChain, originAddress, targetChain, targetAddress, originSymbol, targetSymbol, amount, fee, htlcCreationHash, htlcCreationVout = 0, htlcExpirationTimestamp, htlcVersion = "", senderPubKey, options, }) {
+    const wallet = await proto_signing_1.DirectSecp256k1HdWallet.fromMnemonic(process.env.KIMA_BACKEND_MNEMONIC, { prefix: "kima" });
+    const client = await (0, common_1.TxClient)(wallet);
+    const [firstAccount] = await wallet.getAccounts();
+    const params = {
+        creator: firstAccount.address,
+        originChain,
+        originAddress,
+        targetChain,
+        targetAddress,
+        originSymbol,
+        targetSymbol,
+        amount: amount,
+        fee: fee,
+        htlcCreationHash: htlcCreationHash || "",
+        htlcCreationVout: htlcCreationVout || 0,
+        htlcExpirationTimestamp: htlcExpirationTimestamp || "",
+        htlcVersion,
+        senderPubKey: senderPubKey || new Uint8Array(),
+        options,
+    };
+    const msgTx = await client.msgRequestTransaction(params);
+    const result = await client.signAndBroadcast([msgTx]);
+    return result;
+}
+exports.submitKimaTransferTransaction = submitKimaTransferTransaction;
+async function submitKimaSwapTransaction({ originChain, originAddress, targetChain, targetAddress, originSymbol, targetSymbol, amountIn, amountOut, fee, dex, slippage, options, }) {
+    const wallet = await proto_signing_1.DirectSecp256k1HdWallet.fromMnemonic(process.env.KIMA_BACKEND_MNEMONIC, { prefix: "kima" });
+    const client = await (0, common_1.TxClient)(wallet);
+    const [firstAccount] = await wallet.getAccounts();
+    const params = {
+        creator: firstAccount.address,
+        originChain,
+        originAddress,
+        targetChain,
+        targetAddress,
+        originSymbol,
+        targetSymbol,
+        amountIn: amountIn,
+        amountOut: amountOut,
+        fee: fee,
+        dex: dex,
+        slippage: slippage,
+        options: options,
+    };
+    const msgTx = await client.msgRequestSwapTransaction(params);
+    const result = await client.signAndBroadcast([msgTx]);
+    return result;
+}
+exports.submitKimaSwapTransaction = submitKimaSwapTransaction;

package/build/kima/common.d.ts

@@ -1,8 +1,6 @@
 import { Registry, OfflineSigner, EncodeObject } from "@cosmjs/proto-signing";
-import { MsgRequestTransaction } from "./tx/request";
-import { MsgRequestHtlcLock } from "./tx/htlc-lock";
-import { MsgSetTxHash } from "./tx/set-hash";
-import { MsgHtlcReclaim } from "./tx/htlc-reclaim";
+import { MsgRequestHtlcLock, MsgRequestTransaction, MsgSetTxHash, MsgHtlcReclaim } from "./transfer_tx";
+import { MsgRequestSwapTransaction } from "./swap_tx";
 export declare const registry: Registry;
 export declare const TxClient: (wallet: OfflineSigner) => Promise<{
     signAndBroadcast: (msgs: EncodeObject[]) => Promise<import("@cosmjs/stargate").DeliverTxResponse>;
@@ -10,4 +8,5 @@ export declare const TxClient: (wallet: OfflineSigner) => Promise<{
     msgRequestHtlcLock: (data: MsgRequestHtlcLock) => EncodeObject;
     msgSetTxHash: (data: MsgSetTxHash) => EncodeObject;
     msgHtlcReclaim: (data: MsgHtlcReclaim) => EncodeObject;
+    msgRequestSwapTransaction: (data: MsgRequestSwapTransaction) => EncodeObject;
 }>;

package/build/kima/common.js

@@ -7,20 +7,19 @@ exports.TxClient = exports.registry = void 0;
 const stargate_1 = require("@cosmjs/stargate");
 const dotenv_1 = __importDefault(require("dotenv"));
 const proto_signing_1 = require("@cosmjs/proto-signing");
-const request_1 = require("./tx/request");
-const htlc_lock_1 = require("./tx/htlc-lock");
-const set_hash_1 = require("./tx/set-hash");
-const htlc_reclaim_1 = require("./tx/htlc-reclaim");
+const transfer_tx_1 = require("./transfer_tx");
+const swap_tx_1 = require("./swap_tx");
 dotenv_1.default.config();
 const defaultFee = {
     amount: [(0, proto_signing_1.coin)(200, "uKIMA")],
     gas: "200000", // Gas limit
 };
 const types = [
-    ["/kimablockchain.transaction.MsgRequestTransaction", request_1.MsgRequestTransaction],
-    ["/kimablockchain.transaction.MsgRequestHtlcLock", htlc_lock_1.MsgRequestHtlcLock],
-    ["/kimablockchain.transaction.MsgSetTxHash", set_hash_1.MsgSetTxHash],
-    ["/kimablockchain.transaction.MsgHtlcReclaim", htlc_reclaim_1.MsgHtlcReclaim],
+    ["/kimablockchain.transaction.MsgRequestTransaction", transfer_tx_1.MsgRequestTransaction],
+    ["/kimablockchain.transaction.MsgRequestHtlcLock", transfer_tx_1.MsgRequestHtlcLock],
+    ["/kimablockchain.transaction.MsgSetTxHash", transfer_tx_1.MsgSetTxHash],
+    ["/kimablockchain.transaction.MsgHtlcReclaim", transfer_tx_1.MsgHtlcReclaim],
+    ["/kimablockchain.swap.MsgRequestSwapTransaction", swap_tx_1.MsgRequestSwapTransaction],
 ];
 exports.registry = new proto_signing_1.Registry(types);
 const TxClient = async (wallet) => {
@@ -33,19 +32,23 @@ const TxClient = async (wallet) => {
         },
         msgRequestTransaction: (data) => ({
             typeUrl: "/kimablockchain.transaction.MsgRequestTransaction",
-            value: request_1.MsgRequestTransaction.fromPartial(data),
+            value: transfer_tx_1.MsgRequestTransaction.fromPartial(data),
         }),
         msgRequestHtlcLock: (data) => ({
             typeUrl: "/kimablockchain.transaction.MsgRequestHtlcLock",
-            value: htlc_lock_1.MsgRequestHtlcLock.fromPartial(data),
+            value: transfer_tx_1.MsgRequestHtlcLock.fromPartial(data),
         }),
         msgSetTxHash: (data) => ({
             typeUrl: "/kimablockchain.transaction.MsgSetTxHash",
-            value: set_hash_1.MsgSetTxHash.fromPartial(data),
+            value: transfer_tx_1.MsgSetTxHash.fromPartial(data),
         }),
         msgHtlcReclaim: (data) => ({
             typeUrl: "/kimablockchain.transaction.MsgHtlcReclaim",
-            value: htlc_reclaim_1.MsgHtlcReclaim.fromPartial(data),
+            value: transfer_tx_1.MsgHtlcReclaim.fromPartial(data),
+        }),
+        msgRequestSwapTransaction: (data) => ({
+            typeUrl: "/kimablockchain.swap.MsgRequestSwapTransaction",
+            value: swap_tx_1.MsgRequestSwapTransaction.fromPartial(data),
         }),
     };
 };

package/build/kima/swap_tx.d.ts

@@ -0,0 +1,387 @@
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "kimablockchain.swap";
+export interface MsgRequestSwapTransaction {
+    creator: string;
+    /** the origin chain of the swap transaction */
+    originChain: string;
+    /** the origin address of the swap transaction */
+    originAddress: string;
+    /** the target chain of the swap transaction */
+    targetChain: string;
+    /** the target address of the swap transaction */
+    targetAddress: string;
+    /** the origin symbol of the swap transaction */
+    originSymbol: string;
+    /** the target symbol of the swap transaction */
+    targetSymbol: string;
+    /** the amount in of the swap transaction */
+    amountIn: string;
+    /** the amount out of the swap transaction */
+    amountOut: string;
+    /** the fee of the swap transaction */
+    fee: string;
+    /** the dex of the swap transaction */
+    dex: string;
+    /** the slippage of the swap transaction */
+    slippage: string;
+    /** the options of the swap transaction */
+    options: string;
+}
+export interface MsgRequestSwapTransactionResponse {
+    code: string;
+    msg: string;
+    txId: number;
+}
+export interface MsgSetTxToProcess {
+    creator: string;
+    txId: number;
+    timestamp: number;
+    msgId: string;
+    handleId: number;
+    /** swap transaction type */
+    txType: string;
+    /** the fee id for the transaction */
+    feeId: string;
+    /** the origin gas fee of the transaction */
+    originGasFee: string;
+    /** the target gas fee of the transaction */
+    targetGasFee: string;
+    /** the kima processing fee of the transaction */
+    kimaProcessingFee: string;
+    /** the total fee of the transaction */
+    totalFee: string;
+    /** the pegged to of the transaction */
+    peggedTo: string;
+    /** the expiration of the transaction */
+    expiration: number;
+}
+export interface MsgSetTxToProcessResponse {
+    code: string;
+    msg: string;
+}
+export interface MsgFinalizeSwapTransaction {
+    creator: string;
+    txId: number;
+    txHash: string;
+    success: boolean;
+    errReason: string;
+    tssMsgId: string;
+    /** request_swap, request_swap_refund */
+    txType: string;
+    /** pull, release, refund */
+    payType: string;
+}
+export interface MsgFinalizeSwapTransactionResponse {
+    code: string;
+    msg: string;
+}
+export interface MsgSwapObserveVote {
+    creator: string;
+    txHash: string;
+    chainId: string;
+    tokenSymbol: string;
+    from: string;
+    to: string;
+    amount: string;
+    payType: string;
+    kimaTxId: number;
+    tssMsgId: string;
+    txType: string;
+    succeed: boolean;
+    failReason: string;
+    reserved: string;
+}
+export interface MsgSwapObserveVoteResponse {
+    code: string;
+    msg: string;
+}
+export interface MsgCleanPendingSwapTransaction {
+    creator: string;
+}
+export interface MsgCleanPendingSwapTransactionResponse {
+    code: string;
+    msg: string;
+}
+export interface MsgUpdateSwapTransactionStatus {
+    creator: string;
+    txId: string;
+    status: string;
+    reason: string;
+}
+export interface MsgUpdateSwapTransactionStatusResponse {
+    code: string;
+    msg: string;
+}
+export declare const MsgRequestSwapTransaction: {
+    encode(message: MsgRequestSwapTransaction, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgRequestSwapTransaction;
+    fromJSON(object: any): MsgRequestSwapTransaction;
+    toJSON(message: MsgRequestSwapTransaction): unknown;
+    fromPartial<I extends {
+        creator?: string | undefined;
+        originChain?: string | undefined;
+        originAddress?: string | undefined;
+        targetChain?: string | undefined;
+        targetAddress?: string | undefined;
+        originSymbol?: string | undefined;
+        targetSymbol?: string | undefined;
+        amountIn?: string | undefined;
+        amountOut?: string | undefined;
+        fee?: string | undefined;
+        dex?: string | undefined;
+        slippage?: string | undefined;
+        options?: string | undefined;
+    } & {
+        creator?: string | undefined;
+        originChain?: string | undefined;
+        originAddress?: string | undefined;
+        targetChain?: string | undefined;
+        targetAddress?: string | undefined;
+        originSymbol?: string | undefined;
+        targetSymbol?: string | undefined;
+        amountIn?: string | undefined;
+        amountOut?: string | undefined;
+        fee?: string | undefined;
+        dex?: string | undefined;
+        slippage?: string | undefined;
+        options?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgRequestSwapTransaction>]: never; }>(object: I): MsgRequestSwapTransaction;
+};
+export declare const MsgRequestSwapTransactionResponse: {
+    encode(message: MsgRequestSwapTransactionResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgRequestSwapTransactionResponse;
+    fromJSON(object: any): MsgRequestSwapTransactionResponse;
+    toJSON(message: MsgRequestSwapTransactionResponse): unknown;
+    fromPartial<I extends {
+        code?: string | undefined;
+        msg?: string | undefined;
+        txId?: number | undefined;
+    } & {
+        code?: string | undefined;
+        msg?: string | undefined;
+        txId?: number | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgRequestSwapTransactionResponse>]: never; }>(object: I): MsgRequestSwapTransactionResponse;
+};
+export declare const MsgSetTxToProcess: {
+    encode(message: MsgSetTxToProcess, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetTxToProcess;
+    fromJSON(object: any): MsgSetTxToProcess;
+    toJSON(message: MsgSetTxToProcess): unknown;
+    fromPartial<I extends {
+        creator?: string | undefined;
+        txId?: number | undefined;
+        timestamp?: number | undefined;
+        msgId?: string | undefined;
+        handleId?: number | undefined;
+        txType?: string | undefined;
+        feeId?: string | undefined;
+        originGasFee?: string | undefined;
+        targetGasFee?: string | undefined;
+        kimaProcessingFee?: string | undefined;
+        totalFee?: string | undefined;
+        peggedTo?: string | undefined;
+        expiration?: number | undefined;
+    } & {
+        creator?: string | undefined;
+        txId?: number | undefined;
+        timestamp?: number | undefined;
+        msgId?: string | undefined;
+        handleId?: number | undefined;
+        txType?: string | undefined;
+        feeId?: string | undefined;
+        originGasFee?: string | undefined;
+        targetGasFee?: string | undefined;
+        kimaProcessingFee?: string | undefined;
+        totalFee?: string | undefined;
+        peggedTo?: string | undefined;
+        expiration?: number | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgSetTxToProcess>]: never; }>(object: I): MsgSetTxToProcess;
+};
+export declare const MsgSetTxToProcessResponse: {
+    encode(message: MsgSetTxToProcessResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetTxToProcessResponse;
+    fromJSON(object: any): MsgSetTxToProcessResponse;
+    toJSON(message: MsgSetTxToProcessResponse): unknown;
+    fromPartial<I extends {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgSetTxToProcessResponse>]: never; }>(object: I): MsgSetTxToProcessResponse;
+};
+export declare const MsgFinalizeSwapTransaction: {
+    encode(message: MsgFinalizeSwapTransaction, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgFinalizeSwapTransaction;
+    fromJSON(object: any): MsgFinalizeSwapTransaction;
+    toJSON(message: MsgFinalizeSwapTransaction): unknown;
+    fromPartial<I extends {
+        creator?: string | undefined;
+        txId?: number | undefined;
+        txHash?: string | undefined;
+        success?: boolean | undefined;
+        errReason?: string | undefined;
+        tssMsgId?: string | undefined;
+        txType?: string | undefined;
+        payType?: string | undefined;
+    } & {
+        creator?: string | undefined;
+        txId?: number | undefined;
+        txHash?: string | undefined;
+        success?: boolean | undefined;
+        errReason?: string | undefined;
+        tssMsgId?: string | undefined;
+        txType?: string | undefined;
+        payType?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgFinalizeSwapTransaction>]: never; }>(object: I): MsgFinalizeSwapTransaction;
+};
+export declare const MsgFinalizeSwapTransactionResponse: {
+    encode(message: MsgFinalizeSwapTransactionResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgFinalizeSwapTransactionResponse;
+    fromJSON(object: any): MsgFinalizeSwapTransactionResponse;
+    toJSON(message: MsgFinalizeSwapTransactionResponse): unknown;
+    fromPartial<I extends {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgFinalizeSwapTransactionResponse>]: never; }>(object: I): MsgFinalizeSwapTransactionResponse;
+};
+export declare const MsgSwapObserveVote: {
+    encode(message: MsgSwapObserveVote, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSwapObserveVote;
+    fromJSON(object: any): MsgSwapObserveVote;
+    toJSON(message: MsgSwapObserveVote): unknown;
+    fromPartial<I extends {
+        creator?: string | undefined;
+        txHash?: string | undefined;
+        chainId?: string | undefined;
+        tokenSymbol?: string | undefined;
+        from?: string | undefined;
+        to?: string | undefined;
+        amount?: string | undefined;
+        payType?: string | undefined;
+        kimaTxId?: number | undefined;
+        tssMsgId?: string | undefined;
+        txType?: string | undefined;
+        succeed?: boolean | undefined;
+        failReason?: string | undefined;
+        reserved?: string | undefined;
+    } & {
+        creator?: string | undefined;
+        txHash?: string | undefined;
+        chainId?: string | undefined;
+        tokenSymbol?: string | undefined;
+        from?: string | undefined;
+        to?: string | undefined;
+        amount?: string | undefined;
+        payType?: string | undefined;
+        kimaTxId?: number | undefined;
+        tssMsgId?: string | undefined;
+        txType?: string | undefined;
+        succeed?: boolean | undefined;
+        failReason?: string | undefined;
+        reserved?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgSwapObserveVote>]: never; }>(object: I): MsgSwapObserveVote;
+};
+export declare const MsgSwapObserveVoteResponse: {
+    encode(message: MsgSwapObserveVoteResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSwapObserveVoteResponse;
+    fromJSON(object: any): MsgSwapObserveVoteResponse;
+    toJSON(message: MsgSwapObserveVoteResponse): unknown;
+    fromPartial<I extends {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgSwapObserveVoteResponse>]: never; }>(object: I): MsgSwapObserveVoteResponse;
+};
+export declare const MsgCleanPendingSwapTransaction: {
+    encode(message: MsgCleanPendingSwapTransaction, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCleanPendingSwapTransaction;
+    fromJSON(object: any): MsgCleanPendingSwapTransaction;
+    toJSON(message: MsgCleanPendingSwapTransaction): unknown;
+    fromPartial<I extends {
+        creator?: string | undefined;
+    } & {
+        creator?: string | undefined;
+    } & { [K in Exclude<keyof I, "creator">]: never; }>(object: I): MsgCleanPendingSwapTransaction;
+};
+export declare const MsgCleanPendingSwapTransactionResponse: {
+    encode(message: MsgCleanPendingSwapTransactionResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCleanPendingSwapTransactionResponse;
+    fromJSON(object: any): MsgCleanPendingSwapTransactionResponse;
+    toJSON(message: MsgCleanPendingSwapTransactionResponse): unknown;
+    fromPartial<I extends {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgCleanPendingSwapTransactionResponse>]: never; }>(object: I): MsgCleanPendingSwapTransactionResponse;
+};
+export declare const MsgUpdateSwapTransactionStatus: {
+    encode(message: MsgUpdateSwapTransactionStatus, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateSwapTransactionStatus;
+    fromJSON(object: any): MsgUpdateSwapTransactionStatus;
+    toJSON(message: MsgUpdateSwapTransactionStatus): unknown;
+    fromPartial<I extends {
+        creator?: string | undefined;
+        txId?: string | undefined;
+        status?: string | undefined;
+        reason?: string | undefined;
+    } & {
+        creator?: string | undefined;
+        txId?: string | undefined;
+        status?: string | undefined;
+        reason?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgUpdateSwapTransactionStatus>]: never; }>(object: I): MsgUpdateSwapTransactionStatus;
+};
+export declare const MsgUpdateSwapTransactionStatusResponse: {
+    encode(message: MsgUpdateSwapTransactionStatusResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateSwapTransactionStatusResponse;
+    fromJSON(object: any): MsgUpdateSwapTransactionStatusResponse;
+    toJSON(message: MsgUpdateSwapTransactionStatusResponse): unknown;
+    fromPartial<I extends {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgUpdateSwapTransactionStatusResponse>]: never; }>(object: I): MsgUpdateSwapTransactionStatusResponse;
+};
+/** Msg defines the Msg service. */
+export interface Msg {
+    RequestSwapTransaction(request: MsgRequestSwapTransaction): Promise<MsgRequestSwapTransactionResponse>;
+    SetTxToProcess(request: MsgSetTxToProcess): Promise<MsgSetTxToProcessResponse>;
+    FinalizeSwapTransaction(request: MsgFinalizeSwapTransaction): Promise<MsgFinalizeSwapTransactionResponse>;
+    SwapObserveVote(request: MsgSwapObserveVote): Promise<MsgSwapObserveVoteResponse>;
+    CleanPendingSwapTransaction(request: MsgCleanPendingSwapTransaction): Promise<MsgCleanPendingSwapTransactionResponse>;
+    UpdateSwapTransactionStatus(request: MsgUpdateSwapTransactionStatus): Promise<MsgUpdateSwapTransactionStatusResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    RequestSwapTransaction(request: MsgRequestSwapTransaction): Promise<MsgRequestSwapTransactionResponse>;
+    SetTxToProcess(request: MsgSetTxToProcess): Promise<MsgSetTxToProcessResponse>;
+    FinalizeSwapTransaction(request: MsgFinalizeSwapTransaction): Promise<MsgFinalizeSwapTransactionResponse>;
+    SwapObserveVote(request: MsgSwapObserveVote): Promise<MsgSwapObserveVoteResponse>;
+    CleanPendingSwapTransaction(request: MsgCleanPendingSwapTransaction): Promise<MsgCleanPendingSwapTransactionResponse>;
+    UpdateSwapTransactionStatus(request: MsgUpdateSwapTransactionStatus): Promise<MsgUpdateSwapTransactionStatusResponse>;
+}
+interface Rpc {
+    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : 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>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};