@hot-labs/kit 1.0.48 → 1.0.51

package/src/near/wallet.ts

@@ -1,5 +1,5 @@
 import { NearWalletBase, SignMessageParams, SignedMessage, SignAndSendTransactionParams } from "@hot-labs/near-connect";
-import { base64, base58, hex } from "@scure/base";
+import { base64, base58 } from "@scure/base";
 import { Action } from "@near-js/transactions";
 
 import { OmniConnector } from "../OmniConnector";
@@ -8,6 +8,7 @@ import { WalletType } from "../core/chains";
 import { ReviewFee } from "../core/bridge";
 import { rpc, TGAS } from "../core/nearRpc";
 import { Token } from "../core/token";
+import { Commitment } from "../core";
 
 export default class NearWallet extends OmniWallet {
   readonly type = WalletType.NEAR;
@@ -102,6 +103,7 @@ export default class NearWallet extends OmniWallet {
   }
 
   async needRegisterToken(token: string, address: string): Promise<boolean> {
+    if (token === "native") return false;
     const storage = await rpc.viewMethod({ contractId: token, methodName: "storage_balance_of", args: { account_id: address } }).catch(() => null);
     return storage == null;
   }
@@ -188,27 +190,7 @@ export default class NearWallet extends OmniWallet {
     return await this.sendTransaction({ receiverId: args.token.address, actions });
   }
 
-  async signIntentsWithAuth(domain: string, intents?: Record<string, any>[]) {
-    if (!this.wallet) throw "not impl";
-    const accounts = await this.wallet.getAccounts();
-    if (accounts.length === 0) throw new Error("No account found");
-    const { accountId, publicKey } = accounts[0];
-
-    const seed = hex.encode(window.crypto.getRandomValues(new Uint8Array(32)));
-    const msgBuffer = new TextEncoder().encode(`${domain}_${seed}`);
-    const nonce = await window.crypto.subtle.digest("SHA-256", new Uint8Array(msgBuffer));
-
-    return {
-      signed: await this.signIntents(intents || [], { nonce: new Uint8Array(nonce) }),
-      chainId: WalletType.NEAR,
-      publicKey: publicKey,
-      address: accountId,
-      domain,
-      seed,
-    };
-  }
-
-  async signIntents(intents: Record<string, any>[], options?: { nonce?: Uint8Array; deadline?: number }): Promise<Record<string, any>> {
+  async signIntents(intents: Record<string, any>[], options?: { nonce?: Uint8Array; deadline?: number }): Promise<Commitment> {
     if (!this.wallet) throw "not impl";
 
     const nonce = new Uint8Array(options?.nonce || window.crypto.getRandomValues(new Uint8Array(32)));

package/src/solana/wallet.ts

@@ -20,17 +20,21 @@ import { OmniWallet } from "../OmniWallet";
 import { Token } from "../core/token";
 import { formatter } from "../core/utils";
 import { ReviewFee } from "../core/bridge";
+import { Commitment } from "../core";
+import { api } from "../core/api";
 
 import { ISolanaProtocolWallet } from "./protocol";
 
 class SolanaWallet extends OmniWallet {
   readonly type = WalletType.SOLANA;
-  readonly connection: Connection;
 
   constructor(readonly connector: OmniConnector, readonly wallet: ISolanaProtocolWallet) {
     super(connector);
-    this.connection = new Connection("https://api0.herewallet.app/api/v1/evm/rpc/1001", {
-      httpHeaders: { "Api-Key": connector.wibe3.api.apiKey },
+  }
+
+  getConnection() {
+    return new Connection(api.getRpcUrl(Network.Solana), {
+      httpHeaders: { "Api-Key": api.apiKey },
     });
   }
 
@@ -47,13 +51,15 @@ class SolanaWallet extends OmniWallet {
   }
 
   async fetchBalance(_: number, address: string) {
+    const connection = this.getConnection();
+
     if (address === "native") {
-      const balance = await this.connection.getBalance(new PublicKey(this.address));
+      const balance = await connection.getBalance(new PublicKey(this.address));
       return BigInt(balance);
     }
 
     const ATA = getAssociatedTokenAddressSync(new PublicKey(address), new PublicKey(this.address));
-    const meta = await this.connection.getTokenAccountBalance(ATA);
+    const meta = await connection.getTokenAccountBalance(ATA);
     return BigInt(meta.value.amount);
   }
 
@@ -62,25 +68,12 @@ class SolanaWallet extends OmniWallet {
     super.disconnect();
   }
 
-  async signIntentsWithAuth(domain: string, intents?: Record<string, any>[]) {
-    const seed = hex.encode(window.crypto.getRandomValues(new Uint8Array(32)));
-    const msgBuffer = new TextEncoder().encode(`${domain}_${seed}`);
-    const nonce = await window.crypto.subtle.digest("SHA-256", new Uint8Array(msgBuffer));
-
-    return {
-      signed: await this.signIntents(intents || [], { nonce: new Uint8Array(nonce) }),
-      publicKey: `ed25519:${this.address}`,
-      chainId: WalletType.SOLANA,
-      address: this.address,
-      seed,
-    };
-  }
-
   async buildTranferInstructions(token: Token, amount: bigint, receiver: string, fee: ReviewFee) {
     const destination = new PublicKey(receiver);
     const owner = new PublicKey(this.address);
+    const connection = this.getConnection();
 
-    const reserve = await this.connection.getMinimumBalanceForRentExemption(0);
+    const reserve = await connection.getMinimumBalanceForRentExemption(0);
     let additionalFee = 0n;
 
     if (token.address === "native") {
@@ -96,7 +89,7 @@ class SolanaWallet extends OmniWallet {
     }
 
     const mint = new PublicKey(token.address);
-    const mintAccount = await this.connection.getAccountInfo(mint);
+    const mintAccount = await connection.getAccountInfo(mint);
     const tokenProgramId = mintAccount?.owner.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID;
 
     const tokenFrom = getAssociatedTokenAddressSync(mint, owner, false, tokenProgramId);
@@ -104,11 +97,11 @@ class SolanaWallet extends OmniWallet {
 
     const instructions: TransactionInstruction[] = [ComputeBudgetProgram.setComputeUnitPrice({ microLamports: Number(fee.baseFee) }), ComputeBudgetProgram.setComputeUnitLimit({ units: Number(fee.gasLimit) })];
 
-    const isRegistered = await getAccount(this.connection, tokenTo, "confirmed", tokenProgramId).catch(() => null);
+    const isRegistered = await getAccount(connection, tokenTo, "confirmed", tokenProgramId).catch(() => null);
     if (isRegistered == null) {
       const inst = createAssociatedTokenAccountInstruction(new PublicKey(this.address), tokenTo, destination, mint, tokenProgramId, ASSOCIATED_TOKEN_PROGRAM_ID);
       instructions.push(inst);
-      additionalFee += BigInt(await getMinimumBalanceForRentExemptAccount(this.connection));
+      additionalFee += BigInt(await getMinimumBalanceForRentExemptAccount(connection));
     }
 
     if (tokenProgramId === TOKEN_2022_PROGRAM_ID) {
@@ -121,7 +114,8 @@ class SolanaWallet extends OmniWallet {
   }
 
   async transferFee(token: Token, receiver: string): Promise<ReviewFee> {
-    const { blockhash } = await this.connection.getLatestBlockhash();
+    const connection = this.getConnection();
+    const { blockhash } = await connection.getLatestBlockhash();
     const fee = new ReviewFee({ chain: Network.Solana, gasLimit: 1_400_000n, baseFee: 100n });
     const { instructions, additionalFee, reserve } = await this.buildTranferInstructions(token, 1n, receiver, fee);
 
@@ -134,10 +128,10 @@ class SolanaWallet extends OmniWallet {
     });
 
     if (priorityFeeData?.priorityFeeLevels == null) throw "Failed to fetch gas";
-    const simulate = await this.connection.simulateTransaction(tx).catch(() => null);
+    const simulate = await connection.simulateTransaction(tx).catch(() => null);
     const unitsConsumed = formatter.bigIntMax(BigInt(simulate?.value.unitsConsumed || 10_000n), 10_000n);
 
-    const msgFee = await this.connection.getFeeForMessage(msgForEstimate);
+    const msgFee = await connection.getFeeForMessage(msgForEstimate);
     const medium = BigInt(priorityFeeData.priorityFeeLevels.medium);
     const high = BigInt(priorityFeeData.priorityFeeLevels.high);
     const veryHigh = BigInt(priorityFeeData.priorityFeeLevels.veryHigh);
@@ -158,7 +152,7 @@ class SolanaWallet extends OmniWallet {
   }
 
   async getPriorityFeeEstimate(params: any): Promise<any> {
-    const response = await fetch("https://api0.herewallet.app/api/v1/evm/helius/staked", {
+    const response = await fetch(api.baseUrl + "/api/v1/wibe3/helius/staked", {
       body: JSON.stringify({ jsonrpc: "2.0", id: "helius-sdk", method: "getPriorityFeeEstimate", params: [params] }),
       headers: { "Content-Type": "application/json" },
       method: "POST",
@@ -178,20 +172,23 @@ class SolanaWallet extends OmniWallet {
 
   async sendTransaction(instructions: TransactionInstruction[]): Promise<string> {
     if (!this.wallet.sendTransaction) throw "not impl";
-    const { blockhash } = await this.connection.getLatestBlockhash();
+    const connection = this.getConnection();
+    const { blockhash } = await connection.getLatestBlockhash();
     const message = new TransactionMessage({ payerKey: new PublicKey(this.address), recentBlockhash: blockhash, instructions });
     const transaction = new VersionedTransaction(message.compileToV0Message());
-    return await this.wallet.sendTransaction(transaction, this.connection, { preflightCommitment: "confirmed" });
+    return await this.wallet.sendTransaction(transaction, connection, { preflightCommitment: "confirmed" });
   }
 
   async fetchBalances(chain: number, whitelist: string[]): Promise<Record<string, bigint>> {
     const native = await this.fetchBalance(chain, "native");
+    const connection = this.getConnection();
+
     try {
       const res = await fetch(`https://api0.herewallet.app/api/v1/user/balances/${chain}/${this.address}`, { body: JSON.stringify({ whitelist }), method: "POST" });
       const { balances } = await res.json();
       return { ...balances, native };
     } catch {
-      const tokenAccounts = await this.connection.getParsedTokenAccountsByOwner(new PublicKey(this.address), { programId: TOKEN_PROGRAM_ID });
+      const tokenAccounts = await connection.getParsedTokenAccountsByOwner(new PublicKey(this.address), { programId: TOKEN_PROGRAM_ID });
       const balances = Object.fromEntries(
         tokenAccounts.value.map((account) => {
           const { mint, tokenAmount } = account.account.data.parsed.info;
@@ -208,7 +205,7 @@ class SolanaWallet extends OmniWallet {
     return this.wallet.signMessage(message);
   }
 
-  async signIntents(intents: Record<string, any>[], options?: { deadline?: number; nonce?: Uint8Array }): Promise<Record<string, any>> {
+  async signIntents(intents: Record<string, any>[], options?: { deadline?: number; nonce?: Uint8Array }): Promise<Commitment> {
     const nonce = new Uint8Array(options?.nonce || window.crypto.getRandomValues(new Uint8Array(32)));
 
     const message = JSON.stringify({

package/src/stellar/wallet.ts

@@ -9,6 +9,7 @@ import { ReviewFee } from "../core/bridge";
 import { formatter } from "../core/utils";
 import { Network } from "../core/chains";
 import { Token } from "../core/token";
+import { Commitment } from "../core";
 
 interface ProtocolWallet {
   signTransaction?: (transaction: Transaction) => Promise<{ signedTxXdr: string }>;
@@ -149,20 +150,6 @@ class StellarWallet extends OmniWallet {
     return this.sendTransaction(tx);
   }
 
-  async signIntentsWithAuth(domain: string, intents?: Record<string, any>[]) {
-    const seed = hex.encode(window.crypto.getRandomValues(new Uint8Array(32)));
-    const msgBuffer = new TextEncoder().encode(`${domain}_${seed}`);
-    const nonce = await window.crypto.subtle.digest("SHA-256", new Uint8Array(msgBuffer));
-
-    return {
-      signed: await this.signIntents(intents || [], { nonce: new Uint8Array(nonce) }),
-      publicKey: `ed25519:${this.publicKey}`,
-      chainId: WalletType.STELLAR,
-      address: this.address,
-      seed,
-    };
-  }
-
   async sendTransaction(transaction: Transaction) {
     if (!this.wallet.signTransaction) throw "not impl";
     const result = await this.wallet.signTransaction(transaction);
@@ -176,7 +163,7 @@ class StellarWallet extends OmniWallet {
     return await this.wallet.signMessage(message);
   }
 
-  async signIntents(intents: Record<string, any>[], options?: { deadline?: number; nonce?: Uint8Array }): Promise<Record<string, any>> {
+  async signIntents(intents: Record<string, any>[], options?: { deadline?: number; nonce?: Uint8Array }): Promise<Commitment> {
     const nonce = new Uint8Array(options?.nonce || window.crypto.getRandomValues(new Uint8Array(32)));
 
     const message = JSON.stringify({

package/src/ton/connector.ts

@@ -14,28 +14,19 @@ export interface TonConnectorOptions {
 }
 
 const hotWallet = {
-  app_name: "hot",
   name: "HOT",
+  app_name: "hot",
   image: "https://raw.githubusercontent.com/hot-dao/media/main/logo.png",
   about_url: "https://hot-labs.org/",
   universal_url: "https://t.me/herewalletbot?attach=wallet",
   bridge: [
-    {
-      type: "sse",
-      url: "https://sse-bridge.hot-labs.org",
-    },
-    {
-      type: "js",
-      key: "hotWallet",
-    },
+    { type: "sse", url: "https://sse-bridge.hot-labs.org" },
+    { type: "js", key: "hotWallet" },
   ],
   platforms: ["ios", "android", "chrome", "firefox", "macos", "windows", "linux"],
   features: [
-    {
-      name: "SendTransaction",
-      maxMessages: 4,
-      extraCurrencySupported: false,
-    },
+    { name: "SendTransaction", maxMessages: 4, extraCurrencySupported: false },
+    { name: "SignData", types: ["text", "binary", "cell"] },
   ],
 };
 
@@ -69,6 +60,7 @@ class TonConnector extends OmniConnector<TonWallet> {
         connector: new TonConnect({
           walletsListSource: url,
           manifestUrl: this.args?.tonManifestUrl,
+          walletsRequiredFeatures: { signData: { types: ["text"] } },
         }),
       });
 

package/src/ton/wallet.ts

@@ -136,23 +136,6 @@ class TonWallet extends OmniWallet {
     return tx;
   }
 
-  async signIntentsWithAuth(domain: string, intents?: Record<string, unknown>[]) {
-    const address = this.wallet.account?.address;
-    if (!address) throw new Error("Wallet not connected");
-
-    const seed = hex.encode(window.crypto.getRandomValues(new Uint8Array(32)));
-    const msgBuffer = new TextEncoder().encode(`${domain}_${seed}`);
-    const nonce = await window.crypto.subtle.digest("SHA-256", new Uint8Array(msgBuffer));
-
-    return {
-      signed: await this.signIntents(intents || [], { nonce: new Uint8Array(nonce) }),
-      publicKey: `ed25519:${this.publicKey}`,
-      chainId: WalletType.TON,
-      address: address,
-      seed,
-    };
-  }
-
   async signIntents(intents: Record<string, unknown>[], options?: { deadline?: number; nonce?: Uint8Array }) {
     if (!this.wallet.signData) throw "Not impl";
     const nonce = new Uint8Array(options?.nonce || window.crypto.getRandomValues(new Uint8Array(32)));

package/src/ui/payment/Bridge.tsx

@@ -74,6 +74,11 @@ export const Bridge = observer(({ hot, widget, setup, onClose, onProcess, onSele
     return hot.wallets.find((w) => w.type === from.type);
   });
 
+  useEffect(() => {
+    if (from.type === WalletType.OMNI) setSender(hot.priorityWallet);
+    if (to.type === WalletType.OMNI) setRecipient(Recipient.fromWallet(hot.priorityWallet!));
+  }, [hot.priorityWallet]);
+
   const [recipient, setRecipient] = useState<Recipient | undefined>(() => {
     if (setup?.recipient) return setup.recipient;
     if (to.type === WalletType.OMNI) return Recipient.fromWallet(hot.priorityWallet!);
@@ -267,7 +272,7 @@ export const Bridge = observer(({ hot, widget, setup, onClose, onProcess, onSele
             <div style={{ display: "flex", alignItems: "center", gap: 8 }}>
               <p style={{ fontWeight: "bold" }}>{from.chain === -4 ? "Withdraw HEX from:" : "Send from:"}</p>
               <BadgeButton onClick={() => openSelectSender({ hot, type: from.type, onSelect: (wallet) => setSender(wallet) })}>
-                <p>{formatter.truncateAddress(sender === "qr" ? "QR code" : sender?.address ?? "Connect wallet")}</p>
+                <p>{formatter.truncateAddress(sender === "qr" ? "QR code" : sender?.address ?? "Select sender")}</p>
               </BadgeButton>
             </div>
           </div>