@hot-labs/kit 1.4.26 → 1.5.0

package/src/evm/wallet.ts

@@ -111,6 +111,8 @@ class EvmWallet extends OmniWallet {
   }
 
   async transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }): Promise<string> {
+    if (args.token.isOmni) return await super.transfer(args);
+
     if (args.token.address === "native") {
       return await this.sendTransaction({
         ...args.gasFee?.evmGas,

package/src/hocraft/connector.ts

@@ -0,0 +1,35 @@
+import { ConnectorType, OmniConnector } from "../core/OmniConnector";
+import { Network, WalletType } from "../core/chains";
+import { OmniWallet } from "../core/OmniWallet";
+import { HotConnector } from "../HotConnector";
+import HotCraftWallet from "./wallet";
+
+export default class HotCraftConnector extends OmniConnector<HotCraftWallet> {
+  walletTypes = [WalletType.HotCraft];
+  type = ConnectorType.HOTCRAFT;
+  icon = "https://hotcraft.art/favicon-beige.ico";
+  name = "HotCraft";
+  id = "hotcraft";
+
+  constructor(readonly wibe3: HotConnector) {
+    super(wibe3);
+
+    wibe3.onConnect(async ({ wallet }) => {
+      if (wallet.type === WalletType.HotCraft) return;
+      const craftWallet = new HotCraftWallet(wallet, wibe3.storage);
+      const balances = await craftWallet.fetchBalances(Network.HotCraft);
+      if (Object.values(balances).some((balance) => balance === 0n)) return;
+      this.setWallet({ wallet: craftWallet, isNew: false });
+    });
+
+    wibe3.onDisconnect(async ({ wallet }) => {
+      if (wallet.type === WalletType.HotCraft) return;
+      const craftWallet = this.wallets.find((t) => t.wallet === wallet);
+      if (craftWallet) this.removeWallet(craftWallet);
+    });
+  }
+
+  async connect(id?: string): Promise<OmniWallet | { qrcode: string; deeplink?: string; task: Promise<OmniWallet> }> {
+    throw "Not supported";
+  }
+}

package/src/hocraft/index.ts

@@ -0,0 +1,7 @@
+import { HotConnector } from "../HotConnector";
+import HotCraftConnector from "./connector";
+import HotCraftWallet from "./wallet";
+
+export { HotCraftConnector, HotCraftWallet };
+
+export default () => async (wibe3: HotConnector) => new HotCraftConnector(wibe3);

package/src/hocraft/wallet.ts

@@ -0,0 +1,166 @@
+import crypto from "node:crypto";
+import { base32crockford, base58, base64 } from "@scure/base";
+import { KeyPair, KeyPairString } from "@near-js/crypto";
+
+import { Commitment, Intents, Network, OmniToken, OmniWallet, ReviewFee, Token, WalletType } from "../core";
+import { AutoQueue } from "../core/utils";
+import { DataStorage } from "../storage";
+import { rpc } from "../near/rpc";
+
+export const TGAS = 1_000_000_000_000n;
+
+class HotCraftAccount extends OmniWallet {
+  publicKey?: string | undefined;
+  type = WalletType.HotCraft;
+  omniAddress: string;
+  address: string;
+
+  constructor(readonly wallet: OmniWallet, readonly storage: DataStorage) {
+    super();
+    this.omniAddress = HotCraftAccount.getTradingAddress(wallet.omniAddress);
+    this.address = this.omniAddress;
+  }
+
+  get icon() {
+    return this.wallet.icon;
+  }
+
+  async getTradingKey() {
+    const tradingKey = await this.storage.get(`hotcraft:${this.omniAddress}:key`);
+    if (tradingKey) return KeyPair.fromString(tradingKey as KeyPairString);
+
+    const newTradingKey = KeyPair.fromRandom("ed25519");
+    await this.storage.set(`hotcraft:${this.omniAddress}:key`, newTradingKey.toString());
+    return newTradingKey;
+  }
+
+  static getTradingAddress(signerId: string) {
+    const buffer = crypto.createHash("sha256").update(Buffer.from(signerId, "utf8")).digest();
+    const hash = base32crockford.encode(buffer.slice(0, 20)).toLowerCase();
+    return `${hash}.craft.tg`;
+  }
+
+  async getAuthCommitment({ forceRegister = false }: { forceRegister?: boolean } = {}) {
+    const tradingKey = await this.getTradingKey();
+    const commitment = await this.storage.get(`hotcraft:${this.omniAddress}:auth`);
+
+    try {
+      if (!commitment || forceRegister) throw new Error("No credentials found");
+      if (!commitment.includes(tradingKey.getPublicKey().toString())) throw "Invalid commitment";
+      return JSON.parse(commitment) as Commitment;
+    } catch (error) {
+      const commitment = await this.wallet
+        .intents()
+        .authCall({
+          contractId: "craft.tg",
+          attachNear: 0n,
+          tgas: 250,
+          msg: JSON.stringify({
+            public_key: tradingKey.getPublicKey().toString(),
+            force_register: forceRegister,
+            referral: "hotcraft.art",
+          }),
+        })
+        .sign();
+
+      await this.storage.set(`hotcraft:${this.omniAddress}:auth`, JSON.stringify(commitment));
+      return commitment;
+    }
+  }
+
+  async transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }): Promise<string> {
+    if (args.token.chain !== Network.HotCraft) throw new Error("Invalid token chain");
+    return await this.intents()
+      .transfer({ amount: args.amount, recipient: args.receiver, token: args.token.omniAddress as OmniToken })
+      .execute();
+  }
+
+  _isRegistered = false;
+  async isRegistered() {
+    if (this._isRegistered) return true;
+    const tradingKey = await this.getTradingKey();
+    const result = await rpc.viewMethod({
+      args: { account_id: this.omniAddress, public_key: tradingKey.getPublicKey().toString() },
+      methodName: "has_public_key",
+      contractId: "intents.near",
+    });
+
+    this._isRegistered = result;
+    return this._isRegistered;
+  }
+
+  async doubleCheckRegister() {
+    if (await this.isRegistered()) return true;
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    return await this.isRegistered();
+  }
+
+  async fetchBalance(chain: number, address: string): Promise<bigint> {
+    if (chain !== Network.HotCraft) return 0n;
+    if (!this.omniAddress) return 0n;
+    const balances = await Intents.getIntentsBalances([address], this.omniAddress);
+    return this.setBalance(`${Network.HotCraft}:${address}`, balances[address] || 0n);
+  }
+
+  async fetchBalances(chain: number, whitelist: string[] = []): Promise<Record<string, bigint>> {
+    if (chain !== Network.HotCraft) return {};
+    if (!this.omniAddress) return {};
+
+    const list = whitelist.length > 0 ? whitelist : await Intents.getIntentsAssets(this.omniAddress);
+    const balances = await Intents.getIntentsBalances(list, this.omniAddress);
+    Object.entries(balances).forEach(([address, balance]) => this.setBalance(`${Network.HotCraft}:${address}`, BigInt(balance as unknown as string)));
+    return balances;
+  }
+
+  private queue = new AutoQueue();
+  async registerAccount(): Promise<KeyPair> {
+    return await this.queue.enqueue<KeyPair>(async () => {
+      const tradingKey = await this.getTradingKey();
+      try {
+        if (await this.isRegistered()) return tradingKey;
+        const commitment = await this.getAuthCommitment();
+        console.log("commitment", commitment);
+
+        await Intents.publish([commitment]);
+
+        if (await this.doubleCheckRegister()) return tradingKey;
+        throw "We can't register your account, please try reconnect wallet";
+      } catch (error) {
+        if (await this.doubleCheckRegister()) return tradingKey;
+        if (!error?.toString()?.includes?.("AccountDoesNotExist")) {
+          throw "We can't register your account, please try reconnect wallet";
+        }
+
+        const commitment = await this.getAuthCommitment({ forceRegister: true });
+        console.log("commitment", commitment);
+
+        await Intents.publish([commitment]);
+        return await this.registerAccount();
+      }
+    });
+  }
+
+  async signIntents(intents: Record<string, any>[], options?: { nonce?: Uint8Array; deadline?: number; signerId?: string }): Promise<Commitment> {
+    const tradingKey = await this.registerAccount();
+    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",
+      signer_id: options?.signerId || this.omniAddress,
+      verifying_contract: "intents.near",
+      nonce: base64.encode(nonce),
+      intents: intents,
+    });
+
+    const signature = tradingKey.sign(Buffer.from(message, "utf8"));
+
+    return {
+      standard: "raw_ed25519",
+      payload: message,
+      signature: "ed25519:" + base58.encode(signature.signature),
+      public_key: tradingKey.getPublicKey().toString(),
+    };
+  }
+}
+
+export default HotCraftAccount;

