@keplr-wallet/background 0.12.312 → 0.13.0

package/src/recent-send-history/api.ts

@@ -0,0 +1,119 @@
+import { simpleFetch } from "@keplr-wallet/simple-fetch";
+import {
+  SwapProvider,
+  SwapV2TxStatusResponse,
+  TxStatusResponse,
+  SwapV2TxStatusRequest,
+} from "./types";
+import { EthTxReceipt, JsonRpcResponse } from "@keplr-wallet/types";
+
+export async function requestSkipTxTrack(params: {
+  endpoint: string;
+  chainId: string;
+  txHash: string;
+}) {
+  const { endpoint, chainId, txHash } = params;
+  return simpleFetch<any>(endpoint, "/v1/swap/tx", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      tx_hash: txHash,
+      chain_id: chainId,
+    }),
+  });
+}
+
+export async function requestSkipTxStatus(params: {
+  endpoint: string;
+  chainId: string;
+  txHash: string;
+}) {
+  const { endpoint, chainId, txHash } = params;
+
+  const requestParams = new URLSearchParams({
+    chain_id: chainId,
+    tx_hash: txHash,
+  }).toString();
+
+  return simpleFetch<TxStatusResponse>(
+    endpoint,
+    `/v1/swap/tx?${requestParams}`,
+    {
+      method: "GET",
+      headers: {
+        "content-type": "application/json",
+      },
+    }
+  );
+}
+
+export async function requestSwapV2TxStatus(params: {
+  endpoint: string;
+  fromChainId: string;
+  toChainId: string;
+  provider: SwapProvider;
+  txHash: string;
+}) {
+  const { endpoint, fromChainId, toChainId, provider, txHash } = params;
+
+  const request: SwapV2TxStatusRequest = {
+    provider,
+    from_chain: fromChainId,
+    to_chain: toChainId,
+    tx_hash: txHash,
+  };
+
+  return simpleFetch<SwapV2TxStatusResponse>(endpoint, "v2/swap/tx_status", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(request),
+  });
+}
+
+export async function requestEthTxReceipt(params: {
+  rpc: string;
+  txHash: string;
+  origin?: string;
+  id?: number;
+}) {
+  const { rpc, txHash, origin, id = 1 } = params;
+  return simpleFetch<JsonRpcResponse<EthTxReceipt>>(rpc, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...(origin ? { "request-source": origin } : {}),
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      method: "eth_getTransactionReceipt",
+      params: [txHash],
+      id,
+    }),
+  });
+}
+
+export async function requestEthTxTrace(params: {
+  rpc: string;
+  txHash: string;
+  origin?: string;
+  id?: number;
+}) {
+  const { rpc, txHash, origin, id = 1 } = params;
+  return simpleFetch<JsonRpcResponse<any>>(rpc, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...(origin ? { "request-source": origin } : {}),
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      method: "debug_traceTransaction",
+      params: [txHash, { tracer: "callTracer" }],
+      id,
+    }),
+  });
+}

package/src/recent-send-history/handler.ts

@@ -18,6 +18,11 @@ import {
   RemoveSkipHistoryMsg,
   ClearAllSkipHistoryMsg,
   RecordTxWithSkipSwapMsg,
+  RecordTxWithSwapV2Msg,
+  GetSwapV2HistoriesMsg,
+  RemoveSwapV2HistoryMsg,
+  ClearAllSwapV2HistoryMsg,
+  HideSwapV2HistoryMsg,
 } from "./messages";
 import { RecentSendHistoryService } from "./service";
 
@@ -86,6 +91,31 @@ export const getHandler: (service: RecentSendHistoryService) => Handler = (
           env,
           msg as ClearAllSkipHistoryMsg
         );
