@kimafinance/kima-transaction-api 1.3.7 → 1.4.1

package/src/kima/tx/message-service.ts

@@ -0,0 +1,278 @@
+import _m0 from "../../config/probuff.config";
+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 class MsgClientImpl implements Msg {
+  private readonly rpc: Rpc;
+  constructor(rpc: 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: MsgRequestTransaction
+  ): Promise<MsgRequestTransactionResponse> {
+    const data = MsgRequestTransaction.encode(request).finish();
+    const promise = this.rpc.request(
+      "kimablockchain.transaction.Msg",
+      "RequestTransaction",
+      data
+    );
+    return promise.then((data) =>
+      MsgRequestTransactionResponse.decode(new _m0.Reader(data))
+    );
+  }
+
+  FinalizeTransaction(
+    request: MsgFinalizeTransaction
+  ): Promise<MsgFinalizeTransactionResponse> {
+    const data = MsgFinalizeTransaction.encode(request).finish();
+    const promise = this.rpc.request(
+      "kimablockchain.transaction.Msg",
+      "FinalizeTransaction",
+      data
+    );
+    return promise.then((data) =>
+      MsgFinalizeTransactionResponse.decode(new _m0.Reader(data))
+    );
+  }
+
+  RequestProvisionTransaction(
+    request: MsgRequestProvisionTransaction
+  ): Promise<MsgRequestProvisionTransactionResponse> {
+    const data = MsgRequestProvisionTransaction.encode(request).finish();
+    const promise = this.rpc.request(
+      "kimablockchain.transaction.Msg",
+      "RequestProvisionTransaction",
+      data
+    );
+    return promise.then((data) =>
+      MsgRequestProvisionTransactionResponse.decode(new _m0.Reader(data))
+    );
+  }
+
+  CancelTransaction(
+    request: MsgCancelTransaction
+  ): Promise<MsgCancelTransactionResponse> {
+    const data = MsgCancelTransaction.encode(request).finish();
+    const promise = this.rpc.request(
+      "kimablockchain.transaction.Msg",
+      "CancelTransaction",
+      data
+    );
+    return promise.then((data) =>
+      MsgCancelTransactionResponse.decode(new _m0.Reader(data))
+    );
+  }
+
+  SetTxHash(request: MsgSetTxHash): Promise<MsgSetTxHashResponse> {
+    const data = MsgSetTxHash.encode(request).finish();
+    const promise = this.rpc.request(
+      "kimablockchain.transaction.Msg",
+      "SetTxHash",
+      data
+    );
+    return promise.then((data) =>
+      MsgSetTxHashResponse.decode(new _m0.Reader(data))
+    );
+  }
+
+  SetTxProcess(request: MsgSetTxProcess): Promise<MsgSetTxProcessResponse> {
+    const data = MsgSetTxProcess.encode(request).finish();
+    const promise = this.rpc.request(
+      "kimablockchain.transaction.Msg",
+      "SetTxProcess",
+      data
+    );
+    return promise.then((data) =>
+      MsgSetTxProcessResponse.decode(new _m0.Reader(data))
+    );
+  }
+
+  FinalizeProvisionTransaction(
+    request: MsgFinalizeProvisionTransaction
+  ): Promise<MsgFinalizeProvisionTransactionResponse> {
+    const data = MsgFinalizeProvisionTransaction.encode(request).finish();
+    const promise = this.rpc.request(
+      "kimablockchain.transaction.Msg",
+      "FinalizeProvisionTransaction",
+      data
+    );
+    return promise.then((data) =>
+      MsgFinalizeProvisionTransactionResponse.decode(new _m0.Reader(data))
+    );
+  }
+
+  RequestDrainTransaction(
+    request: MsgRequestDrainTransaction
+  ): Promise<MsgRequestDrainTransactionResponse> {
+    const data = MsgRequestDrainTransaction.encode(request).finish();
+    const promise = this.rpc.request(
+      "kimablockchain.transaction.Msg",
+      "RequestDrainTransaction",
+      data
+    );
+    return promise.then((data) =>
+      MsgRequestDrainTransactionResponse.decode(new _m0.Reader(data))
+    );
+  }
+
+  FinalizeDrainTransaction(
+    request: MsgFinalizeDrainTransaction
+  ): Promise<MsgFinalizeDrainTransactionResponse> {
+    const data = MsgFinalizeDrainTransaction.encode(request).finish();
+    const promise = this.rpc.request(
+      "kimablockchain.transaction.Msg",
+      "FinalizeDrainTransaction",
+      data
+    );
+    return promise.then((data) =>
+      MsgFinalizeDrainTransactionResponse.decode(new _m0.Reader(data))
+    );
+  }
+
+  RequestHtlcLock(
+    request: MsgRequestHtlcLock
+  ): Promise<MsgRequestHtlcLockResponse> {
+    const data = MsgRequestHtlcLock.encode(request).finish();
+    const promise = this.rpc.request(
+      "kimablockchain.transaction.Msg",
+      "RequestHtlcLock",
+      data
+    );
+    return promise.then((data) =>
+      MsgRequestHtlcLockResponse.decode(new _m0.Reader(data))
+    );
+  }
+
+  HtlcReclaim(request: MsgHtlcReclaim): Promise<MsgHtlcReclaimResponse> {
+    const data = MsgHtlcReclaim.encode(request).finish();
+    const promise = this.rpc.request(
+      "kimablockchain.transaction.Msg",
+      "HtlcReclaim",
+      data
+    );
+    return promise.then((data) =>
+      MsgHtlcReclaimResponse.decode(new _m0.Reader(data))
+    );
+  }
+
+  UpdateLiquidityProvisionParams(
+    request: MsgUpdateLiquidityProvisionParams
+  ): Promise<MsgUpdateLiquidityProvisionParamsResponse> {
+    const data = MsgUpdateLiquidityProvisionParams.encode(request).finish();
+    const promise = this.rpc.request(
+      "kimablockchain.transaction.Msg",
+      "UpdateLiquidityProvisionParams",
+      data
+    );
+    return promise.then((data) =>
+      MsgUpdateLiquidityProvisionParamsResponse.decode(new _m0.Reader(data))
+    );
+  }
+
+  UpdateTransferLimitParams(
+    request: MsgUpdateTransferLimitParams
+  ): Promise<MsgUpdateTransferLimitParamsResponse> {
+    const data = MsgUpdateTransferLimitParams.encode(request).finish();
+    const promise = this.rpc.request(
+      "kimablockchain.transaction.Msg",
+      "UpdateTransferLimitParams",
+      data
+    );
+    return promise.then((data) =>
+      MsgUpdateTransferLimitParamsResponse.decode(new _m0.Reader(data))
+    );
+  }
+
+  FinalizeWithdrawTransaction(
+    request: MsgFinalizeWithdrawTransaction
+  ): Promise<MsgFinalizeWithdrawTransactionResponse> {
+    const data = MsgFinalizeWithdrawTransaction.encode(request).finish();
+    const promise = this.rpc.request(
+      "kimablockchain.transaction.Msg",
+      "FinalizeWithdrawTransaction",
+      data
+    );
+    return promise.then((data) =>
+      MsgFinalizeWithdrawTransactionResponse.decode(new _m0.Reader(data))
+    );
+  }
+}