package/src/near/wallet.ts

@@ -140,6 +140,8 @@ export default class NearWallet extends OmniWallet {
   }
 
   async transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }) {
+    if (args.token.isOmni) return await super.transfer(args);
+
     if (args.token.address === "native") {
       return await this.sendTransaction({
         actions: [{ type: "Transfer", params: { deposit: String(args.amount) } }],

package/src/solana/wallet.ts

@@ -162,6 +162,7 @@ class SolanaWallet extends OmniWallet {
   }
 
   async transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee: ReviewFee }): Promise<string> {
+    if (args.token.isOmni) return await super.transfer(args);
     const { instructions } = await this.buildTranferInstructions(args.token, args.amount, args.receiver, args.gasFee);
     return await this.sendTransaction(instructions);
   }

package/src/stellar/wallet.ts

@@ -157,6 +157,7 @@ class StellarWallet extends OmniWallet {
   }
 
   async transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }) {
+    if (args.token.isOmni) return await super.transfer(args);
     const { tx } = await this.emulateTransfer(args.token.address, args.receiver, args.amount, args.comment);
     return this.sendTransaction(tx);
   }

package/src/ton/wallet.ts

@@ -122,6 +122,7 @@ class TonWallet extends OmniWallet {
   }
 
   async transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }) {
+    if (args.token.isOmni) return await super.transfer(args);
     const memo = args.comment ? comment(args.comment) : null;
 
     if (args.token.address === "native") {

package/src/tron/wallet.ts

@@ -84,6 +84,7 @@ class TronWallet extends OmniWallet {
   }
 
   async transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }): Promise<string> {
+    if (args.token.isOmni) return await super.transfer(args);
     if (!this.tronWeb.trx) throw new Error("TronLink not available");
 
     if (args.token.address === "native") {

package/src/ui/bridge/Bridge.tsx

@@ -8,7 +8,7 @@ import ExchangeIcon from "../icons/exchange";
 import RefreshIcon from "../icons/refresh";
 
 import { HotConnector } from "../../HotConnector";
-import { chains, WalletType } from "../../core/chains";
+import { chains, Network, WalletType } from "../../core/chains";
 import { BridgeReview } from "../../core/exchange";
 import { OmniWallet } from "../../core/OmniWallet";
 import { Recipient } from "../../core/recipient";
@@ -17,7 +17,7 @@ import { tokens } from "../../core/tokens";
 import { Token } from "../../core/token";
 
 import { ActionButton, Button } from "../uikit/button";
-import { PLarge, PSmall, PTiny } from "../uikit/text";
+import { PLarge, PMedium, PSmall, PTiny } from "../uikit/text";
 import { Skeleton } from "../uikit/loader";
 import { ImageView } from "../uikit/image";
 
@@ -43,8 +43,6 @@ export interface BridgeProps {
     autoClose?: boolean; // if true, the popup will close automatically when the transaction is successful
     title?: string;
     readonlyAmount?: boolean;
-    readonlyTo?: boolean;
-    readonlyFrom?: boolean;
     type?: "exactIn" | "exactOut";
     sender?: OmniWallet;
     recipient?: Recipient;
@@ -115,8 +113,8 @@ export const Bridge = observer(({ hot, widget, setup, onClose, onProcess, onSele
   const availableBalance = sender !== "qr" ? +Math.max(0, from.float(hot.balance(sender, from)) - from.reserve).toFixed(FIXED) : 0;
 
   let title = "Exchange";
-  if (from.chain === -4) title = `Withdraw ${from.symbol}`;
-  if (to.chain === -4) title = `Deposit ${to.symbol}`;
+  if (from.chain === Network.HotCraft || from.chain === Network.Omni) title = `Withdraw ${from.symbol}`;
+  if (to.chain === Network.HotCraft || to.chain === Network.Omni) title = `Deposit ${to.symbol}`;
   if (to.chain === from.chain) title = "Exchange";
 
   useEffect(() => {
@@ -285,12 +283,13 @@ export const Bridge = observer(({ hot, widget, setup, onClose, onProcess, onSele
   if (processing?.status === "error") {
     return (
       <Popup widget={widget} onClose={onClose} header={<p>{title}</p>} mobileFullscreen={setup?.mobileFullscreen}>
-        <div style={{ width: "100%", height: 400, gap: 8, display: "flex", justifyContent: "center", alignItems: "center", flexDirection: "column" }}>
+        <div style={{ width: "100%", height: 400, marginBottom: 8, gap: 8, display: "flex", justifyContent: "center", alignItems: "center", flexDirection: "column" }}>
           {/* @ts-expect-error: dotlottie-wc is not typed */}
           <dotlottie-wc key="error" src={animations.failed} speed="1" style={{ width: 300, height: 300 }} mode="forward" loop autoplay></dotlottie-wc>
           <p style={{ fontSize: 24, marginTop: -32, fontWeight: "bold" }}>{title} failed</p>
-          <p style={{ fontSize: 14 }}>{processing.message}</p>
+          <TextField>{processing.message}</TextField>
         </div>
+
         <ActionButton onClick={() => (cancelReview(), onClose())}>Continue</ActionButton>
       </Popup>
     );
@@ -338,10 +337,15 @@ export const Bridge = observer(({ hot, widget, setup, onClose, onProcess, onSele
 
           <CardBody>
             <div style={{ width: "100%", display: "flex", alignItems: "center", gap: 8, justifyContent: "space-between" }}>
-              <TokenPreview //
-                onSelect={() => openSelectTokenPopup({ onSelect: (token, wallet) => (setFrom(token), setSender(wallet)), initialChain: from.chain, hot })}
-                style={{ pointerEvents: setup?.readonlyFrom ? "none" : "all" }}
+              <TokenPreview
                 token={from}
+                onSelect={() =>
+                  openSelectTokenPopup({
+                    onSelect: (token, wallet) => (setFrom(token), setSender(wallet)),
+                    initialChain: from.chain,
+                    hot,
+                  })
+                }
               />
 
               {isReviewing && type === "exactOut" ? (
@@ -404,6 +408,7 @@ export const Bridge = observer(({ hot, widget, setup, onClose, onProcess, onSele
                     </Button>
                   </AvailableBalance>
                 )}
+
                 {sender === "qr" && <div />}
                 <div style={{ display: "flex", alignItems: "center", gap: 4 }}>
                   {from.usd !== 0 && <PSmall style={{ marginRight: 8 }}>${from.readable(amountFrom, from.usd)}</PSmall>}
@@ -460,9 +465,8 @@ export const Bridge = observer(({ hot, widget, setup, onClose, onProcess, onSele
 
           <CardBody style={{ borderRadius: "0 0 20px 20px" }}>
             <div style={{ width: "100%", display: "flex", alignItems: "center", gap: 8, justifyContent: "space-between" }}>
-              <TokenPreview //
+              <TokenPreview
                 token={to}
-                style={{ pointerEvents: setup?.readonlyTo ? "none" : "all" }}
                 onSelect={() =>
                   openSelectTokenPopup({
                     hot,
@@ -516,6 +520,19 @@ const TokenPreview = ({ style, token, onSelect }: { style?: React.CSSProperties;
   );
 };
 
+const TextField = styled(PTiny)`
+  width: 100%;
+  overflow: auto;
+  max-height: 200px;
+  background: #2c2c2c;
+  border-radius: 12px;
+  font-size: 12px;
+  padding: 8px;
+  margin-bottom: 12px;
+  white-space: pre-wrap;
+  line-break: anywhere;
+`;
+
 const Tooltip = styled.div`
   transition: 0.2s transform, 0.2s opacity;
   transform: translateY(8px);

package/src/ui/bridge/TokenCard.tsx

@@ -14,7 +14,7 @@ export const TokenIcon = observer(({ token, wallet, withoutChain, size = 40 }: {
     <div style={{ position: "relative", width: size, height: size, flexShrink: 0 }}>
       <ImageView src={token.icon} alt={token.symbol} size={size} />
       {!withoutChain && <ImageView src={token.chainIcon} alt={token.symbol} size={size / 2 - 6} style={{ position: "absolute", bottom: 0, right: 0 }} />}
-      {token.chain === -4 && wallet?.type && <ImageView src={wallet.icon} alt={chains.getByType(wallet.type)?.[0]?.name || ""} size={size / 2 - 6} style={{ position: "absolute", bottom: 0, left: 0 }} />}
+      {token.isOmni && wallet?.type && <ImageView src={wallet.icon} alt={chains.getByType(wallet.type)?.[0]?.name || ""} size={size / 2 - 6} style={{ position: "absolute", bottom: 0, left: 0 }} />}
     </div>
   );
 });
@@ -22,7 +22,7 @@ export const TokenIcon = observer(({ token, wallet, withoutChain, size = 40 }: {
 export const TokenCard = observer(
   ({ token, onSelect, amount, hot, wallet, rightControl }: { rightControl?: React.ReactNode; token: Token; onSelect?: (token: Token, wallet?: OmniWallet) => void; amount?: bigint; hot: HotConnector; wallet?: OmniWallet }) => {
     const balance = amount || hot.balance(wallet, token);
-    const symbol = token.chain === -4 && !token.isMainOmni ? `${token.symbol} (${token.originalChainSymbol})` : token.symbol;
+    const symbol = token.isOmni && !token.isMainOmni ? `${token.symbol} (${token.originalChainSymbol})` : token.symbol;
 
     return (
       <Card key={token.id} onClick={() => onSelect?.(token, wallet)}>

package/src/ui/profile/Profile.tsx

@@ -11,7 +11,7 @@ import { Loader } from "../uikit/loader";
 import { OmniWallet } from "../../core/OmniWallet";
 import { ConnectorType } from "../../core/OmniConnector";
 import { formatter } from "../../core/utils";
-import { OmniToken } from "../../core/chains";
+import { Network, OmniToken } from "../../core/chains";
 import { tokens } from "../../core/tokens";
 
 import { HotConnector } from "../../HotConnector";
@@ -32,7 +32,7 @@ export const Profile = observer(({ hot, onClose }: { hot: HotConnector; onClose:
         component: (
           <TokenCard //
             onSelect={() => {
-              if (token.chain === -4) hot.withdraw(token.address as OmniToken, +token.float(balance).toFixed(6), { sender: wallet });
+              if (token.chain === Network.Omni || token.chain === Network.HotCraft) hot.withdraw(token.address as OmniToken, +token.float(balance).toFixed(6), { sender: wallet });
               else openBridge(hot, { title: "Exchange", sender: wallet, from: token });
             }}
             key={`${wallet.type}:${wallet.address}:${token.id}`}
@@ -45,8 +45,8 @@ export const Profile = observer(({ hot, onClose }: { hot: HotConnector; onClose:
     })
     .filter((t) => t != null);
 
-  const omniTokens = tokensList.filter((t) => t.chain === -4);
-  const nonOmniTokens = tokensList.filter((t) => t.chain !== -4);
+  const omniTokens = tokensList.filter((t) => t.chain === Network.Omni || t.chain === Network.HotCraft);
+  const nonOmniTokens = tokensList.filter((t) => t.chain !== Network.Omni && t.chain !== Network.HotCraft);
   const socialConnector = hot.connectors.find((connector) => connector.type === ConnectorType.SOCIAL && connector.wallets.length > 0);
 
   useEffect(() => {
@@ -57,16 +57,17 @@ export const Profile = observer(({ hot, onClose }: { hot: HotConnector; onClose:
   return (
     <Popup onClose={onClose} style={{ gap: 16 }}>
       <div style={{ display: "flex", flexWrap: "wrap", width: "100%", gap: 8 }}>
-        {hot.connectors.map((connector) =>
-          connector.wallets.map((wallet) => (
+        {hot.connectors.map((connector) => {
+          if (connector.type === ConnectorType.HOTCRAFT) return null;
+          return connector.wallets.map((wallet) => (
             <WalletCard onClick={() => connector.disconnect()}>
-              <ImageView src={wallet.icon} alt={connector.name} size={20} />
-              {connector.type === ConnectorType.SOCIAL && <ImageView style={{ position: "absolute", bottom: 4, left: 20 }} src={connector.icon} alt={connector.name} size={12} />}
+              <ImageView src={connector.icon} alt={connector.name} size={20} />
+              {connector.icon !== wallet.icon && <ImageView style={{ position: "absolute", bottom: 4, left: 20 }} src={wallet.icon} alt={connector.name} size={12} />}
               <div>{formatter.truncateAddress(wallet.address, 8)}</div>
               <LogoutIcon />
             </WalletCard>
-          ))
-        )}
+          ));
+        })}
 
         {hot.wallets.length < hot.connectors.length && (
           <WalletCard