@hot-labs/kit 1.1.2 → 1.2.0-alpha.1

package/src/core/Intents.ts

@@ -1,17 +1,14 @@
 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 { rpc } from "../near/rpc";
+import type { TransferIntent, MtWithdrawIntent, FtWithdrawIntent, TokenDiffIntent, AuthCallIntent } from "./types";
 
-import type { Intent, Commitment, TokenDiffIntent, MtWithdrawIntent, FtWithdrawIntent, NftWithdrawIntent, TransferIntent } from "./types";
 import { OmniToken } from "./chains";
 import { tokens } from "./tokens";
-import { api } from "./api";
-
-import { openConnector, openConnectPrimaryWallet, openPayment, openToast } from "../ui/router";
-import { formatter } from "./utils";
-import { BridgeReview } from "../exchange";
+import { rpc } from "./nearRpc";
 
 export const TGAS = 1000000000000n;
 
@@ -22,22 +19,14 @@ export class Intents {
     return new Intents();
   }
 
-  signedHashes: string[] = [];
-  commitments: Commitment[] = [];
-  need = new Map<OmniToken, bigint>();
-  signer?: OmniWallet;
-
-  unsignedCommitment?: {
-    intents: Intent[];
-    nonce?: Uint8Array;
-    deadline?: Date;
-  };
+  hashes: string[] = [];
+  intents: (TransferIntent | MtWithdrawIntent | FtWithdrawIntent | TokenDiffIntent | AuthCallIntent)[] = [];
+  nonce?: Uint8Array;
+  deadline?: Date;
+  signer?: OmniWallet | { ed25519PrivateKey: Uint8Array; omniAddress?: string };
 