+      case RecordTxWithSwapV2Msg:
+        return handleRecordTxWithSwapV2Msg(service)(
+          env,
+          msg as RecordTxWithSwapV2Msg
+        );
+      case GetSwapV2HistoriesMsg:
+        return handleGetSwapV2HistoriesMsg(service)(
+          env,
+          msg as GetSwapV2HistoriesMsg
+        );
+      case RemoveSwapV2HistoryMsg:
+        return handleRemoveSwapV2HistoryMsg(service)(
+          env,
+          msg as RemoveSwapV2HistoryMsg
+        );
+      case ClearAllSwapV2HistoryMsg:
+        return handleClearAllSwapV2HistoryMsg(service)(
+          env,
+          msg as ClearAllSwapV2HistoryMsg
+        );
+      case HideSwapV2HistoryMsg:
+        return handleHideSwapV2HistoryMsg(service)(
+          env,
+          msg as HideSwapV2HistoryMsg
+        );
       default:
         throw new KeplrError("tx", 110, "Unknown msg type");
     }
@@ -253,3 +283,57 @@ const handleClearAllSkipHistoryMsg: (
     service.clearAllRecentSkipHistory();
   };
 };
+
+const handleRecordTxWithSwapV2Msg: (
+  service: RecentSendHistoryService
+) => InternalHandler<RecordTxWithSwapV2Msg> = (service) => {
+  return async (_env, msg) => {
+    return service.recordTxWithSwapV2(
+      msg.fromChainId,
+      msg.toChainId,
+      msg.provider,
+      msg.destinationAsset,
+      msg.simpleRoute,
+      msg.sender,
+      msg.recipient,
+      msg.amount,
+      msg.notificationInfo,
+      msg.routeDurationSeconds,
+      msg.txHash,
+      msg.isOnlyUseBridge
+    );
+  };
+};
+
+const handleGetSwapV2HistoriesMsg: (
+  service: RecentSendHistoryService
+) => InternalHandler<GetSwapV2HistoriesMsg> = (service) => {
+  return (_env, _msg) => {
+    return service.getRecentSwapV2Histories();
+  };
+};
+
+const handleRemoveSwapV2HistoryMsg: (
+  service: RecentSendHistoryService
+) => InternalHandler<RemoveSwapV2HistoryMsg> = (service) => {
+  return (_env, msg) => {
+    service.removeRecentSwapV2History(msg.id);
+    return service.getRecentSwapV2Histories();
+  };
+};
+
+const handleClearAllSwapV2HistoryMsg: (
+  service: RecentSendHistoryService
+) => InternalHandler<ClearAllSwapV2HistoryMsg> = (service) => {
+  return (_env, _msg) => {
+    service.clearAllRecentSwapV2History();
+  };
+};
+
+const handleHideSwapV2HistoryMsg: (
+  service: RecentSendHistoryService
+) => InternalHandler<HideSwapV2HistoryMsg> = (service) => {
+  return (_env, msg) => {
+    service.hideSwapV2History(msg.id);
+  };
+};

package/src/recent-send-history/init.ts

@@ -12,6 +12,11 @@ import {
   RecordTxWithSkipSwapMsg,
   GetSkipHistoriesMsg,
   RemoveSkipHistoryMsg,
+  RecordTxWithSwapV2Msg,
+  GetSwapV2HistoriesMsg,
+  RemoveSwapV2HistoryMsg,
+  ClearAllSwapV2HistoryMsg,
+  HideSwapV2HistoryMsg,
 } from "./messages";
 import { ROUTE } from "./constants";
 import { getHandler } from "./handler";
@@ -30,6 +35,11 @@ export function init(router: Router, service: RecentSendHistoryService): void {
   router.registerMessage(GetSkipHistoriesMsg);
   router.registerMessage(RemoveSkipHistoryMsg);
   router.registerMessage(ClearAllSkipHistoryMsg);
+  router.registerMessage(RecordTxWithSwapV2Msg);
+  router.registerMessage(GetSwapV2HistoriesMsg);
+  router.registerMessage(RemoveSwapV2HistoryMsg);
+  router.registerMessage(ClearAllSwapV2HistoryMsg);
+  router.registerMessage(HideSwapV2HistoryMsg);
 
   router.addHandler(ROUTE, getHandler(service));
 }

