@keplr-wallet/router 0.9.0 → 0.9.12-rc.3

package/src/guard/extension.ts

@@ -1,36 +0,0 @@
-import { Env, Guard, MessageSender } from "../types";
-import { Message } from "../message";
-
-export class ExtensionGuards {
-  static readonly checkOriginIsValid: Guard = (
-    _: Omit<Env, "requestInteraction">,
-    msg: Message<unknown>,
-    sender: MessageSender
-  ): Promise<void> => {
-    // TODO: When is a url undefined?
-    if (!sender.url) {
-      throw new Error("url is empty");
-    }
-
-    if (!msg.origin) {
-      throw new Error("origin is empty");
-    }
-
-    const url = new URL(sender.url);
-    if (url.origin !== msg.origin) {
-      throw new Error("Invalid origin");
-    }
-    return Promise.resolve();
-  };
-
-  static readonly checkMessageIsInternal: Guard = (
-    env: Omit<Env, "requestInteraction">,
-    msg: Message<unknown>,
-    sender: MessageSender
-  ): Promise<void> => {
-    if (!env.isInternalMsg && !msg.approveExternal(env, sender)) {
-      throw new Error("Permission rejected");
-    }
-    return Promise.resolve();
-  };
-}

package/src/guard/index.ts

@@ -1,3 +0,0 @@
-export * from "./extension";
-export * from "./content-script";
-export * from "./mock";

package/src/guard/mock.ts

@@ -1,10 +0,0 @@
-import { Guard } from "../types";
-import { ExtensionGuards } from "./extension";
-
-export class MockGuards {
-  static readonly checkOriginIsValid: Guard =
-    ExtensionGuards.checkOriginIsValid;
-
-  static readonly checkMessageIsInternal: Guard =
-    ExtensionGuards.checkMessageIsInternal;
-}

package/src/mock/mock.spec.ts

@@ -1,131 +0,0 @@
-import assert from "assert";
-import { Message } from "../message";
-import { MockRouter, Router } from "../router";
-import { MockEnv } from "../env";
-import { MockMessageRequester } from "../requester";
-import { MockGuards } from "../guard";
-
-class MockMessage extends Message<boolean> {
-  public static type() {
-    return "mock";
-  }
-
-  route(): string {
-    return "mock";
-  }
-
-  type(): string {
-    return MockMessage.type();
-  }
-
-  validateBasic(): void {
-    // noop
-  }
-}
-
-class MockExternalMessage extends Message<boolean> {
-  public static type() {
-    return "mock-extern";
-  }
-
-  route(): string {
-    return "mock-extern";
-  }
-
-  type(): string {
-    return MockExternalMessage.type();
-  }
-
-  validateBasic(): void {
-    // noop
-  }
-
-  approveExternal(): boolean {
-    return true;
-  }
-}
-
-describe("Test message permission", () => {
-  const port = "port";
-  const mockId = "mock";
-  const mockUrl = "http://mock.com";
-
-  const mockInternalRequester = new MockMessageRequester(mockId, mockUrl);
-  const mockExternalRequester = new MockMessageRequester(
-    mockId,
-    "http://other.com"
-  );
-  const mockExternalRequester2 = new MockMessageRequester("other", mockUrl);
-  const mockExternalRequester3 = new MockMessageRequester(
-    "other",
-    "http://other.com"
-  );
-
-  let router: Router | undefined;
-  beforeEach(() => {
-    // Init router for mocking.
-    router = new MockRouter(new MockEnv(mockId, mockUrl).envProducer());
-    router.addGuard(MockGuards.checkOriginIsValid);
-    router.addGuard(MockGuards.checkMessageIsInternal);
-
-    router.registerMessage(MockMessage);
-    router.registerMessage(MockExternalMessage);
-
-    router.addHandler("mock", () => true);
-    router.addHandler("mock-extern", () => true);
-
-    router.listen(port);
-  });
-
-  afterEach(() => {
-    if (router) {
-      router.unlisten();
-    }
-  });
-
-  const testSendMessage = async (
-    msg: Message<unknown>,
-    isAllowExternal: boolean
-  ) => {
-    const result = await mockInternalRequester.sendMessage(port, msg);
-    assert.strictEqual(result, true);
-
-    if (isAllowExternal) {
-      await assert.doesNotReject(async () => {
-        const result = await mockExternalRequester.sendMessage(port, msg);
-        assert.strictEqual(result, true);
-      });
-      await assert.doesNotReject(async () => {
-        const result = await mockExternalRequester2.sendMessage(port, msg);
-        assert.strictEqual(result, true);
-      });
-      await assert.doesNotReject(async () => {
-        const result = await mockExternalRequester3.sendMessage(port, msg);
-        assert.strictEqual(result, true);
-      });
-    } else {
-      await assert.rejects(async () => {
-        const result = await mockExternalRequester.sendMessage(port, msg);
-        assert.strictEqual(result, true);
-      });
-      await assert.rejects(async () => {
-        const result = await mockExternalRequester2.sendMessage(port, msg);
-        assert.strictEqual(result, true);
-      });
-      await assert.rejects(async () => {
-        const result = await mockExternalRequester3.sendMessage(port, msg);
-        assert.strictEqual(result, true);
-      });
-    }
-  };
-
-  it("Basic message should be allowed only if it is from internal", async () => {
-    const mockMsg = new MockMessage();
-    await testSendMessage(mockMsg, false);
-  });
-
-  it("External message should be allowed event if it is from external", async () => {
-    const mockMsg = new MockExternalMessage();
-    await testSendMessage(mockMsg, true);
-  });
-});

