Merge pull request #1851 from WalletConnect/feat/optional-request-expiry

feat: optional request expiry

packages/core/src/constants/relayer.ts

@@ -15,6 +15,7 @@ export const RELAYER_EVENTS = {
   error: "relayer_error",
   connection_stalled: "relayer_connection_stalled",
   transport_closed: "relayer_transport_closed",
+  publish: "relayer_publish",
 };
 
 export const RELAYER_SUBSCRIBER_SUFFIX = "_subscription";

packages/core/src/controllers/publisher.ts

@@ -47,6 +47,7 @@ export class Publisher extends IPublisher {
           this.publishTimeout,
         );
         await publish;
+        this.relayer.events.emit(RELAYER_EVENTS.publish, params);
       } catch (err) {
         this.logger.debug(`Publishing Payload stalled`);
         this.relayer.events.emit(RELAYER_EVENTS.connection_stalled);

packages/sign-client/src/constants/engine.ts

@@ -1,4 +1,4 @@
-import { FIVE_MINUTES, ONE_DAY, THIRTY_SECONDS } from "@walletconnect/time";
+import { FIVE_MINUTES, ONE_DAY, SEVEN_DAYS, THIRTY_SECONDS } from "@walletconnect/time";
 import { EngineTypes } from "@walletconnect/types";
 
 export const ENGINE_CONTEXT = "engine";
@@ -102,3 +102,8 @@ export const ENGINE_RPC_OPTS: EngineTypes.RpcOptsMap = {
     },
   },
 };
+
+export const SESSION_REQUEST_EXPIRY_BOUNDARIES = {
+  min: FIVE_MINUTES,
+  max: SEVEN_DAYS,
+};

packages/sign-client/src/controllers/engine.ts

@@ -51,8 +51,14 @@ import {
   TYPE_1,
   getRequiredNamespacesFromNamespaces,
   isValidObject,
+  isValidRequestExpiry,
 } from "@walletconnect/utils";
