feat: decrypted notifications

packages/core/package.json

@@ -46,7 +46,8 @@
     "@walletconnect/utils": "2.10.6",
     "events": "^3.3.0",
     "lodash.isequal": "4.5.0",
-    "uint8arrays": "^3.1.0"
+    "uint8arrays": "^3.1.0",
+    "isomorphic-unfetch": "3.1.0"
   },
   "devDependencies": {
     "@types/lodash.isequal": "4.5.6",

packages/core/src/constants/echo.ts

@@ -0,0 +1,3 @@
+export const ECHO_CONTEXT = "echo";
+
+export const ECHO_URL = "https://echo.walletconnect.com";

packages/core/src/constants/index.ts

@@ -10,3 +10,4 @@ export * from "./pairing";
 export * from "./history";
 export * from "./expirer";
 export * from "./verify";
+export * from "./echo";

packages/core/src/controllers/echo.ts

@@ -0,0 +1,31 @@
+import { generateChildLogger, Logger } from "@walletconnect/logger";
+import { IEchoClient } from "@walletconnect/types";
+import { ECHO_CONTEXT, ECHO_URL } from "../constants";
+import fetch from "isomorphic-unfetch";
+
+export class EchoClient extends IEchoClient {
+  public readonly context = ECHO_CONTEXT;
+  constructor(public projectId: string, public logger: Logger) {
+    super(projectId, logger);
+    this.logger = generateChildLogger(logger, this.context);
+  }
+
+  public registerDeviceToken: IEchoClient["registerDeviceToken"] = async (params) => {
+    const { clientId, token, notificationType, enableEncrypted = false } = params;
+
+    const echoUrl = `${ECHO_URL}/${this.projectId}/clients`;
+
+    await fetch(echoUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        client_id: clientId,
+        type: notificationType,
+        token,
+        always_raw: enableEncrypted,
+      }),
+    });
+  };
+}

packages/core/src/controllers/index.ts

@@ -8,3 +8,4 @@ export * from "./pairing";
 export * from "./history";
 export * from "./expirer";
 export * from "./verify";
+export * from "./echo";

packages/core/src/core.ts

@@ -10,7 +10,15 @@ import {
 } from "@walletconnect/logger";
 import { CoreTypes, ICore } from "@walletconnect/types";
 