package/src/requester/content-script.ts

@@ -1,45 +0,0 @@
-import { MessageRequester } from "../types";
-import { Message } from "../message";
-import { JSONUint8Array } from "../json-uint8-array";
-
-// The message requester to send the message to the content scripts.
-// This will send message to the tab with the content script.
-// And, this can't handle the result of the message sending.
-// TODO: Research to improve this requester.
-export class ContentScriptMessageRequester implements MessageRequester {
-  async sendMessage<M extends Message<unknown>>(
-    port: string,
-    msg: M
-  ): Promise<M extends Message<infer R> ? R : never> {
-    msg.validateBasic();
-
-    // Set message's origin.
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    msg["origin"] = window.location.origin;
-
-    const wrappedMsg = JSONUint8Array.wrap(msg);
-
-    const tabs = await browser.tabs.query({
-      discarded: false,
-      status: "complete",
-    });
-
-    for (let i = 0; i < tabs.length; i++) {
-      const tabId = tabs[i].id;
-      if (tabId) {
-        try {
-          await browser.tabs.sendMessage(tabId, {
-            port,
-            type: msg.type(),
-            msg: wrappedMsg,
-          });
-          // Ignore the failure
-        } catch {}
-      }
-    }
-
-    // This requester can't handle the result of the message.
-    return undefined as any;
-  }
-}

package/src/requester/extension.ts

@@ -1,66 +0,0 @@
-import { MessageRequester } from "../types";
-import { Message } from "../message";
-import { JSONUint8Array } from "../json-uint8-array";
-
-export class InExtensionMessageRequester implements MessageRequester {
-  async sendMessage<M extends Message<unknown>>(
-    port: string,
-    msg: M
-  ): Promise<M extends Message<infer R> ? R : never> {
-    msg.validateBasic();
-
-    // Set message's origin.
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    msg["origin"] = window.location.origin;
-
-    const result = JSONUint8Array.unwrap(
-      await browser.runtime.sendMessage({
-        port,
-        type: msg.type(),
-        msg: JSONUint8Array.wrap(msg),
-      })
-    );
-
-    if (!result) {
-      throw new Error("Null result");
-    }
-
-    if (result.error) {
-      throw new Error(result.error);
-    }
-
-    return result.return;
-  }
-
-  static async sendMessageToTab<M extends Message<unknown>>(
-    tabId: number,
-    port: string,
-    msg: M
-  ): Promise<M extends Message<infer R> ? R : never> {
-    msg.validateBasic();
-
-    // Set message's origin.
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    msg["origin"] = window.location.origin;
-
-    const result = JSONUint8Array.unwrap(
-      await browser.tabs.sendMessage(tabId, {
-        port,
-        type: msg.type(),
-        msg: JSONUint8Array.wrap(msg),
-      })
-    );
-
-    if (!result) {
-      throw new Error("Null result");
-    }
-
-    if (result.error) {
-      throw new Error(result.error);
-    }
-
-    return result.return;
-  }
-}