-import { SESSION_EXPIRY, ENGINE_CONTEXT, ENGINE_RPC_OPTS } from "../constants";
+import {
+  SESSION_EXPIRY,
+  ENGINE_CONTEXT,
+  ENGINE_RPC_OPTS,
+  SESSION_REQUEST_EXPIRY_BOUNDARIES,
+} from "../constants";
 
 export class Engine extends IEngine {
   public name = ENGINE_CONTEXT;
@@ -258,9 +264,9 @@ export class Engine extends IEngine {
   public request: IEngine["request"] = async <T>(params: EngineTypes.RequestParams) => {
     this.isInitialized();
     await this.isValidRequest(params);
-    const { chainId, request, topic } = params;
-    const id = await this.sendRequest(topic, "wc_sessionRequest", { request, chainId });
-    const { done, resolve, reject } = createDelayedPromise<T>();
+    const { chainId, request, topic, expiry } = params;
+    const id = await this.sendRequest(topic, "wc_sessionRequest", { request, chainId }, expiry);
+    const { done, resolve, reject } = createDelayedPromise<T>(expiry);
     this.events.once<"session_request">(engineEvent("session_request", id), ({ error, result }) => {
       if (error) reject(error);
       else resolve(result);
@@ -384,10 +390,11 @@ export class Engine extends IEngine {
     if (expiry) this.client.core.expirer.set(id, calcExpiry(expiry));
   };
 
-  private sendRequest: EnginePrivate["sendRequest"] = async (topic, method, params) => {
+  private sendRequest: EnginePrivate["sendRequest"] = async (topic, method, params, expiry) => {
     const payload = formatJsonRpcRequest(method, params);
     const message = await this.client.core.crypto.encode(topic, payload);
     const opts = ENGINE_RPC_OPTS[method].req;
+    if (expiry) opts.ttl = expiry;
     this.client.core.history.set(topic, payload);
     this.client.core.relayer.publish(topic, message, opts);
     return payload.id;
@@ -980,7 +987,7 @@ export class Engine extends IEngine {
       const { message } = getInternalError("MISSING_OR_INVALID", `request() params: ${params}`);
       throw new Error(message);
     }
-    const { topic, request, chainId } = params;
+    const { topic, request, chainId, expiry } = params;
     await this.isValidSessionTopic(topic);
     const { namespaces } = this.client.session.get(topic);
     if (!isValidNamespacesChainId(namespaces, chainId)) {
@@ -1001,6 +1008,13 @@ export class Engine extends IEngine {
       );
       throw new Error(message);
     }
+    if (expiry && !isValidRequestExpiry(expiry, SESSION_REQUEST_EXPIRY_BOUNDARIES)) {
+      const { message } = getInternalError(
+        "MISSING_OR_INVALID",
+        `request() expiry: ${expiry}. Expiry must be a number (in seconds) between ${SESSION_REQUEST_EXPIRY_BOUNDARIES.min} and ${SESSION_REQUEST_EXPIRY_BOUNDARIES.max}`,
+      );
+      throw new Error(message);
+    }
   };
 
   private isValidRespond: EnginePrivate["isValidRespond"] = async (params) => {

packages/sign-client/test/sdk/client.spec.ts

@@ -1,4 +1,6 @@
+import { RELAYER_EVENTS } from "@walletconnect/core";
 import { formatJsonRpcError, JsonRpcError } from "@walletconnect/jsonrpc-utils";
+import { RelayerTypes } from "@walletconnect/types";
 import { getSdkError } from "@walletconnect/utils";
 import { expect, describe, it, vi } from "vitest";
 import SignClient from "../../src";
@@ -227,4 +229,33 @@ describe("Sign Client Integration", () => {
       await deleteClients(clients);
     });
   });
+
+  describe("session requests", () => {
+    it("should set custom request expiry", async () => {
+      const clients = await initTwoClients();
+      const {
+        sessionA: { topic },
+      } = await testConnectMethod(clients);
+
+      const expiry = 10000;
+
+      await Promise.all([
+        new Promise<void>((resolve) => {
+          clients.A.core.relayer.once(
+            RELAYER_EVENTS.publish,
+            (payload: RelayerTypes.PublishPayload) => {
+              // ttl of the request should match the expiry
+              expect(payload?.opts?.ttl).toEqual(expiry);
+              resolve();
+            },
+          );
+        }),
+        new Promise<void>((resolve) => {
+          clients.A.request({ ...TEST_REQUEST_PARAMS, topic, expiry });
+          resolve();
+        }),
+      ]);
+      await deleteClients(clients);
+    });
+  });
 });

packages/sign-client/test/sdk/validation.spec.ts

@@ -540,6 +540,14 @@ describe("Sign Client Validation", () => {
         clients.A.request({ ...TEST_REQUEST_PARAMS, topic, request: { method: "unknown" } }),
       ).rejects.toThrowError("Missing or invalid. request() method: unknown");
     });
+
+    it("throws when invalid expiry is provider", async () => {
+      await expect(
+        clients.A.request({ ...TEST_REQUEST_PARAMS, topic, expiry: 10 }),
+      ).rejects.toThrowError(
+        "Missing or invalid. request() expiry: 10. Expiry must be a number (in seconds) between 300 and 604800",
+      );
+    });
   });
 
   describe("respond", () => {

packages/types/src/core/relayer.ts

@@ -31,6 +31,11 @@ export declare namespace RelayerTypes {
 
   export type RequestOptions = PublishOptions | SubscribeOptions | UnsubscribeOptions;
 
+  export interface PublishPayload {
+    topic: string;
+    message: string;
+    opts?: RelayerTypes.PublishOptions;
+  }
   export interface MessageEvent {
     topic: string;
     message: string;

packages/types/src/sign-client/engine.ts

@@ -87,6 +87,7 @@ export declare namespace EngineTypes {
       params: any;
     };
     chainId: string;
+    expiry?: number;
   }
 
   interface RespondParams {
@@ -149,6 +150,7 @@ export interface EnginePrivate {
     topic: string,
     method: M,
     params: JsonRpcTypes.RequestParams[M],
+    expiry?: number,
   ): Promise<number>;
 
   sendResult<M extends JsonRpcTypes.WcMethod>(

packages/utils/src/misc.ts

@@ -221,8 +221,8 @@ export function isExpired(expiry: number) {
 }
 
 // -- promises --------------------------------------------- //
-export function createDelayedPromise<T>() {
-  const timeout = toMiliseconds(FIVE_MINUTES);
+export function createDelayedPromise<T>(expiry?: number | undefined) {
+  const timeout = toMiliseconds(expiry || FIVE_MINUTES);
   let cacheResolve: undefined | ((value: T | PromiseLike<T>) => void);
   let cacheReject: undefined | ((value?: ErrorResponse) => void);
   let cacheTimeout: undefined | NodeJS.Timeout;

packages/utils/src/validators.ts

@@ -489,3 +489,7 @@ export function isConformingNamespaces(
 
   return error;
 }
+
+export function isValidRequestExpiry(expiry: number, boundaries: { min: number; max: number }) {
+  return isValidNumber(expiry, false) && expiry <= boundaries.max && expiry >= boundaries.min;
+}