@hot-labs/kit 1.0.33

package/src/cosmos/connector.ts

@@ -0,0 +1,242 @@
+import type { Keplr } from "@keplr-wallet/provider-extension";
+import { TxRaw } from "@keplr-wallet/proto-types/cosmos/tx/v1beta1/tx";
+import { StargateClient } from "@cosmjs/stargate";
+import { hex } from "@scure/base";
+
+import { WalletType } from "../omni/config";
+import { HotConnector } from "../HotConnector";
+import { ConnectorType, OmniConnector, OmniConnectorOptions, WC_ICON } from "../OmniConnector";
+import CosmosWallet from "./wallet";
+import { OmniWallet } from "../OmniWallet";
+
+export interface CosmosConnectorOptions extends OmniConnectorOptions {
+  cosmosChains?: Record<string, { chain: string; rpc: string; denom: string; prefix: string }>;
+}
+
+declare global {
+  interface Window {
+    keplr?: Keplr;
+    leap?: Keplr;
+  }
+}
+
+const wallets = {
+  keplr: {
+    name: "Keplr",
+    icon: "https://cdn.prod.website-files.com/667dc891bc7b863b5397495b/68a4ca95f93a9ab64dc67ab4_keplr-symbol.svg",
+    download: "https://www.keplr.app/get",
+    deeplink: "keplrwallet://wcV2?",
+    type: "extension",
+    id: "keplr",
+  },
+  leap: {
+    name: "Leap",
+    icon: "https://framerusercontent.com/images/AbGYvbwnLekBbsdf5g7PI5PpSg.png?scale-down-to=512",
+    download: "https://www.leapwallet.io/download",
+    deeplink: "leapcosmos://wcV2?",
+    type: "extension",
+    id: "leap",
+  },
+};
+
+export default class CosmosConnector extends OmniConnector<CosmosWallet> {
+  cosmosChains: Record<string, { chain: string; rpc: string; denom: string; prefix: string }>;
+
+  type = ConnectorType.WALLET;
+  walletTypes = [WalletType.COSMOS];
+  icon = "https://legacy.cosmos.network/presskit/cosmos-brandmark-dynamic-dark.svg";
+  name = "Cosmos Wallet";
+  isSupported = true;
+  id = "cosmos";
+
+  constructor(wibe3: HotConnector, options?: CosmosConnectorOptions) {
+    super(wibe3, options);
+
+    this.options = [
+      {
+        name: "keplr" in window ? "Keplr" : "Keplr Mobile",
+        download: "https://www.keplr.app/get",
+        icon: "https://cdn.prod.website-files.com/667dc891bc7b863b5397495b/68a4ca95f93a9ab64dc67ab4_keplr-symbol.svg",
+        type: "keplr" in window ? "extension" : "external",
+        id: "keplr",
+      },
+      {
+        name: "leap" in window ? "Leap" : "Leap Mobile",
+        download: "https://www.leapwallet.io/download",
+        icon: "https://framerusercontent.com/images/AbGYvbwnLekBbsdf5g7PI5PpSg.png?scale-down-to=512",
+        type: "leap" in window ? "extension" : "external",
+        id: "leap",
+      },
+    ];
+
+    this.cosmosChains = {
+      "juno-1": { chain: "juno-1", rpc: "https://juno-rpc.publicnode.com", denom: "ujuno", prefix: "juno" },
+      "gonka-mainnet": { chain: "gonka-mainnet", rpc: "https://dev.herewallet.app/api/v1/evm/rpc/4444119", denom: "ngonka", prefix: "gonka" },
+      "cosmoshub-4": { chain: "cosmoshub-4", rpc: "https://rpc.cosmoshub.certus.one", denom: "uatom", prefix: "cosmos" },
+      ...options?.cosmosChains,
+    };
+
+    this.getStorage().then(({ type, address, publicKey }) => {
+      if (!address || !publicKey) return;
+      if (type === "keplr" && window.keplr) this.setKeplrWallet(window.keplr, address, publicKey);
+      if (type === "leap" && window.leap) this.setKeplrWallet(window.leap, address, publicKey);
+    });
+
+    this.initWalletConnect().then(async (wc) => {
+      this.options.unshift({
+        download: "https://www.walletconnect.com/get",
+        name: "WalletConnect",
+        id: "walletconnect",
+        type: "external",
+        icon: WC_ICON,
+      });
+
+      const selected = await this.getStorage();
+      if (selected.type !== "walletconnect") return;
+      this.setupWalletConnect(selected.id as "keplr" | "leap");
+    });
+  }
+
+  getConfig(chain: string) {
+    return this.cosmosChains[chain];
+  }
+
+  async setupWalletConnect(id?: "keplr" | "leap"): 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");
+    if (!account) throw new Error("Account not found");
+
+    const publicKey = Buffer.from(account.pubKey, "base64").toString("hex");
+    const address = account.bech32Address;
+
+    this.setStorage({ type: "walletconnect", id });
+    const wallet = new CosmosWallet(this, {
+      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}`,
+          deeplink: id ? wallets[id].deeplink : undefined,
+          icon: id ? wallets[id].icon : undefined,
+          name: id ? wallets[id].name : undefined,
+          request: {
+            method: "cosmos_signDirect",
+            params: {
+              signerAddress: address,
+              signDoc: {
+                chainId: signDoc.chainId,
+                accountNumber: signDoc.accountNumber?.toString(),
+                bodyBytes: signDoc.bodyBytes ? Buffer.from(signDoc.bodyBytes).toString("base64") : null,
+                authInfoBytes: signDoc.authInfoBytes ? Buffer.from(signDoc.authInfoBytes).toString("base64") : null,
+              },
+            },
+          },
+        });
+
+        const client = await StargateClient.connect(this.getConfig(signDoc.chainId)?.rpc || "");
+        const protobufTx = TxRaw.encode({
+          bodyBytes: signed.bodyBytes,
+          authInfoBytes: signed.authInfoBytes,
+          signatures: [Buffer.from(signature.signature, "base64")],
+        }).finish();
+
+        const result = await client.broadcastTx(protobufTx);
+        if (result.code !== 0) throw "Transaction failed";
+        return result.transactionHash;
+      },
+    });
+
+    return this.setWallet(wallet);
+  }
+
+  async setKeplrWallet(keplr: Keplr, address: string, publicKey: string) {
+    return this.setWallet(
+      new CosmosWallet(this, {
+        address: address,
+        publicKeyHex: publicKey,
+        disconnect: () => keplr.disable(),
+        sendTransaction: async (signDoc: any, opts = { preferNoSetFee: true }) => {
+          await keplr.enable(Object.keys(this.cosmosChains));
+          const account = await keplr.getKey(signDoc.chainId);
+          const protoSignResponse = await keplr.signDirect(signDoc.chainId, account.bech32Address, signDoc, opts);
+          const client = await StargateClient.connect(this.getConfig(signDoc.chainId)?.rpc || "");
+
+          // Build a TxRaw and serialize it for broadcasting
+          const protobufTx = TxRaw.encode({
+            bodyBytes: protoSignResponse.signed.bodyBytes,
+            authInfoBytes: protoSignResponse.signed.authInfoBytes,
+            signatures: [Buffer.from(protoSignResponse.signature.signature, "base64")],
+          }).finish();
+
+          const result = await client.broadcastTx(protobufTx);
+          if (result.code !== 0) throw "Transaction failed";
+          return result.transactionHash;
+        },
+      })
+    );
+  }
+
+  async connectKeplr(type: "keplr" | "leap", extension?: Keplr): Promise<OmniWallet | { qrcode: string; deeplink?: string; task: Promise<OmniWallet> }> {
+    if (!extension) {
+      return await this.connectWalletConnect({
+        onConnect: () => this.setupWalletConnect(type),
+        deeplink: wallets[type].deeplink,
+        namespaces: {
+          cosmos: {
+            methods: ["cosmos_getAccounts", "cosmos_signDirect"],
+            events: ["chainChanged", "accountsChanged"],
+            chains: Object.keys(this.cosmosChains).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",
+    });
+
+    await extension.enable(Object.keys(this.cosmosChains));
+    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));
+  }
+
+  async connect(id: string) {
+    if (id === "walletconnect") {
+      return await this.connectWalletConnect({
+        onConnect: () => this.setupWalletConnect(),
+        namespaces: {
+          cosmos: {
+            methods: ["cosmos_getAccounts", "cosmos_signDirect"],
+            events: ["chainChanged", "accountsChanged"],
+            chains: Object.keys(this.cosmosChains).map((chain) => `cosmos:${chain}`),
+            rpcMap: {},
+          },
+        },
+      });
+    }
+
+    if (id === "keplr") {
+      return await this.connectKeplr("keplr", window.keplr);
+    }
+
+    if (id === "leap") {
+      return await this.connectKeplr("leap", window.leap);
+    }
+
+    throw new Error("Wallet not found");
+  }
+}

package/src/cosmos/wallet.ts

@@ -0,0 +1,77 @@
+import { StargateClient } from "@cosmjs/stargate";
+
+import { OmniWallet, SignedAuth } from "../OmniWallet";
+import { chainsMap, WalletType } from "../omni/config";
+import { ReviewFee } from "../omni/bridge";
+import CosmosConnector from "./connector";
+
+interface ProtocolWallet {
+  disconnect?: () => Promise<void>;
+  sendTransaction?: (signDoc: any) => Promise<string>;
+  address: string;
+  publicKeyHex: string;
+}
+
+export default class CosmosWallet extends OmniWallet {
+  readonly type = WalletType.COSMOS;
+
+  constructor(readonly connector: CosmosConnector, readonly wallet: ProtocolWallet) {
+    super(connector);
+  }
+
+  get address() {
+    return this.wallet.address;
+  }
+
+  get publicKey() {
+    return this.wallet.publicKeyHex;
+  }
+
+  get omniAddress() {
+    return "";
+  }
+
+  async disconnect() {
+    super.disconnect();
+    this.wallet.disconnect?.();
+  }
+
+  sendTransaction(signDoc: any): Promise<string> {
+    if (!this.wallet.sendTransaction) throw "Not impl";
+    return this.wallet.sendTransaction(signDoc);
+  }
+
+  transferFee(): Promise<ReviewFee> {
+    throw new Error("Method not implemented.");
+  }
+
+  transfer(): Promise<string> {
+    throw "Not impl";
+  }
+
+  signIntentsWithAuth(): Promise<SignedAuth> {
+    throw new Error("Method not implemented.");
+  }
+
+  signIntents(): Promise<Record<string, any>> {
+    throw new Error("Method not implemented.");
+  }
+
+  async fetchBalances(chain: number, whitelist: string[]): Promise<Record<string, bigint>> {
+    const balances = await Promise.all(
+      whitelist.map(async (token) => {
+        const balance = await this.fetchBalance(chain, token);
+        return [token, balance];
+      })
+    );
+    return Object.fromEntries(balances);
+  }
+
+  async fetchBalance(chain: number, token: string): Promise<bigint> {
+    const config = this.connector.getConfig(chainsMap[chain].id);
+    if (!config) throw new Error("Config not found");
+    const client = await StargateClient.connect(config.rpc);
+    const balance = await client.getBalance(this.address, token);
+    return BigInt(balance.amount || 0);
+  }
+}

package/src/events.ts

@@ -0,0 +1,66 @@
+/**
+ * Generic event emitter class for handling typed events and their callbacks
+ * @template T Record type containing event names as keys and their payload types as values
+ */
+export class EventEmitter<T extends Record<string, any>> {
+  /** Internal storage for event callbacks */
+  private events: Partial<Record<keyof T, Array<(payload: any) => void>>> = {};
+
+  /**
+   * Subscribe to an event
+   * @template K Event name type
+   * @param event Name of the event to subscribe to
+   * @param callback Function to be called when event is emitted
+   */
+  on<K extends keyof T>(event: K, callback: (payload: T[K]) => void): void {
+    if (!this.events[event]) this.events[event] = [];
+    this.events[event]!.push(callback);
+  }
+
+  /**
+   * Emit an event with payload
+   * @template K Event name type
+   * @param event Name of the event to emit
+   * @param payload Data to pass to event handlers
+   */
+  emit<K extends keyof T>(event: K, payload: T[K]): void {
+    this.events[event]?.forEach((cb) => cb(payload));
+  }
+
+  /**
+   * Unsubscribe from an event
+   * @template K Event name type
+   * @param event Name of the event to unsubscribe from
+   * @param callback Function to remove from event handlers
+   */
+  off<K extends keyof T>(event: K, callback: (payload: T[K]) => void): void {
+    this.events[event] = this.events[event]?.filter((cb) => cb !== callback);
+  }
+
+  /**
+   * Subscribe to an event for a single emission
+   * @template K Event name type
+   * @param event Name of the event to subscribe to
+   * @param callback Function to be called when event is emitted
+   */
+  once<K extends keyof T>(event: K, callback: (payload: T[K]) => void): void {
+    const onceWrapper = (payload: T[K]) => {
+      callback(payload);
+      this.off(event, onceWrapper);
+    };
+    this.on(event, onceWrapper);
+  }
+
+  /**
+   * Remove all event listeners
+   * @template K Event name type
+   * @param event Optional event name to remove listeners for. If not provided, removes all listeners for all events
+   */
+  removeAllListeners<K extends keyof T>(event?: K): void {
+    if (event) {
+      delete this.events[event];
+    } else {
+      this.events = {};
+    }
+  }
+}

package/src/evm/abi.ts

@@ -0,0 +1,39 @@
+export const erc20abi = [
+  "function name() public view returns (string)",
+  "function symbol() public view returns (string)",
+  "function decimals() public view returns (uint8)",
+  "function totalSupply() public view returns (uint256)",
+  "function balanceOf(address _owner) public view returns (uint256 balance)",
+  "function transfer(address _to, uint256 _value) public returns (bool success)",
+  "function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)",
+  "function approve(address _spender, uint256 _value) public returns (bool success)",
+  "function allowance(address _owner, address _spender) public view returns (uint256 remaining)",
+];
+
+export const bridgeAbi = [
+  "function multi_deposit(bytes memory receiver, address contract_id, uint256[] memory tokenIds)",
+  "function deposit(bytes memory receiver, address contract_id, uint256 tokenId)",
+];
+
+export const nftAbi = [
+  {
+    inputs: [
+      { internalType: "address", name: "operator", type: "address" },
+      { internalType: "bool", name: "approved", type: "bool" },
+    ],
+    name: "setApprovalForAll",
+    stateMutability: "nonpayable",
+    type: "function",
+    outputs: [],
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "account", type: "address" },
+      { internalType: "address", name: "operator", type: "address" },
+    ],
+    name: "isApprovedForAll",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function",
+  },
+];

package/src/evm/connector.ts

@@ -0,0 +1,139 @@
+import MetaMaskSDK from "@metamask/sdk";
+import { runInAction } from "mobx";
+
+import { ConnectorType, OmniConnector, OmniConnectorOptions, WC_ICON } from "../OmniConnector";
+import { WalletType } from "../omni/config";
+import { isInjected } from "../hot-wallet/hot";
+import { HotConnector } from "../HotConnector";
+import EvmWallet, { EvmProvider } from "./wallet";
+
+const chains = [1, 10, 56, 137, 8453, 42161, 421613, 80001];
+
+export interface EvmConnectorOptions extends OmniConnectorOptions {
+  chains?: number[];
+}
+
+class EvmConnector extends OmniConnector<EvmWallet, { provider: EvmProvider }> {
+  icon = "https://storage.herewallet.app/upload/06b43b164683c2cbfe9a9c0699f0953fd56f1f802035e7701ea10501d9e091c6.png";
+  walletTypes = [WalletType.EVM, WalletType.OMNI];
+  type = ConnectorType.WALLET;
+  name = "EVM Wallet";
+  chains = chains;
+  id = "evm";
+
+  MMSDK = new MetaMaskSDK({
+    dappMetadata: {
+      name: "Wibe3",
+      url: window.location.href,
+      // iconUrl: "https://mydapp.com/icon.png" // Optional
+    },
+  });
+
+  constructor(wibe3: HotConnector, readonly settings: EvmConnectorOptions = {}) {
+    super(wibe3, settings);
+
+    if (settings.chains) this.chains.push(...settings.chains);
+
+    window.addEventListener<any>("eip6963:announceProvider", async (provider) => {
+      if (this.options.find((t) => t.name === provider.detail.info.name || t.id === provider.detail.info.uuid)) return;
+
+      runInAction(() => {
+        const info = provider.detail.info;
+        const wallet = {
+          download: `https://${info.rdns.split(".").reverse().join(".")}`,
+          provider: provider.detail.provider,
+          type: "extension" as const,
+          name: info.name,
+          icon: info.icon,
+          id: info.rdns,
+        };
+
+        if (info.rdns === "org.hot-labs") this.options.unshift(wallet);
+        else this.options.push(wallet);
+      });
+
+      const connected = await this.getConnectedWallet();
+      if (connected.type === "wallet" && connected.id === provider.detail.info.rdns) {
+        this.connectWallet(provider.detail.info.rdns, provider.detail.provider);
+      }
+    });
+
+    window.dispatchEvent(new Event("eip6963:requestProvider"));
+
+    this.initWalletConnect().then((wc) => {
+      this.options.unshift({ id: "walletconnect", name: "WalletConnect", icon: WC_ICON, provider: {} as any, type: "external" });
+    });
+
+    this.wc?.then(async (wc) => {
+      const selected = await this.getConnectedWallet();
+      if (selected.id !== "walletconnect") return;
+      this.setupWalletConnect();
+    });
+  }
+
+  async setupWalletConnect(): Promise<EvmWallet> {
+    const wc = await this.wc;
+    if (!wc) throw new Error("WalletConnect not found");
+
+    const address = wc.session?.namespaces.eip155.accounts[0]?.split(":")[2];
+    if (!address) throw new Error("Account not found");
+
+    this.setStorage({ type: "walletconnect" });
+    return this.setWallet(
+      new EvmWallet(this, address, {
+        request: async (request: any) => this.requestWalletConnect<any>({ request }),
+      })
+    );
+  }
+
+  async connectWallet(id: string, provider: EvmProvider) {
+    try {
+      if (this.wallets.length > 0) this.removeWallet();
+
+      const [address] = await provider.request({ method: "eth_requestAccounts" });
+      if (!address) throw "No address found";
+      this.setStorage({ type: "wallet", id });
+
+      const handler = async (data: string[]) => {
+        provider.off?.("accountsChanged", handler as any);
+        if (data.length > 0) this.connectWallet(id, provider);
+        else this.disconnect();
+      };
+
+      provider.on?.("accountsChanged", handler);
+      return this.setWallet(new EvmWallet(this, address, provider));
+    } catch (e) {
+      this.disconnect();
+      throw e;
+    }
+  }
+
+  async getConnectedWallet() {
+    if (isInjected()) return { type: "wallet", id: "org.hot-labs" };
+    return await this.getStorage();
+  }
+
+  async connect(id: string) {
+    if (id === "walletconnect") {
+      return await this.connectWalletConnect({
+        onConnect: () => this.setupWalletConnect(),
+        namespaces: {
+          eip155: {
+            methods: ["eth_sendTransaction", "eth_signTransaction", "eth_sign", "personal_sign", "eth_signTypedData"],
+            chains: chains.map((chain) => `eip155:${chain}`),
+            events: ["chainChanged", "accountsChanged"],
+            rpcMap: {},
+          },
+        },
+      });
+    }
+
+    this.disconnectWalletConnect();
+    const wallet = this.options.find((t) => t.id === id);
+    if (!wallet) throw new Error("Wallet not found");
+
+    return await this.connectWallet(id, wallet.provider);
+  }
+}
+
+export default EvmConnector;