@kimafinance/kima-transaction-api 1.4.0 → 1.4.1

package/src/api/submit.ts

@@ -0,0 +1,132 @@
+import { DirectSecp256k1HdWallet } from "@cosmjs/proto-signing";
+import { TxClient } from "../kima/common";
+import { MsgRequestTransaction } from "../kima/tx/request";
+import { sleep } from "../utils";
+
+export enum SupportedNetworks {
+  ARBITRIUM = "ARB",
+  AVALANCHE = "AVX",
+  BSC = "BSC",
+  BTC = "BTC",
+  ETHEREUM = "ETH",
+  OPTIMISM = "OPT",
+  POLYGON = "POL",
+  SOLANA = "SOL",
+  TRON = "TRX",
+}
+
+export 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 async function submitKimaTransaction({
+  originChain,
+  originAddress,
+  targetChain,
+  targetAddress,
+  originSymbol,
+  targetSymbol,
+  amount,
+  fee,
+  htlcCreationHash,
+  htlcCreationVout,
+  htlcExpirationTimestamp,
+  htlcVersion,
+  senderPubKey,
+}: RequestTxProps) {
+  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: MsgRequestTransaction = {
+    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 sleep(1000);
+  } while (hashResult.code !== 0);
+
+  return result;
+}

package/src/config/global-this.config.ts

@@ -0,0 +1,20 @@
+declare var self: any | undefined;
+declare var window: any | undefined;
+declare var global: any | undefined;
+var globalThis: any = (() => {
+  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";
+})();
+
+export default globalThis;

package/src/config/probuff.config.ts

@@ -0,0 +1,9 @@
+import _m0 from "protobufjs/minimal";
+import Long from "long";
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}
+
+export default _m0

package/src/index.ts