-import { Crypto, Relayer, Pairing, JsonRpcHistory, Expirer, Verify } from "./controllers";
+import {
+  Crypto,
+  Relayer,
+  Pairing,
+  JsonRpcHistory,
+  Expirer,
+  Verify,
+  EchoClient,
+} from "./controllers";
 import {
   CORE_CONTEXT,
   CORE_DEFAULT,
@@ -39,6 +47,7 @@ export class Core extends ICore {
   public expirer: ICore["expirer"];
   public pairing: ICore["pairing"];
   public verify: ICore["verify"];
+  public echoClient: ICore["echoClient"];
 
   private initialized = false;
 
@@ -77,6 +86,7 @@ export class Core extends ICore {
     });
     this.pairing = new Pairing(this, this.logger);
     this.verify = new Verify(this.projectId || "", this.logger);
+    this.echoClient = new EchoClient(this.projectId || "", this.logger);
   }
 
   get context() {

packages/sign-client/src/index.ts

@@ -1,6 +1,7 @@
 import { SignClient as Client } from "./client";
-
+import { Session } from "./controllers/session";
 export * from "./constants";
 
+export const SessionStore = Session;
 export const SignClient = Client;
 export default Client;

packages/types/src/core/core.ts

@@ -10,6 +10,7 @@ import { IExpirer } from "./expirer";
 import { IPairing } from "./pairing";
 import { Logger } from "@walletconnect/logger";
 import { IVerify } from "./verify";
+import { IEchoClient } from "./echo";
 export declare namespace CoreTypes {
   interface Options {
     projectId?: string;
@@ -54,6 +55,7 @@ export abstract class ICore extends IEvents {
   public abstract expirer: IExpirer;
   public abstract pairing: IPairing;
   public abstract verify: IVerify;
+  public abstract echoClient: IEchoClient;
 
   constructor(public opts?: CoreTypes.Options) {
     super();

packages/types/src/core/echo.ts

@@ -0,0 +1,18 @@
+import { Logger } from "@walletconnect/logger";
+
+export declare namespace EchoClientTypes {
+  type RegisterDeviceTokenParams = {
+    clientId: string;
+    token: string;
+    notificationType: "fcm" | "apns" | "apns-sandbox" | "noop";
+    enableEncrypted?: boolean;
+  };
+}
+export abstract class IEchoClient {
+  public abstract readonly context: string;
+  constructor(public projectId: string, public logger: Logger) {}
+
+  public abstract registerDeviceToken(
+    params: EchoClientTypes.RegisterDeviceTokenParams,
+  ): Promise<void>;
+}

packages/types/src/core/index.ts

@@ -10,3 +10,4 @@ export * from "./keychain";
 export * from "./expirer";
 export * from "./pairing";
 export * from "./verify";
+export * from "./echo";

packages/web3wallet/src/client.ts

@@ -2,6 +2,7 @@ import EventEmitter from "events";
 import { CLIENT_CONTEXT } from "./constants";
 import { Engine } from "./controllers";
 import { IWeb3Wallet, Web3WalletTypes } from "./types";
+import { Notifications } from "./utils";
 
 export class Web3Wallet extends IWeb3Wallet {
   public name: IWeb3Wallet["name"];
@@ -10,6 +11,7 @@ export class Web3Wallet extends IWeb3Wallet {
   public events: IWeb3Wallet["events"] = new EventEmitter();
   public engine: IWeb3Wallet["engine"];
   public metadata: IWeb3Wallet["metadata"];
+  public static notifications: Web3WalletTypes.INotifications = Notifications;
 
   static async init(opts: Web3WalletTypes.Options) {
     const client = new Web3Wallet(opts);
@@ -173,6 +175,15 @@ export class Web3Wallet extends IWeb3Wallet {
     }
   };
 
+  public registerDeviceToken: IWeb3Wallet["registerDeviceToken"] = (params) => {
+    try {
+      return this.engine.registerDeviceToken(params);
+    } catch (error: any) {
+      this.logger.error(error.message);
+      throw error;
+    }
+  };
+
   // ---------- Private ----------------------------------------------- //
 
   private async initialize() {

packages/web3wallet/src/controllers/engine.ts

@@ -98,6 +98,11 @@ export class Engine extends IWeb3WalletEngine {
     return this.authClient.formatMessage(params, iss);
   };
 
+  // Push //
+  public registerDeviceToken: IWeb3WalletEngine["registerDeviceToken"] = (params) => {
+    return this.client.core.echoClient.registerDeviceToken(params);
+  };
+
   // ---------- Private ----------------------------------------------- //
 
   private onSessionRequest = (event: Web3WalletTypes.SessionRequest) => {

packages/web3wallet/src/types/client.ts

@@ -1,8 +1,9 @@
 import EventEmmiter, { EventEmitter } from "events";
-import { ICore, ProposalTypes, Verify } from "@walletconnect/types";
+import { ICore, CoreTypes, ProposalTypes, Verify } from "@walletconnect/types";
 import { AuthClientTypes } from "@walletconnect/auth-client";
 import { IWeb3WalletEngine } from "./engine";
 import { Logger } from "@walletconnect/logger";
+import { JsonRpcPayload } from "@walletconnect/jsonrpc-utils";
 
 export declare namespace Web3WalletTypes {
   type Event = "session_proposal" | "session_request" | "session_delete" | "auth_request";
@@ -41,7 +42,21 @@ export declare namespace Web3WalletTypes {
     name?: string;
   }
 
-  type Metadata = AuthClientTypes.Metadata;
+  type Metadata = CoreTypes.Metadata;
+
+  interface INotifications {
+    decryptMessage: (params: {
+      topic: string;
+      encryptedMessage: string;
+      storageOptions?: CoreTypes.Options["storageOptions"];
+      storage?: CoreTypes.Options["storage"];
+    }) => Promise<JsonRpcPayload>;
+    getMetadata: (params: {
+      topic: string;
+      storageOptions?: CoreTypes.Options["storageOptions"];
+      storage?: CoreTypes.Options["storage"];
+    }) => Promise<CoreTypes.Metadata>;
+  }
 }
 
 export abstract class IWeb3WalletEvents extends EventEmmiter {
@@ -104,6 +119,8 @@ export abstract class IWeb3Wallet {
   public abstract respondAuthRequest: IWeb3WalletEngine["respondAuthRequest"];
   public abstract getPendingAuthRequests: IWeb3WalletEngine["getPendingAuthRequests"];
   public abstract formatMessage: IWeb3WalletEngine["formatMessage"];
+  // push
+  public abstract registerDeviceToken: IWeb3WalletEngine["registerDeviceToken"];
 
   // ---------- Event Handlers ----------------------------------------------- //
   public abstract on: <E extends Web3WalletTypes.Event>(

packages/web3wallet/src/types/engine.ts

@@ -5,6 +5,7 @@ import {
   PendingRequestTypes,
   ProposalTypes,
   SessionTypes,
+  EchoClientTypes,
 } from "@walletconnect/types";
 import { IWeb3Wallet } from "./client";
 
@@ -83,4 +84,9 @@ export abstract class IWeb3WalletEngine {
 
   // format payload to message string
   public abstract formatMessage(payload: AuthEngineTypes.CacaoRequestPayload, iss: string): string;
+
+  // ---------- Push ------------------------------------------------- //
+  public abstract registerDeviceToken(
+    params: EchoClientTypes.RegisterDeviceTokenParams,
+  ): Promise<void>;
 }

packages/web3wallet/src/utils/index.ts

@@ -0,0 +1 @@
+export * from "./notifications";

packages/web3wallet/src/utils/notifications.ts

@@ -0,0 +1,34 @@
+import { Core } from "@walletconnect/core";
+import { Web3WalletTypes } from "../types";
+import { SessionStore } from "@walletconnect/sign-client";
+
+export const Notifications: Web3WalletTypes.INotifications = {
+  decryptMessage: async (params) => {
+    const instance = {
+      core: new Core({
+        storageOptions: params.storageOptions,
+        storage: params.storage,
+      }),
+    } as any;
+    await instance.core.crypto.init();
+    const decoded = instance.core.crypto.decode(params.topic, params.encryptedMessage);
+    instance.core = null;
+    return decoded;
+  },
+  getMetadata: async (params) => {
+    const instances = {
+      core: new Core({
+        storageOptions: params.storageOptions,
+        storage: params.storage,
+      }),
+      sessionStore: null,
+    } as any;
+    instances.sessionStore = new SessionStore(instances.core, instances.core.logger);
+    await instances.sessionStore.init();
+    const session = instances.sessionStore.get(params.topic);
+    const metadata = session?.peer.metadata;
+    instances.core = null;
+    instances.sessionStore = null;
+    return metadata;
+  },
+};