package/src/requester/index.ts

@@ -1,3 +0,0 @@
-export * from "./extension";
-export * from "./content-script";
-export * from "./mock";

package/src/requester/mock.ts

@@ -1,48 +0,0 @@
-import { MessageRequester } from "../types";
-import { Message } from "../message";
-import { JSONUint8Array } from "../json-uint8-array";
-import { MockRouter } from "../router";
-import { Result } from "../interfaces";
-
-export class MockMessageRequester implements MessageRequester {
-  constructor(protected readonly id: string, protected readonly url: string) {}
-
-  async sendMessage<M extends Message<unknown>>(
-    port: string,
-    msg: M
-  ): Promise<M extends Message<infer R> ? R : never> {
-    msg.validateBasic();
-
-    // Set message's origin.
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    msg["origin"] = new URL(this.url).origin;
-
-    const result: Result = JSONUint8Array.unwrap(
-      await new Promise((resolve) => {
-        MockRouter.eventEmitter.emit("message", {
-          message: {
-            port,
-            type: msg.type(),
-            msg: JSONUint8Array.wrap(msg),
-          },
-          sender: {
-            id: this.id,
-            url: this.url,
-            resolver: resolve,
-          },
-        });
-      })
-    );
-
-    if (!result) {
-      throw new Error("Null result");
-    }
-
-    if (result.error) {
-      throw new Error(result.error);
-    }
-
-    return result.return;
-  }
-}

package/src/router/extension.ts

@@ -1,72 +0,0 @@
-import { Router } from "./types";
-import { MessageSender } from "../types";
-import { Result } from "../interfaces";
-
-export class ExtensionRouter extends Router {
-  listen(port: string): void {
-    if (!port) {
-      throw new Error("Empty port");
-    }
-
-    this.port = port;
-    browser.runtime.onMessage.addListener(this.onMessage);
-    // Although security considerations cross-extension communication are in place,
-    // we have put in additional security measures by disbling extension-to-extension communication until a formal security audit has taken place.
-    /*
-    if (browser.runtime.onMessageExternal) {
-      browser.runtime.onMessageExternal.addListener(this.onMessage);
-    }
-     */
-  }
-
-  unlisten(): void {
-    this.port = "";
-    browser.runtime.onMessage.removeListener(this.onMessage);
-    // Although security considerations cross-extension communication are in place,
-    // we have put in additional security measures by disbling extension-to-extension communication until a formal security audit has taken place.
-    /*
-    if (browser.runtime.onMessageExternal) {
-      browser.runtime.onMessageExternal.removeListener(this.onMessage);
-    }
-     */
-  }
-
-  // You shouldn't set this handler as async funtion,
-  // because mozila's extension polyfill deals with the message handler as resolved if it returns the `Promise`.
-  // So, if this handler is async function, it always return the `Promise` if it returns `undefined` and it is dealt with as resolved.
-  protected onMessage = (
-    message: any,
-    sender: MessageSender
-  ): Promise<Result> | undefined => {
-    if (message.port !== this.port) {
-      return;
-    }
-
-    return this.onMessageHandler(message, sender);
-  };
-
-  protected async onMessageHandler(
-    message: any,
-    sender: MessageSender
-  ): Promise<Result> {
-    try {
-      const result = await this.handleMessage(message, sender);
-      return {
-        return: result,
-      };
-    } catch (e) {
-      console.log(
-        `Failed to process msg ${message.type}: ${e?.message || e?.toString()}`
-      );
-      if (e) {
-        return Promise.resolve({
-          error: e.message || e.toString(),
-        });
-      } else {
-        return Promise.resolve({
-          error: "Unknown error, and error is null",
-        });
-      }
-    }
-  }
-}

