@kimafinance/kima-transaction-api 1.4.0 → 1.4.1

package/README.md

@@ -20,16 +20,29 @@ import {
   submitKimaTransaction,
   SupportNetworks,
   CurrencyOptions,
-} from "@kimafinance/kima-transaction-backend";
+} from "@kimafinance/kima-transaction-api";
 
 const txResult = await submitKimaTransaction({
   originAddress: "0x1234123412341234123412341234123412341234",
   originChain: "ETH",
+  originSymbol: "USDK",
   targetAddress: "0x1234123412341234123412341234123412341234",
   targetChain: "POL",
-  symbol: "USDK",
-  amount: 100,
-  fee: 0.3,
+  targetSymbol: "USDK",
+  amount: "100",
+  fee: "0.3",
+  htlcCreationHash: "", // required to send empty strings for now
+  htlcCreationVout: "",
+  htlcExpirationTimestamp: "",
+  htlcVersion: "",
+  senderPubKey: "",
+  options: {
+    signature: "", // required: generated signature from the approval message
+    feeId: "", // required: id returned from calculated fee in fcs
+    chargeFeeAtTarget: false // required: wether to deduct fees from origin or target
+    transactionIdSeed: "", // optional: used in fiat on ramp payments
+    transactionIdSignature: "", // optional: used to validate transaction idempotency
+  }
 });
 ```
 
@@ -39,9 +52,10 @@ const txResult = await submitKimaTransaction({
 
     - `originAddress`: sending address
     - `originChain`: sending chain
+    - `originSymbol`: sending token symbol
     - `targetAddress`: receiving address
     - `targetChain`: receiving chain
-    - `symbol`: token symbol
+    - `targetSymbol`: receiving token symbol
     - `amount`: amount of token to transfer
     - `fee`: amount of token that kima consumes to pay gas fee for pulling & releasing token transactions
 

package/build/api/htlc-lock.d.ts

@@ -0,0 +1,23 @@
+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 declare function submitHtlcLock({ fromAddress, senderPubkey, amount, htlcTimeout, txHash, htlcAddress, }: RequestHtlcLockProps): Promise<import("@cosmjs/stargate").DeliverTxResponse>;

package/build/api/htlc-lock.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitHtlcLock = void 0;
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const common_1 = require("../kima/common");
+/**
+ * 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>}
+ */
+async function submitHtlcLock({ fromAddress, senderPubkey, amount, htlcTimeout, txHash, htlcAddress, }) {
+    const wallet = await proto_signing_1.DirectSecp256k1HdWallet.fromMnemonic(process.env.KIMA_BACKEND_MNEMONIC, { prefix: "kima" });
+    const client = await (0, common_1.TxClient)(wallet);
+    const [firstAccount] = await wallet.getAccounts();
+    const params = {
+        creator: firstAccount.address,
+        fromAddress,
+        senderPubkey,
+        amount,
+        htlcTimeout,
+        htlcAddress,
+        txHash,
+    };
+    let msg = await client.msgRequestHtlcLock(params);
+    const result = await client.signAndBroadcast([msg]);
+    return result;
+}
+exports.submitHtlcLock = submitHtlcLock;

package/build/api/htlc-reclaim.d.ts

@@ -0,0 +1,14 @@
+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 declare function HtlcReclaim({ senderAddress, txHash, }: RequestHtlcReclaimProps): Promise<import("@cosmjs/stargate").DeliverTxResponse>;

package/build/api/htlc-reclaim.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtlcReclaim = void 0;
+const proto_signing_1 = require("@cosmjs/proto-signing");
+const common_1 = require("../kima/common");
+/**
+ * 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>}
+ */
+async function HtlcReclaim({ senderAddress, txHash, }) {
+    const wallet = await proto_signing_1.DirectSecp256k1HdWallet.fromMnemonic(process.env.KIMA_BACKEND_MNEMONIC, { prefix: "kima" });
+    const client = await (0, common_1.TxClient)(wallet);
+    const [firstAccount] = await wallet.getAccounts();
+    const params = {
+        creator: firstAccount.address,
+        senderAddress,
+        txHash,
+    };
+    let msg = await client.msgHtlcReclaim(params);
+    const result = await client.signAndBroadcast([msg]);
+    return result;
+}
+exports.HtlcReclaim = HtlcReclaim;

package/build/api/submit.d.ts

@@ -0,0 +1,54 @@
+export declare enum SupportedNetworks {
+    ARBITRIUM = "ARB",
+    AVALANCHE = "AVX",
+    BSC = "BSC",
+    BTC = "BTC",
+    ETHEREUM = "ETH",
+    OPTIMISM = "OPT",
+    POLYGON = "POL",
+    SOLANA = "SOL",
+    TRON = "TRX"
+}
+export declare enum CurrencyOptions {
+    USDT = "USDT",
+    USDC = "USDC",
+    USDK = "USDK"
+}
+export interface RequestTxProps {
+    originChain: SupportedNetworks;
+    originAddress: string;
+    targetChain: SupportedNetworks;
+    targetAddress: string;
+    originSymbol: CurrencyOptions;
+    targetSymbol: CurrencyOptions;
+    amount: number;
+    fee: number;
+    htlcCreationHash: string;
+    htlcCreationVout: number;
+    htlcExpirationTimestamp: string;
+    htlcVersion: string;
+    senderPubKey: Uint8Array;
+}
+/**
+ * Create a Kima transfer transaction. The HTLC parameters are only required on Bitcoin, use blank strings (or zeros) for other chains.
+ * The approval or HTLC transaction must be completed before submitting the Kima transaction or it will fail.
+ *
+ * @export
+ * @async
+ * @param {RequestTxProps} param0
+ * @param {SupportedNetworks} param0.originChain - The chain the funds are being transferred from
+ * @param {string} param0.originAddress - The user wallet address
+ * @param {SupportedNetworks} param0.targetChain - The chain the funds are being transferred to
+ * @param {string} param0.targetAddress - The destination wallet address
+ * @param {CurrencyOptions} param0.originSymbol - The starting token symbol
+ * @param {CurrencyOptions} param0.targetSymbol - The destination token symbol
+ * @param {number} param0.amount - amount of tokens to be transferred
+ * @param {number} param0.fee - The total fees to be paid
+ * @param {string} param0.htlcCreationHash - (if applicable) The transaction hash of the HTLC lock
+ * @param {number} param0.htlcCreationVout - (if applicable) The vout of the HTLC lock
+ * @param {string} param0.htlcExpirationTimestamp - (if applicable) The expiration timestamp of the HTLC lock
+ * @param {string} param0.htlcVersion - (if applicable) The version of the HTLC lock
+ * @param {Uint8Array} param0.senderPubKey - (if HTLC) The creator wallet public key
+ * @returns {Promise<DeliverTxResponse>}
+ */
+export declare function submitKimaTransaction({ originChain, originAddress, targetChain, targetAddress, originSymbol, targetSymbol, amount, fee, htlcCreationHash, htlcCreationVout, htlcExpirationTimestamp, htlcVersion, senderPubKey, }: RequestTxProps): Promise<import("@cosmjs/stargate").DeliverTxResponse>;

package/build/api/submit.js

@@ -0,0 +1,94 @@
+"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");
+const utils_1 = require("../utils");
+var SupportedNetworks;
+(function (SupportedNetworks) {
+    SupportedNetworks["ARBITRIUM"] = "ARB";
+    SupportedNetworks["AVALANCHE"] = "AVX";
+    SupportedNetworks["BSC"] = "BSC";
+    SupportedNetworks["BTC"] = "BTC";
+    SupportedNetworks["ETHEREUM"] = "ETH";
+    SupportedNetworks["OPTIMISM"] = "OPT";
+    SupportedNetworks["POLYGON"] = "POL";
+    SupportedNetworks["SOLANA"] = "SOL";
+    SupportedNetworks["TRON"] = "TRX";
+})(SupportedNetworks = exports.SupportedNetworks || (exports.SupportedNetworks = {}));
+var CurrencyOptions;
+(function (CurrencyOptions) {
+    CurrencyOptions["USDT"] = "USDT";
+    CurrencyOptions["USDC"] = "USDC";
+    CurrencyOptions["USDK"] = "USDK";
+})(CurrencyOptions = exports.CurrencyOptions || (exports.CurrencyOptions = {}));
+/**
+ * Create a Kima transfer transaction. The HTLC parameters are only required on Bitcoin, use blank strings (or zeros) for other chains.
+ * The approval or HTLC transaction must be completed before submitting the Kima transaction or it will fail.
+ *
+ * @export
+ * @async
+ * @param {RequestTxProps} param0
+ * @param {SupportedNetworks} param0.originChain - The chain the funds are being transferred from
+ * @param {string} param0.originAddress - The user wallet address
+ * @param {SupportedNetworks} param0.targetChain - The chain the funds are being transferred to
+ * @param {string} param0.targetAddress - The destination wallet address
+ * @param {CurrencyOptions} param0.originSymbol - The starting token symbol
+ * @param {CurrencyOptions} param0.targetSymbol - The destination token symbol
+ * @param {number} param0.amount - amount of tokens to be transferred
+ * @param {number} param0.fee - The total fees to be paid
+ * @param {string} param0.htlcCreationHash - (if applicable) The transaction hash of the HTLC lock
+ * @param {number} param0.htlcCreationVout - (if applicable) The vout of the HTLC lock
+ * @param {string} param0.htlcExpirationTimestamp - (if applicable) The expiration timestamp of the HTLC lock
+ * @param {string} param0.htlcVersion - (if applicable) The version of the HTLC lock
+ * @param {Uint8Array} param0.senderPubKey - (if HTLC) The creator wallet public key
+ * @returns {Promise<DeliverTxResponse>}
+ */
+async function submitKimaTransaction({ originChain, originAddress, targetChain, targetAddress, originSymbol, targetSymbol, amount, fee, htlcCreationHash, htlcCreationVout, htlcExpirationTimestamp, htlcVersion, senderPubKey, }) {
+    const wallet = await proto_signing_1.DirectSecp256k1HdWallet.fromMnemonic(process.env.KIMA_BACKEND_MNEMONIC, { prefix: "kima" });
+    const client = await (0, common_1.TxClient)(wallet);
+    const [firstAccount] = await wallet.getAccounts();
+    const params = {
+        creator: firstAccount.address,
+        originChain,
+        originAddress,
+        targetChain,
+        targetAddress,
+        originSymbol,
+        targetSymbol,
+        amount: amount.toString(),
+        fee: fee.toString(),
+        htlcCreationHash,
+        htlcCreationVout,
+        htlcExpirationTimestamp,
+        htlcVersion,
+        senderPubKey,
+        options: "",
+    };
+    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,
+        txType: "request_transaction",
+    });
+    console.log(msg);
+    let hashResult;
+    do {
+        hashResult = await client.signAndBroadcast([msg]);
+        await (0, utils_1.sleep)(1000);
+    } while (hashResult.code !== 0);
+    return result;
+}
+exports.submitKimaTransaction = submitKimaTransaction;

package/build/config/global-this.config.d.ts

@@ -0,0 +1,2 @@
+declare var globalThis: any;
+export default globalThis;

package/build/config/global-this.config.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var globalThis = (() => {
+    if (typeof globalThis !== "undefined") {
+        return globalThis;
+    }
+    if (typeof self !== "undefined") {
+        return self;
+    }
+    if (typeof window !== "undefined") {
+        return window;
+    }
+    if (typeof global !== "undefined") {
+        return global;
+    }
+    throw "Unable to locate global object";
+})();
+exports.default = globalThis;

package/build/config/probuff.config.d.ts

@@ -0,0 +1,2 @@
+import _m0 from "protobufjs/minimal";
+export default _m0;

package/build/config/probuff.config.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const minimal_1 = __importDefault(require("protobufjs/minimal"));
+const long_1 = __importDefault(require("long"));
+if (minimal_1.default.util.Long !== long_1.default) {
+    minimal_1.default.util.Long = long_1.default;
+    minimal_1.default.configure();
+}
+exports.default = minimal_1.default;

package/build/index.d.ts

@@ -1,50 +1,3 @@
-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 RequestHtlcReclaimProps {
-    senderAddress: string;
-    txHash: string;
-}
-export declare function HtlcReclaim({ senderAddress, txHash, }: RequestHtlcReclaimProps): Promise<import("@cosmjs/stargate").DeliverTxResponse>;
-interface RequestHtlcLockProps {
-    fromAddress: string;
-    senderPubkey: string;
-    amount: string;
-    htlcTimeout: string;
-    txHash: string;
-    htlcAddress: string;
-}
-export declare function submitHtlcLock({ fromAddress, senderPubkey, amount, htlcTimeout, txHash, htlcAddress, }: RequestHtlcLockProps): Promise<import("@cosmjs/stargate").DeliverTxResponse>;
-interface RequestTxProps {
-    originChain: SupportedNetworks;
-    originAddress: string;
-    targetChain: SupportedNetworks;
-    targetAddress: string;
-    originSymbol: CurrencyOptions;
-    targetSymbol: CurrencyOptions;
-    amount: string;
-    fee: string;
-    htlcCreationHash: string;
-    htlcCreationVout: number;
-    htlcExpirationTimestamp: string;
-    htlcVersion: string;
-    senderPubKey: Uint8Array;
-    options: string;
-}
-export declare function getCreatorAddress(): Promise<import("@cosmjs/proto-signing").AccountData>;
-export declare function submitKimaTransaction({ originChain, originAddress, targetChain, targetAddress, originSymbol, targetSymbol, amount, fee, htlcCreationHash, htlcCreationVout, htlcExpirationTimestamp, htlcVersion, senderPubKey, options, }: RequestTxProps): Promise<import("@cosmjs/stargate").DeliverTxResponse>;
-export {};
+export * from "./api/htlc-reclaim";
+export * from "./api/htlc-lock";
+export * from "./api/submit";

package/build/index.js

@@ -1,123 +1,19 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.submitKimaTransaction = exports.getCreatorAddress = exports.submitHtlcLock = exports.HtlcReclaim = 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 = {}));
-async function HtlcReclaim({ senderAddress, txHash, }) {
-    const wallet = await proto_signing_1.DirectSecp256k1HdWallet.fromMnemonic(process.env.KIMA_BACKEND_MNEMONIC, { prefix: "kima" });
-    const client = await (0, common_1.TxClient)(wallet);
-    const [firstAccount] = await wallet.getAccounts();
-    const params = {
-        creator: firstAccount.address,
-        senderAddress,
-        txHash,
-    };
-    let msg = await client.msgHtlcReclaim(params);
-    const result = await client.signAndBroadcast([msg]);
-    return result;
-}
-exports.HtlcReclaim = HtlcReclaim;
-async function submitHtlcLock({ fromAddress, senderPubkey, amount, htlcTimeout, txHash, htlcAddress, }) {
-    const wallet = await proto_signing_1.DirectSecp256k1HdWallet.fromMnemonic(process.env.KIMA_BACKEND_MNEMONIC, { prefix: "kima" });
-    const client = await (0, common_1.TxClient)(wallet);
-    const [firstAccount] = await wallet.getAccounts();
-    const params = {
-        creator: firstAccount.address,
-        fromAddress,
-        senderPubkey,
-        amount,
-        htlcTimeout,
-        htlcAddress,
-        txHash,
-    };
-    let msg = await client.msgRequestHtlcLock(params);
-    const result = await client.signAndBroadcast([msg]);
-    return result;
-}
-exports.submitHtlcLock = submitHtlcLock;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function getCreatorAddress() {
-    const wallet = await proto_signing_1.DirectSecp256k1HdWallet.fromMnemonic(process.env.KIMA_BACKEND_MNEMONIC, { prefix: "kima" });
-    const [firstAccount] = await wallet.getAccounts();
-    return firstAccount;
-}
-exports.getCreatorAddress = getCreatorAddress;
-async function submitKimaTransaction({ originChain, originAddress, targetChain, targetAddress, originSymbol, targetSymbol, amount, fee, htlcCreationHash, htlcCreationVout, htlcExpirationTimestamp, htlcVersion, senderPubKey, options, }) {
-    const wallet = await proto_signing_1.DirectSecp256k1HdWallet.fromMnemonic(process.env.KIMA_BACKEND_MNEMONIC, { prefix: "kima" });
-    const client = await (0, common_1.TxClient)(wallet);
-    const [firstAccount] = await wallet.getAccounts();
-    const params = {
-        creator: firstAccount.address,
-        originChain,
-        originAddress,
-        targetChain,
-        targetAddress,
-        originSymbol,
-        targetSymbol,
-        amount: amount,
-        fee: fee,
-        htlcCreationHash,
-        htlcCreationVout,
-        htlcExpirationTimestamp,
-        htlcVersion,
-        senderPubKey,
-        options,
-    };
-    const msgTx = await client.msgRequestTransaction(params);
-    const result = await client.signAndBroadcast([msgTx]);
-    if (result.code !== 0) {
-        return result;
-    }
-    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;
-                }
-            }
-        }
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
-    await sleep(5000);
-    const msgSetHash = await client.msgSetTxHash({
-        creator: firstAccount.address,
-        txId,
-        txHash: result.transactionHash,
-        txType: "request_transaction",
-    });
-    console.log(msgSetHash);
-    let hashResult;
-    do {
-        try {
-            hashResult = await client.signAndBroadcast([msgSetHash]);
-        }
-        catch (error) {
-            console.log(error);
-            await sleep(5000);
-            continue;
-        }
-    } while (hashResult?.code !== 0);
-    return result;
-}
-exports.submitKimaTransaction = submitKimaTransaction;
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api/htlc-reclaim"), exports);
+__exportStar(require("./api/htlc-lock"), exports);
+__exportStar(require("./api/submit"), exports);

package/build/kima/common.d.ts

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

package/build/kima/common.js

@@ -7,17 +7,20 @@ 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");
+const request_1 = require("./tx/request");
+const htlc_lock_1 = require("./tx/htlc-lock");
+const set_hash_1 = require("./tx/set-hash");
+const htlc_reclaim_1 = require("./tx/htlc-reclaim");
 dotenv_1.default.config();
 const defaultFee = {
     amount: [(0, proto_signing_1.coin)(200, "uKIMA")],
     gas: "200000", // Gas limit
 };
 const types = [
-    ["/kimablockchain.transaction.MsgRequestTransaction", tx_1.MsgRequestTransaction],
-    ["/kimablockchain.transaction.MsgRequestHtlcLock", tx_1.MsgRequestHtlcLock],
-    ["/kimablockchain.transaction.MsgSetTxHash", tx_1.MsgSetTxHash],
-    ["/kimablockchain.transaction.MsgHtlcReclaim", tx_1.MsgHtlcReclaim],
+    ["/kimablockchain.transaction.MsgRequestTransaction", request_1.MsgRequestTransaction],
+    ["/kimablockchain.transaction.MsgRequestHtlcLock", htlc_lock_1.MsgRequestHtlcLock],
+    ["/kimablockchain.transaction.MsgSetTxHash", set_hash_1.MsgSetTxHash],
+    ["/kimablockchain.transaction.MsgHtlcReclaim", htlc_reclaim_1.MsgHtlcReclaim],
 ];
 exports.registry = new proto_signing_1.Registry(types);
 const TxClient = async (wallet) => {
@@ -30,19 +33,19 @@ const TxClient = async (wallet) => {
         },
         msgRequestTransaction: (data) => ({
             typeUrl: "/kimablockchain.transaction.MsgRequestTransaction",
-            value: tx_1.MsgRequestTransaction.fromPartial(data),
+            value: request_1.MsgRequestTransaction.fromPartial(data),
         }),
         msgRequestHtlcLock: (data) => ({
             typeUrl: "/kimablockchain.transaction.MsgRequestHtlcLock",
-            value: tx_1.MsgRequestHtlcLock.fromPartial(data),
+            value: htlc_lock_1.MsgRequestHtlcLock.fromPartial(data),
         }),
         msgSetTxHash: (data) => ({
             typeUrl: "/kimablockchain.transaction.MsgSetTxHash",
-            value: tx_1.MsgSetTxHash.fromPartial(data),
+            value: set_hash_1.MsgSetTxHash.fromPartial(data),
         }),
         msgHtlcReclaim: (data) => ({
             typeUrl: "/kimablockchain.transaction.MsgHtlcReclaim",
-            value: tx_1.MsgHtlcReclaim.fromPartial(data),
+            value: htlc_reclaim_1.MsgHtlcReclaim.fromPartial(data),
         }),
     };
 };

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

@@ -0,0 +1,35 @@
+import _m0 from "../../config/probuff.config";
+export interface MsgCancelTransaction {
+    creator: string;
+    transactionId: string;
+}
+export interface MsgCancelTransactionResponse {
+    code: string;
+    msg: string;
+}
+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;
+};