feat: wallet api improvements

.eslintignore

@@ -36,3 +36,5 @@ packages/proto-types/!(proto-types-gen)/**/*.mjs
 packages/proto-types/!(proto-types-gen)/**/*.cjs
 packages/proto-types/!(proto-types-gen)/**/*.map
 packages/proto-types/outputHash
+
+packages/mobile

.eslintrc.js

@@ -6,7 +6,7 @@ module.exports = {
     "plugin:prettier/recommended",
     "prettier",
     "plugin:import/typescript",
-    "plugin:storybook/recommended"
+    "plugin:storybook/recommended",
   ],
   plugins: ["react-hooks", "unicorn", "import", "unused-imports"],
   parserOptions: {

.prettierignore

@@ -39,3 +39,5 @@ packages/proto-types/outputHash
 
 package.json
 tsconfig.json
+
+packages/mobile

packages/background/package.json

@@ -33,6 +33,7 @@
     "@ethersproject/hash": "^5.7.0",
     "@ethersproject/transactions": "^5.7.0",
     "@ethersproject/wallet": "^5.7.0",
+    "@fetchai/wallet-types": "^0.1.1",
     "@keplr-wallet/chain-validator": "0.12.12",
     "@keplr-wallet/common": "0.12.12",
     "@keplr-wallet/cosmos": "0.12.12",

packages/background/src/address-book/constants.ts

@@ -0,0 +1 @@
+export const ROUTE = "address-book";

packages/background/src/address-book/handler.ts

@@ -0,0 +1,83 @@
+import { Env, Handler, InternalHandler, Message } from "@keplr-wallet/router";
+import { AddressBookService } from "./service";
+import {
+  AddEntryMsg,
+  DeleteEntryMsg,
+  ListEntriesMsg,
+  UpdateEntryMsg,
+} from "./messages";
+
+export const getHandler: (service: AddressBookService) => Handler = (
+  service: AddressBookService
+) => {
+  return (env: Env, msg: Message<unknown>) => {
+    switch (msg.constructor) {
+      case ListEntriesMsg:
+        return handleListEntriesMsg(service)(env, msg as ListEntriesMsg);
+      case AddEntryMsg:
+        return handleAddEntryMsg(service)(env, msg as AddEntryMsg);
+      case UpdateEntryMsg:
+        return handleUpdateEntryMsg(service)(env, msg as UpdateEntryMsg);
+      case DeleteEntryMsg:
+        return handleDeleteEntryMsg(service)(env, msg as DeleteEntryMsg);
+      default:
+        throw new Error("Unknown msg type");
+    }
+  };
+};
+
+const handleListEntriesMsg: (
+  service: AddressBookService
+) => InternalHandler<ListEntriesMsg> = (service) => {
+  return async (_env, _msg) => {
+    const chainId = await service.chainService.getSelectedChain();
+    await service.permissionService.checkBasicAccessPermission(
+      _env,
+      [chainId],
+      _msg.origin
+    );
+    return service.listEntries();
+  };
+};
+
+const handleAddEntryMsg: (
+  service: AddressBookService
+) => InternalHandler<AddEntryMsg> = (service) => {
+  return async (_env, _msg) => {
+    const chainId = await service.chainService.getSelectedChain();
+    await service.permissionService.checkBasicAccessPermission(
+      _env,
+      [chainId],
+      _msg.origin
+    );
+    return service.addEntry(_msg.entry);
+  };
+};
+
+const handleUpdateEntryMsg: (
+  service: AddressBookService
+) => InternalHandler<UpdateEntryMsg> = (service) => {
+  return async (_env, _msg) => {
+    const chainId = await service.chainService.getSelectedChain();
+    await service.permissionService.checkBasicAccessPermission(
+      _env,
+      [chainId],
+      _msg.origin
+    );
+    return service.updateEntry(_msg.entry);
+  };
+};
+
+const handleDeleteEntryMsg: (
+  service: AddressBookService
+) => InternalHandler<DeleteEntryMsg> = (service) => {
+  return async (_env, _msg) => {
+    const chainId = await service.chainService.getSelectedChain();
+    await service.permissionService.checkBasicAccessPermission(
+      _env,
+      [chainId],
+      _msg.origin
+    );
+    return service.deleteEntry(_msg.address);
+  };
+};

packages/background/src/address-book/index.ts

@@ -0,0 +1,2 @@
+export * from "./messages";
+export * from "./service";

packages/background/src/address-book/init.ts

@@ -0,0 +1,19 @@
+import { Router } from "@keplr-wallet/router";
+import { ROUTE } from "./constants";
+import { getHandler } from "./handler";
+import {
+  AddEntryMsg,
+  DeleteEntryMsg,
+  ListEntriesMsg,
+  UpdateEntryMsg,
+} from "./messages";
+import { AddressBookService } from "./service";
+
+export function init(router: Router, service: AddressBookService): void {
+  router.registerMessage(ListEntriesMsg);
+  router.registerMessage(UpdateEntryMsg);
+  router.registerMessage(DeleteEntryMsg);
+  router.registerMessage(AddEntryMsg);
+
+  router.addHandler(ROUTE, getHandler(service));
+}

packages/background/src/address-book/internal.ts

@@ -0,0 +1,2 @@
+export * from "./service";
+export * from "./init";

packages/background/src/address-book/messages.ts

@@ -0,0 +1,91 @@
+import { AddressBookEntry } from "@fetchai/wallet-types";
+import { Message } from "@keplr-wallet/router";
+import { ROUTE } from "./constants";
+
+export class ListEntriesMsg extends Message<AddressBookEntry[]> {
+  public static type() {
+    return "list-entries-msg";
+  }
+
+  constructor() {
+    super();
+  }
+
+  validateBasic(): void {
+    // noop
+  }
+
+  route(): string {
+    return ROUTE;
+  }
+
+  type(): string {
+    return ListEntriesMsg.type();
+  }
+}
+
+export class AddEntryMsg extends Message<void> {
+  public static type() {
+    return "add-entry-msg";
+  }
+
+  constructor(public readonly entry: AddressBookEntry) {
+    super();
+  }
+
+  validateBasic(): void {
+    // noop
+  }
+
+  route(): string {
+    return ROUTE;
+  }
+
+  type(): string {
+    return AddEntryMsg.type();
+  }
+}
+
+export class UpdateEntryMsg extends Message<void> {
+  public static type() {
+    return "update-entry-msg";
+  }
+
+  constructor(public readonly entry: AddressBookEntry) {
+    super();
+  }
+
+  validateBasic(): void {
+    // noop
+  }
+
+  route(): string {
+    return ROUTE;
+  }
+
+  type(): string {
+    return UpdateEntryMsg.type();
+  }
+}
+
+export class DeleteEntryMsg extends Message<void> {
+  public static type() {
+    return "delete-entry-msg";
+  }
+
+  constructor(public readonly address: string) {
+    super();
+  }
+
+  validateBasic(): void {
+    // noop
+  }
+
+  route(): string {
+    return ROUTE;
+  }
+
+  type(): string {
+    return DeleteEntryMsg.type();
+  }
+}

packages/background/src/address-book/service.ts

@@ -0,0 +1,77 @@
+import { AddressBookEntry } from "@fetchai/wallet-types";
+import { ExtensionKVStore } from "@keplr-wallet/common";
+import { ChainsService } from "src/chains";
+import { PermissionService } from "src/permission";
+
+export class AddressBookService {
+  protected addressBook: AddressBookEntry[] = [];
+  protected kvStore: ExtensionKVStore;
+
+  public chainService!: ChainsService;
+  public permissionService!: PermissionService;
+  constructor(
+    chainService: ChainsService,
+    permissionService: PermissionService
+  ) {
+    this.chainService = chainService;
+    this.kvStore = new ExtensionKVStore("address-book");
+    this.permissionService = permissionService;
+  }
+
+  public async listEntries() {
+    const chainInfo = await this.chainService.getChainInfo(
+      await this.chainService.getSelectedChain()
+    );
+    const addressBook = await this.kvStore.get(`${chainInfo.chainName}`);
+    return addressBook as AddressBookEntry[];
+  }
+
+  public async addEntry(entry: AddressBookEntry) {
+    const chainInfo = await this.chainService.getChainInfo(
+      await this.chainService.getSelectedChain()
+    );
+    const addressBook: AddressBookEntry[] | undefined =
+      (await this.kvStore.get(`${chainInfo.chainName}`)) ?? [];
+
+    const entryExists = addressBook.find((a) => {
+      return a.address === entry.address;
+    });
+
+    if (!entryExists) {
+      addressBook.push(entry);
+      await this.kvStore.set(`${chainInfo.chainName}`, addressBook);
+    }
+  }
+
+  public async updateEntry(entry: AddressBookEntry) {
+    const chainInfo = await this.chainService.getChainInfo(
+      await this.chainService.getSelectedChain()
+    );
+    const addressBook: AddressBookEntry[] | undefined =
+      (await this.kvStore.get(`${chainInfo.chainName}`)) ?? [];
+
+    const updatedAddressBook = addressBook.map((_entry) => {
+      if (_entry.address === entry.address || _entry.name === entry.name) {
+        return entry;
+      } else {
+        return _entry;
+      }
+    });
+
+    await this.kvStore.set(`${chainInfo.chainName}`, updatedAddressBook);
+  }
+
+  public async deleteEntry(address: string) {
+    const chainInfo = await this.chainService.getChainInfo(
+      await this.chainService.getSelectedChain()
+    );
+    const addressBook: AddressBookEntry[] | undefined =
+      (await this.kvStore.get(`${chainInfo.chainName}`)) ?? [];
+
+    const updatedAddressBook = addressBook.filter((entry) => {
+      return entry.address !== address;
+    });
+
+    await this.kvStore.set(`${chainInfo.chainName}`, updatedAddressBook);
+  }
+}