@@ -1,206 +1,3 @@
-import { DirectSecp256k1HdWallet } from "@cosmjs/proto-signing";
-import { TxClient } from "./kima/common";
-import {
-  MsgHtlcReclaim,
-  MsgRequestHtlcLock,
-  MsgRequestTransaction,
-} from "./kima/tx";
-
-export enum SupportedNetworks {
-  ETHEREUM = "ETH",
-  POLYGON = "POL",
-  AVALANCHE = "AVX",
-  SOLANA = "SOL",
-  FUSE = "FUS",
-  CELO = "CEL",
-  BSC = "BSC",
-  ARBITRIUM = "ARB",
-  OPTIMISM = "OPT",
-  POLYGON_ZKEVM = "ZKE",
-}
-
-export enum CurrencyOptions {
-  USDT = "USDT",
-  USDC = "USDC",
-  USDK = "USDK",
-}
-
-interface RequestHtlcReclaimProps {
-  senderAddress: string;
-  txHash: string;
-}
-
-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;
-}
-
-interface RequestHtlcLockProps {
-  fromAddress: string;
-  senderPubkey: string;
-  amount: string;
-  htlcTimeout: string;
-  txHash: string;
-  htlcAddress: string;
-}
-
-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;
-}
-
-interface RequestTxProps {
-  originChain: SupportedNetworks;
-  originAddress: string;
-  targetChain: SupportedNetworks;
-  targetAddress: string;
-  originSymbol: CurrencyOptions;
-  targetSymbol: CurrencyOptions;
-  amount: string; // number in whole units i.e. "12.34"
-  fee: string; // number in whole units i.e "0.061234"
-  htlcCreationHash: string;
-  htlcCreationVout: number;
-  htlcExpirationTimestamp: string;
-  htlcVersion: string;
-  senderPubKey: Uint8Array;
-  options: string;
-}
-
-function sleep(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export async function getCreatorAddress() {
-  const wallet = await DirectSecp256k1HdWallet.fromMnemonic(
-    process.env.KIMA_BACKEND_MNEMONIC as string,
-    { prefix: "kima" }
-  );
-  const [firstAccount] = await wallet.getAccounts();
-  return firstAccount;
-}
-
-export async function submitKimaTransaction({
-  originChain,
-  originAddress,
-  targetChain,
-  targetAddress,
-  originSymbol,
-  targetSymbol,
-  amount,
-  fee,
-  htlcCreationHash,
-  htlcCreationVout,
-  htlcExpirationTimestamp,
-  htlcVersion,
-  senderPubKey,
-  options,
-}: RequestTxProps) {
-  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: MsgRequestTransaction = {
-    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;
-}
+export * from "./api/htlc-reclaim";
+export * from "./api/htlc-lock";
+export * from "./api/submit";

package/src/kima/common.ts

@@ -1,17 +1,10 @@
 import { SigningStargateClient, StdFee } from "@cosmjs/stargate";
 import dotenv from "dotenv";
-import {
-  Registry,
-  OfflineSigner,
-  EncodeObject,
-  coin,
-} from "@cosmjs/proto-signing";
-import {
-  MsgRequestHtlcLock,
-  MsgRequestTransaction,
-  MsgSetTxHash,
-  MsgHtlcReclaim,
-} from "./tx";
+import { Registry, OfflineSigner, EncodeObject, coin } 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";
 
 dotenv.config();
 

package/src/kima/tx/cancel.ts

@@ -0,0 +1,147 @@
+import _m0 from "../../config/probuff.config";
+import { DeepPartial, Exact, isSet } from "../../utils";
+
+export interface MsgCancelTransaction {
+  creator: string;
+  transactionId: string;
+}
+
+export interface MsgCancelTransactionResponse {
+  code: string;
+  msg: string;
+}
+
+function createBaseMsgCancelTransaction(): MsgCancelTransaction {
+  return { creator: "", transactionId: "" };
+}
+
+export const MsgCancelTransaction = {
+  encode(
+    message: MsgCancelTransaction,
+    writer: _m0.Writer = _m0.Writer.create()
+  ): _m0.Writer {
+    if (message.creator !== "") {
+      writer.uint32(10).string(message.creator);
+    }
+    if (message.transactionId !== "") {
+      writer.uint32(18).string(message.transactionId);
+    }
+    return writer;
+  },
+
+  decode(
+    input: _m0.Reader | Uint8Array,
+    length?: number
+  ): MsgCancelTransaction {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgCancelTransaction();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.creator = reader.string();
+          break;
+        case 2:
+          message.transactionId = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MsgCancelTransaction {
+    return {
+      creator: isSet(object.creator) ? String(object.creator) : "",
+      transactionId: isSet(object.transactionId)
+        ? String(object.transactionId)
+        : "",
+    };
+  },
+
+  toJSON(message: MsgCancelTransaction): unknown {
+    const obj: any = {};
+    message.creator !== undefined && (obj.creator = message.creator);
+    message.transactionId !== undefined &&
+      (obj.transactionId = message.transactionId);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<MsgCancelTransaction>, I>>(
+    object: I
+  ): MsgCancelTransaction {
+    const message = createBaseMsgCancelTransaction();
+    message.creator = object.creator ?? "";
+    message.transactionId = object.transactionId ?? "";
+    return message;
+  },
+};
+
+function createBaseMsgCancelTransactionResponse(): MsgCancelTransactionResponse {
+  return { code: "", msg: "" };
+}
+
+export const MsgCancelTransactionResponse = {
+  encode(
+    message: MsgCancelTransactionResponse,
+    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
+  ): MsgCancelTransactionResponse {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMsgCancelTransactionResponse();
+    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): MsgCancelTransactionResponse {
+    return {
+      code: isSet(object.code) ? String(object.code) : "",
+      msg: isSet(object.msg) ? String(object.msg) : "",
+    };
+  },
+
+  toJSON(message: MsgCancelTransactionResponse): 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<MsgCancelTransactionResponse>, I>>(
+    object: I
+  ): MsgCancelTransactionResponse {
+    const message = createBaseMsgCancelTransactionResponse();
+    message.code = object.code ?? "";
+    message.msg = object.msg ?? "";
+    return message;
+  },
+};