@kimafinance/kima-transaction-api 1.4.0 → 1.4.1

package/build/kima/tx/message-service.d.ts

@@ -0,0 +1,54 @@
+import { MsgCancelTransaction, MsgCancelTransactionResponse } from "./cancel";
+import { MsgRequestDrainTransaction, MsgRequestDrainTransactionResponse } from "./drain";
+import { MsgFinalizeDrainTransaction, MsgFinalizeDrainTransactionResponse } from "./drain-finalize";
+import { MsgFinalizeTransaction, MsgFinalizeTransactionResponse } from "./finalize";
+import { MsgRequestHtlcLock, MsgRequestHtlcLockResponse } from "./htlc-lock";
+import { MsgHtlcReclaim, MsgHtlcReclaimResponse } from "./htlc-reclaim";
+import { MsgUpdateLiquidityProvisionParams, MsgUpdateLiquidityProvisionParamsResponse } from "./liquidity-provision";
+import { MsgRequestProvisionTransaction, MsgRequestProvisionTransactionResponse } from "./provision";
+import { MsgFinalizeProvisionTransaction, MsgFinalizeProvisionTransactionResponse } from "./provision-finalize";
+import { MsgRequestTransaction } from "./request";
+import { MsgRequestTransactionResponse } from "./response";
+import { MsgSetTxHash, MsgSetTxHashResponse } from "./set-hash";
+import { MsgSetTxProcess, MsgSetTxProcessResponse } from "./set-process";
+import { MsgUpdateTransferLimitParams, MsgUpdateTransferLimitParamsResponse } from "./transfer-limit";
+import { MsgFinalizeWithdrawTransaction, MsgFinalizeWithdrawTransactionResponse } from "./withdraw";
+/** 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>;
+    RequestHtlcLock(request: MsgRequestHtlcLock): Promise<MsgRequestHtlcLockResponse>;
+    HtlcReclaim(request: MsgHtlcReclaim): Promise<MsgHtlcReclaimResponse>;
+    UpdateLiquidityProvisionParams(request: MsgUpdateLiquidityProvisionParams): Promise<MsgUpdateLiquidityProvisionParamsResponse>;
+    UpdateTransferLimitParams(request: MsgUpdateTransferLimitParams): Promise<MsgUpdateTransferLimitParamsResponse>;
+    FinalizeWithdrawTransaction(request: MsgFinalizeWithdrawTransaction): Promise<MsgFinalizeWithdrawTransactionResponse>;
+}
+interface Rpc {
+    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+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>;
+    RequestHtlcLock(request: MsgRequestHtlcLock): Promise<MsgRequestHtlcLockResponse>;
+    HtlcReclaim(request: MsgHtlcReclaim): Promise<MsgHtlcReclaimResponse>;
+    UpdateLiquidityProvisionParams(request: MsgUpdateLiquidityProvisionParams): Promise<MsgUpdateLiquidityProvisionParamsResponse>;
+    UpdateTransferLimitParams(request: MsgUpdateTransferLimitParams): Promise<MsgUpdateTransferLimitParamsResponse>;
+    FinalizeWithdrawTransaction(request: MsgFinalizeWithdrawTransaction): Promise<MsgFinalizeWithdrawTransactionResponse>;
+}
+export {};

package/build/kima/tx/message-service.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgClientImpl = void 0;
+const probuff_config_1 = __importDefault(require("../../config/probuff.config"));
+const cancel_1 = require("./cancel");
+const drain_1 = require("./drain");
+const drain_finalize_1 = require("./drain-finalize");
+const finalize_1 = require("./finalize");
+const htlc_lock_1 = require("./htlc-lock");
+const htlc_reclaim_1 = require("./htlc-reclaim");
+const liquidity_provision_1 = require("./liquidity-provision");
+const provision_1 = require("./provision");
+const provision_finalize_1 = require("./provision-finalize");
+const request_1 = require("./request");
+const response_1 = require("./response");
+const set_hash_1 = require("./set-hash");
+const set_process_1 = require("./set-process");
+const transfer_limit_1 = require("./transfer-limit");
+const withdraw_1 = require("./withdraw");
+class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+        this.RequestTransaction = this.RequestTransaction.bind(this);
+        this.FinalizeTransaction = this.FinalizeTransaction.bind(this);
+        this.RequestProvisionTransaction =
+            this.RequestProvisionTransaction.bind(this);
+        this.CancelTransaction = this.CancelTransaction.bind(this);
+        this.SetTxHash = this.SetTxHash.bind(this);
+        this.SetTxProcess = this.SetTxProcess.bind(this);
+        this.FinalizeProvisionTransaction =
+            this.FinalizeProvisionTransaction.bind(this);
+        this.RequestDrainTransaction = this.RequestDrainTransaction.bind(this);
+        this.FinalizeDrainTransaction = this.FinalizeDrainTransaction.bind(this);
+        this.RequestHtlcLock = this.RequestHtlcLock.bind(this);
+        this.HtlcReclaim = this.HtlcReclaim.bind(this);
+        this.UpdateLiquidityProvisionParams =
+            this.UpdateLiquidityProvisionParams.bind(this);
+        this.UpdateTransferLimitParams = this.UpdateTransferLimitParams.bind(this);
+        this.FinalizeWithdrawTransaction =
+            this.FinalizeWithdrawTransaction.bind(this);
+    }
+    RequestTransaction(request) {
+        const data = request_1.MsgRequestTransaction.encode(request).finish();
+        const promise = this.rpc.request("kimablockchain.transaction.Msg", "RequestTransaction", data);
+        return promise.then((data) => response_1.MsgRequestTransactionResponse.decode(new probuff_config_1.default.Reader(data)));
+    }
+    FinalizeTransaction(request) {
+        const data = finalize_1.MsgFinalizeTransaction.encode(request).finish();
+        const promise = this.rpc.request("kimablockchain.transaction.Msg", "FinalizeTransaction", data);
+        return promise.then((data) => finalize_1.MsgFinalizeTransactionResponse.decode(new probuff_config_1.default.Reader(data)));
+    }
+    RequestProvisionTransaction(request) {
+        const data = provision_1.MsgRequestProvisionTransaction.encode(request).finish();
+        const promise = this.rpc.request("kimablockchain.transaction.Msg", "RequestProvisionTransaction", data);
+        return promise.then((data) => provision_1.MsgRequestProvisionTransactionResponse.decode(new probuff_config_1.default.Reader(data)));
+    }
+    CancelTransaction(request) {
+        const data = cancel_1.MsgCancelTransaction.encode(request).finish();
+        const promise = this.rpc.request("kimablockchain.transaction.Msg", "CancelTransaction", data);
+        return promise.then((data) => cancel_1.MsgCancelTransactionResponse.decode(new probuff_config_1.default.Reader(data)));
+    }
+    SetTxHash(request) {
+        const data = set_hash_1.MsgSetTxHash.encode(request).finish();
+        const promise = this.rpc.request("kimablockchain.transaction.Msg", "SetTxHash", data);
+        return promise.then((data) => set_hash_1.MsgSetTxHashResponse.decode(new probuff_config_1.default.Reader(data)));
+    }
+    SetTxProcess(request) {
+        const data = set_process_1.MsgSetTxProcess.encode(request).finish();
+        const promise = this.rpc.request("kimablockchain.transaction.Msg", "SetTxProcess", data);
+        return promise.then((data) => set_process_1.MsgSetTxProcessResponse.decode(new probuff_config_1.default.Reader(data)));
+    }
+    FinalizeProvisionTransaction(request) {
+        const data = provision_finalize_1.MsgFinalizeProvisionTransaction.encode(request).finish();
+        const promise = this.rpc.request("kimablockchain.transaction.Msg", "FinalizeProvisionTransaction", data);
+        return promise.then((data) => provision_finalize_1.MsgFinalizeProvisionTransactionResponse.decode(new probuff_config_1.default.Reader(data)));
+    }
+    RequestDrainTransaction(request) {
+        const data = drain_1.MsgRequestDrainTransaction.encode(request).finish();
+        const promise = this.rpc.request("kimablockchain.transaction.Msg", "RequestDrainTransaction", data);
+        return promise.then((data) => drain_1.MsgRequestDrainTransactionResponse.decode(new probuff_config_1.default.Reader(data)));
+    }
+    FinalizeDrainTransaction(request) {
+        const data = drain_finalize_1.MsgFinalizeDrainTransaction.encode(request).finish();
+        const promise = this.rpc.request("kimablockchain.transaction.Msg", "FinalizeDrainTransaction", data);
+        return promise.then((data) => drain_finalize_1.MsgFinalizeDrainTransactionResponse.decode(new probuff_config_1.default.Reader(data)));
+    }
+    RequestHtlcLock(request) {
+        const data = htlc_lock_1.MsgRequestHtlcLock.encode(request).finish();
+        const promise = this.rpc.request("kimablockchain.transaction.Msg", "RequestHtlcLock", data);
+        return promise.then((data) => htlc_lock_1.MsgRequestHtlcLockResponse.decode(new probuff_config_1.default.Reader(data)));
+    }
+    HtlcReclaim(request) {
+        const data = htlc_reclaim_1.MsgHtlcReclaim.encode(request).finish();
+        const promise = this.rpc.request("kimablockchain.transaction.Msg", "HtlcReclaim", data);
+        return promise.then((data) => htlc_reclaim_1.MsgHtlcReclaimResponse.decode(new probuff_config_1.default.Reader(data)));
+    }
+    UpdateLiquidityProvisionParams(request) {
+        const data = liquidity_provision_1.MsgUpdateLiquidityProvisionParams.encode(request).finish();
+        const promise = this.rpc.request("kimablockchain.transaction.Msg", "UpdateLiquidityProvisionParams", data);
+        return promise.then((data) => liquidity_provision_1.MsgUpdateLiquidityProvisionParamsResponse.decode(new probuff_config_1.default.Reader(data)));
+    }
+    UpdateTransferLimitParams(request) {
+        const data = transfer_limit_1.MsgUpdateTransferLimitParams.encode(request).finish();
+        const promise = this.rpc.request("kimablockchain.transaction.Msg", "UpdateTransferLimitParams", data);
+        return promise.then((data) => transfer_limit_1.MsgUpdateTransferLimitParamsResponse.decode(new probuff_config_1.default.Reader(data)));
+    }
+    FinalizeWithdrawTransaction(request) {
+        const data = withdraw_1.MsgFinalizeWithdrawTransaction.encode(request).finish();
+        const promise = this.rpc.request("kimablockchain.transaction.Msg", "FinalizeWithdrawTransaction", data);
+        return promise.then((data) => withdraw_1.MsgFinalizeWithdrawTransactionResponse.decode(new probuff_config_1.default.Reader(data)));
+    }
+}
+exports.MsgClientImpl = MsgClientImpl;

package/build/kima/tx/provision-finalize.d.ts

@@ -0,0 +1,47 @@
+import _m0 from "../../config/probuff.config";
+export interface MsgFinalizeProvisionTransaction {
+    creator: string;
+    txId: number;
+    txHash: string;
+    success: boolean;
+    signedKey: string;
+    errReason: string;
+}
+export interface MsgFinalizeProvisionTransactionResponse {
+    code: string;
+    msg: string;
+}
+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?: boolean | undefined;
+        signedKey?: string | undefined;
+        errReason?: string | undefined;
+    } & {
+        creator?: string | undefined;
+        txId?: number | undefined;
+        txHash?: string | undefined;
+        success?: boolean | undefined;
+        signedKey?: string | undefined;
+        errReason?: 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;
+};

package/build/kima/tx/provision-finalize.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgFinalizeProvisionTransactionResponse = exports.MsgFinalizeProvisionTransaction = void 0;
+const probuff_config_1 = __importDefault(require("../../config/probuff.config"));
+const utils_1 = require("../../utils");
+function createBaseMsgFinalizeProvisionTransaction() {
+    return {
+        creator: "",
+        txId: 0,
+        txHash: "",
+        success: false,
+        signedKey: "",
+        errReason: "",
+    };
+}
+exports.MsgFinalizeProvisionTransaction = {
+    encode(message, writer = probuff_config_1.default.Writer.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.txId !== 0) {
+            writer.uint32(16).uint64(message.txId);
+        }
+        if (message.txHash !== "") {
+            writer.uint32(26).string(message.txHash);
+        }
+        if (message.success === true) {
+            writer.uint32(32).bool(message.success);
+        }
+        if (message.signedKey !== "") {
+            writer.uint32(42).string(message.signedKey);
+        }
+        if (message.errReason !== "") {
+            writer.uint32(50).string(message.errReason);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof probuff_config_1.default.Reader ? input : new probuff_config_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgFinalizeProvisionTransaction();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.txId = (0, utils_1.longToNumber)(reader.uint64());
+                    break;
+                case 3:
+                    message.txHash = reader.string();
+                    break;
+                case 4:
+                    message.success = reader.bool();
+                    break;
+                case 5:
+                    message.signedKey = reader.string();
+                    break;
+                case 6:
+                    message.errReason = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            creator: (0, utils_1.isSet)(object.creator) ? String(object.creator) : "",
+            txId: (0, utils_1.isSet)(object.txId) ? Number(object.txId) : 0,
+            txHash: (0, utils_1.isSet)(object.txHash) ? String(object.txHash) : "",
+            success: (0, utils_1.isSet)(object.success) ? Boolean(object.success) : false,
+            signedKey: (0, utils_1.isSet)(object.signedKey) ? String(object.signedKey) : "",
+            errReason: (0, utils_1.isSet)(object.errReason) ? String(object.errReason) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.creator !== undefined && (obj.creator = message.creator);
+        message.txId !== undefined && (obj.txId = Math.round(message.txId));
+        message.txHash !== undefined && (obj.txHash = message.txHash);
+        message.success !== undefined && (obj.success = message.success);
+        message.signedKey !== undefined && (obj.signedKey = message.signedKey);
+        message.errReason !== undefined && (obj.errReason = message.errReason);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgFinalizeProvisionTransaction();
+        message.creator = object.creator ?? "";
+        message.txId = object.txId ?? 0;
+        message.txHash = object.txHash ?? "";
+        message.success = object.success ?? false;
+        message.signedKey = object.signedKey ?? "";
+        message.errReason = object.errReason ?? "";
+        return message;
+    },
+};
+function createBaseMsgFinalizeProvisionTransactionResponse() {
+    return { code: "", msg: "" };
+}
+exports.MsgFinalizeProvisionTransactionResponse = {
+    encode(message, writer = probuff_config_1.default.Writer.create()) {
+        if (message.code !== "") {
+            writer.uint32(10).string(message.code);
+        }
+        if (message.msg !== "") {
+            writer.uint32(18).string(message.msg);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof probuff_config_1.default.Reader ? input : new probuff_config_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgFinalizeProvisionTransactionResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.code = reader.string();
+                    break;
+                case 2:
+                    message.msg = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            code: (0, utils_1.isSet)(object.code) ? String(object.code) : "",
+            msg: (0, utils_1.isSet)(object.msg) ? String(object.msg) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.code !== undefined && (obj.code = message.code);
+        message.msg !== undefined && (obj.msg = message.msg);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgFinalizeProvisionTransactionResponse();
+        message.code = object.code ?? "";
+        message.msg = object.msg ?? "";
+        return message;
+    },
+};

package/build/kima/tx/provision.d.ts

@@ -0,0 +1,70 @@
+import _m0 from "../../config/probuff.config";
+export interface MsgRequestProvisionTransaction {
+    creator: string;
+    chain: string;
+    fromAddress: string;
+    symbol: string;
+    amount: string;
+    options: string;
+    /** BTC transaction */
+    htlcExpirationTimestamp: string;
+    /** the txhash locking the funds in the HTLC */
+    htlcCreationHash: string;
+    /** the output index of the locked funds  in the HTLC creation transaction */
+    htlcCreationVout: number;
+    /** a version denoting which HTLC script version is being using for the HTLC transaction */
+    htlcVersion: string;
+    /** the (compressed) public key of the sender */
+    senderPubKey: Uint8Array;
+}
+export interface MsgRequestProvisionTransactionResponse {
+    code: string;
+    msg: string;
+    txId: number;
+}
+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;
+        htlcExpirationTimestamp?: string | undefined;
+        htlcCreationHash?: string | undefined;
+        htlcCreationVout?: number | undefined;
+        htlcVersion?: string | undefined;
+        senderPubKey?: Uint8Array | undefined;
+    } & {
+        creator?: string | undefined;
+        chain?: string | undefined;
+        fromAddress?: string | undefined;
+        symbol?: string | undefined;
+        amount?: string | undefined;
+        options?: string | undefined;
+        htlcExpirationTimestamp?: string | undefined;
+        htlcCreationHash?: string | undefined;
+        htlcCreationVout?: number | undefined;
+        htlcVersion?: string | undefined;
+        senderPubKey?: Uint8Array | 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;
+};