package/src/router/mock.ts

@@ -1,55 +0,0 @@
-import { Router } from "./types";
-import { MessageSender } from "../types";
-import { Result } from "../interfaces";
-import { EventEmitter } from "events";
-
-export class MockRouter extends Router {
-  public static eventEmitter = new EventEmitter();
-
-  listen(port: string): void {
-    if (!port) {
-      throw new Error("Empty port");
-    }
-
-    this.port = port;
-    MockRouter.eventEmitter.addListener("message", this.onMessage);
-  }
-
-  unlisten(): void {
-    this.port = "";
-    MockRouter.eventEmitter.removeListener("message", this.onMessage);
-  }
-
-  protected onMessage = async (params: {
-    message: any;
-    sender: MessageSender & {
-      resolver: (result: Result) => void;
-    };
-  }): Promise<void> => {
-    const { message, sender } = params;
-    if (message.port !== this.port) {
-      return;
-    }
-
-    try {
-      const result = await this.handleMessage(message, sender);
-      sender.resolver({
-        return: result,
-      });
-      return;
-    } catch (e) {
-      console.log(
-        `Failed to process msg ${message.type}: ${e?.message || e?.toString()}`
-      );
-      if (e) {
-        sender.resolver({
-          error: e.message || e.toString(),
-        });
-      } else {
-        sender.resolver({
-          error: "Unknown error, and error is null",
-        });
-      }
-    }
-  };
-}

package/src/router/types.ts

@@ -1,64 +0,0 @@
-import { Message } from "../message";
-import { Handler } from "../handler";
-import { EnvProducer, Guard, MessageSender } from "../types";
-import { MessageRegistry } from "../encoding";
-import { JSONUint8Array } from "../json-uint8-array";
-
-export abstract class Router {
-  protected msgRegistry: MessageRegistry = new MessageRegistry();
-  protected registeredHandler: Map<string, Handler> = new Map();
-
-  protected guards: Guard[] = [];
-
-  protected port = "";
-
-  constructor(protected readonly envProducer: EnvProducer) {}
-
-  public registerMessage(
-    msgCls: { new (...args: any): Message<unknown> } & { type(): string }
-  ): void {
-    this.msgRegistry.registerMessage(msgCls);
-  }
-
-  public addHandler(route: string, handler: Handler) {
-    if (this.registeredHandler.has(route)) {
-      throw new Error(`Already registered type ${route}`);
-    }
-
-    this.registeredHandler.set(route, handler);
-  }
-
-  public addGuard(guard: Guard): void {
-    this.guards.push(guard);
-  }
-
-  public abstract listen(port: string): void;
-
-  public abstract unlisten(): void;
-
-  protected async handleMessage(
-    message: any,
-    sender: MessageSender
-  ): Promise<unknown> {
-    const msg = this.msgRegistry.parseMessage(JSONUint8Array.unwrap(message));
-    const env = this.envProducer(sender);
-
-    for (const guard of this.guards) {
-      await guard(env, msg, sender);
-    }
-
-    // Can happen throw
-    msg.validateBasic();
-
-    const route = msg.route();
-    if (!route) {
-      throw new Error("Null router");
-    }
-    const handler = this.registeredHandler.get(route);
-    if (!handler) {
-      throw new Error("Can't get handler");
-    }
-
-    return JSONUint8Array.wrap(await handler(env, msg));
-  }
-}