package/src/recent-send-history/messages.ts

@@ -1,6 +1,12 @@
 import { Message } from "@keplr-wallet/router";
 import { ROUTE } from "./constants";
-import { IBCHistory, RecentSendHistory, SkipHistory } from "./types";
+import {
+  IBCHistory,
+  RecentSendHistory,
+  SkipHistory,
+  SwapProvider,
+  SwapV2History,
+} from "./types";
 import { AppCurrency } from "@keplr-wallet/types";
 
 export class GetRecentSendHistoriesMsg extends Message<RecentSendHistory[]> {
@@ -539,3 +545,159 @@ export class ClearAllSkipHistoryMsg extends Message<void> {
     return ClearAllSkipHistoryMsg.type();
   }
 }
+
+export class RecordTxWithSwapV2Msg extends Message<string> {
+  public static type() {
+    return "record-tx-with-swap-v2";
+  }
+
+  constructor(
+    public readonly fromChainId: string,
+    public readonly toChainId: string,
+    public readonly provider: SwapProvider,
+    public readonly destinationAsset: {
+      chainId: string;
+      denom: string;
+      expectedAmount: string;
+    },
+    public readonly simpleRoute: {
+      isOnlyEvm: boolean;
+      chainId: string;
+      receiver: string;
+    }[],
+    public readonly sender: string,
+    public readonly recipient: string,
+    public readonly amount: {
+      readonly amount: string;
+      readonly denom: string;
+    }[],
+    public readonly notificationInfo: {
+      currencies: AppCurrency[];
+    },
+    public readonly routeDurationSeconds: number,
+    public readonly txHash: string,
+    public readonly isOnlyUseBridge?: boolean
+  ) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.fromChainId) {
+      throw new Error("chain id is empty");
+    }
+
+    if (!this.toChainId) {
+      throw new Error("chain id is empty");
+    }
+
+    if (!this.simpleRoute) {
+      throw new Error("simple route is empty");
+    }
+
+    if (!this.sender) {
+      throw new Error("sender is empty");
+    }
+
+    if (!this.recipient) {
+      throw new Error("recipient is empty");
+    }
+  }
+
+  route(): string {
+    return ROUTE;
+  }
+
+  type(): string {
+    return RecordTxWithSwapV2Msg.type();
+  }
+}
+
+export class GetSwapV2HistoriesMsg extends Message<SwapV2History[]> {
+  public static type() {
+    return "get-swap-v2-histories";
+  }
+
+  constructor() {
+    super();
+  }
+
+  validateBasic(): void {
+    // noop
+  }
+
+  route(): string {
+    return ROUTE;
+  }
+
+  type(): string {
+    return GetSwapV2HistoriesMsg.type();
+  }
+}
+
+export class RemoveSwapV2HistoryMsg extends Message<SwapV2History[]> {
+  public static type() {
+    return "remove-swap-v2-histories";
+  }
+
+  constructor(public readonly id: string) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.id) {
+      throw new Error("id is empty");
+    }
+  }
+
+  route(): string {
+    return ROUTE;
+  }
+
+  type(): string {
+    return RemoveSwapV2HistoryMsg.type();
+  }
+}
+
+export class ClearAllSwapV2HistoryMsg extends Message<void> {
+  public static type() {
+    return "clear-all-swap-v2-histories";
+  }
+
+  constructor() {
+    super();
+  }
+
+  validateBasic(): void {
+    // noop
+  }
+
+  route(): string {
+    return ROUTE;
+  }
+
+  type(): string {
+    return ClearAllSwapV2HistoryMsg.type();
+  }
+}
+
+export class HideSwapV2HistoryMsg extends Message<void> {
+  public static type() {
+    return "hide-swap-v2-history";
+  }
+
+  constructor(public readonly id: string) {
+    super();
+  }
+
+  validateBasic(): void {
+    // noop
+  }
+
+  route(): string {
+    return ROUTE;
+  }
+
+  type(): string {
+    return HideSwapV2HistoryMsg.type();
+  }
+}