@hot-labs/kit 1.0.56 → 1.1.0-beta.1

package/src/OmniConnector.ts

@@ -30,8 +30,8 @@ export abstract class OmniConnector<T extends OmniWallet = OmniWallet, O = {}> {
 
   private storage = new LocalStorage();
   protected events = new EventEmitter<{
-    connect: { wallet: T };
-    disconnect: { wallet: T };
+    connect: { wallet: T; connector: OmniConnector<T, O> };
+    disconnect: { wallet: T; connector: OmniConnector<T, O> };
   }>();
 
   protected wc: Promise<UniversalProvider> | null = null;
@@ -101,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 });
+    this.events.emit("connect", { wallet, connector: this });
     return wallet;
   }
 
   protected removeWallet() {
     runInAction(() => {
       const wallet = this.wallets.pop();
-      if (wallet) this.events.emit("disconnect", { wallet });
+      if (wallet) this.events.emit("disconnect", { wallet, connector: this });
     });
   }
 
@@ -116,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 }));
+      wallets.forEach((wallet) => this.events.emit("disconnect", { wallet, connector: this }));
     });
   }
 
@@ -130,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) throw new Error("No storage found");
+    if (!data) return {};
     return JSON.parse(data);
   }
 
@@ -138,19 +138,19 @@ export abstract class OmniConnector<T extends OmniWallet = OmniWallet, O = {}> {
     this.events.removeAllListeners();
   }
 
