@hot-labs/kit 1.0.33

package/src/stellar/connector.ts

@@ -0,0 +1,69 @@
+import { sep43Modules, HotWalletModule, StellarWalletsKit, WalletNetwork, ISupportedWallet } from "@creit.tech/stellar-wallets-kit";
+import { Transaction } from "@stellar/stellar-base";
+
+import { WalletType } from "../omni/config";
+import { HotConnector } from "../HotConnector";
+import { ConnectorType, OmniConnector } from "../OmniConnector";
+import { isInjected } from "../hot-wallet/hot";
+import { OmniWallet } from "../OmniWallet";
+import StellarWallet from "./wallet";
+
+class StellarConnector extends OmniConnector<StellarWallet, ISupportedWallet> {
+  stellarKit: StellarWalletsKit;
+
+  icon = "https://storage.herewallet.app/upload/1469894e53ca248ac6adceb2194e6950a13a52d972beb378a20bce7815ba01a4.png";
+  walletTypes = [WalletType.STELLAR, WalletType.OMNI];
+  type = ConnectorType.WALLET;
+  name = "Stellar Wallet";
+  id = "stellar";
+
+  constructor(wibe3: HotConnector, stellarKit?: StellarWalletsKit) {
+    super(wibe3);
+
+    this.stellarKit = stellarKit || new StellarWalletsKit({ network: WalletNetwork.PUBLIC, modules: isInjected() ? [new HotWalletModule()] : sep43Modules() });
+    this.stellarKit.getSupportedWallets().then((wallets) => {
+      const hot = wallets.find((w) => w.id === "hot-wallet");
+      this.options = wallets.filter((w) => w.id !== "hot-wallet").map((w) => ({ ...w, name: w.name, icon: w.icon, download: w.url, type: "external" as const, id: w.id }));
+      if (hot) this.options.unshift({ ...hot, name: hot.name, icon: hot.icon, download: hot.url, type: "external" as const, id: hot.id });
+    });
+
+    this.getConnectedWallet().then((data) => {
+      if (!data || !this.stellarKit) throw "No wallet";
+
+      this.stellarKit.setWallet(data.id!);
+      const signMessage = async (message: string) => this.stellarKit.signMessage(message);
+      const signTransaction = async (transaction: Transaction) => this.stellarKit.signTransaction(transaction.toXDR());
+      this.setWallet(new StellarWallet(this, { address: data.address!, signMessage, signTransaction }));
+    });
+  }
+
+  async createWallet(address: string): Promise<OmniWallet> {
+    return new StellarWallet(this, { address });
+  }
+
+  async getConnectedWallet() {
+    if (isInjected()) {
+      this.stellarKit.setWallet("hot-wallet");
+      const { address } = await this.stellarKit.getAddress();
+      return { type: "wallet", id: "hot-wallet", address };
+    }
+
+    return await this.getStorage();
+  }
+
+  async connect(id: string) {
+    this.stellarKit.setWallet(id);
+    const { address } = await this.stellarKit.getAddress();
+    const signMessage = async (message: string) => this.stellarKit.signMessage(message);
+    const signTransaction = async (transaction: Transaction) => this.stellarKit.signTransaction(transaction.toXDR());
+    this.setStorage({ type: "wallet", id, address });
+    return this.setWallet(new StellarWallet(this, { address, signMessage, signTransaction }));
+  }
+
+  async disconnect() {
+    super.disconnect();
+    this.stellarKit.disconnect();
+  }
+}
+
+export default StellarConnector;

package/src/stellar/wallet.ts