package/src/kima/tx/provision-finalize.ts

@@ -0,0 +1,191 @@
+import _m0 from "../../config/probuff.config";
+import { DeepPartial, Exact, isSet, longToNumber } from "../../utils";
+
+export interface MsgFinalizeProvisionTransaction {
+  creator: string;
+  txId: number;
+  txHash: string;
+  success: boolean;
+  signedKey: string;
+  errReason: string;
+}
+
+export interface MsgFinalizeProvisionTransactionResponse {
+  code: string;
+  msg: string;
+}
+
+function createBaseMsgFinalizeProvisionTransaction(): MsgFinalizeProvisionTransaction {
+  return {
+    creator: "",
+    txId: 0,
+    txHash: "",
+    success: false,
+    signedKey: "",
+    errReason: "",
+  };
+}
+
+export const MsgFinalizeProvisionTransaction = {
+  encode(
+    message: MsgFinalizeProvisionTransaction,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    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: _m0.Reader | Uint8Array,
+    length?: number
+  ): MsgFinalizeProvisionTransaction {
+    const reader = input instanceof _m0.Reader ? input : new _m0.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 = longToNumber(reader.uint64() as Long);
+          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: any): MsgFinalizeProvisionTransaction {
+    return {
+      creator: isSet(object.creator) ? String(object.creator) : "",
+      txId: isSet(object.txId) ? Number(object.txId) : 0,
+      txHash: isSet(object.txHash) ? String(object.txHash) : "",
+      success: isSet(object.success) ? Boolean(object.success) : false,
+      signedKey: isSet(object.signedKey) ? String(object.signedKey) : "",
+      errReason: isSet(object.errReason) ? String(object.errReason) : "",
+    };
+  },
+
+  toJSON(message: MsgFinalizeProvisionTransaction): unknown {
+    const obj: any = {};
+    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<I extends Exact<DeepPartial<MsgFinalizeProvisionTransaction>, I>>(
+    object: I
+  ): MsgFinalizeProvisionTransaction {
+    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(): MsgFinalizeProvisionTransactionResponse {
+  return { code: "", msg: "" };
+}
+
+export const MsgFinalizeProvisionTransactionResponse = {
+  encode(
+    message: MsgFinalizeProvisionTransactionResponse,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.code !== "") {
+      writer.uint32(10).string(message.code);
+    }
+    if (message.msg !== "") {
+      writer.uint32(18).string(message.msg);
+    }
+    return writer;
+  },
+
+  decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number
+  ): MsgFinalizeProvisionTransactionResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.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: any): MsgFinalizeProvisionTransactionResponse {
+    return {
+      code: isSet(object.code) ? String(object.code) : "",
+      msg: isSet(object.msg) ? String(object.msg) : "",
+    };
+  },
+
+  toJSON(message: MsgFinalizeProvisionTransactionResponse): unknown {
+    const obj: any = {};
+    message.code !== undefined && (obj.code = message.code);
+    message.msg !== undefined && (obj.msg = message.msg);
+    return obj;
+  },
+
+  fromPartial<
+    I extends Exact<DeepPartial<MsgFinalizeProvisionTransactionResponse>, I>
+  >(object: I): MsgFinalizeProvisionTransactionResponse {
+    const message = createBaseMsgFinalizeProvisionTransactionResponse();
+    message.code = object.code ?? "";
+    message.msg = object.msg ?? "";
+    return message;
+  },
+};