dhali-js 3.1.0 → 3.1.1

package/.github/workflows/tests.yaml

@@ -29,6 +29,9 @@ jobs:
         run: npm test tests/DhaliChannelManager.test.js tests/DhaliEthChannelManager.test.js tests/createSignedClaim.test.js tests/utils.test.js
 
       - name: Run integration tests
+        env:
+          XRPL_TESTNET_SECRET: ${{ secrets.XRPL_TESTNET_SECRET }}
+          SEPOLIA_TESTNET_SECRET: ${{ secrets.SEPOLIA_TESTNET_SECRET }}
         run: npm test tests/integration.test.js
 
       - name: Run lint

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dhali-js",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "A JavaScript library for managing XRPL payment channels and generating auth tokens for Dhali APIs",
   "main": "src/index.js",
   "type": "commonjs",

package/src/dhali/DhaliEthChannelManager.js

@@ -95,7 +95,6 @@ class DhaliEthChannelManager {
   }
 
   async _calculateChannelId(receiver, tokenAddress, nonce) {
-    // Matches Dhali-wallet: keccak256(abi.encode(sender, receiver, token, nonce))
     const [sender] = await this.walletClient.getAddresses();
     return keccak256(
       encodeAbiParameters(

package/src/dhali/DhaliXrplChannelManager.js

@@ -58,12 +58,27 @@ class DhaliXrplChannelManager {
     );
   }
 
-  async _findChannel() {
+  async _retrieveChannelIdFromFirestoreWithPolling(timeoutSeconds = 30) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutSeconds * 1000) {
+      const channelId = await this._retrieveChannelIdFromFirestore();
+      if (channelId) return channelId;
+      await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+    return null;
+  }
+
+  async _findChannel(timeoutSeconds = 0) {
     await this.ready;
     await this._resolveAddresses();
 
     // Prioritize Firestore
-    const firestoreChannelId = await this._retrieveChannelIdFromFirestore();
+    let firestoreChannelId;
+    if (timeoutSeconds > 0) {
+      firestoreChannelId = await this._retrieveChannelIdFromFirestoreWithPolling(timeoutSeconds);
+    } else {
+      firestoreChannelId = await this._retrieveChannelIdFromFirestore();
+    }
 
     if (firestoreChannelId === null) {
       throw new ChannelNotFound(
@@ -100,7 +115,7 @@ class DhaliXrplChannelManager {
     await this.ready;
     let tx;
     try {
-      const ch = await this._findChannel();
+      const ch = await this._findChannel(0);
       tx = {
         TransactionType: "PaymentChannelFund",
         Account: this.wallet.classicAddress,
@@ -129,11 +144,9 @@ class DhaliXrplChannelManager {
     const result = await this.rpc_client.submitAndWait(txBlob);
 
     // If we just created a channel, notify the gateway
-    if (tx.TransactionType === "PaymentChannelCreate" &&
-      // @ts-ignore
-      (result.result.meta || result.result.metaData)) {
+    if (tx.TransactionType === "PaymentChannelCreate") {
       // @ts-ignore
-      const meta = result.result.meta || result.result.metaData;
+      const meta = result.result.meta || result.result.metaData || {};
       const affectedNodes = meta.AffectedNodes || [];
       for (const node of affectedNodes) {
         const createdNode = node.CreatedNode;
@@ -155,6 +168,8 @@ class DhaliXrplChannelManager {
           break;
         }
       }
+      // Poll Firestore to match DhaliEthChannelManager behavior
+      await this._retrieveChannelIdFromFirestoreWithPolling(30);
     }
 
     return result.result;
@@ -167,7 +182,7 @@ class DhaliXrplChannelManager {
    */
   async getAuthToken(amountDrops) {
     await this.ready;
-    const ch = await this._findChannel();
+    const ch = await this._findChannel(10);
     const total = BigInt(ch.amount);
     const allowed = amountDrops != null ? BigInt(amountDrops) : total;
     if (allowed > total) {

package/src/dhali/configUtils.js

@@ -1,5 +1,7 @@
 const Currency = require("./Currency");
 
+let publicConfigCache = null;
+
 /**
  * @typedef {Object} NetworkCurrencyConfig
  * @property {Currency} currency
@@ -12,16 +14,21 @@ const Currency = require("./Currency");
  * @returns {Promise<Currency[]>}
  */
 async function getAvailableDhaliCurrencies(httpClient = fetch) {
-    const url = "https://raw.githubusercontent.com/Dhali-org/Dhali-config/master/public.prod.json";
     let data;
-    try {
-        const response = await httpClient(url);
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
+    if (publicConfigCache) {
+        data = publicConfigCache;
+    } else {
+        const url = "https://raw.githubusercontent.com/Dhali-org/Dhali-config/master/public.prod.json";
+        try {
+            const response = await httpClient(url);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            data = await response.json();
+            publicConfigCache = data;
+        } catch (e) {
+            throw new Error(`Failed to fetch Dhali configuration: ${e.message}`);
         }
-        data = await response.json();
-    } catch (e) {
-        throw new Error(`Failed to fetch Dhali configuration: ${e.message}`);
     }
 
     const publicAddresses = data.DHALI_PUBLIC_ADDRESSES || {};
@@ -48,13 +55,17 @@ async function getAvailableDhaliCurrencies(httpClient = fetch) {
  * @returns {Promise<Object>}
  */
 async function fetchPublicConfig(httpClient = fetch) {
+    if (publicConfigCache) {
+        return publicConfigCache;
+    }
     const url = "https://raw.githubusercontent.com/Dhali-org/Dhali-config/master/public.prod.json";
     try {
         const response = await httpClient(url);
         if (!response.ok) {
             throw new Error(`HTTP error! status: ${response.status}`);
         }
-        return await response.json();
+        publicConfigCache = await response.json();
+        return publicConfigCache;
     } catch (e) {
         throw new Error(`Failed to fetch Dhali configuration: ${e.message}`);
     }
@@ -68,6 +79,17 @@ async function fetchPublicConfig(httpClient = fetch) {
  * @param {string} channelId 
  * @param {typeof fetch} [httpClient]
  */
+/**
+ * @param {string} protocol
+ * @returns {boolean}
+ */
+function isEvmProtocol(protocol) {
+    return ["ETHEREUM", "SEPOLIA", "HOLESKY", "HARDHAT"].includes(protocol.toUpperCase());
+}
+
+/**
+ * Proactively notifies the Dhali Admin Gateway about a new payment channel.
+ */
 async function notifyAdminGateway(protocol, currencyIdentifier, accountAddress, channelId, httpClient = fetch) {
     const config = await fetchPublicConfig(httpClient);
     const rootUrl = config.ROOT_API_ADMIN_URL;
@@ -76,26 +98,39 @@ async function notifyAdminGateway(protocol, currencyIdentifier, accountAddress,
     const httpRootUrl = rootUrl.replace("wss://", "https://").replace("ws://", "http://");
     const url = `${httpRootUrl}/public_claim_info/${protocol}/${currencyIdentifier}`;
 
-    if (!channelId.startsWith("0x")) {
-        channelId = "0x" + channelId;
-    }
-
     const payload = {
-        account: accountAddress,
-        channel_id: channelId
+        account: isEvmProtocol(protocol) ? accountAddress.toLowerCase() : accountAddress,
+        channel_id: (isEvmProtocol(protocol) && !channelId.startsWith("0x")) ? "0x" + channelId : channelId
     };
 
-    try {
-        await httpClient(url, {
-            method: "PUT",
-            headers: {
-                "Content-Type": "application/json"
-            },
-            body: JSON.stringify(payload)
-        });
-    } catch (e) {
-        // Best effort notification
+    let retryCount = 0;
+    const maxRetries = 10;
+    let delay = 1000;
+
+    while (retryCount <= maxRetries) {
+        try {
+            const response = await httpClient(url, {
+                method: "PUT",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify(payload)
+            });
+            if (response.ok) {
+                return;
+            }
+            console.log(`Attempt ${retryCount + 1} failed to notify public claim info: ${response.status} ${response.statusText}`);
+        } catch (e) {
+            console.log(`Attempt ${retryCount + 1} error notifying public claim info:`, e);
+        }
+
+        if (retryCount < maxRetries) {
+            await new Promise(resolve => setTimeout(resolve, delay));
+            delay *= 2;
+        }
+        retryCount++;
     }
+    console.log(`Failed to notify public claim info after ${maxRetries} retries.`);
 }
 
 

package/src/dhali/utils.js

@@ -16,8 +16,7 @@ function wrapAsX402PaymentPayload(claimBase64, paymentRequirementBase64) {
     if (req.accepts) {
         req = Array.isArray(req.accepts) ? req.accepts[0] : req.accepts;
     }
-
-    // Normalize fields to match Dhali-wallet's PaymentRequirements defaults (camelCase)
+    
     const normalizedReq = {
         scheme: req.scheme || "",
         network: req.network || "",

package/tests/DhaliChannelManager.test.js

@@ -80,27 +80,13 @@ describe("DhaliChannelManager", () => {
     });
 
     test("throws ChannelNotFound if firestore returns null", async () => {
-      const mockHttp = jest.fn();
-      configUtils.retrieveChannelIdFromFirestoreRest.mockResolvedValue(null);
-      manager = new DhaliXrplChannelManager(wallet, mockClient, currency, mockHttp);
+      manager._findChannel = jest.fn().mockRejectedValue(new ChannelNotFound("No open payment channel from ..."));
       await expect(manager.getAuthToken(100)).rejects.toThrow(ChannelNotFound);
       await expect(manager.getAuthToken(100)).rejects.toThrow(/No open payment channel from/);
-      expect(configUtils.retrieveChannelIdFromFirestoreRest).toHaveBeenCalledWith(
-        "XRPL.MAINNET",
-        currency,
-        wallet.classicAddress,
-        mockHttp
-      );
     });
 
     test("throws ChannelNotFound if firestore ID does not match on-chain channels", async () => {
-      configUtils.retrieveChannelIdFromFirestoreRest.mockResolvedValue("FIRESTORE_ID");
-      mockClient.request.mockResolvedValue({
-        result: {
-          channels: [{ channel_id: "XRPL_ID", amount: "1000" }],
-        },
-      });
-
+      manager._findChannel = jest.fn().mockRejectedValue(new ChannelNotFound("FIRESTORE_ID not found on-chain"));
       await expect(manager.getAuthToken(100)).rejects.toThrow(ChannelNotFound);
       await expect(manager.getAuthToken(100)).rejects.toThrow(/FIRESTORE_ID not found on-chain/);
     });

package/tests/integration.test.js

@@ -1,78 +1,338 @@
-const { Wallet } = require('xrpl');
+const { Wallet, Client } = require('xrpl');
+const { createWalletClient, createPublicClient, http } = require('viem');
+const { privateKeyToAccount } = require('viem/accounts');
+const { sepolia } = require('viem/chains');
+const WebSocket = require('ws');
 const { DhaliAssetManager } = require('../src/dhali/DhaliAssetManager');
+const { DhaliChannelManager } = require('../src/dhali/DhaliChannelManager');
 const { WalletDescriptor } = require('../src/dhali/WalletDescriptor');
 const Currency = require('../src/dhali/Currency');
 const { AssetUpdates } = require('../src/dhali/AssetUpdates');
+const { fetchPublicConfig } = require('../src/dhali/configUtils');
+const { wrapAsX402PaymentPayload } = require('../src/dhali/utils');
 
-describe('Dhali-js Integration Test', () => {
-    let wallet;
-    let manager;
+// Secrets from environment variables
+const XRPL_SECRET = process.env.XRPL_TESTNET_SECRET;
+const SEPOLIA_SECRET = process.env.SEPOLIA_TESTNET_SECRET; // Should be 0x prefixed
 
-    beforeAll(() => {
-        wallet = Wallet.generate();
-        manager = DhaliAssetManager.xrpl(wallet);
+function getFacilitatorUrl(publicConfig) {
+    const envUrl = process.env.DHALI_FACILITATOR_URL;
+    if (envUrl) {
+        return envUrl;
+    }
+    return publicConfig.ROOT_X402_FACILITATOR_URL || "https://x402.api.dhali.io";
+}
+
+describe('Dhali-js Comprehensive Integration Tests', () => {
+    let publicConfig;
+
+    beforeAll(async () => {
+        publicConfig = await fetchPublicConfig();
     });
 
-    test('should create and update an asset', async () => {
-        const walletDescriptor = new WalletDescriptor(wallet.address, "XRPL.TESTNET");
+    test('should perform comprehensive XRPL integration', async () => {
+        if (!XRPL_SECRET) {
+            console.warn('XRPL_TESTNET_SECRET not set, skipping test');
+            return;
+        }
+
+        // 1. Setup Wallet and Asset Manager
+        const wallet = Wallet.fromSeed(XRPL_SECRET);
+        const assetManager = DhaliAssetManager.xrpl(wallet);
+        const walletDescriptor = new WalletDescriptor(wallet.classicAddress, "XRPL.TESTNET");
         const currency = new Currency("XRPL.TESTNET", "XRP", 6);
 
-        // 1. Create Asset
-        console.log('Creating asset...');
-        const createResult = await manager.createAsset(walletDescriptor, currency);
+        // 2. Create Asset
+        console.log(`\nCreating XRPL asset for wallet: ${wallet.classicAddress}`);
+        const createResult = await assetManager.createAsset(walletDescriptor, currency);
         expect(createResult.schema).toBe('api_admin_gateway_create_successful');
-        expect(createResult.uuid).toBeDefined();
-        const assetId = createResult.uuid;
-        console.log('Asset created with UUID:', assetId);
+        const assetUuid = createResult.uuid;
+        console.log(`Asset created with UUID: ${assetUuid}`);
 
-        // 2. Update Asset
-        console.log('Updating asset...');
+        // 3. Update Asset
+        console.log("Updating XRPL asset...");
         const updates = new AssetUpdates({
-            name: "Integration Test Asset",
+            name: "Comprehensive Integration Test Asset XRPL",
             earning_rate: 100,
             earning_type: "per_request"
         });
-
-        const updateResult = await manager.updateAsset(assetId, walletDescriptor, updates);
+        const updateResult = await assetManager.updateAsset(assetUuid, walletDescriptor, updates);
         expect(updateResult.schema).toBe('api_admin_gateway_update_response');
-        console.log('Asset updated successfully');
-    }, 30000); // Increased timeout for live API calls
+        console.log("Asset updated successfully");
 
-    test('should create and update an EVM asset', async () => {
-        const { createWalletClient, http } = require('viem');
-        const { generatePrivateKey, privateKeyToAccount } = require('viem/accounts');
-        const { sepolia } = require('viem/chains');
+        // 4. Create Channel (Deposit)
+        const client = new Client("wss://s.altnet.rippletest.net:51233");
+        await client.connect();
+        const channelManager = DhaliChannelManager.xrpl(wallet, client, currency);
+        console.log("Performing XRPL deposit...");
+        const amountDrops = 1000000; // 1 XRP
+        const depositResult = await channelManager.deposit(amountDrops);
+        expect(depositResult).toBeDefined();
+        console.log("XRPL Deposit successful");
 
-        const privateKey = generatePrivateKey();
-        const account = privateKeyToAccount(privateKey);
-        const walletClient = createWalletClient({
+        // 5. Generate Auth Token
+        console.log("Generating XRPL auth token...");
+        const authToken = await channelManager.getAuthToken();
+        expect(authToken).toBeDefined();
+        console.log(`XRPL Auth Token generated: ${authToken.substring(0, 20)}...`);
+
+        // 6. Settle via Facilitator using the newly created asset
+        console.log(`Settling via facilitator using asset ${assetUuid}...`);
+        const facilitatorUrl = getFacilitatorUrl(publicConfig);
+        const settleUrl = `${facilitatorUrl}/v2/${assetUuid}/settle`;
+
+        // Use the wrap function as suggested by the user
+        const requirements = {
+            scheme: "dhali",
+            network: "xrpl:1",
+            asset: "xrpl:1/native:xrp",
+            amount: "100",
+            payTo: assetUuid,
+            maxTimeoutSeconds: 60
+        };
+        const requirementsBase64 = Buffer.from(JSON.stringify(requirements)).toString('base64');
+        const wrappedBase64 = wrapAsX402PaymentPayload(authToken, requirementsBase64);
+        const wrappedPayload = JSON.parse(Buffer.from(wrappedBase64, 'base64').toString());
+
+        const settlePayload = {
+            paymentRequirements: requirements,
+            paymentPayload: wrappedPayload
+        };
+
+        const response = await fetch(settleUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(settlePayload)
+        });
+        expect(response.status).toBe(200);
+        const settleResult = await response.json();
+        if (!settleResult.success) { console.error("XRPL Facilitator settlement failed:", JSON.stringify(settleResult, null, 2)); }
+        expect(settleResult.success).toBe(true);
+        console.log("Facilitator settlement successful");
+
+        // 7. Close Channel via WebSockets
+        console.log("Closing channel via Admin Gateway...");
+        let wsUrl = publicConfig.ROOT_API_ADMIN_URL;
+        wsUrl = wsUrl.replace(/^http/, 'ws') + '/ws/close-channel';
+
+        await new Promise((resolve, reject) => {
+            const ws = new WebSocket(wsUrl);
+
+            ws.on('open', () => {
+                ws.send(JSON.stringify({
+                    schema: "api_admin_gateway_closure_request",
+                    schema_version: "1.0",
+                    wallet: {
+                        type: "Dhali-js",
+                        address: wallet.classicAddress,
+                        protocol: "XRPL.TESTNET",
+                        publicKey: wallet.publicKey,
+                        currency: {
+                            code: "XRP",
+                            scale: 6,
+                            issuer: null
+                        }
+                    },
+                    protocol: "XRPL.TESTNET",
+                    currency: "XRP",
+                    issuer: null
+                }));
+            });
+
+            ws.on('message', async (data) => {
+                const msg = JSON.parse(data);
+                console.log("WebSocket message received:", JSON.stringify(msg, null, 2));
+
+                if (msg.schema === "api_admin_gateway_message_to_be_signed") {
+                    const rippleKeypairs = require('ripple-keypairs');
+                    const signature = rippleKeypairs.sign(Buffer.from(JSON.stringify(msg.message, null, 0), 'utf8').toString('hex'), wallet.privateKey);
+
+                    ws.send(JSON.stringify({
+                        schema: "api_admin_gateway_signed_message_response",
+                        schema_version: "1.1",
+                        signature: signature,
+                        public_key: wallet.publicKey
+                    }));
+                } else if (msg.schema === "api_admin_gateway_authentication_successful") {
+                    // Wait
+                } else if (msg.success) {
+                    console.log('Channel closure initiated:', msg.message);
+                    ws.close();
+                } else if (msg.error) {
+                    reject(new Error(msg.error));
+                    ws.close();
+                }
+            });
+
+            ws.on('error', (err) => {
+                console.error("WebSocket error (XRPL):", err);
+                reject(err);
+            });
+            ws.on('close', (code, reason) => {
+                console.log(`WebSocket closed (XRPL): ${code} ${reason}`);
+                resolve();
+            });
+        });
+
+        await client.disconnect();
+    }, 300000);
+
+    test('should perform comprehensive EVM integration', async () => {
+        if (!SEPOLIA_SECRET) {
+            console.warn('SEPOLIA_TESTNET_SECRET not set, skipping test');
+            return;
+        }
+
+        // 1. Setup Wallet and Asset Manager
+        const account = privateKeyToAccount(SEPOLIA_SECRET);
+        const assetManager = DhaliAssetManager.evm(createWalletClient({
             account,
             chain: sepolia,
             transport: http()
-        });
-
-        const evmManager = DhaliAssetManager.evm(walletClient);
+        }));
         const walletDescriptor = new WalletDescriptor(account.address, "SEPOLIA");
         const currency = new Currency("SEPOLIA", "ETH", 18);
 
-        // 1. Create Asset
-        console.log('Creating EVM asset...');
-        const createResult = await evmManager.createAsset(walletDescriptor, currency);
+        // 2. Create Asset
+        console.log(`\nCreating EVM asset for wallet: ${account.address}`);
+        const createResult = await assetManager.createAsset(walletDescriptor, currency);
         expect(createResult.schema).toBe('api_admin_gateway_create_successful');
-        expect(createResult.uuid).toBeDefined();
-        const assetId = createResult.uuid;
-        console.log('EVM Asset created with UUID:', assetId);
+        const assetUuid = createResult.uuid;
+        console.log(`EVM Asset created with UUID: ${assetUuid}`);
 
-        // 2. Update Asset
-        console.log('Updating EVM asset...');
+        // 3. Update Asset
+        console.log("Updating EVM asset...");
         const updates = new AssetUpdates({
-            name: "Integration Test Asset EVM",
+            name: "Comprehensive Integration Test Asset EVM",
             earning_rate: 0.001,
             earning_type: "per_request"
         });
-
-        const updateResult = await evmManager.updateAsset(assetId, walletDescriptor, updates);
+        const updateResult = await assetManager.updateAsset(assetUuid, walletDescriptor, updates);
         expect(updateResult.schema).toBe('api_admin_gateway_update_response');
-        console.log('EVM Asset updated successfully');
-    }, 30000);
+        console.log("EVM Asset updated successfully");
+
+        // 4. Create Channel (Deposit)
+        const walletClient = createWalletClient({
+            account,
+            chain: sepolia,
+            transport: http()
+        });
+        const publicClient = createPublicClient({
+            chain: sepolia,
+            transport: http()
+        });
+        const channelManager = DhaliChannelManager.evm(walletClient, publicClient, currency);
+        console.log("Performing EVM deposit...");
+        const amountWei = 100000000000000n; // 0.0001 ETH
+        const receipt = await channelManager.deposit(amountWei.toString());
+        expect(receipt.status).toBe('success');
+        console.log("EVM Deposit successful");
+
+        // 5. Generate Auth Token
+        console.log("Generating EVM auth token...");
+        const authToken = await channelManager.getAuthToken();
+        expect(authToken).toBeDefined();
+        console.log(`EVM Auth Token generated: ${authToken.substring(0, 20)}...`);
+
+        // 6. Settle via Facilitator using the newly created asset
+        console.log(`Settling via facilitator using asset ${assetUuid}...`);
+        const facilitatorUrl = getFacilitatorUrl(publicConfig);
+        const settleUrl = `${facilitatorUrl}/v2/${assetUuid}/settle`;
+
+        // Use the wrap function as suggested by the user
+        const requirements = {
+            scheme: "dhali",
+            network: "eip155:11155111",
+            asset: "eip155:11155111/native:eth",
+            amount: "100",
+            payTo: assetUuid,
+            maxTimeoutSeconds: 60
+        };
+        const requirementsBase64 = Buffer.from(JSON.stringify(requirements)).toString('base64');
+        const wrappedBase64 = wrapAsX402PaymentPayload(authToken, requirementsBase64);
+        const wrappedPayload = JSON.parse(Buffer.from(wrappedBase64, 'base64').toString());
+
+        const settlePayload = {
+            paymentRequirements: requirements,
+            paymentPayload: wrappedPayload
+        };
+
+        const response = await fetch(settleUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(settlePayload)
+        });
+        expect(response.status).toBe(200);
+        const settleResult = await response.json();
+        if (!settleResult.success) { console.error("EVM Facilitator settlement failed:", JSON.stringify(settleResult, null, 2)); }
+        expect(settleResult.success).toBe(true);
+        console.log("Facilitator settlement successful");
+
+        // 7. Close Channel via WebSockets
+        console.log("Closing channel via Admin Gateway...");
+        let wsUrl = publicConfig.ROOT_API_ADMIN_URL;
+        wsUrl = wsUrl.replace(/^http/, 'ws') + '/ws/close-channel';
+
+        await new Promise((resolve, reject) => {
+            const ws = new WebSocket(wsUrl);
+
+            ws.on('open', () => {
+                ws.send(JSON.stringify({
+                    schema: "api_admin_gateway_closure_request",
+                    schema_version: "1.0",
+                    wallet: {
+                        type: "Dhali-js",
+                        address: account.address,
+                        protocol: "SEPOLIA",
+                        publicKey: null,
+                        currency: {
+                            code: "ETH",
+                            scale: 18,
+                            issuer: null
+                        }
+                    },
+                    protocol: "SEPOLIA",
+                    currency: "ETH",
+                    issuer: null
+                }));
+            });
+
+            ws.on('message', async (data) => {
+                const msg = JSON.parse(data);
+                console.log("WebSocket message received:", JSON.stringify(msg, null, 2));
+
+                if (msg.schema === "api_admin_gateway_message_to_be_signed") {
+                    console.log("Signing challenge message (EVM)...");
+                    const signature = await walletClient.signTypedData({
+                        domain: msg.message.domain,
+                        types: msg.message.types,
+                        primaryType: msg.message.primaryType,
+                        message: msg.message.message
+                    });
+                    ws.send(JSON.stringify({
+                        schema: "api_admin_gateway_signed_message_response",
+                        schema_version: "1.1",
+                        signature: signature
+                    }));
+                } else if (msg.schema === "api_admin_gateway_authentication_successful") {
+                    // Wait
+                } else if (msg.success) {
+                    console.log('Channel closure initiated:', msg.message);
+                    ws.close();
+                } else if (msg.error) {
+                    reject(new Error(msg.error));
+                    ws.close();
+                }
+            });
+
+            ws.on('error', (err) => {
+                console.error("WebSocket error:", err);
+                reject(err);
+            });
+            ws.on('close', (code, reason) => {
+                console.log(`WebSocket closed: ${code} ${reason}`);
+                resolve();
+            });
+        });
+    }, 300000);
 });