@kimafinance/kima-transaction-api 1.3.7 → 1.4.1

package/build/kima/tx/set-process.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgSetTxProcessResponse = exports.MsgSetTxProcess = void 0;
+const probuff_config_1 = __importDefault(require("../../config/probuff.config"));
+const utils_1 = require("../../utils");
+function createBaseMsgSetTxProcess() {
+    return { creator: "", txId: 0, timestamp: 0, msgId: "", txType: "" };
+}
+exports.MsgSetTxProcess = {
+    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.timestamp !== 0) {
+            writer.uint32(24).uint64(message.timestamp);
+        }
+        if (message.msgId !== "") {
+            writer.uint32(34).string(message.msgId);
+        }
+        if (message.txType !== "") {
+            writer.uint32(42).string(message.txType);
+        }
+        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 = createBaseMsgSetTxProcess();
+        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.timestamp = (0, utils_1.longToNumber)(reader.uint64());
+                    break;
+                case 4:
+                    message.msgId = reader.string();
+                    break;
+                case 5:
+                    message.txType = 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,
+            timestamp: (0, utils_1.isSet)(object.timestamp) ? Number(object.timestamp) : 0,
+            msgId: (0, utils_1.isSet)(object.msgId) ? String(object.msgId) : "",
+            txType: (0, utils_1.isSet)(object.txType) ? String(object.txType) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.creator !== undefined && (obj.creator = message.creator);
+        message.txId !== undefined && (obj.txId = Math.round(message.txId));
+        message.timestamp !== undefined &&
+            (obj.timestamp = Math.round(message.timestamp));
+        message.msgId !== undefined && (obj.msgId = message.msgId);
+        message.txType !== undefined && (obj.txType = message.txType);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgSetTxProcess();
+        message.creator = object.creator ?? "";
+        message.txId = object.txId ?? 0;
+        message.timestamp = object.timestamp ?? 0;
+        message.msgId = object.msgId ?? "";
+        message.txType = object.txType ?? "";
+        return message;
+    },
+};
+function createBaseMsgSetTxProcessResponse() {
+    return {};
+}
+exports.MsgSetTxProcessResponse = {
+    encode(_, writer = probuff_config_1.default.Writer.create()) {
+        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 = createBaseMsgSetTxProcessResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(_) {
+        return {};
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgSetTxProcessResponse();
+        return message;
+    },
+};

package/build/kima/tx/transfer-limit.d.ts

@@ -0,0 +1,30 @@
+import _m0 from "../../config/probuff.config";
+export interface MsgUpdateTransferLimitParams {
+    authority: string;
+    maxBTC: string;
+    maxUSDT: string;
+}
+export interface MsgUpdateTransferLimitParamsResponse {
+}
+export declare const MsgUpdateTransferLimitParams: {
+    encode(message: MsgUpdateTransferLimitParams, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateTransferLimitParams;
+    fromJSON(object: any): MsgUpdateTransferLimitParams;
+    toJSON(message: MsgUpdateTransferLimitParams): unknown;
+    fromPartial<I extends {
+        authority?: string | undefined;
+        maxBTC?: string | undefined;
+        maxUSDT?: string | undefined;
+    } & {
+        authority?: string | undefined;
+        maxBTC?: string | undefined;
+        maxUSDT?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgUpdateTransferLimitParams>]: never; }>(object: I): MsgUpdateTransferLimitParams;
+};
+export declare const MsgUpdateTransferLimitParamsResponse: {
+    encode(_: MsgUpdateTransferLimitParamsResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgUpdateTransferLimitParamsResponse;
+    fromJSON(_: any): MsgUpdateTransferLimitParamsResponse;
+    toJSON(_: MsgUpdateTransferLimitParamsResponse): unknown;
+    fromPartial<I extends {} & {} & { [K in Exclude<keyof I, never>]: never; }>(_: I): MsgUpdateTransferLimitParamsResponse;
+};

package/build/kima/tx/transfer-limit.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgUpdateTransferLimitParamsResponse = exports.MsgUpdateTransferLimitParams = void 0;
+const probuff_config_1 = __importDefault(require("../../config/probuff.config"));
+const utils_1 = require("../../utils");
+function createBaseMsgUpdateTransferLimitParams() {
+    return { authority: "", maxBTC: "", maxUSDT: "" };
+}
+exports.MsgUpdateTransferLimitParams = {
+    encode(message, writer = probuff_config_1.default.Writer.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.maxBTC !== "") {
+            writer.uint32(18).string(message.maxBTC);
+        }
+        if (message.maxUSDT !== "") {
+            writer.uint32(26).string(message.maxUSDT);
+        }
+        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 = createBaseMsgUpdateTransferLimitParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.maxBTC = reader.string();
+                    break;
+                case 3:
+                    message.maxUSDT = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            authority: (0, utils_1.isSet)(object.authority) ? String(object.authority) : "",
+            maxBTC: (0, utils_1.isSet)(object.maxBTC) ? String(object.maxBTC) : "",
+            maxUSDT: (0, utils_1.isSet)(object.maxUSDT) ? String(object.maxUSDT) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.authority !== undefined && (obj.authority = message.authority);
+        message.maxBTC !== undefined && (obj.maxBTC = message.maxBTC);
+        message.maxUSDT !== undefined && (obj.maxUSDT = message.maxUSDT);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateTransferLimitParams();
+        message.authority = object.authority ?? "";
+        message.maxBTC = object.maxBTC ?? "";
+        message.maxUSDT = object.maxUSDT ?? "";
+        return message;
+    },
+};
+function createBaseMsgUpdateTransferLimitParamsResponse() {
+    return {};
+}
+exports.MsgUpdateTransferLimitParamsResponse = {
+    encode(_, writer = probuff_config_1.default.Writer.create()) {
+        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 = createBaseMsgUpdateTransferLimitParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(_) {
+        return {};
+    },
+    toJSON(_) {
+        const obj = {};
+        return obj;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateTransferLimitParamsResponse();
+        return message;
+    },
+};

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

@@ -0,0 +1,47 @@
+import _m0 from "../../config/probuff.config";
+export interface MsgFinalizeWithdrawTransaction {
+    creator: string;
+    txId: number;
+    txHash: string;
+    success: boolean;
+    signedKey: string;
+    errReason: string;
+}
+export interface MsgFinalizeWithdrawTransactionResponse {
+    code: string;
+    msg: string;
+}
+export declare const MsgFinalizeWithdrawTransaction: {
+    encode(message: MsgFinalizeWithdrawTransaction, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgFinalizeWithdrawTransaction;
+    fromJSON(object: any): MsgFinalizeWithdrawTransaction;
+    toJSON(message: MsgFinalizeWithdrawTransaction): 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 MsgFinalizeWithdrawTransaction>]: never; }>(object: I): MsgFinalizeWithdrawTransaction;
+};
+export declare const MsgFinalizeWithdrawTransactionResponse: {
+    encode(message: MsgFinalizeWithdrawTransactionResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgFinalizeWithdrawTransactionResponse;
+    fromJSON(object: any): MsgFinalizeWithdrawTransactionResponse;
+    toJSON(message: MsgFinalizeWithdrawTransactionResponse): unknown;
+    fromPartial<I extends {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & {
+        code?: string | undefined;
+        msg?: string | undefined;
+    } & { [K in Exclude<keyof I, keyof MsgFinalizeWithdrawTransactionResponse>]: never; }>(object: I): MsgFinalizeWithdrawTransactionResponse;
+};

package/build/kima/tx/withdraw.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.MsgFinalizeWithdrawTransactionResponse = exports.MsgFinalizeWithdrawTransaction = void 0;
+const probuff_config_1 = __importDefault(require("../../config/probuff.config"));
+const utils_1 = require("../../utils");
+function createBaseMsgFinalizeWithdrawTransaction() {
+    return {
+        creator: "",
+        txId: 0,
+        txHash: "",
+        success: false,
+        signedKey: "",
+        errReason: "",
+    };
+}
+exports.MsgFinalizeWithdrawTransaction = {
+    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 = createBaseMsgFinalizeWithdrawTransaction();
+        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 = createBaseMsgFinalizeWithdrawTransaction();
+        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 createBaseMsgFinalizeWithdrawTransactionResponse() {
+    return { code: "", msg: "" };
+}
+exports.MsgFinalizeWithdrawTransactionResponse = {
+    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 = createBaseMsgFinalizeWithdrawTransactionResponse();
+        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 = createBaseMsgFinalizeWithdrawTransactionResponse();
+        message.code = object.code ?? "";
+        message.msg = object.msg ?? "";
+        return message;
+    },
+};

package/build/utils.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="long" />
+export declare function isSet(value: any): boolean;
+export declare function bytesFromBase64(b64: string): Uint8Array;
+export declare function base64FromBytes(arr: Uint8Array): string;
+export declare function sleep(ms: number): Promise<unknown>;
+export 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 declare function longToNumber(long: Long): number;
+export {};

package/build/utils.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.longToNumber = exports.sleep = exports.base64FromBytes = exports.bytesFromBase64 = exports.isSet = void 0;
+const global_this_config_1 = __importDefault(require("./config/global-this.config"));
+function isSet(value) {
+    return value !== null && value !== undefined;
+}
+exports.isSet = isSet;
+function bytesFromBase64(b64) {
+    if (global_this_config_1.default.Buffer) {
+        return Uint8Array.from(global_this_config_1.default.Buffer.from(b64, "base64"));
+    }
+    else {
+        const bin = global_this_config_1.default.atob(b64);
+        const arr = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; ++i) {
+            arr[i] = bin.charCodeAt(i);
+        }
+        return arr;
+    }
+}
+exports.bytesFromBase64 = bytesFromBase64;
+function base64FromBytes(arr) {
+    if (global_this_config_1.default.Buffer) {
+        return global_this_config_1.default.Buffer.from(arr).toString("base64");
+    }
+    else {
+        const bin = [];
+        arr.forEach((byte) => {
+            bin.push(String.fromCharCode(byte));
+        });
+        return global_this_config_1.default.btoa(bin.join(""));
+    }
+}
+exports.base64FromBytes = base64FromBytes;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+exports.sleep = sleep;
+function longToNumber(long) {
+    if (long.gt(Number.MAX_SAFE_INTEGER)) {
+        throw new global_this_config_1.default.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    }
+    return long.toNumber();
+}
+exports.longToNumber = longToNumber;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kimafinance/kima-transaction-api",
-  "version": "1.3.7",
+  "version": "1.4.1",
   "description": "A wrapper around Kima's API, enabling sending and monitoring transactions (Beta version)",
   "repository": "https://github.com/kima-finance/kima-transaction-api",
   "author": "",
@@ -8,7 +8,7 @@
   "main": "build/index.js",
   "source": "src/index.ts",
   "engines": {
-    "node": ">=10"
+    "node": ">=20"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -18,16 +18,16 @@
   },
   "keywords": [],
   "devDependencies": {
-    "@types/node": "^18.11.9",
-    "nodemon": "^2.0.20",
-    "rimraf": "^3.0.2",
-    "ts-node": "^10.9.1",
+    "@types/node": "^20.17.6",
+    "nodemon": "^3.1.7",
+    "rimraf": "^5.0.10",
+    "ts-node": "^10.9.2",
     "typescript": "^4.9.3"
   },
   "dependencies": {
-    "@cosmjs/cosmwasm-stargate": "^0.31.1",
-    "@cosmjs/proto-signing": "^0.31.1",
-    "@cosmjs/stargate": "^0.31.1",
-    "dotenv": "^16.0.3"
+    "@cosmjs/cosmwasm-stargate": "^0.32.4",
+    "@cosmjs/proto-signing": "^0.32.4",
+    "@cosmjs/stargate": "^0.32.4",
+    "dotenv": "^16.4.5"
   }
 }

package/src/api/htlc-lock.ts

@@ -0,0 +1,57 @@
+import { DirectSecp256k1HdWallet } from "@cosmjs/proto-signing";
+import { TxClient } from "../kima/common";
+import { MsgRequestHtlcLock } from "../kima/tx/htlc-lock";
+
+export interface RequestHtlcLockProps {
+  fromAddress: string;
+  senderPubkey: string;
+  amount: string;
+  htlcTimeout: string;
+  txHash: string;
+  htlcAddress: string;
+}
+
+
+/**
+ * Create an HTCL transaction
+ *
+ * @export
+ * @async
+ * @param {RequestHtlcLockProps} param0
+ * @param {string} param0.fromAddress - The creator wallet address
+ * @param {string} param0.senderPubkey - The creator wallet public key
+ * @param {string} param0.amount - The total amount to be locked including fees
+ * @param {string} param0.htlcTimeout - The time in seconds the HTLC will be valid for
+ * @param {string} param0.txHash - The transaction hash of the HTLC lock
+ * @param {string} param0.htlcAddress - The HTLC address
+ * @returns {Promise<DeliverTxResponse>}
+ */
+export async function submitHtlcLock({
+  fromAddress,
+  senderPubkey,
+  amount,
+  htlcTimeout,
+  txHash,
+  htlcAddress,
+}: RequestHtlcLockProps) {
+  const wallet = await DirectSecp256k1HdWallet.fromMnemonic(
+    process.env.KIMA_BACKEND_MNEMONIC as string,
+    { prefix: "kima" }
+  );
+  const client = await TxClient(wallet);
+  const [firstAccount] = await wallet.getAccounts();
+  const params: MsgRequestHtlcLock = {
+    creator: firstAccount.address,
+    fromAddress,
+    senderPubkey,
+    amount,
+    htlcTimeout,
+    htlcAddress,
+    txHash,
+  };
+
+  let msg = await client.msgRequestHtlcLock(params);
+  const result = await client.signAndBroadcast([msg]);
+
+  return result;
+}

package/src/api/htlc-reclaim.ts

@@ -0,0 +1,39 @@
+import { DirectSecp256k1HdWallet } from "@cosmjs/proto-signing";
+import { TxClient } from "../kima/common";
+import { MsgHtlcReclaim } from "../kima/tx/htlc-reclaim";
+
+export interface RequestHtlcReclaimProps {
+  senderAddress: string;
+  txHash: string;
+}
+
+/**
+ * Cancel an HTCL lock by user taking back the funds
+ * @export
+ * @async
+ * @param {RequestHtlcReclaimProps} param0
+ * @param {string} param0.senderAddress - The creator wallet address
+ * @param {string} param0.txHash - The transaction hash of the HTLC lock
+ * @returns {Promise<DeliverTxResponse>}
+ */
+export async function HtlcReclaim({
+  senderAddress,
+  txHash,
+}: RequestHtlcReclaimProps) {
+  const wallet = await DirectSecp256k1HdWallet.fromMnemonic(
+    process.env.KIMA_BACKEND_MNEMONIC as string,
+    { prefix: "kima" }
+  );
+  const client = await TxClient(wallet);
+  const [firstAccount] = await wallet.getAccounts();
+  const params: MsgHtlcReclaim = {
+    creator: firstAccount.address,
+    senderAddress,
+    txHash,
+  };
+
+  let msg = await client.msgHtlcReclaim(params);
+  const result = await client.signAndBroadcast([msg]);
+
+  return result;
+}