@kimafinance/kima-transaction-api 1.0.20-beta.1 → 1.0.22-beta.1

package/.github/workflows/dev_auto_publish_npm.yml

@@ -6,6 +6,9 @@ on:
 jobs:
   build:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
 
     steps:
       - uses: actions/checkout@v2
@@ -22,7 +25,8 @@ jobs:
         run: |
 
           npm install
-          npm publish
+          npm start
+          npm publish --provenance
 
         env:
           NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/build/index.d.ts

@@ -0,0 +1,28 @@
+export declare enum SupportedNetworks {
+    ETHEREUM = "ETH",
+    POLYGON = "POL",
+    AVALANCHE = "AVX",
+    SOLANA = "SOL",
+    FUSE = "FUS",
+    CELO = "CEL",
+    BSC = "BSC",
+    ARBITRIUM = "ARB",
+    OPTIMISM = "OPT",
+    POLYGON_ZKEVM = "ZKE"
+}
+export declare enum CurrencyOptions {
+    USDT = "USDT",
+    USDC = "USDC",
+    USDK = "USDK"
+}
+interface Props {
+    originChain: SupportedNetworks;
+    originAddress: string;
+    targetChain: SupportedNetworks;
+    targetAddress: string;
+    symbol: CurrencyOptions;
+    amount: number;
+    fee: number;
+}
+export declare function submitKimaTransaction({ originChain, originAddress, targetChain, targetAddress, symbol, amount, fee, }: Props): Promise<import("@cosmjs/stargate").DeliverTxResponse>;
+export {};

package/build/index.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitKimaTransaction = exports.CurrencyOptions = exports.SupportedNetworks = void 0;
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const common_1 = require("./kima/common");
+var SupportedNetworks;
+(function (SupportedNetworks) {
+    SupportedNetworks["ETHEREUM"] = "ETH";
+    SupportedNetworks["POLYGON"] = "POL";
+    SupportedNetworks["AVALANCHE"] = "AVX";
+    SupportedNetworks["SOLANA"] = "SOL";
+    SupportedNetworks["FUSE"] = "FUS";
+    SupportedNetworks["CELO"] = "CEL";
+    SupportedNetworks["BSC"] = "BSC";
+    SupportedNetworks["ARBITRIUM"] = "ARB";
+    SupportedNetworks["OPTIMISM"] = "OPT";
+    SupportedNetworks["POLYGON_ZKEVM"] = "ZKE";
+})(SupportedNetworks = exports.SupportedNetworks || (exports.SupportedNetworks = {}));
+var CurrencyOptions;
+(function (CurrencyOptions) {
+    CurrencyOptions["USDT"] = "USDT";
+    CurrencyOptions["USDC"] = "USDC";
+    CurrencyOptions["USDK"] = "USDK";
+})(CurrencyOptions = exports.CurrencyOptions || (exports.CurrencyOptions = {}));
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function submitKimaTransaction({ originChain, originAddress, targetChain, targetAddress, symbol, amount, fee, }) {
+    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,
+        symbol,
+        amount: amount.toString(),
+        fee: fee.toString(),
+    };
+    let msg = await client.msgRequestTransaction(params);
+    const result = await client.signAndBroadcast([msg]);
+    let txId = 1;
+    for (const event of result.events) {
+        if (event.type === "transaction_requested") {
+            for (const attr of event.attributes) {
+                if (attr.key === "txId") {
+                    txId = +attr.value;
+                }
+            }
+        }
+    }
+    msg = await client.msgSetTxHash({
+        creator: firstAccount.address,
+        txId,
+        txHash: result.transactionHash,
+    });
+    console.log(msg);
+    let hashResult;
+    do {
+        hashResult = await client.signAndBroadcast([msg]);
+        await sleep(1000);
+    } while (hashResult.code !== 0);
+    return result;
+}
+exports.submitKimaTransaction = submitKimaTransaction;

package/build/kima/common.d.ts

