@hot-labs/kit 1.1.3 → 1.2.0-alpha.2

package/src/HotConnector.ts

@@ -8,12 +8,10 @@ import { OmniToken } from "./core/chains";
 import { formatter } from "./core/utils";
 import { Intents } from "./core/Intents";
 import { tokens } from "./core/tokens";
-import { Telemetry } from "./core/telemetry";
+import { rpc } from "./core/nearRpc";
 import { Token } from "./core/token";
 import { api } from "./core/api";
-import { rpc } from "./near/rpc";
 
-import { defaultConnectors } from "./defaults";
 import type CosmosWallet from "./cosmos/wallet";
 import type NearWallet from "./near/wallet";
 import type EvmWallet from "./evm/wallet";
@@ -21,7 +19,7 @@ import type SolanaWallet from "./solana/wallet";
 import type StellarWallet from "./stellar/wallet";
 import type TonWallet from "./ton/wallet";
 
-import { openBridge, openConnector, openProfile, openWalletPicker } from "./ui/router";
+import { openBridge, openConnector, openPayment, openProfile, openWalletPicker } from "./ui/router";
 import { ConnectorType, OmniConnector } from "./OmniConnector";
 import { OmniWallet } from "./OmniWallet";
 import { Exchange } from "./exchange";
@@ -45,15 +43,16 @@ interface HotConnectorOptions {
 export class HotConnector {
   public connectors: OmniConnector[] = [];
   public balances: Record<string, Record<string, bigint>> = {};
-  public telemetry: Telemetry;
 
   public activity: Activity;
   public hotBridge: HotBridge;
   public exchange: Exchange;
 
+  readonly version = "1.0.58";
+
   private events = new EventEmitter<{
-    connect: { wallet: OmniWallet; connector: OmniConnector };
-    disconnect: { wallet: OmniWallet; connector: OmniConnector };
+    connect: { wallet: OmniWallet };
+    disconnect: { wallet: OmniWallet };
     tokensUpdate: { tokens: Token[] };
   }>();
 
@@ -85,14 +84,12 @@ export class HotConnector {
     this.settings.metadata = options?.walletConnect?.metadata ?? undefined;
     Object.values(options?.chains ?? {}).forEach((chain) => chains.register(chain));
 
-    this.telemetry = new Telemetry(this);
     this.hotBridge = createHotBridge();
     this.exchange = new Exchange(this);
     this.activity = new Activity(this);
 
     const connectors: OmniConnector[] = [];
-    const configConnectors = options?.connectors || defaultConnectors;
-    const tasks = configConnectors.map(async (initConnector, index) => {
+    const tasks = options?.connectors?.map(async (initConnector, index) => {
       const connector = await initConnector(this);
       connector.onConnect((payload) => this.events.emit("connect", payload));
       connector.onDisconnect((payload) => this.events.emit("disconnect", payload));
@@ -299,16 +296,36 @@ export class HotConnector {
     });
   }
 
-  intentsBuilder(wallet?: OmniWallet) {
-    return new Intents(this).attachWallet(wallet);
+  async requestToken(token: OmniToken, amount: bigint | number): Promise<{ wallet: OmniWallet; token: Token; amount: bigint }> {
+    if (!token) throw new Error("Token not found");
+
+    const tokensList = await tokens.getTokens();
+    const ftToken = tokensList.find((t) => t.address === token)!;
+    const amountInt = typeof amount === "number" ? ftToken.int(amount) : amount;
+    const [existed] = this.walletsTokens.filter((t) => t.token.id === ftToken.id);
+
+    if (existed?.balance >= amountInt) return { token: ftToken, wallet: existed.wallet, amount: amountInt };
+
+    const needed = amountInt - (existed?.balance ?? 0n);
+    const result = await openPayment(this, ftToken, needed, Recipient.fromWallet(existed?.wallet));
+
+    const recipientWallet = this.wallets.find((w) => w.address === result.recipient.address);
+    if (!recipientWallet) throw new Error("Recipient not found");
+    const exist = await this.fetchToken(ftToken, recipientWallet);
+
+    return {
+      token: result.to,
+      wallet: recipientWallet,
+      amount: formatter.bigIntMin(exist, amountInt),
+    };
   }
 
-  onConnect(handler: (payload: { wallet: OmniWallet; connector: OmniConnector }) => void) {
+  onConnect(handler: (payload: { wallet: OmniWallet }) => void) {
     this.events.on("connect", handler);
     return () => this.events.off("connect", handler);
   }
 
-  onDisconnect(handler: (payload: { wallet: OmniWallet; connector: OmniConnector }) => void) {
+  onDisconnect(handler: (payload: { wallet: OmniWallet }) => void) {
     this.events.on("disconnect", handler);
     return () => this.events.off("disconnect", handler);
   }
@@ -369,14 +386,4 @@ export class HotConnector {
     if (!connector) throw new Error("Connector not found");
     return openWalletPicker(connector);
   }
-
-  async disconnect(wallet: WalletType | OmniWallet) {
-    const connector = this.connectors.find((t) => {
-      if (wallet instanceof OmniWallet) return t.wallets.includes(wallet);
-      return t.walletTypes.includes(wallet);
-    });
-
-    if (!connector) throw new Error("Connector not found");
-    await connector.disconnect();
-  }
 }

package/src/OmniConnector.ts

@@ -19,7 +19,6 @@ export interface OmniConnectorOption {
   icon: string;
   id: string;
   download?: string;
-  deeplink?: string;
   type: "extension" | "external";
 }
 
@@ -31,8 +30,8 @@ export abstract class OmniConnector<T extends OmniWallet = OmniWallet, O = {}> {
 
   private storage = new LocalStorage();
   protected events = new EventEmitter<{
-    connect: { wallet: T; connector: OmniConnector<T, O> };
-    disconnect: { wallet: T; connector: OmniConnector<T, O> };
+    connect: { wallet: T };
+    disconnect: { wallet: T };
   }>();
 
   protected wc: Promise<UniversalProvider> | null = null;
@@ -102,14 +101,14 @@ export abstract class OmniConnector<T extends OmniWallet = OmniWallet, O = {}> {
 
   protected setWallet(wallet: T) {
     runInAction(() => this.wallets.push(wallet));
-    this.events.emit("connect", { wallet, connector: this });
+    this.events.emit("connect", { wallet });
     return wallet;
   }
 
   protected removeWallet() {
     runInAction(() => {
       const wallet = this.wallets.pop();
-      if (wallet) this.events.emit("disconnect", { wallet, connector: this });
+      if (wallet) this.events.emit("disconnect", { wallet });
     });
   }
 
@@ -117,7 +116,7 @@ export abstract class OmniConnector<T extends OmniWallet = OmniWallet, O = {}> {
     runInAction(() => {
       const wallets = this.wallets;
       this.wallets = [];
-      wallets.forEach((wallet) => this.events.emit("disconnect", { wallet, connector: this }));
+      wallets.forEach((wallet) => this.events.emit("disconnect", { wallet }));
     });
   }
 
@@ -131,7 +130,7 @@ export abstract class OmniConnector<T extends OmniWallet = OmniWallet, O = {}> {
 
   async getStorage(): Promise<{ type?: string; id?: string; address?: string; publicKey?: string }> {
     const data = await this.storage.get(`wibe3:${this.id}`);
-    if (!data) return {};
+    if (!data) throw new Error("No storage found");
     return JSON.parse(data);
   }
 
@@ -139,19 +138,19 @@ export abstract class OmniConnector<T extends OmniWallet = OmniWallet, O = {}> {
     this.events.removeAllListeners();
   }
 
-  onConnect(handler: (payload: { wallet: T; connector: OmniConnector<T, O> }) => void) {
+  onConnect(handler: (payload: { wallet: T }) => void) {
     this.events.on("connect", handler);
     return () => this.events.off("connect", handler);
   }
 
-  onDisconnect(handler: (payload: { wallet: T; connector: OmniConnector<T, O> }) => void) {
+  onDisconnect(handler: (payload: { wallet: T }) => void) {
     this.events.on("disconnect", handler);
     return () => this.events.off("disconnect", handler);
   }
 
   async disconnect() {
     this.disconnectWalletConnect();
-    this.removeAllWallets();
     this.removeStorage();
+    this.removeWallet();
   }
 }

package/src/OmniWallet.ts

@@ -1,7 +1,9 @@
+import { sha256 } from "@noble/hashes/sha2.js";
 import { hex } from "@scure/base";
 
 import { openAuthPopup } from "./ui/connect/AuthPopup";
-import { WalletType } from "./core/chains";
+import { OmniToken, WalletType } from "./core/chains";
+import { OmniConnector } from "./OmniConnector";
 import { Intents } from "./core/Intents";
 import { ReviewFee } from "./core/bridge";
 import { Token } from "./core/token";
@@ -9,44 +11,38 @@ import { Commitment } from "./core";
 import { api } from "./core/api";
 
 export abstract class OmniWallet {
+  constructor(readonly connector: OmniConnector) {}
+
   abstract address: string;
   abstract publicKey?: string;
   abstract omniAddress: string;
   abstract type: WalletType;
-  abstract icon: string;
 
-  async depositNfts(nftIds: string[], receiver: string) {
-    // TODO
+  async disconnect() {
+    if (!this.connector) throw new Error("Connector not implemented");
+    await this.connector.disconnect();
   }
 
-  async withdrawNfts(nftIds: string[], receiver: string) {
-    // TODO
-  }
+  abstract transferFee(token: Token, receiver: string, amount: bigint): Promise<ReviewFee>;
+  abstract transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }): Promise<string>;
+  abstract signIntents(intents: Record<string, any>[], options?: { nonce?: Uint8Array; deadline?: number }): Promise<Commitment>;
 
-  async getDepositNftsFee(nfts: string[]) {
-    return new ReviewFee({ chain: -4 });
-  }
+  abstract fetchBalance(chain: number, address: string): Promise<bigint>;
+  abstract fetchBalances(chain?: number, whitelist?: string[]): Promise<Record<string, bigint>>;
 
-  async transferNft(nftId: string, receiver: string) {
-    // TODO
+  async executeIntents(intents: Record<string, any>[], hashes: string[] = []) {
+    const signed = await this.signIntents(intents);
+    return await Intents.publishSignedIntents([signed], hashes);
   }
 
-  async getTranferNftFee(nftId: string, receiver: string) {
-    return new ReviewFee({ chain: -4 });
+  get icon() {
+    return this.connector?.icon;
   }
 
-  async getNfts(onLoad: (nfts: string[]) => void) {
-    // TODO
+  get intents() {
+    return new Intents(this.connector.wibe3).attachWallet(this);
   }
 
-  abstract transferFee(token: Token, receiver: string, amount: bigint): Promise<ReviewFee>;
-  abstract transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }): Promise<string>;
-
-  abstract fetchBalance(chain: number, address: string): Promise<bigint>;
-  abstract fetchBalances(chain?: number, whitelist?: string[]): Promise<Record<string, bigint>>;
-
-  abstract signIntents(intents: Record<string, any>[], options?: { nonce?: Uint8Array; deadline?: number }): Promise<Commitment>;
-
   async auth(intents?: Record<string, any>[]): Promise<string> {
     return openAuthPopup(this, async () => {
       const seed = hex.encode(new Uint8Array(window.crypto.getRandomValues(new Uint8Array(32))));
@@ -57,6 +53,11 @@ export abstract class OmniWallet {
     });
   }
 
+  async pay({ token, amount, recipient, paymentId }: { token: OmniToken; amount: number; recipient: string; paymentId: string }) {
+    const nonce = new Uint8Array(sha256(new TextEncoder().encode(paymentId))).slice(0, 32);
+    return this.intents.attachNonce(nonce).transfer({ recipient, token, amount }).execute();
+  }
+
   async waitUntilBalance(need: Record<string, bigint>, receiver: string, attempts = 0) {
     if (attempts > 120) throw "Balance is not enough";
     const assets = Object.keys(need) as string[];