chore: solution brainstroming for ingres_expiry

src/agent/custom-http-agent.ts

@@ -1,9 +1,11 @@
 import {
   Certificate,
+  Expiry,
   HttpAgent,
   Nonce,
   defaultStrategy,
   lookupResultToBuffer,
+  makeExpiryTransform,
   makeNonceTransform,
   pollForResponse as pollForResponseAgent,
   type CallRequest,
@@ -13,7 +15,10 @@ import {
 import {bufFromBufLike} from '@dfinity/candid';
 import {Principal} from '@dfinity/principal';
 import {base64ToUint8Array, isNullish, nonNullish} from '@dfinity/utils';
+import {DEFAULT_EXPIRY_DURATION} from '../constants/http-agent.constants';
 import type {IcrcCallCanisterRequestParams} from '../types/icrc-requests';
+import {generateHash} from '../utils/crypto.utils';
+import {expiryToMs, isTimestampExpired} from '../utils/custom-http-agent.utils';
 
 export type CustomHttpAgentResponse = Pick<Required<SubmitResponse>, 'requestDetails'> & {
   certificate: Certificate;
@@ -30,9 +35,11 @@ export class UndefinedRootKeyError extends Error {}
 // Therefore, it is cleaner in my opinion to encapsulate the agent rather than extend it.
 export class CustomHttpAgent {
   readonly #agent: HttpAgent;
+  #cache: Map<string, Expiry>;
 
   private constructor(agent: HttpAgent) {
     this.#agent = agent;
+    this.#cache = new Map();
   }
 
   static async create(
@@ -55,9 +62,14 @@ export class CustomHttpAgent {
     arg,
     canisterId,
     method: methodName,
-    nonce
-  }: Omit<IcrcCallCanisterRequestParams, 'sender'>): Promise<CustomHttpAgentResponse> => {
+    nonce,
+    sender
+  }: IcrcCallCanisterRequestParams): Promise<CustomHttpAgentResponse> => {
+    const hash = await generateHash({canisterId, sender, method: methodName, arg, nonce});    
+    const ingressExpiry = this.getIngressExpiry(hash);
+
     this.attachRequestNonce({nonce});
+    this.attachAddTransformExpiry(ingressExpiry);
 
     const {requestDetails, ...restResponse} = await this.#agent.call(canisterId, {
       methodName,
@@ -210,4 +222,21 @@ export class CustomHttpAgent {
       makeNonceTransform((): Nonce => base64ToUint8Array(nonce) as Nonce)
     );
   }
+  private attachAddTransformExpiry(expiry: number): void {
+    this.#agent.addTransform('update', makeExpiryTransform(expiry));
+  }
+
+  private getIngressExpiry(hash: string): number {
+    const existingExpiry = this.#cache.get(hash);
+
+    if (existingExpiry && !isTimestampExpired(expiryToMs(existingExpiry))) {
+        const delta = expiryToMs(existingExpiry) - Date.now();
+        return delta;
+    }
+
+    const newExpiry = new Expiry(DEFAULT_EXPIRY_DURATION);
+    this.#cache.set(hash, newExpiry);
+
+    return DEFAULT_EXPIRY_DURATION;
+}
 }

src/api/signer.api.ts

@@ -13,13 +13,14 @@ export class SignerApi extends Icrc21Canister {
   async call({
     owner,
     host,
-    params: {canisterId, method, arg, nonce}
+    params: {canisterId, method, arg, nonce, sender}
   }: {
     params: IcrcCallCanisterRequestParams;
   } & SignerOptions): Promise<IcrcCallCanisterResult> {
     const agent = await this.getAgent({host, owner});
 
     const result = await agent.request({
+      sender,
       canisterId,
       method,
       arg,

src/constants/http-agent.constants.ts

@@ -0,0 +1 @@
+export const DEFAULT_EXPIRY_DURATION = 5 * 60 * 1000;

src/utils/crypto.utils.ts

@@ -0,0 +1,16 @@
+import { IcrcCallCanisterRequestParams } from 'src/types/icrc-requests';
+
+export async function generateHash(params: IcrcCallCanisterRequestParams): Promise<string> {
+    const jsonString = JSON.stringify(params, Object.keys(params).sort());
+
+    const dataBuffer = new TextEncoder().encode(jsonString);
+    const hashBuffer = await crypto.subtle.digest('SHA-256', dataBuffer);
+
+    return bufferToHex(hashBuffer);
+}
+
+function bufferToHex(buffer: ArrayBuffer): string {
+    return [...new Uint8Array(buffer)]
+      .map(byte => byte.toString(16).padStart(2, '0'))
+      .join('');
+  }

src/utils/custom-http-agent.utils.ts

@@ -0,0 +1,9 @@
+import {Expiry} from '@dfinity/agent';
+
+export function isTimestampExpired(timestamp: number): boolean {
+  return Date.now() > timestamp;
+}
+
+export function expiryToMs(expiry: Expiry): number {
+  return Number(expiry['_value'] / 1000000n);
+}