@@ -0,0 +1,14 @@
+import { StdFee } from "@cosmjs/stargate";
+import { Registry, OfflineSigner, EncodeObject } from "@cosmjs/proto-signing";
+import { MsgRequestTransaction, MsgSetTxHash } from "./tx";
+interface SignAndBroadcastOptions {
+    fee: StdFee;
+    memo?: string;
+}
+export declare const registry: Registry;
+export declare const TxClient: (wallet: OfflineSigner) => Promise<{
+    signAndBroadcast: (msgs: EncodeObject[], { fee, memo }?: SignAndBroadcastOptions) => Promise<import("@cosmjs/stargate").DeliverTxResponse>;
+    msgRequestTransaction: (data: MsgRequestTransaction) => EncodeObject;
+    msgSetTxHash: (data: MsgSetTxHash) => EncodeObject;
+}>;
+export {};

package/build/kima/common.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 tx_1 = require("./tx");
+dotenv_1.default.config();
+const defaultFee = {
+    amount: [],
+    gas: "2000000",
+};
+const types = [
+    ["/kimablockchain.transaction.MsgRequestTransaction", tx_1.MsgRequestTransaction],
+    ["/kimablockchain.transaction.MsgSetTxHash", tx_1.MsgSetTxHash],
+];
+exports.registry = new proto_signing_1.Registry(types);
+const TxClient = async (wallet) => {
+    const client = await stargate_1.SigningStargateClient.connectWithSigner(process.env.KIMA_BACKEND_NODE_PROVIDER, wallet, { registry: exports.registry });
+    const { address } = (await wallet.getAccounts())[0];
+    return {
+        signAndBroadcast: (msgs, { fee, memo } = { fee: defaultFee, memo: "" }) => client.signAndBroadcast(address, msgs, fee, memo),
+        msgRequestTransaction: (data) => ({
+            typeUrl: "/kimablockchain.transaction.MsgRequestTransaction",
+            value: tx_1.MsgRequestTransaction.fromPartial(data),
+        }),
+        msgSetTxHash: (data) => ({
+            typeUrl: "/kimablockchain.transaction.MsgSetTxHash",
+            value: tx_1.MsgSetTxHash.fromPartial(data),
+        }),
+    };
+};
+exports.TxClient = TxClient;

package/build/kima/tx.d.ts

