@kimafinance/kima-transaction-api 1.4.1 → 1.4.2

package/build/index.d.ts

@@ -1,3 +1,50 @@
-export * from "./api/htlc-reclaim";
-export * from "./api/htlc-lock";
-export * from "./api/submit";
+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 {};

package/build/index.js

@@ -1,19 +1,123 @@
 "use strict";
-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]; } };
-    }
-    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);
+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;
+                }
+            }
+        }
+    }
+    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;

package/build/kima/common.d.ts

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