package/build/kima/tx/provision.js

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgRequestProvisionTransactionResponse = exports.MsgRequestProvisionTransaction = void 0;
+const probuff_config_1 = __importDefault(require("../../config/probuff.config"));
+const utils_1 = require("../../utils");
+function createBaseMsgRequestProvisionTransaction() {
+    return {
+        creator: "",
+        chain: "",
+        fromAddress: "",
+        symbol: "",
+        amount: "",
+        options: "",
+        htlcExpirationTimestamp: "",
+        htlcCreationHash: "",
+        htlcCreationVout: 0,
+        htlcVersion: "",
+        senderPubKey: new Uint8Array(),
+    };
+}
+exports.MsgRequestProvisionTransaction = {
+    encode(message, writer = probuff_config_1.default.Writer.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.chain !== "") {
+            writer.uint32(18).string(message.chain);
+        }
+        if (message.fromAddress !== "") {
+            writer.uint32(26).string(message.fromAddress);
+        }
+        if (message.symbol !== "") {
+            writer.uint32(34).string(message.symbol);
+        }
+        if (message.amount !== "") {
+            writer.uint32(42).string(message.amount);
+        }
+        if (message.options !== "") {
+            writer.uint32(50).string(message.options);
+        }
+        if (message.htlcExpirationTimestamp !== "") {
+            writer.uint32(58).string(message.htlcExpirationTimestamp);
+        }
+        if (message.htlcCreationHash !== "") {
+            writer.uint32(66).string(message.htlcCreationHash);
+        }
+        if (message.htlcCreationVout !== 0) {
+            writer.uint32(72).uint32(message.htlcCreationVout);
+        }
+        if (message.htlcVersion !== "") {
+            writer.uint32(82).string(message.htlcVersion);
+        }
+        if (message.senderPubKey.length !== 0) {
+            writer.uint32(90).bytes(message.senderPubKey);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof probuff_config_1.default.Reader ? input : new probuff_config_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgRequestProvisionTransaction();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.chain = reader.string();
+                    break;
+                case 3:
+                    message.fromAddress = reader.string();
+                    break;
+                case 4:
+                    message.symbol = reader.string();
+                    break;
+                case 5:
+                    message.amount = reader.string();
+                    break;
+                case 6:
+                    message.options = reader.string();
+                    break;
+                case 7:
+                    message.htlcExpirationTimestamp = reader.string();
+                    break;
+                case 8:
+                    message.htlcCreationHash = reader.string();
+                    break;
+                case 9:
+                    message.htlcCreationVout = reader.uint32();
+                    break;
+                case 10:
+                    message.htlcVersion = reader.string();
+                    break;
+                case 11:
+                    message.senderPubKey = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            creator: (0, utils_1.isSet)(object.creator) ? String(object.creator) : "",
+            chain: (0, utils_1.isSet)(object.chain) ? String(object.chain) : "",
+            fromAddress: (0, utils_1.isSet)(object.fromAddress) ? String(object.fromAddress) : "",
+            symbol: (0, utils_1.isSet)(object.symbol) ? String(object.symbol) : "",
+            amount: (0, utils_1.isSet)(object.amount) ? String(object.amount) : "",
+            options: (0, utils_1.isSet)(object.options) ? String(object.options) : "",
+            htlcExpirationTimestamp: (0, utils_1.isSet)(object.htlcExpirationTimestamp)
+                ? String(object.htlcExpirationTimestamp)
+                : "",
+            htlcCreationHash: (0, utils_1.isSet)(object.htlcCreationHash)
+                ? String(object.htlcCreationHash)
+                : "",
+            htlcCreationVout: (0, utils_1.isSet)(object.htlcCreationVout)
+                ? Number(object.htlcCreationVout)
+                : 0,
+            htlcVersion: (0, utils_1.isSet)(object.htlcVersion) ? String(object.htlcVersion) : "",
+            senderPubKey: (0, utils_1.isSet)(object.senderPubKey)
+                ? (0, utils_1.bytesFromBase64)(object.senderPubKey)
+                : new Uint8Array(),
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.creator !== undefined && (obj.creator = message.creator);
+        message.chain !== undefined && (obj.chain = message.chain);
+        message.fromAddress !== undefined &&
+            (obj.fromAddress = message.fromAddress);
+        message.symbol !== undefined && (obj.symbol = message.symbol);
+        message.amount !== undefined && (obj.amount = message.amount);
+        message.options !== undefined && (obj.options = message.options);
+        message.htlcExpirationTimestamp !== undefined &&
+            (obj.htlcExpirationTimestamp = message.htlcExpirationTimestamp);
+        message.htlcCreationHash !== undefined &&
+            (obj.htlcCreationHash = message.htlcCreationHash);
+        message.htlcCreationVout !== undefined &&
+            (obj.htlcCreationVout = Math.round(message.htlcCreationVout));
+        message.htlcVersion !== undefined &&
+            (obj.htlcVersion = message.htlcVersion);
+        message.senderPubKey !== undefined &&
+            (obj.senderPubKey = (0, utils_1.base64FromBytes)(message.senderPubKey !== undefined
+                ? message.senderPubKey
+                : new Uint8Array()));
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRequestProvisionTransaction();
+        message.creator = object.creator ?? "";
+        message.chain = object.chain ?? "";
+        message.fromAddress = object.fromAddress ?? "";
+        message.symbol = object.symbol ?? "";
+        message.amount = object.amount ?? "";
+        message.options = object.options ?? "";
+        message.htlcExpirationTimestamp = object.htlcExpirationTimestamp ?? "";
+        message.htlcCreationHash = object.htlcCreationHash ?? "";
+        message.htlcCreationVout = object.htlcCreationVout ?? 0;
+        message.htlcVersion = object.htlcVersion ?? "";
+        message.senderPubKey = object.senderPubKey ?? new Uint8Array();
+        return message;
+    },
+};
+function createBaseMsgRequestProvisionTransactionResponse() {
+    return { code: "", msg: "", txId: 0 };
+}
+exports.MsgRequestProvisionTransactionResponse = {
+    encode(message, writer = probuff_config_1.default.Writer.create()) {
+        if (message.code !== "") {
+            writer.uint32(10).string(message.code);
+        }
+        if (message.msg !== "") {
+            writer.uint32(18).string(message.msg);
+        }
+        if (message.txId !== 0) {
+            writer.uint32(24).uint64(message.txId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof probuff_config_1.default.Reader ? input : new probuff_config_1.default.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgRequestProvisionTransactionResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.code = reader.string();
+                    break;
+                case 2:
+                    message.msg = reader.string();
+                    break;
+                case 3:
+                    message.txId = (0, utils_1.longToNumber)(reader.uint64());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            code: (0, utils_1.isSet)(object.code) ? String(object.code) : "",
+            msg: (0, utils_1.isSet)(object.msg) ? String(object.msg) : "",
+            txId: (0, utils_1.isSet)(object.txId) ? Number(object.txId) : 0,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.code !== undefined && (obj.code = message.code);
+        message.msg !== undefined && (obj.msg = message.msg);
+        message.txId !== undefined && (obj.txId = Math.round(message.txId));
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRequestProvisionTransactionResponse();
+        message.code = object.code ?? "";
+        message.msg = object.msg ?? "";
+        message.txId = object.txId ?? 0;
+        return message;
+    },
+};