-  addIntent(intent: Intent) {
-    if (!this.unsignedCommitment) this.unsignedCommitment = { intents: [] };
-    this.unsignedCommitment.intents.push(intent);
-    return this;
-  }
+  commitments: Record<string, any>[] = [];
+  need = new Map<OmniToken, bigint>();
 
   addNeed(token: OmniToken, amount: bigint) {
     if (!this.need.has(token)) this.need.set(token, 0n);
@@ -47,7 +36,7 @@ export class Intents {
 
   authCall(args: { contractId: string; msg: string; attachNear: bigint; tgas: number }) {
     this.addNeed(OmniToken.NEAR, args.attachNear);
-    this.addIntent({
+    this.intents.push({
       min_gas: (BigInt(args.tgas) * TGAS).toString(),
       attached_deposit: args.attachNear.toString(),
       contract_id: args.contractId,
@@ -58,22 +47,6 @@ export class Intents {
     return this;
   }
 
-  /**
-   * Use this method to pay for a merchant's item created in pay.hot-labs.org
-   */
-  merchantPayment({ merchantId, token, itemId, email, amount, memo }: { token: OmniToken; merchantId: string; itemId: string; amount: number | bigint; memo: string; email: string }) {
-    return this.transfer({
-      msg: JSON.stringify({ merchant_id: merchantId, item_id: itemId, memo: memo }),
-      recipient: "pay.fi.tg",
-      amount,
-      token,
-    }).depositAndExecute({
-      title: `Pay ${this.wibe3?.omni(token).readable(amount)} ${this.wibe3?.omni(token).symbol}`,
-      serverSideProcessing: true,
-      payload: { email },
-    });
-  }
-
   transfer(args: { recipient: string; token: OmniToken; amount: number | bigint; 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();
@@ -87,7 +60,7 @@ export class Intents {
     };
 
     this.addNeed(args.token, BigInt(amount));
-    this.addIntent(intent);
+    this.intents.push(intent);
     return this;
   }
 
@@ -109,11 +82,11 @@ export class Intents {
       msg: args.msg,
     };
 
-    this.addIntent(intent);
+    this.intents.push(intent);
     return this;
   }
 
-  tokenDiff(args: Record<string, bigint | number>) {
+  tokenDiff(args: Record<OmniToken, 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()];
@@ -132,44 +105,45 @@ export class Intents {
       }
     }
 
-    this.addIntent(intent);
+    this.intents.push(intent);
     return this;
   }
 
-  addRawIntent(rawIntent: Intent) {
+  addRawIntent(rawIntent: Record<string, any>) {
     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(rawIntent.diff)) {
+      for (const [token, amountStr] of Object.entries(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,
-        tokens,
+        tgas: rawIntent.min_gas ? Number(BigInt(rawIntent.min_gas) / TGAS) : undefined,
       });
     }
 
     if (intentType === "mt_withdraw") {
-      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.addIntent({
+      const intent: MtWithdrawIntent = {
         intent: "mt_withdraw",
         amounts: rawIntent.amounts,
         receiver_id: rawIntent.receiver_id,
@@ -178,71 +152,58 @@ export class Intents {
         memo: rawIntent.memo,
         msg: rawIntent.msg,
         min_gas: rawIntent.min_gas,
-      } as 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);
       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({
-        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,
+        attachNear: BigInt(rawIntent.attached_deposit),
+        tgas: Number(BigInt(rawIntent.min_gas) / TGAS),
       });
     }
 
     throw new Error(`Unsupported intent type: ${intentType}`);
   }
 
-  addPublicKey(publicKey: string) {
-    this.addIntent({ intent: "add_public_key", public_key: publicKey });
-    return this;
-  }
-
-  removePublicKey(publicKey: string) {
-    this.addIntent({ intent: "remove_public_key", public_key: publicKey });
-    return this;
-  }
-
-  withdraw(args: { token: string; amount: number | bigint; receiver: string; memo?: string; msg?: string; tgas?: number }) {
+  withdraw(args: { token: OmniToken; 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 as OmniToken, BigInt(amount));
+    this.addNeed(args.token, BigInt(amount));
 
     if (standart === "nep245") {
       const mtContract = tokenParts[0];
       const tokenId = tokenParts.slice(1).join(":");
-      this.addIntent({
+      const intent: MtWithdrawIntent = {
         intent: "mt_withdraw",
         amounts: [amount],
         receiver_id: args.receiver,
@@ -251,31 +212,23 @@ export class Intents {
         memo: args.memo,
         msg: args.msg,
         min_gas: args.tgas ? (BigInt(args.tgas) * TGAS).toString() : undefined,
-      } as MtWithdrawIntent);
+      };
+
+      this.intents.push(intent);
       return this;
     }
 
     if (standart === "nep141") {
-      this.addIntent({
+      const intent: FtWithdrawIntent = {
         intent: "ft_withdraw",
         receiver_id: args.receiver,
         token: tokenParts.join(":"),
         amount: amount,
         memo: args.memo,
         msg: args.msg,
-      } as FtWithdrawIntent);
-      return this;
-    }
+      };
 
-    if (standart === "nep171") {
-      this.addIntent({
-        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);
+      this.intents.push(intent);
       return this;
     }
 
@@ -283,188 +236,164 @@ export class Intents {
   }
 
   attachHashes(hashes: string[]) {
-    this.signedHashes.push(...hashes);
+    this.hashes.push(...hashes);
     return this;
   }
 
-  attachWallet(wallet?: OmniWallet) {
+  attachWallet(wallet: OmniWallet) {
     this.signer = wallet;
     return this;
   }
 
   attachDeadline(deadline: Date) {
-    if (!this.unsignedCommitment) this.unsignedCommitment = { intents: [] };
-    this.unsignedCommitment.deadline = deadline;
+    this.deadline = deadline;
     return this;
   }
 
   attachNonce(nonce: Uint8Array) {
-    if (!this.unsignedCommitment) this.unsignedCommitment = { intents: [] };
-    this.unsignedCommitment.nonce = nonce;
+    this.nonce = nonce;
     return this;
   }
 
   attachTimeout(seconds: number) {
-    if (!this.unsignedCommitment) this.unsignedCommitment = { intents: [] };
-    this.unsignedCommitment.deadline = new Date(Date.now() + seconds * 1000);
+    this.deadline = new Date(Date.now() + seconds * 1000);
     return this;
   }
 
   attachSeed(seed: string) {
-    if (!this.unsignedCommitment) this.unsignedCommitment = { intents: [] };
-    this.unsignedCommitment.nonce = new Uint8Array(sha256(new TextEncoder().encode(seed))).slice(0, 32);
-    return this;
-  }
-
-  attachCommitment(commitment: Commitment) {
-    this.commitments.push(commitment);
+    this.nonce = new Uint8Array(sha256(new TextEncoder().encode(seed))).slice(0, 32);
     return this;
   }
 
-  take(token: string, amount: number | bigint) {
+  take(token: OmniToken, amount: number | bigint) {
     const intAmount = typeof amount === "number" ? tokens.get(token).int(amount) : amount;
 
-    // this.addNeed(token, -intAmount); Do we need to add the need here?
-    const tokenDiff = this.unsignedCommitment?.intents.find((intent) => intent.intent === "token_diff");
+    this.addNeed(token, intAmount);
+    const tokenDiff = this.intents.find((intent) => intent.intent === "token_diff");
 
     if (tokenDiff) tokenDiff.diff[token.toString()] = intAmount.toString();
-    else this.addIntent({ intent: "token_diff", diff: { [token.toString()]: intAmount.toString() } });
+    else this.intents.push({ intent: "token_diff", diff: { [token.toString()]: intAmount.toString() } });
     return this;
   }
 
-  give(token: string, amount: number | bigint) {
+  give(token: OmniToken, amount: number | bigint) {
     const intAmount = typeof amount === "number" ? tokens.get(token).int(amount) : amount;
 
-    this.addNeed(token as OmniToken, intAmount);
-    const tokenDiff = this.unsignedCommitment?.intents.find((intent) => intent.intent === "token_diff");
+    this.addNeed(token, -intAmount);
+    const tokenDiff = this.intents.find((intent) => intent.intent === "token_diff");
 
     if (tokenDiff) tokenDiff.diff[token.toString()] = (-intAmount).toString();
-    else this.addIntent({ intent: "token_diff", diff: { [token.toString()]: (-intAmount).toString() } });
+    else this.intents.push({ intent: "token_diff", diff: { [token.toString()]: (-intAmount).toString() } });
     return this;
   }
 
-  async signSequence() {
-    const signer = this.signer;
-    if (!signer) throw new Error("No signer attached");
-    if (!signer.omniAddress) throw new Error("No omni address");
-
-    const commitments: Commitment[] = [];
-    for (const intent of this.unsignedCommitment?.intents || []) {
-      commitments.push(
-        await signer.signIntents([intent], {
-          deadline: this.unsignedCommitment?.deadline ? +this.unsignedCommitment.deadline : undefined,
-          nonce: this.unsignedCommitment?.nonce,
-        })
-      );
+  async signRaw({ ed25519PrivateKey, intentsAddress, checkTokens }: { ed25519PrivateKey: Uint8Array; intentsAddress?: string; checkTokens?: boolean }) {
+    if (checkTokens) {
+      await this.checkRequiredTokens();
     }
 
-    return commitments;
-  }
+    const publicKey = ed25519.getPublicKey(ed25519PrivateKey);
+    const nonce = new Uint8Array(this.nonce || window.crypto.getRandomValues(new Uint8Array(32)));
 
-  async sign() {
-    const signer = this.signer;
-    if (!signer) throw new Error("No signer attached");
-    if (!signer.omniAddress) throw new Error("No omni address");
-    const commitment = await signer.signIntents(this.unsignedCommitment?.intents || [], {
-      deadline: this.unsignedCommitment?.deadline ? +this.unsignedCommitment.deadline : undefined,
-      nonce: this.unsignedCommitment?.nonce,
+    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,
     });
 
-    this.unsignedCommitment = undefined;
+    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 simulate() {
-    if (this.commitments.length === 0) throw new Error("No commitments attached");
-    return await Intents.simulateIntents(this.commitments);
+  async attachSigner(signer: OmniWallet | { ed25519PrivateKey: Uint8Array; omniAddress?: string }) {
+    this.signer = signer;
+    return this;
   }
 
-  async setupSigner() {
-    if (!this.wibe3) throw new Error("No wibe3 attached");
-    if (this.signer) return this.signer;
-
-    if (this.wibe3.priorityWallet) {
-      this.signer = this.wibe3.priorityWallet;
-      return this.signer;
+  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);
     }
+  }
 
-    if (this.wibe3.wallets.length > 0) await openConnectPrimaryWallet(this.wibe3);
-    else await openConnector(this.wibe3);
+  async sign(params = { checkTokens: true }) {
+    const signer = this.signer;
+    if (!signer) throw new Error("No signer attached");
+    if (!signer.omniAddress) throw new Error("No omni address");
 
-    if (this.wibe3.priorityWallet == undefined) throw new Error("No signer attached");
-    this.signer = this.wibe3.priorityWallet;
-    return this.signer;
-  }
+    if ("ed25519PrivateKey" in signer) {
+      return await this.signRaw({
+        ed25519PrivateKey: signer.ed25519PrivateKey,
+        intentsAddress: signer.omniAddress,
+        checkTokens: params.checkTokens,
+      });
+    }
 
-  async openSignFlow({ title, allowedTokens, onConfirm }: { title?: string; allowedTokens?: string[]; onConfirm: (args: { depositQoute?: BridgeReview; processing?: () => Promise<BridgeReview> }) => Promise<void> }) {
-    if (!this.wibe3) throw "Attach wibe3";
-    if (!this.signer) throw "Attach signer";
-
-    // TODO: Handle multiple payables
-    const payableToken = tokens.get(Array.from(this.need.keys())[0]);
-    const payableAmount = this.need.get(payableToken.omniAddress as OmniToken) || 0n;
-    const balance = await this.wibe3.fetchToken(payableToken!, this.signer);
-    const prepaidAmount = formatter.bigIntMin(payableAmount, balance);
-
-    return await openPayment(this.wibe3, {
-      onConfirm,
-      needAmount: payableAmount - prepaidAmount,
-      allowedTokens,
-      prepaidAmount,
-      payableToken,
-      intents: this,
-      title,
-    });
-  }
+    if (params.checkTokens) {
+      await this.checkRequiredTokens();
+    }
 
-  async depositAndExecute({ title = "Payment", message, allowedTokens, serverSideProcessing, payload }: { title?: string; message?: string; allowedTokens?: string[]; serverSideProcessing?: boolean; payload?: Record<string, any> } = {}) {
-    await this.setupSigner();
-    if (this.need.size === 0) return this.execute();
-
-    await this.openSignFlow({
-      title,
-      allowedTokens,
-      onConfirm: async ({ depositQoute, processing }: { depositQoute?: BridgeReview; processing?: () => Promise<BridgeReview> }) => {
-        if (!serverSideProcessing) return;
-
-        let depositAddress: string | undefined;
-        if (depositQoute?.qoute === "deposit") await processing?.();
-        else if (depositQoute?.qoute === "withdraw") await processing?.();
-        else depositAddress = depositQoute?.qoute?.depositAddress;
-
-        await api.yieldIntentCall({
-          depositAddress: depositAddress,
-          commitment: this.commitments[0],
-          payload: payload || {},
-        });
-      },
+    return await signer.signIntents(this.intents, {
+      deadline: this.deadline ? +this.deadline : undefined,
+      nonce: this.nonce,
     });
-
-    if (serverSideProcessing) return;
-    const close = openToast(message || "Executing payment");
-    await this.execute().finally(() => close());
   }
 
-  async execute() {
-    if (this.unsignedCommitment != null) await this.sign();
-    const task = Intents.publish(this.commitments, this.signedHashes);
-    this.commitments = [];
-    this.signedHashes = [];
+  async simulate(params = { checkTokens: true }) {
+    const signed = await this.sign(params);
+    return await Intents.simulateIntents([signed]);
+  }
 
-    const hash = await task;
+  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;
   }
 
-  static async publish(signed: Commitment[], hashes: string[] = []): Promise<string> {
-    const result = await api.publishIntents(signed, hashes);
+  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",
+      }),
+    });
+
+    const { result } = await res.json();
     if (result.status === "FAILED") throw result.reason;
     const intentResult = result.intent_hashes[0];
 
     const getStatus = async () => {
-      const statusResult = await api.getIntentsStatus(intentResult);
-      return statusResult;
+      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 fetchResult = async () => {
@@ -488,7 +417,7 @@ export class Intents {
     });
   }
 
-  static async simulateIntents(signed: Commitment[]) {
+  static async simulateIntents(signed: Record<string, any>[]) {
     return await rpc.viewMethod({
       args: { signed: signed },
       methodName: "simulate_intents",

package/src/core/api.ts

@@ -8,16 +8,6 @@ export class ApiError extends Error {
   }
 }
 
-export interface PaymentStatus {
-  payment_id: string;
-  timestamp: number;
-  amount: string;
-  token_id: string;
-  sender_id: string;
-  near_trx: string;
-  status: string;
-}
-
 export interface TokenType {
   icon: string;
   symbol: string;
@@ -79,29 +69,9 @@ export class Api {
     return result.balances?.[chain] || [];
   }
 
-  async yieldIntentCall(args: { commitment: Commitment; depositAddress?: string; payload?: Record<string, any> }) {
-    return await this.request(`/api/v1/wibe3/yield_intent_call`, {
-      method: "POST",
-      body: JSON.stringify({
-        commitment: args.commitment,
-        deposit_address: args.depositAddress,
-        ...args.payload,
-      }),
-    });
-  }
-
-  async paymentStatus(memo: string): Promise<PaymentStatus> {
-    const result = await this.request(`/partners/processed_payments?memo=${memo}`, { method: "GET" });
-    return result.payments[0];
-  }
-
-  async getPayments(merchantId: string): Promise<PaymentStatus[]> {
-    const result = await this.request(`/partners/processed_payments?merchant_id=${merchantId}`, { method: "GET" });
-    return result.payments;
-  }
-
   async publishIntents(signed: Record<string, any>[], hashes: string[]) {
-    const result = await this.request(`/api/v1/wibe3/solver-bus`, {
+    return await this.request(`/api/v1/wibe3/solver-bus`, {
+      headers: { "Content-Type": "application/json" },
       method: "POST",
       body: JSON.stringify({
         params: [{ signed_datas: signed, quote_hashes: hashes }],
@@ -110,12 +80,11 @@ export class Api {
         jsonrpc: "2.0",
       }),
     });
-
-    return result.result;
   }
 
   async getIntentsStatus(intentHash: string) {
-    const result = await this.request(`/api/v1/wibe3/solver-bus`, {
+    return await this.request(`/api/v1/wibe3/solver-bus`, {
+      headers: { "Content-Type": "application/json" },
       method: "POST",
       body: JSON.stringify({
         params: [{ intent_hash: intentHash }],
@@ -124,8 +93,6 @@ export class Api {
         jsonrpc: "2.0",
       }),
     });
-
-    return result.result;
   }
 }
 

package/src/core/bridge.ts

@@ -1,14 +1,13 @@
 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: Commitment[], hashes: string[] = []) => {
-      const hash = await Intents.publish(signed, hashes);
+    publishIntents: async (signed: Record<string, any>[], hashes: string[] = []) => {
+      const hash = await Intents.publishSignedIntents(signed, hashes);
       return { sender: "intents.near", hash };
     },