@hot-labs/kit 1.4.5 → 1.4.7

package/src/cosmos/connector.ts

@@ -1,5 +1,7 @@
 import { Keplr } from "@keplr-wallet/provider-extension";
+import { StdSignature } from "@keplr-wallet/types";
 import { TxRaw } from "@keplr-wallet/proto-types/cosmos/tx/v1beta1/tx";
+import UniversalProvider from "@walletconnect/universal-provider";
 import { StargateClient } from "@cosmjs/stargate";
 import { base64, hex } from "@scure/base";
 import { runInAction } from "mobx";
@@ -55,7 +57,7 @@ export default class CosmosConnector extends OmniConnector<CosmosWallet> {
   isSupported = true;
   id = "cosmos";
 
-  constructor(wibe3: HotConnector) {
+  constructor(wibe3: HotConnector, readonly chainId = "gonka-mainnet") {
     super(wibe3);
 
     this.options = Object.values(wallets);
@@ -67,16 +69,18 @@ export default class CosmosConnector extends OmniConnector<CosmosWallet> {
       });
     });
 
-    this.getStorage().then(async ({ type, address, publicKey }) => {
-      if (!address || !publicKey) return;
+    this.getStorage().then(async (data) => {
+      if (!data[this.chainId]) return;
 
-      if (type === "keplr") {
+      if (data.type === "keplr") {
         const keplr = await Keplr.getKeplr();
-        if (keplr) this.setKeplrWallet(keplr, address, publicKey);
+        if (keplr) this.setKeplrWallet(keplr, data[this.chainId]);
         else this.disconnect();
       }
 
-      if (type === "leap" && window.leap) this.setKeplrWallet(window.leap, address, publicKey);
+      if (data.type === "leap" && window.leap) {
+        this.setKeplrWallet(window.leap, data[this.chainId]);
+      }
     });
 
     this.initWalletConnect()
@@ -105,45 +109,59 @@ export default class CosmosConnector extends OmniConnector<CosmosWallet> {
     return chains.getByType(WalletType.COSMOS).map((t) => t.key);
   }
 
+  async getAccountFromWalletConnect(wc: UniversalProvider, chainId: string, id?: "keplr" | "leap" | "gonkaWallet") {
+    const properties = JSON.parse(wc.session?.sessionProperties?.keys || "{}");
+    const account = properties?.find?.((t: any) => t.chainId === chainId);
+
+    if (account) {
+      const publicKey = Buffer.from(account.pubKey, "base64").toString("hex");
+      const address = account.bech32Address || "";
+      return { publicKey, address };
+    }
+
+    const savedAccount = await this.getStorage().catch(() => null);
+    if (savedAccount?.[chainId]) return savedAccount[chainId];
+
+    const data = await this.requestWalletConnect({
+      deeplink: id ? wallets[id].deeplink : undefined,
+      icon: id ? wallets[id].icon : undefined,
+      name: id ? wallets[id].name : undefined,
+      request: {
+        method: "cosmos_getAccounts",
+        params: { chainId },
+      },
+    });
+
+    if (!Array.isArray(data) || data.length === 0) throw new Error("Account not found");
+    return { publicKey: hex.encode(base64.decode(data[0].pubkey)), address: data[0].address };
+  }
+
   async setupWalletConnect(id?: "keplr" | "leap" | "gonkaWallet"): Promise<CosmosWallet> {
     const wc = await this.wc;
     if (!wc) throw new Error("WalletConnect not found");
 
-    const properties = JSON.parse(wc.session?.sessionProperties?.keys || "{}");
-    const account = properties?.find?.((t: any) => t.chainId === "gonka-mainnet");
-    let publicKey = "";
-    let address = "";
+    const chainAccount = await this.getAccountFromWalletConnect(wc, this.chainId, id);
+    await this.setStorage({ type: "walletconnect", id, [this.chainId]: chainAccount });
 
-    if (account) {
-      publicKey = Buffer.from(account.pubKey, "base64").toString("hex");
-      address = account.bech32Address || "";
-    } else {
-      const savedAccount = await this.getStorage().catch(() => null);
-      if (savedAccount?.address && savedAccount?.publicKey) {
-        publicKey = savedAccount.publicKey;
-        address = savedAccount.address;
-      } else {
-        const data = await this.requestWalletConnect({
-          deeplink: id ? wallets[id].deeplink : undefined,
-          icon: id ? wallets[id].icon : undefined,
-          name: id ? wallets[id].name : undefined,
+    const cosmosAccount = await this.getAccountFromWalletConnect(wc, "cosmoshub-4", id);
+    await this.setStorage({ type: "walletconnect", id, [this.chainId]: chainAccount, "cosmoshub-4": cosmosAccount });
+
+    const wallet = new CosmosWallet({
+      chainId: this.chainId,
+      account: chainAccount,
+      cosmos: cosmosAccount,
+      disableOmni: true,
+
+      disconnect: () => this.disconnectWalletConnect(),
+      signAmino: async (chainId: string, address: string, signDoc: any) => {
+        return await this.requestWalletConnect<{ signature: StdSignature }>({
           request: {
-            method: "cosmos_getAccounts",
-            params: { chainId: "gonka-mainnet" },
+            method: "cosmos_signAmino",
+            params: { signerAddress: address, signDoc },
           },
         });
+      },
 
-        if (!Array.isArray(data) || data.length === 0) throw new Error("Account not found");
-        publicKey = hex.encode(base64.decode(data[0].pubkey));
-        address = data[0].address;
-      }
-    }
-
-    this.setStorage({ type: "walletconnect", id, address, publicKey });
-    const wallet = new CosmosWallet({
-      address: address,
-      publicKeyHex: publicKey,
-      disconnect: () => this.disconnectWalletConnect(),
       sendTransaction: async (signDoc: any) => {
         const { signed, signature } = await this.requestWalletConnect<{ signed: TxRaw; signature: { signature: string } }>({
           chain: `cosmos:${signDoc.chainId}`,
@@ -153,7 +171,7 @@ export default class CosmosConnector extends OmniConnector<CosmosWallet> {
           request: {
             method: "cosmos_signDirect",
             params: {
-              signerAddress: address,
+              signerAddress: chainAccount.address,
               signDoc: {
                 chainId: signDoc.chainId,
                 accountNumber: signDoc.accountNumber?.toString(),
@@ -183,17 +201,30 @@ export default class CosmosConnector extends OmniConnector<CosmosWallet> {
     return this.setWallet(wallet);
   }
 
-  async setKeplrWallet(keplr: Keplr, address: string, publicKey: string) {
+  async setKeplrWallet(keplr: Keplr, data: { address: string; publicKey: string }) {
+    const account = await keplr.getKey("cosmoshub-4");
     return this.setWallet(
       new CosmosWallet({
-        address: address,
-        publicKeyHex: publicKey,
+        account: data,
+        cosmos: { address: account.bech32Address, publicKey: hex.encode(account.pubKey) },
+        chainId: this.chainId,
+        disableOmni: true,
+
         disconnect: () => keplr.disable(),
+
+        signMessage: async (chainId: string, address: string, message: string) => {
+          return await keplr.signArbitrary(chainId, address, message);
+        },
+
         sendTransaction: async (signDoc: any) => {
           await keplr.enable(this.chains);
           const rpcEndpoint = chains.getByKey(signDoc.chainId)?.rpc || "";
           return await signAndSendTx(keplr, rpcEndpoint, api.apiKey, signDoc);
         },
+
+        signAmino: async (chainId: string, address: string, signDoc: any) => {
+          return await keplr.signAmino(chainId, address, signDoc);
+        },
       })
     );
   }
@@ -204,9 +235,9 @@ export default class CosmosConnector extends OmniConnector<CosmosWallet> {
       deeplink: wallets["gonkaWallet"].deeplink,
       namespaces: {
         cosmos: {
+          chains: [...new Set([`cosmos:${this.chainId}`, "cosmos:cosmoshub-4"])],
           methods: ["cosmos_getAccounts", "cosmos_signDirect"],
           events: ["chainChanged", "accountsChanged"],
-          chains: this.chains.map((chain) => `cosmos:${chain}`),
           rpcMap: {},
         },
       },
@@ -223,31 +254,34 @@ export default class CosmosConnector extends OmniConnector<CosmosWallet> {
         deeplink: wallets[type].deeplink,
         namespaces: {
           cosmos: {
+            chains: [...new Set([`cosmos:${this.chainId}`, "cosmos:cosmoshub-4"])],
             methods: ["cosmos_getAccounts", "cosmos_signDirect"],
             events: ["chainChanged", "accountsChanged"],
-            chains: this.chains.map((chain) => `cosmos:${chain}`),
             rpcMap: {},
           },
         },
       });
     }
 
-    await extension.experimentalSuggestChain({
-      bech32Config: { bech32PrefixAccAddr: "gonka", bech32PrefixAccPub: "gonka", bech32PrefixValAddr: "gonka", bech32PrefixValPub: "gonka", bech32PrefixConsAddr: "gonka", bech32PrefixConsPub: "gonka" },
-      feeCurrencies: [{ coinDenom: "GNK", coinMinimalDenom: "ngonka", coinDecimals: 9, coinGeckoId: "gonka", gasPriceStep: { low: 0, average: 0, high: 0 } }],
-      stakeCurrency: { coinDenom: "GNK", coinMinimalDenom: "ngonka", coinDecimals: 9, coinGeckoId: "gonka" },
-      currencies: [{ coinDenom: "GNK", coinMinimalDenom: "ngonka", coinDecimals: 9, coinGeckoId: "gonka" }],
-      rpc: "https://gonka04.6block.com:8443/chain-rpc",
-      rest: "https://gonka04.6block.com:8443/chain-api",
-      bip44: { coinType: 1200 },
-      chainId: "gonka-mainnet",
-      chainName: "Gonka",
-    });
+    if (this.chainId === "gonka-mainnet") {
+      await extension.experimentalSuggestChain({
+        bech32Config: { bech32PrefixAccAddr: "gonka", bech32PrefixAccPub: "gonka", bech32PrefixValAddr: "gonka", bech32PrefixValPub: "gonka", bech32PrefixConsAddr: "gonka", bech32PrefixConsPub: "gonka" },
+        feeCurrencies: [{ coinDenom: "GNK", coinMinimalDenom: "ngonka", coinDecimals: 9, coinGeckoId: "gonka", gasPriceStep: { low: 0, average: 0, high: 0 } }],
+        stakeCurrency: { coinDenom: "GNK", coinMinimalDenom: "ngonka", coinDecimals: 9, coinGeckoId: "gonka" },
+        currencies: [{ coinDenom: "GNK", coinMinimalDenom: "ngonka", coinDecimals: 9, coinGeckoId: "gonka" }],
+        rpc: "https://gonka04.6block.com:8443/chain-rpc",
+        rest: "https://gonka04.6block.com:8443/chain-api",
+        bip44: { coinType: 1200 },
+        chainId: "gonka-mainnet",
+        chainName: "Gonka",
+      });
+    }
 
     await extension.enable(this.chains);
-    const account = await extension.getKey("gonka-mainnet");
-    await this.setStorage({ type, address: account.bech32Address, publicKey: hex.encode(account.pubKey) });
-    return await this.setKeplrWallet(extension, account.bech32Address, hex.encode(account.pubKey));
+    const account = await extension.getKey(this.chainId);
+    const chainAccount = { address: account.bech32Address, publicKey: hex.encode(account.pubKey) };
+    await this.setStorage({ type, [this.chainId]: chainAccount });
+    return await this.setKeplrWallet(extension, chainAccount);
   }
 
   async connect(id: string) {
@@ -256,9 +290,9 @@ export default class CosmosConnector extends OmniConnector<CosmosWallet> {
         onConnect: () => this.setupWalletConnect(),
         namespaces: {
           cosmos: {
+            chains: [...new Set([`cosmos:${this.chainId}`, "cosmos:cosmoshub-4"])],
             methods: ["cosmos_getAccounts", "cosmos_signDirect"],
             events: ["chainChanged", "accountsChanged"],
-            chains: this.chains.map((chain) => `cosmos:${chain}`),
             rpcMap: {},
           },
         },

package/src/cosmos/wallet.ts

@@ -1,14 +1,25 @@
+import { Signature, computeAddress, recoverAddress } from "ethers";
+import { StdSignature } from "@keplr-wallet/types";
 import { StargateClient } from "@cosmjs/stargate";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { base58, base64, hex } from "@scure/base";
+
 import { OmniWallet } from "../core/OmniWallet";
 import { chains, WalletType } from "../core/chains";
+import { Commitment } from "../core/types";
 import { ReviewFee } from "../core/bridge";
-import { Commitment } from "../core";
+
+import { makeADR36AminoSignDoc, serializeSignDoc } from "./adr36";
 
 interface ProtocolWallet {
   disconnect?: () => Promise<void>;
+  signMessage?: (chainId: string, address: string, message: string) => Promise<StdSignature>;
+  signAmino: (chainId: string, address: string, signDoc: any) => Promise<{ signature: StdSignature }>;
   sendTransaction?: (signDoc: any) => Promise<string>;
-  address: string;
-  publicKeyHex: string;
+  account: { address: string; publicKey: string };
+  cosmos: { address: string; publicKey: string };
+  disableOmni: boolean;
+  chainId: string;
 }
 
 export default class CosmosWallet extends OmniWallet {
@@ -20,15 +31,16 @@ export default class CosmosWallet extends OmniWallet {
   }
 
   get address() {
-    return this.wallet.address;
+    return this.wallet.account.address;
   }
 
   get publicKey() {
-    return this.wallet.publicKeyHex;
+    return this.wallet.account.publicKey;
   }
 
   get omniAddress() {
-    return "";
+    if (this.wallet.disableOmni) return "";
+    return computeAddress(`0x${this.wallet.cosmos.publicKey}`).toLowerCase();
   }
 
   sendTransaction(signDoc: any): Promise<string> {
@@ -44,8 +56,56 @@ export default class CosmosWallet extends OmniWallet {
     throw "Not impl";
   }
 
-  signIntents(): Promise<Commitment> {
-    throw new Error("Method not implemented.");
+  async findFullSignature(signature: Uint8Array, msgHash: Uint8Array) {
+    const validate = (v: 0 | 1) => {
+      const sign = Signature.from({ v: v, r: "0x" + hex.encode(signature.slice(0, 32)), s: "0x" + hex.encode(signature.slice(32)) });
+      const recoveredAddr = recoverAddress(msgHash, sign.serialized);
+      if (this.omniAddress === recoveredAddr.toLowerCase()) return new Uint8Array([...signature, v]);
+      return null;
+    };
+
+    const sig27 = validate(0);
+    if (sig27) return sig27;
+
+    const sig28 = validate(1);
+    if (sig28) return sig28;
+
+    throw "Invalid signature";
+  }
+
+  async signMessage(message: string): Promise<StdSignature> {
+    if (!this.wallet.signMessage) {
+      const signDoc = makeADR36AminoSignDoc(this.wallet.cosmos.address, message);
+      const { signature } = await this.wallet.signAmino("cosmoshub-4", this.wallet.cosmos.address, signDoc);
+      return signature;
+    }
+
+    return await this.wallet.signMessage("cosmoshub-4", this.wallet.cosmos.address, message);
+  }
+
+  async signIntents(intents: Record<string, any>[], options?: { deadline?: number; nonce?: Uint8Array }): Promise<Commitment> {
+    if (this.wallet.disableOmni) throw "Sign intents is not supported for this wallet";
+
+    const nonce = new Uint8Array(options?.nonce || window.crypto.getRandomValues(new Uint8Array(32)));
+    const message = JSON.stringify({
+      deadline: options?.deadline ? new Date(options.deadline).toISOString() : "2100-01-01T00:00:00.000Z",
+      verifying_contract: "intents.near",
+      signer_id: this.omniAddress,
+      nonce: base64.encode(nonce),
+      intents: intents,
+    });
+
+    const signDoc = makeADR36AminoSignDoc(this.wallet.cosmos.address, message);
+    const { signature } = await this.signMessage(message);
+
+    const msgHash = sha256(serializeSignDoc(signDoc));
+    const fullSignature = await this.findFullSignature(base64.decode(signature), msgHash);
+
+    return {
+      standard: "adr36",
+      signature: `secp256k1:${base58.encode(fullSignature)}`,
+      payload: { signer: this.wallet.cosmos.address, message },
+    };
   }
 
   async fetchBalances(chain: number, whitelist: string[] = []): Promise<Record<string, bigint>> {

package/src/defaults.ts

@@ -3,5 +3,6 @@ import solana from "./solana";
 import near from "./near";
 import evm from "./evm";
 import ton from "./ton";
+import tron from "./tron";
 
-export const defaultConnectors = [near(), evm(), solana(), ton(), stellar()];
+export const defaultConnectors = [near(), evm(), solana(), ton(), stellar(), tron()];

package/src/evm/wallet.ts

@@ -35,7 +35,6 @@ class EvmWallet extends OmniWallet {
 
   private rpcs: Record<number, JsonRpcProvider> = {};
   rpc(chain: number) {
-    console.log("getting rpc for chain", { chain });
     if (chain < 1 || chain == null) throw "Invalid chain";
     if (this.rpcs[chain]) return this.rpcs[chain];
 

package/src/solana/connector.ts

@@ -58,7 +58,7 @@ class SolanaConnector extends OmniConnector<SolanaWallet, { wallet: Wallet }> {
 
       try {
         const connected = await this.getConnectedWallet();
-        if (connected !== wallet.name) return;
+        if (connected.id !== wallet.name) return;
         const protocolWallet = await SolanaProtocolWallet.connect(wallet, { silent: true });
         this.setWallet(new SolanaWallet(protocolWallet));
       } catch {

package/src/tron/connector.ts

@@ -26,8 +26,8 @@ declare global {
 const TRONLINK = {
   id: "tronlink",
   name: "Tron Link",
-  type: window?.tronLink ? ("extension" as const) : ("external" as const),
-  icon: "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/tron/info/logo.png",
+  type: "extension" as const,
+  icon: "https://cdn.brandfetch.io/id0PcTcDBs/w/400/h/400/theme/dark/icon.jpeg",
   download: "https://www.tronlink.org/",
 };
 
@@ -36,11 +36,11 @@ class TronConnector extends OmniConnector<TronWallet> {
   walletTypes = [WalletType.Tron, WalletType.OMNI];
   icon = "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/tron/info/logo.png";
   name = "TRON Wallet";
-  options = [TRONLINK];
   id = "tron";
 
   constructor(wibe3: HotConnector) {
     super(wibe3);
+    this.options = [TRONLINK];
 
     this.syncFromProvider().catch(() => this.removeStorage());
     window.addEventListener("message", () => {

package/src/ui/connect/ConnectWallet.tsx

@@ -22,8 +22,8 @@ interface MultichainPopupProps {
 }
 
 export const Connector = observer(({ hot, onClose, title, walletType, widget }: MultichainPopupProps) => {
-  const onechain = hot.connectors.filter((t) => t.type === ConnectorType.WALLET && (walletType == null || t.walletTypes.includes(walletType as WalletType)));
-  const social = hot.connectors.filter((t) => t.type === ConnectorType.SOCIAL && (walletType == null || t.walletTypes.includes(walletType as WalletType)));
+  const onechain = hot.connectors.filter((t) => t.type === ConnectorType.WALLET && (walletType == null || t.walletTypes.includes(walletType as WalletType)) && t.options.length > 0);
+  const social = hot.connectors.filter((t) => t.type === ConnectorType.SOCIAL && (walletType == null || t.walletTypes.includes(walletType as WalletType)) && t.options.length > 0);
 
   const selectConnector = async (t: OmniConnector) => {
     if (t.wallets[0]) return t.disconnect();

package/src/ui/profile/Payment.tsx

@@ -4,7 +4,6 @@ import styled from "styled-components";
 
 import { HelpIcon } from "../icons/help";
 import { WalletIcon } from "../icons/wallet";
-import { PopupOption, PopupOptionInfo } from "../styles";
 
 import { Commitment, Intents } from "../../core";
 import { BridgeReview } from "../../core/exchange";
@@ -17,9 +16,10 @@ import { ActionButton } from "../uikit/button";
 import { H6, PSmall } from "../uikit/text";
 import { Loader } from "../uikit/loader";
 
-import { openConnector } from "../router";
+import { PopupOption, PopupOptionInfo } from "../styles";
 import { HotConnector } from "../../HotConnector";
 import { TokenCard } from "../bridge/TokenCard";
+import { openConnector } from "../router";
 import Popup from "../Popup";
 
 interface PaymentProps {
@@ -81,11 +81,12 @@ export const Payment = observer(({ connector, intents, title = "Payment", allowe
     const isStable = isStableFrom && isStableTo;
 
     let tasks: Promise<BridgeReview>[] = [];
-    if (isStable) {
+    if (isStable && !isDirectDeposit) {
       const slippages = [0.0005, 0.001, 0.0015];
-      tasks = slippages.map((slippage) =>
-        connector.exchange.reviewSwap({
-          amount: needAmount + (isDirectDeposit ? 0n : (needAmount * BigInt(Math.floor(slippage * 1000))) / BigInt(1000)),
+      tasks = slippages.map((slippage) => {
+        const extra = (needAmount * BigInt(Math.floor(slippage * 1000))) / BigInt(1000);
+        return connector.exchange.reviewSwap({
+          amount: from.int(payableToken.float(needAmount + extra)),
           recipient: intents.signer!,
           slippage: slippage,
           sender: wallet,
@@ -93,12 +94,12 @@ export const Payment = observer(({ connector, intents, title = "Payment", allowe
           type: "exactIn",
           to: payableToken,
           from,
-        })
-      );
+        });
+      });
     }
 
-    tasks.push(
-      connector.exchange.reviewSwap({
+    const exectOutReview = await connector.exchange
+      .reviewSwap({
         slippage: isStable ? STABLE_SLIPPAGE : PAY_SLIPPAGE,
         recipient: intents.signer!,
         amount: needAmount,
@@ -108,7 +109,7 @@ export const Payment = observer(({ connector, intents, title = "Payment", allowe
         to: payableToken,
         from,
       })
-    );
+      .catch(() => null);
 
     for (const task of tasks) {
       const review = await task.catch((e) => {
@@ -116,12 +117,22 @@ export const Payment = observer(({ connector, intents, title = "Payment", allowe
         return null;
       });
 
+      // console.log(task);
       if (!review) continue;
+      // console.log(review.to.float(review.minAmountOut), review.to.float(needAmount));
       if (review.minAmountOut < needAmount) continue;
+
+      // If exact out review is available and it's qoute is better than the exact in qoute, skip the exact in qoute
+      // console.log("EXACT IN", review.from.float(review.amountIn), "EXECT_OUT", exectOutReview?.from.float(exectOutReview.amountIn));
+      if (exectOutReview != null && review.amountIn > exectOutReview.amountIn) continue;
+
+      // console.log("RESULT EXACT IN", review);
       return setFlow({ token: from, wallet, review, step: "sign" });
     }
 
-    setFlow({ token: from, wallet, error: true, step: "sign" });
+    if (exectOutReview == null) return setFlow({ token: from, wallet, error: true, step: "sign" });
+    setFlow({ token: from, wallet, review: exectOutReview, step: "sign" });
+    // console.log("RESULT EXECT OUT", exectOutReview);
   };
 
   const signStep = async () => {

package/src/ui/profile/Profile.tsx

@@ -64,7 +64,7 @@ export const Profile = observer(({ hot, onClose }: { hot: HotConnector; onClose:
           ))
         )}
 
-        {hot.wallets.length < 6 && (
+        {hot.wallets.length < hot.connectors.length && (
           <WalletCard style={{ paddingRight: 12 }} onClick={() => openConnector(hot)}>
             <PlusIcon />
             Add wallet