@@ -0,0 +1,426 @@
+import _m0 from "protobufjs/minimal";
+export declare const protobufPackage = "kimablockchain.transaction";
+export interface MsgRequestTransaction {
+    creator: string;
+    originChain: string;
+    originAddress: string;
+    targetChain: string;
+    targetAddress: string;
+    symbol: string;
+    amount: string;
+    fee: string;
+}
+export interface MsgRequestTransactionResponse {
+    code: string;
+    msg: string;
+    txId: number;
+}
+export interface MsgFinalizeTransaction {
+    creator: string;
+    txId: number;
+    txHash: string;
+    success: string;
+    signedKey: string;
+}
+export interface MsgFinalizeTransactionResponse {
+    code: string;
+    msg: string;
+}
+export interface MsgFinalizeProvisionTransaction {
+    creator: string;
+    txId: number;
+    txHash: string;
+    success: string;
+    signedKey: string;
+}
+export interface MsgFinalizeProvisionTransactionResponse {
+    code: string;
+    msg: string;
+}
+export interface MsgRequestProvisionTransaction {
+    creator: string;
+    chain: string;
+    fromAddress: string;
+    symbol: string;
+    amount: string;
+    options: string;
+}
+export interface MsgRequestProvisionTransactionResponse {
+    code: string;
+    msg: string;
+    txId: number;
+}
+export interface MsgCancelTransaction {
+    creator: string;
+    transactionId: string;
+}
+export interface MsgCancelTransactionResponse {
+    code: string;
+    msg: string;
+}
+export interface MsgSetTxHash {
+    creator: string;
+    txId: number;
+    txHash: string;
+}
+export interface MsgSetTxHashResponse {
+    code: string;
+    msg: string;
+}
+export interface MsgSetTxProcess {
+    creator: string;
+    txId: number;
+    timestamp: number;
+    msgId: string;
+}
+export interface MsgSetTxProcessResponse {
+}
+export interface MsgRequestDrainTransaction {
+    creator: string;
+    toChain: string;
+    toAddress: string;
+    symbol: string;
+    amount: string;
+    options: string;
+}
+export interface MsgRequestDrainTransactionResponse {
+    code: string;
+    msg: string;
+    txId: number;
+}
+export interface MsgFinalizeDrainTransaction {
+    creator: string;
+    txId: number;
+    txHash: string;
+    success: string;
+    signedKey: string;
+}
+export interface MsgFinalizeDrainTransactionResponse {
+    code: string;
+    msg: string;
+}
+export declare const MsgRequestTransaction: {
+    encode(message: MsgRequestTransaction, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgRequestTransaction;
+    fromJSON(object: any): MsgRequestTransaction;
+    toJSON(message: MsgRequestTransaction): unknown;
+    fromPartial<I extends {
+        creator?: string | undefined;
+        originChain?: string | undefined;
+        originAddress?: string | undefined;
+        targetChain?: string | undefined;
+        targetAddress?: string | undefined;
+        symbol?: string | undefined;
+        amount?: string | undefined;
+        fee?: string | undefined;
+    } & {
+        creator?: string | undefined;
+        originChain?: string | undefined;
+        originAddress?: string | undefined;
+        targetChain?: string | undefined;
+        targetAddress?: string | undefined;
+        symbol?: string | undefined;
+        amount?: string | undefined;
+        fee?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgRequestTransaction>]: never; }>(object: I): MsgRequestTransaction;
+};
+export declare const MsgRequestTransactionResponse: {
+    encode(message: MsgRequestTransactionResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgRequestTransactionResponse;
+    fromJSON(object: any): MsgRequestTransactionResponse;
+    toJSON(message: MsgRequestTransactionResponse): 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 MsgRequestTransactionResponse>]: never; }>(object: I): MsgRequestTransactionResponse;
+};
+export declare const MsgFinalizeTransaction: {
+    encode(message: MsgFinalizeTransaction, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgFinalizeTransaction;
+    fromJSON(object: any): MsgFinalizeTransaction;
+    toJSON(message: MsgFinalizeTransaction): unknown;
+    fromPartial<I extends {
+        creator?: string | undefined;
+        txId?: number | undefined;
+        txHash?: string | undefined;
+        success?: string | undefined;
+        signedKey?: string | undefined;
+    } & {
+        creator?: string | undefined;
+        txId?: number | undefined;
+        txHash?: string | undefined;
+        success?: string | undefined;
+        signedKey?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgFinalizeTransaction>]: never; }>(object: I): MsgFinalizeTransaction;
+};
+export declare const MsgFinalizeTransactionResponse: {
+    encode(message: MsgFinalizeTransactionResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgFinalizeTransactionResponse;
+    fromJSON(object: any): MsgFinalizeTransactionResponse;
+    toJSON(message: MsgFinalizeTransactionResponse): unknown;
+    fromPartial<I extends {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgFinalizeTransactionResponse>]: never; }>(object: I): MsgFinalizeTransactionResponse;
+};
+export declare const MsgFinalizeProvisionTransaction: {
+    encode(message: MsgFinalizeProvisionTransaction, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgFinalizeProvisionTransaction;
+    fromJSON(object: any): MsgFinalizeProvisionTransaction;
+    toJSON(message: MsgFinalizeProvisionTransaction): unknown;
+    fromPartial<I extends {
+        creator?: string | undefined;
+        txId?: number | undefined;
+        txHash?: string | undefined;
+        success?: string | undefined;
+        signedKey?: string | undefined;
+    } & {
+        creator?: string | undefined;
+        txId?: number | undefined;
+        txHash?: string | undefined;
+        success?: string | undefined;
+        signedKey?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgFinalizeProvisionTransaction>]: never; }>(object: I): MsgFinalizeProvisionTransaction;
+};
+export declare const MsgFinalizeProvisionTransactionResponse: {
+    encode(message: MsgFinalizeProvisionTransactionResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgFinalizeProvisionTransactionResponse;
+    fromJSON(object: any): MsgFinalizeProvisionTransactionResponse;
+    toJSON(message: MsgFinalizeProvisionTransactionResponse): unknown;
+    fromPartial<I extends {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgFinalizeProvisionTransactionResponse>]: never; }>(object: I): MsgFinalizeProvisionTransactionResponse;
+};
+export declare const MsgRequestProvisionTransaction: {
+    encode(message: MsgRequestProvisionTransaction, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgRequestProvisionTransaction;
+    fromJSON(object: any): MsgRequestProvisionTransaction;
+    toJSON(message: MsgRequestProvisionTransaction): unknown;
+    fromPartial<I extends {
+        creator?: string | undefined;
+        chain?: string | undefined;
+        fromAddress?: string | undefined;
+        symbol?: string | undefined;
+        amount?: string | undefined;
+        options?: string | undefined;
+    } & {
+        creator?: string | undefined;
+        chain?: string | undefined;
+        fromAddress?: string | undefined;
+        symbol?: string | undefined;
+        amount?: string | undefined;
+        options?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgRequestProvisionTransaction>]: never; }>(object: I): MsgRequestProvisionTransaction;
+};
+export declare const MsgRequestProvisionTransactionResponse: {
+    encode(message: MsgRequestProvisionTransactionResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgRequestProvisionTransactionResponse;
+    fromJSON(object: any): MsgRequestProvisionTransactionResponse;
+    toJSON(message: MsgRequestProvisionTransactionResponse): 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 MsgRequestProvisionTransactionResponse>]: never; }>(object: I): MsgRequestProvisionTransactionResponse;
+};
+export declare const MsgCancelTransaction: {
+    encode(message: MsgCancelTransaction, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCancelTransaction;
+    fromJSON(object: any): MsgCancelTransaction;
+    toJSON(message: MsgCancelTransaction): unknown;
+    fromPartial<I extends {
+        creator?: string | undefined;
+        transactionId?: string | undefined;
+    } & {
+        creator?: string | undefined;
+        transactionId?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgCancelTransaction>]: never; }>(object: I): MsgCancelTransaction;
+};
+export declare const MsgCancelTransactionResponse: {
+    encode(message: MsgCancelTransactionResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCancelTransactionResponse;
+    fromJSON(object: any): MsgCancelTransactionResponse;
+    toJSON(message: MsgCancelTransactionResponse): unknown;
+    fromPartial<I extends {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgCancelTransactionResponse>]: never; }>(object: I): MsgCancelTransactionResponse;
+};
+export declare const MsgSetTxHash: {
+    encode(message: MsgSetTxHash, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetTxHash;
+    fromJSON(object: any): MsgSetTxHash;
+    toJSON(message: MsgSetTxHash): unknown;
+    fromPartial<I extends {
+        creator?: string | undefined;
+        txId?: number | undefined;
+        txHash?: string | undefined;
+    } & {
+        creator?: string | undefined;
+        txId?: number | undefined;
+        txHash?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgSetTxHash>]: never; }>(object: I): MsgSetTxHash;
+};
+export declare const MsgSetTxHashResponse: {
+    encode(message: MsgSetTxHashResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetTxHashResponse;
+    fromJSON(object: any): MsgSetTxHashResponse;
+    toJSON(message: MsgSetTxHashResponse): unknown;
+    fromPartial<I extends {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgSetTxHashResponse>]: never; }>(object: I): MsgSetTxHashResponse;
+};
+export declare const MsgSetTxProcess: {
+    encode(message: MsgSetTxProcess, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetTxProcess;
+    fromJSON(object: any): MsgSetTxProcess;
+    toJSON(message: MsgSetTxProcess): unknown;
+    fromPartial<I extends {
+        creator?: string | undefined;
+        txId?: number | undefined;
+        timestamp?: number | undefined;
+        msgId?: string | undefined;
+    } & {
+        creator?: string | undefined;
+        txId?: number | undefined;
+        timestamp?: number | undefined;
+        msgId?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgSetTxProcess>]: never; }>(object: I): MsgSetTxProcess;
+};
+export declare const MsgSetTxProcessResponse: {
+    encode(_: MsgSetTxProcessResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgSetTxProcessResponse;
+    fromJSON(_: any): MsgSetTxProcessResponse;
+    toJSON(_: MsgSetTxProcessResponse): unknown;
+    fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): MsgSetTxProcessResponse;
+};
+export declare const MsgRequestDrainTransaction: {
+    encode(message: MsgRequestDrainTransaction, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgRequestDrainTransaction;
+    fromJSON(object: any): MsgRequestDrainTransaction;
+    toJSON(message: MsgRequestDrainTransaction): unknown;
+    fromPartial<I extends {
+        creator?: string | undefined;
+        toChain?: string | undefined;
+        toAddress?: string | undefined;
+        symbol?: string | undefined;
+        amount?: string | undefined;
+        options?: string | undefined;
+    } & {
+        creator?: string | undefined;
+        toChain?: string | undefined;
+        toAddress?: string | undefined;
+        symbol?: string | undefined;
+        amount?: string | undefined;
+        options?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgRequestDrainTransaction>]: never; }>(object: I): MsgRequestDrainTransaction;
+};
+export declare const MsgRequestDrainTransactionResponse: {
+    encode(message: MsgRequestDrainTransactionResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgRequestDrainTransactionResponse;
+    fromJSON(object: any): MsgRequestDrainTransactionResponse;
+    toJSON(message: MsgRequestDrainTransactionResponse): 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 MsgRequestDrainTransactionResponse>]: never; }>(object: I): MsgRequestDrainTransactionResponse;
+};
+export declare const MsgFinalizeDrainTransaction: {
+    encode(message: MsgFinalizeDrainTransaction, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgFinalizeDrainTransaction;
+    fromJSON(object: any): MsgFinalizeDrainTransaction;
+    toJSON(message: MsgFinalizeDrainTransaction): unknown;
+    fromPartial<I extends {
+        creator?: string | undefined;
+        txId?: number | undefined;
+        txHash?: string | undefined;
+        success?: string | undefined;
+        signedKey?: string | undefined;
+    } & {
+        creator?: string | undefined;
+        txId?: number | undefined;
+        txHash?: string | undefined;
+        success?: string | undefined;
+        signedKey?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgFinalizeDrainTransaction>]: never; }>(object: I): MsgFinalizeDrainTransaction;
+};
+export declare const MsgFinalizeDrainTransactionResponse: {
+    encode(message: MsgFinalizeDrainTransactionResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgFinalizeDrainTransactionResponse;
+    fromJSON(object: any): MsgFinalizeDrainTransactionResponse;
+    toJSON(message: MsgFinalizeDrainTransactionResponse): unknown;
+    fromPartial<I extends {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgFinalizeDrainTransactionResponse>]: never; }>(object: I): MsgFinalizeDrainTransactionResponse;
+};
+/** Msg defines the Msg service. */
+export interface Msg {
+    RequestTransaction(request: MsgRequestTransaction): Promise<MsgRequestTransactionResponse>;
+    FinalizeTransaction(request: MsgFinalizeTransaction): Promise<MsgFinalizeTransactionResponse>;
+    RequestProvisionTransaction(request: MsgRequestProvisionTransaction): Promise<MsgRequestProvisionTransactionResponse>;
+    CancelTransaction(request: MsgCancelTransaction): Promise<MsgCancelTransactionResponse>;
+    SetTxHash(request: MsgSetTxHash): Promise<MsgSetTxHashResponse>;
+    SetTxProcess(request: MsgSetTxProcess): Promise<MsgSetTxProcessResponse>;
+    FinalizeProvisionTransaction(request: MsgFinalizeProvisionTransaction): Promise<MsgFinalizeProvisionTransactionResponse>;
+    RequestDrainTransaction(request: MsgRequestDrainTransaction): Promise<MsgRequestDrainTransactionResponse>;
+    FinalizeDrainTransaction(request: MsgFinalizeDrainTransaction): Promise<MsgFinalizeDrainTransactionResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    RequestTransaction(request: MsgRequestTransaction): Promise<MsgRequestTransactionResponse>;
+    FinalizeTransaction(request: MsgFinalizeTransaction): Promise<MsgFinalizeTransactionResponse>;
+    RequestProvisionTransaction(request: MsgRequestProvisionTransaction): Promise<MsgRequestProvisionTransactionResponse>;
+    CancelTransaction(request: MsgCancelTransaction): Promise<MsgCancelTransactionResponse>;
+    SetTxHash(request: MsgSetTxHash): Promise<MsgSetTxHashResponse>;
+    SetTxProcess(request: MsgSetTxProcess): Promise<MsgSetTxProcessResponse>;
+    FinalizeProvisionTransaction(request: MsgFinalizeProvisionTransaction): Promise<MsgFinalizeProvisionTransactionResponse>;
+    RequestDrainTransaction(request: MsgRequestDrainTransaction): Promise<MsgRequestDrainTransactionResponse>;
+    FinalizeDrainTransaction(request: MsgFinalizeDrainTransaction): Promise<MsgFinalizeDrainTransactionResponse>;
+}
+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 {};