@keplr-wallet/background 0.13.12 → 0.13.14

package/src/keyring/handler.ts

@@ -31,11 +31,31 @@ import {
   ShowSensitiveLegacyKeyRingDataMsg,
   ExportKeyRingVaultsMsg,
   SearchKeyRingsMsg,
+  GetAllWalletsMsg,
+  SwitchAccountMsg,
 } from "./messages";
 import { KeyRingService } from "./service";
+import { PermissionService } from "../permission/service";
+import { getBasicAccessPermissionType } from "../permission/types";
+import { ChainsService } from "../chains/service";
+import type { KeyRingCosmosService } from "../keyring-cosmos/service";
+import type { KeyRingStarknetService } from "../keyring-starknet/service";
+import type { PermissionInteractiveService } from "../permission-interactive/service";
 
-export const getHandler: (service: KeyRingService) => Handler = (
-  service: KeyRingService
+export const getHandler: (
+  service: KeyRingService,
+  permissionService: PermissionService,
+  permissionInteractiveService: PermissionInteractiveService,
+  chainsService: ChainsService,
+  keyRingCosmosService: KeyRingCosmosService,
+  keyRingStarknetService: KeyRingStarknetService
+) => Handler = (
+  service,
+  permissionService,
+  permissionInteractiveService,
+  chainsService,
+  keyRingCosmosService,
+  keyRingStarknetService
 ) => {
   return (env: Env, msg: Message<unknown>) => {
     switch (msg.constructor) {
@@ -134,6 +154,20 @@ export const getHandler: (service: KeyRingService) => Handler = (
         );
       case SearchKeyRingsMsg:
         return handleSearchKeyRingsMsg(service)(env, msg as SearchKeyRingsMsg);
+      case GetAllWalletsMsg:
+        return handleGetAllWalletsMsg(
+          service,
+          permissionService,
+          permissionInteractiveService,
+          chainsService,
+          keyRingCosmosService,
+          keyRingStarknetService
+        )(env, msg as GetAllWalletsMsg);
+      case SwitchAccountMsg:
+        return handleSwitchAccountMsg(service, permissionService)(
+          env,
+          msg as SwitchAccountMsg
+        );
       default:
         throw new KeplrError("keyring", 221, "Unknown msg type");
     }
@@ -435,3 +469,136 @@ const handleSearchKeyRingsMsg: (
     return service.searchKeyRings(msg.searchText);
   };
 };
+
+const handleGetAllWalletsMsg: (
+  service: KeyRingService,
+  permissionService: PermissionService,
+  permissionInteractiveService: PermissionInteractiveService,
+  chainsService: ChainsService,
+  keyRingCosmosService: KeyRingCosmosService,
+  keyRingStarknetService: KeyRingStarknetService
+) => InternalHandler<GetAllWalletsMsg> = (
+  service,
+  permissionService,
+  permissionInteractiveService,
+  chainsService,
+  keyRingCosmosService,
+  keyRingStarknetService
+) => {
+  return async (env, msg) => {
+    const origin = msg.origin;
+    const permittedChains = permissionService.getOriginPermittedChains(
+      origin,
+      getBasicAccessPermissionType()
+    );
+
+    if (permittedChains.length === 0) {
+      throw new KeplrError(
+        "keyring",
+        510,
+        "No permitted chains. Call enable() first."
+      );
+    }
+
+    const returnAll =
+      await permissionInteractiveService.checkOrGrantGetAllKeyRingInfosPermission(
+        env,
+        origin
+      );
+    const keyInfos = returnAll
+      ? service.getKeyInfos()
+      : service.getKeyInfos().filter((k) => k.isSelected);
+    const wallets: {
+      id: string;
+      name: string;
+      isSelected: boolean;
+      addresses: { [chainId: string]: string };
+    }[] = [];
+
+    for (const keyInfo of keyInfos) {
+      const addresses: { [chainId: string]: string } = {};
+
+      for (const chainIdentifier of permittedChains) {
+        try {
+          const modularChainInfo =
+            chainsService.getModularChainInfoOrThrow(chainIdentifier);
+
+          if ("cosmos" in modularChainInfo) {
+            const key = await keyRingCosmosService.getKey(
+              keyInfo.id,
+              modularChainInfo.chainId
+            );
+            const chainInfo = modularChainInfo.cosmos;
+            const isEthermintLike = KeyRingService.isEthermintLike(chainInfo);
+            const evmInfo = ChainsService.getEVMInfo(chainInfo);
+
+            if (isEthermintLike || evmInfo !== undefined) {
+              addresses[modularChainInfo.chainId] = key.ethereumHexAddress;
+            } else {
+              addresses[modularChainInfo.chainId] = key.bech32Address;
+            }
+          } else if ("starknet" in modularChainInfo) {
+            const starknetKey = await keyRingStarknetService.getStarknetKey(
+              keyInfo.id,
+              modularChainInfo.chainId
+            );
+            addresses[modularChainInfo.chainId] = starknetKey.hexAddress;
+          }
+          // Bitcoin: skip (out of scope)
+        } catch (e) {
+          console.log(e);
+          continue;
+        }
+      }
+
+      wallets.push({
+        id: keyInfo.id,
+        name: keyInfo.name,
+        isSelected: keyInfo.isSelected,
+        addresses,
+      });
+    }
+
+    return wallets;
+  };
+};
+
+const handleSwitchAccountMsg: (
+  service: KeyRingService,
+  permissionService: PermissionService
+) => InternalHandler<SwitchAccountMsg> = (service, permissionService) => {
+  return async (env, msg) => {
+    if (msg.id === service.selectedVaultId) {
+      return;
+    }
+
+    await service.ensureUnlockInteractive(env);
+
+    const permittedChains = permissionService.getOriginPermittedChains(
+      msg.origin,
+      getBasicAccessPermissionType()
+    );
+    if (permittedChains.length === 0) {
+      throw new KeplrError(
+        "keyring",
+        510,
+        "No permitted chains. Call enable() first."
+      );
+    }
+
+    if (
+      !permissionService.hasGlobalPermission(
+        "get-all-keyring-infos",
+        msg.origin
+      )
+    ) {
+      throw new KeplrError(
+        "keyring",
+        511,
+        "Permission denied. The requested account is not accessible from this origin."
+      );
+    }
+
+    await service.switchAccountInteractive(env, msg.id, msg.origin);
+  };
+};

package/src/keyring/init.ts

@@ -26,11 +26,26 @@ import {
   ExportKeyRingVaultsMsg,
   SearchKeyRingsMsg,
   AppendLedgerExtendedKeysMsg,
+  GetAllWalletsMsg,
+  SwitchAccountMsg,
 } from "./messages";
 import { ROUTE } from "./constants";
 import { getHandler } from "./handler";
+import type { PermissionService } from "../permission/service";
+import type { PermissionInteractiveService } from "../permission-interactive/service";
+import type { ChainsService } from "../chains/service";
+import type { KeyRingCosmosService } from "../keyring-cosmos/service";
+import type { KeyRingStarknetService } from "../keyring-starknet/service";
 
-export function init(router: Router, service: KeyRingService): void {
+export function init(
+  router: Router,
+  service: KeyRingService,
+  permissionService: PermissionService,
+  permissionInteractiveService: PermissionInteractiveService,
+  chainsService: ChainsService,
+  keyRingCosmosService: KeyRingCosmosService,
+  keyRingStarknetService: KeyRingStarknetService
+): void {
   router.registerMessage(GetIsLockedMsg);
   router.registerMessage(GetKeyRingStatusMsg);
   router.registerMessage(GetKeyRingStatusOnlyMsg);
@@ -56,6 +71,18 @@ export function init(router: Router, service: KeyRingService): void {
   router.registerMessage(ShowSensitiveLegacyKeyRingDataMsg);
   router.registerMessage(ExportKeyRingVaultsMsg);
   router.registerMessage(SearchKeyRingsMsg);
+  router.registerMessage(GetAllWalletsMsg);
+  router.registerMessage(SwitchAccountMsg);
 
-  router.addHandler(ROUTE, getHandler(service));
+  router.addHandler(
+    ROUTE,
+    getHandler(
+      service,
+      permissionService,
+      permissionInteractiveService,
+      chainsService,
+      keyRingCosmosService,
+      keyRingStarknetService
+    )
+  );
 }

package/src/keyring/messages.ts

@@ -781,3 +781,64 @@ export class SearchKeyRingsMsg extends Message<KeyInfo[]> {
     return SearchKeyRingsMsg.type();
   }
 }
+
+export class GetAllWalletsMsg extends Message<
+  {
+    id: string;
+    name: string;
+    isSelected: boolean;
+    addresses: { [chainId: string]: string };
+  }[]
+> {
+  public static type() {
+    return "get-all-wallets";
+  }
+
+  constructor() {
+    super();
+  }
+
+  validateBasic(): void {
+    // noop
+  }
+
+  override approveExternal(): boolean {
+    return true;
+  }
+
+  route(): string {
+    return ROUTE;
+  }
+
+  type(): string {
+    return GetAllWalletsMsg.type();
+  }
+}
+
+export class SwitchAccountMsg extends Message<void> {
+  public static type() {
+    return "switch-account";
+  }
+
+  constructor(public readonly id: string) {
+    super();
+  }
+
+  validateBasic(): void {
+    if (!this.id) {
+      throw new Error("id not set");
+    }
+  }
+
+  override approveExternal(): boolean {
+    return true;
+  }
+
+  route(): string {
+    return ROUTE;
+  }
+
+  type(): string {
+    return SwitchAccountMsg.type();
+  }
+}

package/src/keyring/service.ts

@@ -1067,6 +1067,37 @@ export class KeyRingService {
     );
   }
 
+  async switchAccountInteractive(
+    env: Env,
+    vaultId: string,
+    origin: string
+  ): Promise<void> {
+    if (this.vaultService.isLocked) {
+      throw new Error("KeyRing is locked");
+    }
+
+    const vault = this.vaultService.getVault("keyRing", vaultId);
+    if (!vault) {
+      throw new Error("Vault is null");
+    }
+
+    const targetName = this.getKeyRingName(vaultId);
+
+    await this.interactionService.waitApproveV2(
+      env,
+      "/switch-account",
+      "switch-account",
+      {
+        vaultId,
+        name: targetName,
+        origin,
+      },
+      () => {
+        this.selectKeyRing(vaultId);
+      }
+    );
+  }
+
   async deleteKeyRing(vaultId: string, password: string) {
     if (this.vaultService.isLocked) {
       throw new Error("KeyRing is locked");

package/src/keyring-bitcoin/service.ts

@@ -14,7 +14,6 @@ import {
   GENESIS_HASH_TO_CHAIN_TYPE,
   CHAIN_TYPE_TO_GENESIS_HASH,
   SignPsbtOptions,
-  Inscription,
 } from "@keplr-wallet/types";
 import { Env, KeplrError, WEBPAGE_PORT } from "@keplr-wallet/router";
 import { Psbt, address } from "bitcoinjs-lib";
@@ -32,6 +31,10 @@ import {
   signet,
   testnet,
 } from "./constants";
+import {
+  adaptUniSatInscriptionDataResponse,
+  UniSatInscriptionDataResponse,
+} from "./unisat-inscriptions";
 import { AnalyticsService } from "../analytics";
 import { KVStore } from "@keplr-wallet/common";
 import { action, autorun, makeObservable, observable, runInAction } from "mobx";
@@ -738,50 +741,28 @@ export class KeyRingBitcoinService {
     const bitcoinKey = await this.getBitcoinKeySelected(currentChainId);
 
     const network = this.getNetworkConfig(currentChainId).id;
+
+    if (network !== Network.MAINNET && network !== Network.LIVENET) {
+      return {
+        total: 0,
+        list: [],
+      };
+    }
+
     const apiUrl = getBitcoinInscriptionsApiUrl(network);
 
     const params = new URLSearchParams();
-    params.append("sort_by", "inscr_num");
-    params.append("order", "desc");
-    params.append("exclude_brc20", "false");
-    params.append("address", bitcoinKey.address);
-    params.append("offset", offset?.toString() ?? "0");
-    params.append("count", limit?.toString() ?? "20");
+    params.append("cursor", offset?.toString() ?? "0");
+    params.append("size", limit?.toString() ?? "20");
 
     // execute API request through rate limiter to avoid rate limit from the server
     const res = await bitcoinInscriptionsRateLimiter.add(async () => {
-      return await simpleFetch<{
-        data: Array<{
-          inscription_name?: string;
-          inscription_id: string;
-          inscription_number: number;
-          parent_ids: string[];
-          output_value: number;
-          genesis_block_hash: string;
-          genesis_ts: string;
-          genesis_height: number;
-          metadata: any;
-          mime_type?: string;
-          owner_wallet_addr: string;
-          last_sale_price?: number;
-          slug?: string;
-          collection_name?: string;
-          satpoint: string;
-          last_transfer_block_height?: number;
-          content_url: string;
-          bis_url: string;
-          render_url?: string;
-          bitmap_number?: number;
-          delegate?: {
-            delegate_id: string;
-            render_url?: string;
-            mime_type?: string;
-            content_url: string;
-            bis_url: string;
-          };
-        }>;
-        block_height: number;
-      }>(`${apiUrl}/wallet/inscriptions?${params.toString()}`);
+      return await simpleFetch<UniSatInscriptionDataResponse>(
+        `${apiUrl}/unisat`,
+        `/v1/indexer/address/${
+          bitcoinKey.address
+        }/inscription-data?${params.toString()}`
+      );
     });
 
     if (res.status === 429) {
@@ -792,44 +773,7 @@ export class KeyRingBitcoinService {
       throw new Error("Failed to get inscriptions");
     }
 
-    const list: Inscription[] = [];
-
-    for (const item of res.data.data) {
-      const {
-        inscription_id,
-        inscription_number,
-        owner_wallet_addr,
-        mime_type,
-        satpoint,
-        output_value,
-        genesis_height,
-        content_url,
-        render_url,
-      } = item;
-
-      const [txid, outputIndex, satIndex] = satpoint.split(":");
-
-      list.push({
-        id: inscription_id,
-        inscriptionId: inscription_id,
-        content: content_url,
-        number: inscription_number,
-        address: owner_wallet_addr,
-        contentType: mime_type ?? "",
-        output: `${txid}:${outputIndex}`,
-        location: satpoint,
-        genesisTransaction: txid,
-        height: genesis_height,
-        preview: render_url ?? "",
-        outputValue: output_value,
-        offset: parseInt(satIndex, 10),
-      });
-    }
-
-    return {
-      total: list.length,
-      list,
-    };
+    return adaptUniSatInscriptionDataResponse(network, res.data);
   }
 
   async sendBitcoin(

package/src/keyring-bitcoin/unisat-inscriptions.ts

@@ -0,0 +1,78 @@
+import { Inscription, Network } from "@keplr-wallet/types";
+
+export interface UniSatInscriptionDataItem {
+  utxo: {
+    txid: string;
+    vout: number;
+    satoshi: number;
+    address: string;
+  };
+  address: string;
+  offset: number;
+  inscriptionNumber: number;
+  inscriptionId: string;
+  contentType?: string;
+  height: number;
+}
+
+export interface UniSatInscriptionDataResponse {
+  code: number;
+  msg?: string;
+  data: {
+    cursor: number;
+    total: number;
+    totalConfirmed?: number;
+    totalUnconfirmed?: number;
+    totalUnconfirmedSpend?: number;
+    inscription: UniSatInscriptionDataItem[];
+  };
+}
+
+export const getOrdinalsExplorerBaseUrl = (network: Network): string => {
+  switch (network) {
+    case Network.LIVENET:
+    case Network.MAINNET:
+      return "https://ordinals.com";
+    case Network.TESTNET:
+    case Network.SIGNET:
+      return "";
+  }
+};
+
+export const adaptUniSatInscriptionDataResponse = (
+  network: Network,
+  response: UniSatInscriptionDataResponse
+): { total: number; list: Inscription[] } => {
+  const explorerBaseUrl = getOrdinalsExplorerBaseUrl(network);
+
+  return {
+    total: response.data.total,
+    list: response.data.inscription.map((item) => {
+      const {
+        inscriptionId,
+        inscriptionNumber,
+        address,
+        contentType,
+        offset,
+        height,
+        utxo,
+      } = item;
+
+      return {
+        id: inscriptionId,
+        inscriptionId,
+        content: `${explorerBaseUrl}/content/${inscriptionId}`,
+        number: inscriptionNumber,
+        address,
+        contentType: contentType ?? "",
+        output: `${utxo.txid}:${utxo.vout}`,
+        location: `${utxo.txid}:${utxo.vout}:${offset}`,
+        genesisTransaction: utxo.txid,
+        height,
+        preview: `${explorerBaseUrl}/preview/${inscriptionId}`,
+        outputValue: utxo.satoshi,
+        offset,
+      };
+    }),
+  };
+};

package/src/permission-interactive/service.ts

@@ -240,4 +240,43 @@ export class PermissionInteractiveService {
       origin
     );
   }
+
+  async checkOrGrantGetAllKeyRingInfosPermission(
+    env: Env,
+    origin: string
+  ): Promise<boolean> {
+    await this.keyRingService.ensureUnlockInteractive(env);
+
+    if (
+      this.permissionService.hasGlobalPermission(
+        "get-all-keyring-infos",
+        origin
+      )
+    ) {
+      return true;
+    }
+
+    if (
+      this.permissionService.hasGlobalPermission(
+        "get-current-keyring-info",
+        origin
+      )
+    ) {
+      return false;
+    }
+
+    try {
+      await this.permissionService.checkOrGrantGlobalPermission(
+        env,
+        "get-all-keyring-infos",
+        origin
+      );
+      return true;
+    } catch {
+      this.permissionService.addGlobalPermission("get-current-keyring-info", [
+        origin,
+      ]);
+      return false;
+    }
+  }
 }