@@ -0,0 +1,267 @@
+import { base64, base58, hex, base32 } from "@scure/base";
+import { Address, Asset, BASE_FEE, Claimant, Contract, Memo, nativeToScVal, Networks, Operation, TimeoutInfinite, Transaction, TransactionBuilder, xdr } from "@stellar/stellar-base";
+import { rpc } from "@stellar/stellar-sdk";
+
+import { WalletType } from "../omni/config";
+import { OmniWallet } from "../OmniWallet";
+import { OmniConnector } from "../OmniConnector";
+import { bridge, ReviewFee } from "../omni/bridge";
+import { formatter } from "../omni/utils";
+import { Network } from "../omni/config";
+import { Token } from "../omni/token";
+
+interface ProtocolWallet {
+  signTransaction?: (transaction: Transaction) => Promise<{ signedTxXdr: string }>;
+  signMessage?: (message: string) => Promise<{ signedMessage: string }>;
+  address: string;
+}
+
+export const ACCOUNT_FOR_SIMULATE = "GAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWN7";
+export enum ASSET_CONTRACT_METHOD {
+  GET_ALLOWANCE = "allowance",
+  APPROVE_ALLOWANCE = "approve",
+  GET_BALANCE = "balance",
+  TRANSFER = "transfer",
+  NAME = "name",
+  BURN = "burn",
+}
+
+class StellarWallet extends OmniWallet {
+  readonly type = WalletType.STELLAR;
+
+  constructor(readonly connector: OmniConnector, readonly wallet: ProtocolWallet) {
+    super(connector);
+  }
+
+  get address() {
+    return this.wallet.address;
+  }
+
+  get publicKey() {
+    const payload = base32.decode(this.address);
+    return base58.encode(payload.slice(1, -2));
+  }
+
+  get omniAddress() {
+    const payload = base32.decode(this.address);
+    return hex.encode(payload.slice(1, -2));
+  }
+
+  async fetchBalances(): Promise<Record<string, bigint>> {
+    const data = await fetch(`https://horizon.stellar.org/accounts/${this.address}`).then((res) => res.json());
+    const balances = data.balances?.map((ft: { asset_type: string; sponsor?: string | null; asset_code: string; asset_issuer: string; balance: string }) => {
+      const asset = ft.asset_type === "native" ? Asset.native() : new Asset(ft.asset_code, ft.asset_issuer);
+      const contractId = ft.asset_type === "native" ? "native" : asset.contractId(Networks.PUBLIC);
+
+      if (contractId === "native") {
+        const activatingReserve = ft.sponsor != null ? 0 : 1;
+        const trustlines = data.balances.filter((t: any) => t.asset_type !== "native" && t.sponsor == null);
+        const balance = BigInt(formatter.parseAmount(ft.balance, 7));
+        const reserved = BigInt(formatter.parseAmount(activatingReserve + 0.5 * (trustlines.length + (data.num_sponsoring || 0)), 7));
+        return [contractId, formatter.bigIntMax(0n, balance - BigInt(reserved))];
+      }
+
+      return [contractId, BigInt(formatter.parseAmount(ft.balance, 7))];
+    });
+
+    return Object.fromEntries(balances);
+  }
+
+  async fetchBalance(chain: number, token: string): Promise<bigint> {
+    if (chain !== Network.Stellar) throw "Invalid chain";
+    const balances = await this.fetchBalances();
+    return balances[token] || 0n;
+  }
+
+  async transferFee(token: Token): Promise<ReviewFee> {
+    return new ReviewFee({ baseFee: 0n, gasLimit: 0n, chain: token.chain });
+  }
+
+  async emulateTransfer(token: string, receiver: string, amount: bigint, memo?: string): Promise<{ fee: ReviewFee; tx: Transaction }> {
+    const asset = await this.getAssetFromContractId(token);
+    const sendAmount = formatter.formatAmount(amount, 7);
+
+    const account = await bridge.stellar.callSoroban((s) => s.getAccount(this.address));
+    const baseFee = await bridge.stellar.callHorizon((h) => h.fetchBaseFee()).catch(() => +BASE_FEE);
+    const builder = new TransactionBuilder(account, {
+      memo: memo ? Memo.text(memo) : undefined,
+      networkPassphrase: Networks.PUBLIC,
+      fee: String(baseFee),
+    }).setTimeout(TimeoutInfinite);
+
+    if (receiver.startsWith("C")) {
+      const contract = new Contract(asset.contractId(Networks.PUBLIC));
+      const amountScVal = nativeToScVal(amount, { type: "i128" });
+      builder.addOperation(
+        contract.call(
+          "transfer", //
+          Address.fromString(this.address).toScVal(),
+          Address.fromString(receiver).toScVal(),
+          amountScVal
+        )
+      );
+
+      const tx = await bridge.stellar.callSoroban((s) => s.prepareTransaction(builder.build() as any));
+      const fee = BigInt(Math.floor(baseFee * tx.operations.length));
+      return { fee: new ReviewFee({ baseFee: fee, priorityFee: 0n, gasLimit: 1n, chain: Network.Stellar }), tx: tx as unknown as Transaction };
+    }
+
+    let needXlm = 0;
+    const receiverAccount = await bridge.stellar.callHorizon((h) => h.loadAccount(receiver)).catch(() => null);
+    const claimableBalance = Operation.createClaimableBalance({ amount: amount.toString(), claimants: [new Claimant(receiver)], asset });
+
+    if (receiverAccount == null) {
+      if (token === "native") {
+        builder.addOperation(Operation.createAccount({ destination: receiver, startingBalance: Math.max(1, sendAmount).toString() }));
+        needXlm = Math.max(1, sendAmount);
+      } else {
+        builder.addOperation(Operation.createAccount({ destination: receiver, startingBalance: "1" }));
+        builder.addOperation(claimableBalance);
+        needXlm = 1;
+      }
+    } else {
+      const trustline = receiverAccount.balances.find((b: any) => {
+        if (b.asset_type === "native") return false;
+        return b.asset_code === asset.code && b.asset_issuer === asset.issuer;
+      });
+
+      // Check if trustline exists for non-native assets
+      if (token !== "native" && !trustline) {
+        builder.addOperation(claimableBalance);
+      } else {
+        builder.addOperation(Operation.payment({ destination: receiver, asset, amount: sendAmount.toString() }));
+      }
+    }
+
+    const tx = builder.build();
+    const fee = BigInt(Math.floor(baseFee * tx.operations.length));
+    const need = fee + BigInt(formatter.parseAmount(needXlm, 7));
+
+    return { fee: new ReviewFee({ baseFee: need, priorityFee: 0n, gasLimit: 1n, chain: Network.Stellar }), tx };
+  }
+
+  async transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }) {
+    const { tx } = await this.emulateTransfer(args.token.address, args.receiver, args.amount, args.comment);
+    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);
+    const txObject = new Transaction(result.signedTxXdr, Networks.PUBLIC);
+    const { hash } = await bridge.stellar.callHorizon((t) => t.submitTransaction(txObject as any));
+    return hash;
+  }
+
+  async signMessage(message: string) {
+    if (!this.wallet.signMessage) throw "not impl";
+    return await this.wallet.signMessage(message);
+  }
+
+  async signIntents(intents: Record<string, any>[], options?: { deadline?: number; nonce?: Uint8Array }): Promise<Record<string, any>> {
+    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",
+      nonce: base64.encode(nonce),
+      verifying_contract: "intents.near",
+      signer_id: this.omniAddress,
+      intents: intents,
+    });
+
+    const signature = await this.signMessage(message);
+
+    return {
+      signature: `ed25519:${base58.encode(base64.decode(signature.signedMessage))}`,
+      public_key: `ed25519:${this.publicKey}`,
+      standard: "sep53",
+      payload: message,
+    };
+  }
+
+  static async isTokenActivated(address: string, token: string) {
+    if (address === "native") return true;
+    const data = await bridge.stellar.callHorizon((h) => h.loadAccount(address));
+    return data.balances.some((ft: any) => {
+      if (!ft.asset_issuer) return false;
+      const asset = new Asset(ft.asset_code, ft.asset_issuer).contractId(Networks.PUBLIC);
+      return asset.toLowerCase() === token.toLowerCase();
+    });
+  }
+
+  async changeTrustline(address: string) {
+    if (address === "native") return;
+    const asset = await this.getAssetFromContractId(address);
+    const account = await bridge.stellar.callHorizon((h) => h.loadAccount(this.address));
+    const trustlineOp = Operation.changeTrust({ asset: asset, source: this.address });
+    const trustlineTx = new TransactionBuilder(account, { fee: BASE_FEE, networkPassphrase: Networks.PUBLIC }) //
+      .addOperation(trustlineOp)
+      .setTimeout(TimeoutInfinite)
+      .build();
+
+    return this.sendTransaction(trustlineTx);
+  }
+
+  readonly assetsCache = new Map<string, Asset>();
+  async getAssetFromContractId(id: string): Promise<Asset> {
+    if (id === "native") return Asset.native();
+    if (this.assetsCache.has(id)) {
+      return Promise.resolve(this.assetsCache.get(id)!);
+    }
+
+    const tx = await this.buildSmartContactTx(ACCOUNT_FOR_SIMULATE, id, ASSET_CONTRACT_METHOD.NAME);
+    const result = (await bridge.stellar.callSoroban((s) => s.simulateTransaction(tx as any))) as unknown as rpc.Api.SimulateTransactionSuccessResponse;
+
+    const value = result?.result?.retval?.value();
+    if (!value) throw "Asset not found";
+
+    const [code, issuer] = value.toString().split(":");
+    const asset = issuer ? new Asset(code, issuer) : Asset.native();
+    this.assetsCache.set(id, asset);
+    return asset;
+  }
+
+  async buildSmartContactTx(publicKey: string, contactId: string, method: string, ...args: any[]) {
+    const account = await bridge.stellar.callSoroban((s) => s.getAccount(publicKey));
+    const contract = new Contract(contactId);
+    const builtTx = new TransactionBuilder(account, { fee: BASE_FEE, networkPassphrase: Networks.PUBLIC });
+
+    if (args) builtTx.addOperation(contract.call(method, ...args));
+    else builtTx.addOperation(contract.call(method));
+    return builtTx.setTimeout(TimeoutInfinite).build();
+  }
+
+  async getTokenBalance(token: Asset | string, contract: string): Promise<bigint> {
+    const tx = await this.buildSmartContactTx(
+      ACCOUNT_FOR_SIMULATE, //
+      typeof token === "string" ? (token === "native" ? new Asset("XLM").contractId(Networks.PUBLIC) : token) : token.contractId(Networks.PUBLIC),
+      ASSET_CONTRACT_METHOD.GET_BALANCE,
+      Address.fromString(contract).toScVal()
+    );
+
+    const result = (await bridge.stellar.callSoroban((s) => s.simulateTransaction(tx as any))) as unknown as rpc.Api.SimulateTransactionSuccessResponse;
+    if (result) return BigInt(this.i128ToInt(result.result?.retval.value() as xdr.Int128Parts));
+    return 0n;
+  }
+
+  i128ToInt(val: xdr.Int128Parts): string {
+    // @ts-expect-error TODO: fix this
+    return new BigNumber(val.hi()._value).plus(val.lo()._value).div(1e7).toString();
+  }
+}
+
+export default StellarWallet;

