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

package/src/core/Intents.ts

@@ -1,14 +1,17 @@
 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 { formatter } from "./utils";
 import { tokens } from "./tokens";
-import { rpc } from "./nearRpc";
+import { api } from "./api";
+
+import { openConnector, openConnectPrimaryWallet, openPayment, openToast } from "../ui/router";
+import { BridgeReview } from "../exchange";
 
 export const TGAS = 1000000000000n;
 
@@ -19,14 +22,22 @@ export class Intents {
     return new Intents();
   }
 
-  hashes: string[] = [];
-  intents: (TransferIntent | MtWithdrawIntent | FtWithdrawIntent | TokenDiffIntent | AuthCallIntent)[] = [];
-  nonce?: Uint8Array;
-  deadline?: Date;
-  signer?: OmniWallet | { ed25519PrivateKey: Uint8Array; omniAddress?: string };
-
-  commitments: Record<string, any>[] = [];
+  signedHashes: string[] = [];
+  commitments: Commitment[] = [];
   need = new Map<OmniToken, bigint>();
+  signer?: OmniWallet;
+
+  unsignedCommitment?: {
+    intents: Intent[];
+    nonce?: Uint8Array;
+    deadline?: Date;
+  };
+
+  addIntent(intent: Intent) {
+    if (!this.unsignedCommitment) this.unsignedCommitment = { intents: [] };
+    this.unsignedCommitment.intents.push(intent);
+    return this;
+  }
 
   addNeed(token: OmniToken, amount: bigint) {
     if (!this.need.has(token)) this.need.set(token, 0n);
@@ -36,7 +47,7 @@ export class Intents {
 
   authCall(args: { contractId: string; msg: string; attachNear: bigint; tgas: number }) {
     this.addNeed(OmniToken.NEAR, args.attachNear);
-    this.intents.push({
+    this.addIntent({
       min_gas: (BigInt(args.tgas) * TGAS).toString(),
       attached_deposit: args.attachNear.toString(),
       contract_id: args.contractId,
@@ -47,6 +58,22 @@ 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();
@@ -60,7 +87,7 @@ export class Intents {
     };
 
     this.addNeed(args.token, BigInt(amount));
-    this.intents.push(intent);
+    this.addIntent(intent);
     return this;
   }
 
@@ -82,11 +109,11 @@ export class Intents {
       msg: args.msg,
     };
 
-    this.intents.push(intent);
+    this.addIntent(intent);
     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()];
@@ -105,45 +132,44 @@ export class Intents {
       }
     }
 
-    this.intents.push(intent);
+    this.addIntent(intent);
     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.addIntent({
         intent: "mt_withdraw",
         amounts: rawIntent.amounts,
         receiver_id: rawIntent.receiver_id,
@@ -152,58 +178,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.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 }) {
     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.addIntent({
         intent: "mt_withdraw",
         amounts: [amount],
         receiver_id: args.receiver,
@@ -212,23 +251,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.addIntent({
         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.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);
       return this;
     }
 
@@ -236,164 +283,188 @@ export class Intents {
   }
 
   attachHashes(hashes: string[]) {
-    this.hashes.push(...hashes);
+    this.signedHashes.push(...hashes);
     return this;
   }
 
-  attachWallet(wallet: OmniWallet) {
+  attachWallet(wallet?: OmniWallet) {
     this.signer = wallet;
     return this;
   }
 
   attachDeadline(deadline: Date) {
-    this.deadline = deadline;
+    if (!this.unsignedCommitment) this.unsignedCommitment = { intents: [] };
+    this.unsignedCommitment.deadline = deadline;
     return this;
   }
 
   attachNonce(nonce: Uint8Array) {
-    this.nonce = nonce;
+    if (!this.unsignedCommitment) this.unsignedCommitment = { intents: [] };
+    this.unsignedCommitment.nonce = nonce;
     return this;
   }
 
   attachTimeout(seconds: number) {
-    this.deadline = new Date(Date.now() + seconds * 1000);
+    if (!this.unsignedCommitment) this.unsignedCommitment = { intents: [] };
+    this.unsignedCommitment.deadline = new Date(Date.now() + seconds * 1000);
     return this;
   }
 
   attachSeed(seed: string) {
-    this.nonce = new Uint8Array(sha256(new TextEncoder().encode(seed))).slice(0, 32);
+    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);
     return this;
   }
 
-  take(token: OmniToken, amount: number | bigint) {
+  take(token: string, amount: number | bigint) {
     const intAmount = typeof amount === "number" ? tokens.get(token).int(amount) : amount;
 
-    this.addNeed(token, intAmount);
-    const tokenDiff = this.intents.find((intent) => intent.intent === "token_diff");
+    // this.addNeed(token, -intAmount); Do we need to add the need here?
+    const tokenDiff = this.unsignedCommitment?.intents.find((intent) => intent.intent === "token_diff");
 
     if (tokenDiff) tokenDiff.diff[token.toString()] = intAmount.toString();
-    else this.intents.push({ intent: "token_diff", diff: { [token.toString()]: intAmount.toString() } });
+    else this.addIntent({ intent: "token_diff", diff: { [token.toString()]: intAmount.toString() } });
     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);
-    const tokenDiff = this.intents.find((intent) => intent.intent === "token_diff");
+    this.addNeed(token as OmniToken, intAmount);
+    const tokenDiff = this.unsignedCommitment?.intents.find((intent) => intent.intent === "token_diff");
 
     if (tokenDiff) tokenDiff.diff[token.toString()] = (-intAmount).toString();
-    else this.intents.push({ intent: "token_diff", diff: { [token.toString()]: (-intAmount).toString() } });
+    else this.addIntent({ intent: "token_diff", diff: { [token.toString()]: (-intAmount).toString() } });
     return this;
   }
 
-  async signRaw({ ed25519PrivateKey, intentsAddress, checkTokens }: { ed25519PrivateKey: Uint8Array; intentsAddress?: string; checkTokens?: boolean }) {
-    if (checkTokens) {
-      await this.checkRequiredTokens();
+  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,
+        })
+      );
     }
 
-    const publicKey = ed25519.getPublicKey(ed25519PrivateKey);
-    const nonce = new Uint8Array(this.nonce || window.crypto.getRandomValues(new Uint8Array(32)));
+    return commitments;
+  }
 
-    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,
+  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,
     });
 
-    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.unsignedCommitment = undefined;
     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 simulate() {
+    if (this.commitments.length === 0) throw new Error("No commitments attached");
+    return await Intents.simulateIntents(this.commitments);
   }
 
-  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");
+  async setupSigner() {
+    if (!this.wibe3) throw new Error("No wibe3 attached");
+    if (this.signer) return this.signer;
 
-    if ("ed25519PrivateKey" in signer) {
-      return await this.signRaw({
-        ed25519PrivateKey: signer.ed25519PrivateKey,
-        intentsAddress: signer.omniAddress,
-        checkTokens: params.checkTokens,
-      });
+    if (this.wibe3.priorityWallet) {
+      this.signer = this.wibe3.priorityWallet;
+      return this.signer;
     }
 
-    if (params.checkTokens) {
-      await this.checkRequiredTokens();
-    }
+    if (this.wibe3.wallets.length > 0) await openConnectPrimaryWallet(this.wibe3);
+    else await openConnector(this.wibe3);
+
+    if (this.wibe3.priorityWallet == undefined) throw new Error("No signer attached");
+    this.signer = this.wibe3.priorityWallet;
+    return this.signer;
+  }
 
-    return await signer.signIntents(this.intents, {
-      deadline: this.deadline ? +this.deadline : undefined,
-      nonce: this.nonce,
+  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,
     });
   }
 
-  async simulate(params = { checkTokens: true }) {
-    const signed = await this.sign(params);
-    return await Intents.simulateIntents([signed]);
+  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 || {},
+        });
+      },
+    });
+
+    if (serverSideProcessing) return;
+    const close = openToast(message || "Executing payment");
+    await this.execute().finally(() => close());
   }
 
-  async execute(params = { checkTokens: true }) {
-    const signed = await this.sign(params);
-    const hash = await Intents.publishSignedIntents([...this.commitments, signed], this.hashes);
+  async execute() {
+    if (this.unsignedCommitment != null) await this.sign();
+    const task = Intents.publish(this.commitments, this.signedHashes);
+    this.commitments = [];
+    this.signedHashes = [];
+
+    const hash = await task;
     await rpc.waitTransactionResult(hash, "intents.near");
     return hash;
   }
 
-  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();
+  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 +488,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",