-  onConnect(handler: (payload: { wallet: T }) => void) {
+  onConnect(handler: (payload: { wallet: T; connector: OmniConnector<T, O> }) => void) {
     this.events.on("connect", handler);
     return () => this.events.off("connect", handler);
   }
 
-  onDisconnect(handler: (payload: { wallet: T }) => void) {
+  onDisconnect(handler: (payload: { wallet: T; connector: OmniConnector<T, O> }) => 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,9 +1,7 @@
-import { sha256 } from "@noble/hashes/sha2.js";
 import { hex } from "@scure/base";
 
 import { openAuthPopup } from "./ui/connect/AuthPopup";
-import { OmniToken, WalletType } from "./core/chains";
-import { OmniConnector } from "./OmniConnector";
+import { WalletType } from "./core/chains";
 import { Intents } from "./core/Intents";
 import { ReviewFee } from "./core/bridge";
 import { Token } from "./core/token";
@@ -11,38 +9,44 @@ 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 disconnect() {
-    if (!this.connector) throw new Error("Connector not implemented");
-    await this.connector.disconnect();
+  async depositNfts(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 withdrawNfts(nftIds: string[], receiver: string) {
+    // TODO
+  }
 
-  abstract fetchBalance(chain: number, address: string): Promise<bigint>;
-  abstract fetchBalances(chain?: number, whitelist?: string[]): Promise<Record<string, bigint>>;
+  async getDepositNftsFee(nfts: string[]) {
+    return new ReviewFee({ chain: -4 });
+  }
 
-  async executeIntents(intents: Record<string, any>[], hashes: string[] = []) {
-    const signed = await this.signIntents(intents);
-    return await Intents.publishSignedIntents([signed], hashes);
+  async transferNft(nftId: string, receiver: string) {
+    // TODO
   }
 
-  get icon() {
-    return this.connector?.icon;
+  async getTranferNftFee(nftId: string, receiver: string) {
+    return new ReviewFee({ chain: -4 });
   }
 
-  get intents() {
-    return new Intents(this.connector.wibe3).attachWallet(this);
+  async getNfts(onLoad: (nfts: string[]) => void) {
+    // 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 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))));
@@ -53,11 +57,6 @@ 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[];

package/src/core/Intents.ts

@@ -1,14 +1,16 @@
 import { sha256 } from "@noble/hashes/sha2.js";
-import { ed25519 } from "@noble/curves/ed25519";
-import { base58, base64, hex } from "@scure/base";
 
 import type { HotConnector } from "../HotConnector";
 import type { OmniWallet } from "../OmniWallet";
-import type { TransferIntent, MtWithdrawIntent, FtWithdrawIntent, TokenDiffIntent, AuthCallIntent } from "./types";
+import { rpc } from "../near/rpc";
 
+import type { Intent, Commitment, TokenDiffIntent, MtWithdrawIntent, FtWithdrawIntent, NftWithdrawIntent, TransferIntent } from "./types";
 import { OmniToken } from "./chains";
 import { tokens } from "./tokens";
-import { rpc } from "./nearRpc";
+import { formatter } from "./utils";
+import { api } from "./api";
+
+import { openPayment } from "../ui/router";
 
 export const TGAS = 1000000000000n;
 
@@ -20,12 +22,12 @@ export class Intents {
   }
 
   hashes: string[] = [];
-  intents: (TransferIntent | MtWithdrawIntent | FtWithdrawIntent | TokenDiffIntent | AuthCallIntent)[] = [];
+  intents: Intent[] = [];
+  signer?: OmniWallet;
   nonce?: Uint8Array;
   deadline?: Date;
-  signer?: OmniWallet | { ed25519PrivateKey: Uint8Array; omniAddress?: string };
 
-  commitments: Record<string, any>[] = [];
+  commitments: Commitment[] = [];
   need = new Map<OmniToken, bigint>();
 
   addNeed(token: OmniToken, amount: bigint) {
@@ -86,7 +88,7 @@ export class Intents {
     return this;
   }
 
-  tokenDiff(args: Record<OmniToken, bigint | number>) {
+  tokenDiff(args: Record<string, bigint | number>) {
     const parse = (token: OmniToken, amount: bigint | number): [string, string] => {
       if (typeof amount === "number") return [token.toString(), tokens.get(token).int(amount).toString()];
       return [token.toString(), amount.toString()];
@@ -109,41 +111,40 @@ export class Intents {
     return this;
   }
 
-  addRawIntent(rawIntent: Record<string, any>) {
+  addRawIntent(rawIntent: Intent) {
     if (!rawIntent.intent) throw new Error("Intent must have 'intent' field");
     const intentType = rawIntent.intent;
 
     if (intentType === "token_diff") {
-      const diff = rawIntent.diff || rawIntent.token_diff;
-      if (!diff) throw new Error("token_diff intent must have 'diff' or 'token_diff' field");
-
       const tokenDiffArgs: Record<OmniToken, bigint> = {} as Record<OmniToken, bigint>;
-      for (const [token, amountStr] of Object.entries(diff)) {
+      for (const [token, amountStr] of Object.entries(rawIntent.diff)) {
         tokenDiffArgs[token as OmniToken] = BigInt(amountStr as string);
       }
       return this.tokenDiff(tokenDiffArgs);
     }
 
     if (intentType === "transfer") {
-      if (!rawIntent.tokens || !rawIntent.receiver_id) {
-        throw new Error("transfer intent must have 'tokens' and 'receiver_id' fields");
-      }
-
       const tokens: Record<OmniToken, bigint> = {} as Record<OmniToken, bigint>;
       for (const [token, amount] of Object.entries(rawIntent.tokens)) {
         tokens[token as OmniToken] = BigInt(amount as string);
       }
+
       return this.batchTransfer({
+        tgas: rawIntent.min_gas ? Number(BigInt(rawIntent.min_gas) / TGAS) : undefined,
         recipient: rawIntent.receiver_id,
-        tokens,
         memo: rawIntent.memo,
         msg: rawIntent.msg,
-        tgas: rawIntent.min_gas ? Number(BigInt(rawIntent.min_gas) / TGAS) : undefined,
+        tokens,
       });
     }
 
     if (intentType === "mt_withdraw") {
-      const intent: MtWithdrawIntent = {
+      for (let i = 0; i < rawIntent.amounts.length; i++) {
+        const token = `nep245:${rawIntent.token}:${rawIntent.token_ids[i]}` as OmniToken;
+        this.addNeed(token, BigInt(rawIntent.amounts[i]));
+      }
+
+      this.intents.push({
         intent: "mt_withdraw",
         amounts: rawIntent.amounts,
         receiver_id: rawIntent.receiver_id,
@@ -152,58 +153,71 @@ export class Intents {
         memo: rawIntent.memo,
         msg: rawIntent.msg,
         min_gas: rawIntent.min_gas,
-      };
-
-      for (let i = 0; i < rawIntent.amounts.length; i++) {
-        const token = `nep245:${rawIntent.token}:${rawIntent.token_ids[i]}` as OmniToken;
-        this.addNeed(token, BigInt(rawIntent.amounts[i]));
-      }
-
-      this.intents.push(intent);
+      } as MtWithdrawIntent);
       return this;
     }
 
     if (intentType === "ft_withdraw") {
-      if (!rawIntent.token || !rawIntent.receiver_id || !rawIntent.amount) {
-        throw new Error("ft_withdraw intent must have 'token', 'receiver_id', and 'amount' fields");
-      }
-
-      const token = `nep141:${rawIntent.token}` as OmniToken;
       return this.withdraw({
+        token: `nep141:${rawIntent.token}`,
         amount: BigInt(rawIntent.amount),
         receiver: rawIntent.receiver_id,
         memo: rawIntent.memo,
         msg: rawIntent.msg,
-        token,
       });
     }
 
     if (intentType === "auth_call") {
-      if (!rawIntent.contract_id || !rawIntent.msg || !rawIntent.attached_deposit || !rawIntent.min_gas) {
-        throw new Error("auth_call intent must have 'contract_id', 'msg', 'attached_deposit', and 'min_gas' fields");
-      }
-
       return this.authCall({
-        contractId: rawIntent.contract_id,
-        msg: rawIntent.msg,
         attachNear: BigInt(rawIntent.attached_deposit),
         tgas: Number(BigInt(rawIntent.min_gas) / TGAS),
+        contractId: rawIntent.contract_id,
+        msg: rawIntent.msg,
+      });
+    }
+
+    if (intentType === "add_public_key") {
+      return this.addPublicKey(rawIntent.public_key);
+    }
+
+    if (intentType === "remove_public_key") {
+      return this.removePublicKey(rawIntent.public_key);
+    }
+
+    if (intentType === "nft_withdraw") {
+      return this.withdraw({
+        token: rawIntent.token_id,
+        receiver: rawIntent.receiver_id,
+        memo: rawIntent.memo,
+        msg: rawIntent.msg,
+        tgas: rawIntent.min_gas ? Number(BigInt(rawIntent.min_gas) / TGAS) : undefined,
+        amount: 1n,
       });
     }
 
     throw new Error(`Unsupported intent type: ${intentType}`);
   }
 
-  withdraw(args: { token: OmniToken; amount: number | bigint; receiver: string; memo?: string; msg?: string; tgas?: number }) {
+  addPublicKey(publicKey: string) {
+    this.intents.push({ intent: "add_public_key", public_key: publicKey });
+    return this;
+  }
+
+  removePublicKey(publicKey: string) {
+    this.intents.push({ intent: "remove_public_key", public_key: publicKey });
+    return this;
+  }
+
+  withdraw(args: { token: string; amount: number | bigint; receiver: string; memo?: string; msg?: string; tgas?: number }) {
     const omniToken = tokens.get(args.token);
     const amount = (typeof args.amount === "number" ? omniToken.int(args.amount) : args.amount).toString();
     const [standart, ...tokenParts] = args.token.split(":");
-    this.addNeed(args.token, BigInt(amount));
+    this.addNeed(args.token as OmniToken, BigInt(amount));
 
     if (standart === "nep245") {
       const mtContract = tokenParts[0];
       const tokenId = tokenParts.slice(1).join(":");
-      const intent: MtWithdrawIntent = {
+      this.intents.push({
         intent: "mt_withdraw",
         amounts: [amount],
         receiver_id: args.receiver,
@@ -212,23 +226,31 @@ export class Intents {
         memo: args.memo,
         msg: args.msg,
         min_gas: args.tgas ? (BigInt(args.tgas) * TGAS).toString() : undefined,
-      };
-
-      this.intents.push(intent);
+      } as MtWithdrawIntent);
       return this;
     }
 
     if (standart === "nep141") {
-      const intent: FtWithdrawIntent = {
+      this.intents.push({
         intent: "ft_withdraw",
         receiver_id: args.receiver,
         token: tokenParts.join(":"),
         amount: amount,
         memo: args.memo,
         msg: args.msg,
-      };
+      } as FtWithdrawIntent);
+      return this;
+    }
 
-      this.intents.push(intent);
+    if (standart === "nep171") {
+      this.intents.push({
+        intent: "nft_withdraw",
+        receiver_id: args.receiver,
+        token_id: tokenParts.join(":"),
+        min_gas: args.tgas ? (BigInt(args.tgas) * TGAS).toString() : undefined,
+        memo: args.memo,
+        msg: args.msg,
+      } as NftWithdrawIntent);
       return this;
     }
 
@@ -240,7 +262,7 @@ export class Intents {
     return this;
   }
 
-  attachWallet(wallet: OmniWallet) {
+  attachWallet(wallet?: OmniWallet) {
     this.signer = wallet;
     return this;
   }
@@ -265,10 +287,15 @@ export class Intents {
     return this;
   }
 
-  take(token: OmniToken, amount: number | bigint) {
+  attachCommitment(commitment: Commitment) {
+    this.commitments.push(commitment);
+    return this;
+  }
+
+  take(token: string, amount: number | bigint) {
     const intAmount = typeof amount === "number" ? tokens.get(token).int(amount) : amount;
 
-    this.addNeed(token, intAmount);
+    // this.addNeed(token, -intAmount); Do we need to add the need here?
     const tokenDiff = this.intents.find((intent) => intent.intent === "token_diff");
 
     if (tokenDiff) tokenDiff.diff[token.toString()] = intAmount.toString();
@@ -276,10 +303,10 @@ export class Intents {
     return this;
   }
 
-  give(token: OmniToken, amount: number | bigint) {
+  give(token: string, amount: number | bigint) {
     const intAmount = typeof amount === "number" ? tokens.get(token).int(amount) : amount;
 
-    this.addNeed(token, -intAmount);
+    this.addNeed(token as OmniToken, intAmount);
     const tokenDiff = this.intents.find((intent) => intent.intent === "token_diff");
 
     if (tokenDiff) tokenDiff.diff[token.toString()] = (-intAmount).toString();
@@ -287,113 +314,70 @@ export class Intents {
     return this;
   }
 
-  async signRaw({ ed25519PrivateKey, intentsAddress, checkTokens }: { ed25519PrivateKey: Uint8Array; intentsAddress?: string; checkTokens?: boolean }) {
-    if (checkTokens) {
-      await this.checkRequiredTokens();
-    }
-
-    const publicKey = ed25519.getPublicKey(ed25519PrivateKey);
-    const nonce = new Uint8Array(this.nonce || window.crypto.getRandomValues(new Uint8Array(32)));
-
-    const message = JSON.stringify({
-      deadline: this.deadline ? new Date(this.deadline).toISOString() : "2100-01-01T00:00:00.000Z",
-      nonce: base64.encode(nonce),
-      verifying_contract: "intents.near",
-      signer_id: intentsAddress || hex.encode(publicKey).toLowerCase(),
-      intents: this.intents,
-    });
-
-    return {
-      signature: `ed25519:${base58.encode(ed25519.sign(message, ed25519PrivateKey))}`,
-      public_key: `ed25519:${base58.encode(publicKey)}`,
-      standard: "raw_ed25519",
-      payload: message,
-    };
-  }
-
-  async attachCommitment(commitment: Record<string, any>) {
-    this.commitments.push(commitment);
-    return this;
-  }
-
-  async attachSigner(signer: OmniWallet | { ed25519PrivateKey: Uint8Array; omniAddress?: string }) {
-    this.signer = signer;
-    return this;
-  }
-
-  async checkRequiredTokens() {
-    if (this.wibe3 == null) return;
-    for (const [token, needAmount] of this.need.entries()) {
-      if (needAmount <= 0n) continue;
-      await this.wibe3.requestToken(token, needAmount);
-    }
-  }
-
-  async sign(params = { checkTokens: true }) {
+  async signSequence() {
     const signer = this.signer;
     if (!signer) throw new Error("No signer attached");
     if (!signer.omniAddress) throw new Error("No omni address");
 
-    if ("ed25519PrivateKey" in signer) {
-      return await this.signRaw({
-        ed25519PrivateKey: signer.ed25519PrivateKey,
-        intentsAddress: signer.omniAddress,
-        checkTokens: params.checkTokens,
-      });
+    const commitments: Commitment[] = [];
+    for (const intent of this.intents) {
+      const signed = await signer.signIntents([intent], { deadline: this.deadline ? +this.deadline : undefined, nonce: this.nonce });
+      commitments.push(signed);
     }
 
-    if (params.checkTokens) {
-      await this.checkRequiredTokens();
-    }
+    return commitments;
+  }
 
+  async sign() {
+    const signer = this.signer;
+    if (!signer) throw new Error("No signer attached");
+    if (!signer.omniAddress) throw new Error("No omni address");
     return await signer.signIntents(this.intents, {
       deadline: this.deadline ? +this.deadline : undefined,
       nonce: this.nonce,
     });
   }
 
-  async simulate(params = { checkTokens: true }) {
-    const signed = await this.sign(params);
+  async simulate() {
+    if (!this.signer) throw new Error("No signer attached");
+    const signed = await this.sign();
     return await Intents.simulateIntents([signed]);
   }
 
-  async execute(params = { checkTokens: true }) {
-    const signed = await this.sign(params);
-    const hash = await Intents.publishSignedIntents([...this.commitments, signed], this.hashes);
-    await rpc.waitTransactionResult(hash, "intents.near");
-    return hash;
+  async execute() {
+    if (!this.wibe3) throw new Error("No wibe3 attached");
+    return openPayment(this.wibe3, this);
   }
 
-  static async publishSignedIntents(signed: Record<string, any>[], hashes: string[] = []): Promise<string> {
-    const res = await fetch("https://api0.herewallet.app/api/v1/evm/intent-solver", {
-      headers: { "Content-Type": "application/json" },
-      method: "POST",
-      body: JSON.stringify({
-        params: [{ signed_datas: signed, quote_hashes: hashes }],
-        method: "publish_intents",
-        id: "dontcare",
-        jsonrpc: "2.0",
-      }),
-    });
+  async executeBatch(params = { checkTokens: true, chunkSize: this.intents.length, onSuccess: (bucket: number, hash: string) => {} }) {
+    if (!this.signer) throw new Error("No signer attached");
+    const batches = formatter.chunk(this.intents, params.chunkSize);
+    let index = 0;
 
-    const { result } = await res.json();
+    const hashes: string[] = [];
+    for (const batch of batches) {
+      const signed = await this.signer.signIntents(batch, {
+        deadline: this.deadline ? +this.deadline : undefined,
+        nonce: this.nonce,
+      });
+
+      const hash = await Intents.publish([...this.commitments, signed], this.hashes);
+      await rpc.waitTransactionResult(hash, "intents.near");
+      params.onSuccess(index++, hash);
+      hashes.push(hash);
+    }
+
+    return hashes;
+  }
+
+  static async publish(signed: Commitment[], hashes: string[] = []): Promise<string> {
+    const result = await api.publishIntents(signed, hashes);
     if (result.status === "FAILED") throw result.reason;
     const intentResult = result.intent_hashes[0];
 
     const getStatus = async () => {
-      const statusRes = await fetch("https://api0.herewallet.app/api/v1/evm/intent-solver", {
-        headers: { "Content-Type": "application/json" },
-        method: "POST",
-        body: JSON.stringify({
-          params: [{ intent_hash: intentResult }],
-          method: "get_status",
-          id: "dontcare",
-          jsonrpc: "2.0",
-        }),
-      });
-
-      const { result } = await statusRes.json();
-      return result;
+      const statusResult = await api.getIntentsStatus(intentResult);
+      return statusResult;
     };
 
     const fetchResult = async () => {
@@ -417,7 +401,7 @@ export class Intents {
     });
   }
 
-  static async simulateIntents(signed: Record<string, any>[]) {
+  static async simulateIntents(signed: Commitment[]) {
     return await rpc.viewMethod({
       args: { signed: signed },
       methodName: "simulate_intents",

package/src/core/api.ts

@@ -69,8 +69,15 @@ export class Api {
     return result.balances?.[chain] || [];
   }
 
+  async pendingPayment(commitment: Commitment, depositAddress: string) {
+    return await this.request(`/api/v1/wibe3/yield_intent_call`, {
+      body: JSON.stringify({ commitment, deposit_address: depositAddress }),
+      method: "POST",
+    });
+  }
+
   async publishIntents(signed: Record<string, any>[], hashes: string[]) {
-    return await this.request(`/api/v1/wibe3/solver-bus`, {
+    const result = await this.request(`/api/v1/wibe3/solver-bus`, {
       headers: { "Content-Type": "application/json" },
       method: "POST",
       body: JSON.stringify({
@@ -80,10 +87,12 @@ export class Api {
         jsonrpc: "2.0",
       }),
     });
+
+    return result.result;
   }
 
   async getIntentsStatus(intentHash: string) {
-    return await this.request(`/api/v1/wibe3/solver-bus`, {
+    const result = await this.request(`/api/v1/wibe3/solver-bus`, {
       headers: { "Content-Type": "application/json" },
       method: "POST",
       body: JSON.stringify({
@@ -93,6 +102,8 @@ export class Api {
         jsonrpc: "2.0",
       }),
     });
+
+    return result.result;
   }
 }
 

package/src/core/bridge.ts

@@ -1,13 +1,14 @@
 import { CosmosConfig, HotBridge, ReviewFee } from "@hot-labs/omni-sdk";
 import { chains, Network, WalletType } from "./chains";
 import { Intents } from "./Intents";
+import { Commitment } from "./types";
 
 export { ReviewFee, HotBridge };
 
 export const createHotBridge = () => {
   return new HotBridge({
-    publishIntents: async (signed: Record<string, any>[], hashes: string[] = []) => {
-      const hash = await Intents.publishSignedIntents(signed, hashes);
+    publishIntents: async (signed: Commitment[], hashes: string[] = []) => {
+      const hash = await Intents.publish(signed, hashes);
       return { sender: "intents.near", hash };
     },
 

package/src/core/chains.ts

@@ -133,9 +133,9 @@ const chainsRepository: Record<number, ChainConfig> = {
     logo: "https://storage.herewallet.app/ft/4444119:ngonka.png",
     currency: { id: "ngonka", symbol: "GNK", decimals: 6, logo: logo(Network.Gonka) },
     rpc: rpc(Network.Gonka),
-    prefix: "gonka",
     type: WalletType.COSMOS,
     gasLimit: 200000n,
+    prefix: "gonka",
   },
   [Network.Monad]: {
     id: Network.Monad,

package/src/core/index.ts

@@ -1,6 +1,6 @@
 export { OmniToken, WalletType, Network, chains } from "./chains";
 export { createHotBridge, HotBridge, ReviewFee } from "./bridge";
-export { rpc as nearRpc, TGAS } from "./nearRpc";
+export { rpc as nearRpc, TGAS } from "../near/rpc";
 export { EventEmitter } from "./events";
 export { Recipient } from "./recipient";
 export { formatter } from "./utils";