package/src/storage.ts

@@ -0,0 +1,19 @@
+export interface DataStorage {
+  get(key: string): Promise<string | null>;
+  set(key: string, value: string): Promise<void>;
+  remove(key: string): Promise<void>;
+}
+
+export class LocalStorage implements DataStorage {
+  async get(key: string) {
+    return localStorage.getItem(key);
+  }
+
+  async set(key: string, value: string) {
+    localStorage.setItem(key, value);
+  }
+
+  async remove(key: string) {
+    localStorage.removeItem(key);
+  }
+}

package/src/ton/connector.ts

@@ -0,0 +1,138 @@
+import { TonConnectUI, TonConnect } from "@tonconnect/ui";
+import { runInAction } from "mobx";
+
+import { WalletType } from "../omni/config";
+import { HotConnector } from "../HotConnector";
+import { ConnectorType, OmniConnector } from "../OmniConnector";
+import { isInjected } from "../hot-wallet/hot";
+import TonWallet from "./wallet";
+
+export interface TonConnectorOptions {
+  tonConnect?: TonConnectUI;
+  tonWalletsUrl?: string;
+  tonManifestUrl?: string;
+}
+
+const hotWallet = {
+  app_name: "hot",
+  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",
+    },
+  ],
+  platforms: ["ios", "android", "chrome", "firefox", "macos", "windows", "linux"],
+  features: [
+    {
+      name: "SendTransaction",
+      maxMessages: 4,
+      extraCurrencySupported: false,
+    },
+  ],
+};
+
+class TonConnector extends OmniConnector<TonWallet> {
+  type = ConnectorType.WALLET;
+  walletTypes = [WalletType.TON, WalletType.OMNI];
+  icon = "https://storage.herewallet.app/upload/3ffa61e237f8e38d390abd60200db8edff3ec2b20aad0cc0a8c7a8ba9c318124.png";
+  name = "TON Wallet";
+  id = "ton";
+
+  private tonConnect = this.initializeConnector();
+  constructor(wibe3: HotConnector, readonly args?: TonConnectorOptions) {
+    super(wibe3);
+  }
+
+  async initializeConnector() {
+    if (typeof window === "undefined") throw "TonConnector can only be initialized in the browser";
+
+    const url = await fetch(this.args?.tonWalletsUrl || "https://config.ton.org/wallets-v2.json")
+      .then((res) => res.json())
+      .then((data) => {
+        const list = data.filter((t: any) => t.app_name !== "hot");
+        list.unshift(hotWallet);
+        const myBlob = new Blob([JSON.stringify(list)], { type: "text/plain" });
+        return URL.createObjectURL(myBlob);
+      });
+
+    const tonConnect =
+      this.args?.tonConnect ||
+      new TonConnectUI({
+        connector: new TonConnect({
+          walletsListSource: url,
+          manifestUrl: this.args?.tonManifestUrl,
+        }),
+      });
+
+    tonConnect.onStatusChange(async (wallet) => {
+      if (!wallet) return this.removeWallet();
+      this.setWallet(
+        new TonWallet(this, {
+          sendTransaction: (params) => tonConnect.sendTransaction(params),
+          signData: (params) => tonConnect.signData(params),
+          account: wallet.account,
+        })
+      );
+    });
+
+    tonConnect.connector.restoreConnection();
+    tonConnect.getWallets().then((wallets) => {
+      runInAction(() => {
+        this.options = wallets.map((w) => ({
+          name: w.name,
+          icon: w.imageUrl,
+          id: w.appName,
+          download: w.aboutUrl,
+          type: "external" as const,
+        }));
+      });
+    });
+
+    const tcRoot = document.querySelector("#tc-widget-root");
+    if (tcRoot instanceof HTMLElement) {
+      tcRoot.style.zIndex = "10000000000";
+      tcRoot.style.position = "fixed";
+    }
+
+    if (isInjected()) {
+      tonConnect.getWallets().then((wallets) => {
+        const wallet = wallets.find((w) => w.appName === "hot");
+        if (wallet) tonConnect.connector.connect(wallet, { tonProof: "wibe3" });
+      });
+    }
+
+    return tonConnect;
+  }
+
+  async createWallet(address: string) {
+    return new TonWallet(this, { account: { address } });
+  }
+
+  async connect(id: string) {
+    const connector = await this.tonConnect;
+    connector.openSingleWalletModal(id);
+    return new Promise<TonWallet>((resolve) => {
+      const dispose = this.onConnect(({ wallet }) => {
+        if (!wallet) return;
+        resolve(wallet);
+        dispose();
+      });
+    });
+  }
+
+  async disconnect() {
+    super.disconnect();
+    const connector = await this.tonConnect;
+    connector.disconnect();
+  }
+}
+
+export default TonConnector;

package/src/ton/utils.ts

@@ -0,0 +1,73 @@
+import { Address, beginCell, Cell, loadStateInit, toNano } from "@ton/core";
+import { Maybe } from "@ton/core/dist/utils/maybe";
+import { JettonBalance, TonApiClient } from "@ton-api/client";
+import { GlobalSettings } from "../settings";
+
+export const tonApi = new TonApiClient({ baseUrl: "https://tonapi.io", apiKey: GlobalSettings.tonApi });
+
+export const jettonTransferAmount = toNano(0.1);
+export const jettonTransferForwardAmount = BigInt(1);
+
+export enum JettonExtension {
+  NonTransferable = "non_transferable",
+  CustomPayload = "custom_payload",
+}
+
+const seeIfCompressed = (jetton: JettonBalance) => {
+  return !!jetton.extensions && jetton.extensions.includes(JettonExtension.CustomPayload);
+};
+
+export type StateInit = ReturnType<typeof toStateInit>;
+export const toStateInit = (stateInit?: string): { code: Maybe<Cell>; data: Maybe<Cell> } | undefined => {
+  if (!stateInit) return undefined;
+  const { code, data } = loadStateInit(Cell.fromBase64(stateInit).asSlice());
+  return { code, data };
+};
+
+export const getJettonCustomPayload = async (walletAddress: Address, token: Address): Promise<{ jettonWallet: Address; customPayload: Cell | null; stateInit?: StateInit }> => {
+  const jetton = await tonApi.accounts.getAccountJettonBalance(walletAddress, token, { supported_extensions: ["custom_payload"] });
+  const jettonWallet = jetton.walletAddress.address;
+
+  if (!seeIfCompressed(jetton)) return { jettonWallet, customPayload: null, stateInit: undefined };
+  const { customPayload, stateInit } = await tonApi.jettons.getJettonTransferPayload(walletAddress, jetton.jetton.address);
+
+  return {
+    customPayload: customPayload ? Cell.fromBase64(Buffer.from(customPayload, "hex").toString("base64")) : null,
+    stateInit: stateInit ? toStateInit(Buffer.from(stateInit, "hex").toString("base64")) : undefined,
+    jettonWallet,
+  };
+};
+
+export const jettonTransferBody = (params: { queryId: bigint; jettonAmount: bigint; toAddress: Address; responseAddress: Address; forwardAmount: bigint; forwardPayload: Cell | null; customPayload: Cell | null }) => {
+  return beginCell()
+    .storeUint(0xf_8a_7e_a5, 32) // request_transfer op
+    .storeUint(params.queryId, 64)
+    .storeCoins(params.jettonAmount)
+    .storeAddress(params.toAddress)
+    .storeAddress(params.responseAddress)
+    .storeMaybeRef(params.customPayload) // null custom_payload
+    .storeCoins(params.forwardAmount)
+    .storeMaybeRef(params.forwardPayload) // storeMaybeRef put 1 bit before cell (forward_payload in cell) or 0 for null (forward_payload in slice)
+    .endCell();
+};
+
+export const createJettonTransferMsgParams = async ({ jetton, amount, recipient, address, forwardPayload }: { address: Address; recipient: Address; jetton: Address; amount: bigint; forwardPayload: Cell | null }) => {
+  const { jettonWallet, customPayload, stateInit } = await getJettonCustomPayload(address, jetton);
+  const body = jettonTransferBody({
+    queryId: 0n,
+    jettonAmount: amount,
+    toAddress: recipient,
+    responseAddress: address,
+    forwardAmount: 1n,
+    forwardPayload,
+    customPayload,
+  });
+
+  return {
+    to: jettonWallet,
+    value: jettonTransferAmount,
+    init: stateInit,
+    body: body,
+    bounce: true,
+  };
+};