dhali-js 3.0.4 → 3.1.1

package/.github/workflows/tests.yaml

@@ -25,8 +25,14 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
-      - name: Run tests
-        run: npm test
+      - name: Run unit tests
+        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
         run: npx tsc src/dhali/*.js --allowJs --checkJs --noEmit --moduleResolution node --module commonjs --target esnext --skipLibCheck

package/README.md

@@ -148,6 +148,81 @@ async function main() {
 main();
 ```
 
+
+---
+
+## Asset Management (for Providers)
+
+If you have an API you want to monetize on Dhali, you can use the `DhaliAssetManager` to create and update your asset on the network.
+
+### 1. Create an Asset
+
+This generates an **Asset ID (UUID)**.
+
+#### XRPL Setup
+```js
+const { Wallet } = require('xrpl');
+const wallet = Wallet.fromSeed("s..."); // Your XRPL seed
+```
+
+#### EVM Setup
+```js
+const { createWalletClient, http } = require('viem');
+const { privateKeyToAccount } = require('viem/accounts');
+const { sepolia } = require('viem/chains');
+
+const walletClient = createWalletClient({
+    account: privateKeyToAccount("0x..."),
+    chain: sepolia,
+    transport: http()
+});
+```
+
+#### Initialization & Creation
+```js
+const { DhaliAssetManager, WalletDescriptor, Currency } = require('dhali-js');
+
+async function main() {
+    // For XRPL
+    const manager = DhaliAssetManager.xrpl(wallet);
+    const walletDescriptor = new WalletDescriptor(wallet.classicAddress, "XRPL.TESTNET");
+    
+    // OR For EVM
+    // const manager = DhaliAssetManager.evm(walletClient);
+    // const walletDescriptor = new WalletDescriptor(walletClient.account.address, "SEPOLIA");
+
+    const currency = new Currency("XRPL.TESTNET", "XRP", 6);
+
+    // Create the asset
+    const result = await manager.createAsset(walletDescriptor, currency);
+    console.log("Your new Asset ID:", result.uuid);
+}
+```
+
+Once created, your asset is represented by an **off-chain facilitator address**:  
+`https://x402.api.dhali.io/<uuid>`
+
+This facilitator is used for protocol-level concerns like verification and settlement, while your actual service requests are sent to your **Resource Server**.
+
+### 2. Update an Asset
+
+You can update your asset's metadata (name, rates, etc.) at any time.
+
+```js
+const { AssetUpdates } = require('dhali-js');
+
+async function main() {
+    const updates = new AssetUpdates({
+        name: "My Optimized AI API",
+        earning_rate: 100,            // 100 drops per request
+        earning_type: "per_request"   // or "per_second"
+    });
+
+    const result = await manager.updateAsset(assetId, walletDescriptor, updates);
+    console.log("Asset updated successfully");
+}
+```
+
 ---
 
 ## API Reference

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dhali-js",
-  "version": "3.0.4",
+  "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",
@@ -18,6 +18,7 @@
   "dependencies": {
     "ripple-keypairs": "^2.0.0",
     "viem": "^2.23.5",
+    "ws": "^8.18.0",
     "xrpl": "^4.0.0"
   },
   "devDependencies": {

package/src/dhali/AssetUpdates.js

@@ -0,0 +1,67 @@
+class AssetUpdates {
+    /**
+     * @param {Object} options
+     * @param {string} [options.name]
+     * @param {number} [options.earningRate]
+     * @param {string} [options.earningType]
+     * @param {string} [options.url]
+     * @param {Object} [options.headers]
+     * @param {string} [options.docs]
+     * @param {number} [options.maxSurcharge]
+     * @param {number} [options.assetPricingRate]
+     * @param {number} [options.assetPricingMaxSurcharge]
+     * @param {Object} [options.assetPricingCurrency]
+     */
+    constructor({
+        name,
+        earningRate,
+        earningType,
+        url,
+        headers,
+        docs,
+        maxSurcharge,
+        assetPricingRate,
+        assetPricingMaxSurcharge,
+        assetPricingCurrency
+    } = {}) {
+        this.name = name;
+        this.earningRate = earningRate;
+        this.earningType = earningType;
+        this.url = url;
+        this.headers = headers;
+        this.docs = docs;
+        this.maxSurcharge = maxSurcharge;
+        this.assetPricingRate = assetPricingRate;
+        this.assetPricingMaxSurcharge = assetPricingMaxSurcharge;
+        this.assetPricingCurrency = assetPricingCurrency;
+    }
+
+    /**
+     * Converts the updates to the format expected by api-admin-gateway
+     * @returns {Object}
+     */
+    toGatewayFormat() {
+        const updates = {};
+        if (this.name !== undefined) updates["name"] = this.name;
+        if (this.earningRate !== undefined) updates["asset_earning_rate"] = this.earningRate;
+        if (this.earningType !== undefined) updates["asset_earning_type"] = this.earningType;
+        if (this.docs !== undefined) updates["docs"] = this.docs;
+        if (this.maxSurcharge !== undefined) updates["asset_earning_max_surcharge"] = this.maxSurcharge;
+        if (this.assetPricingRate !== undefined) updates["asset_pricing_rate"] = this.assetPricingRate;
+        if (this.assetPricingMaxSurcharge !== undefined) updates["asset_pricing_max_surcharge"] = this.assetPricingMaxSurcharge;
+        if (this.assetPricingCurrency !== undefined) updates["asset_pricing_currency"] = this.assetPricingCurrency;
+
+        // Credentials/URL and headers are special
+        if (this.url !== undefined || this.headers !== undefined) {
+            updates["api_credentials"] = {};
+            if (this.url !== undefined) updates["api_credentials"]["url"] = this.url;
+            if (this.headers !== undefined) {
+                Object.assign(updates["api_credentials"], this.headers);
+            }
+        }
+
+        return updates;
+    }
+}
+
+module.exports = { AssetUpdates };

package/src/dhali/BaseAssetManager.js

@@ -0,0 +1,182 @@
+const { WebSocket } = require('ws');
+const Currency = require('./Currency');
+const { AssetUpdates } = require('./AssetUpdates');
+const { WalletDescriptor } = require('./WalletDescriptor');
+const { fetchPublicConfig } = require('./configUtils');
+
+class BaseAssetManager {
+    /**
+     * @param {any} wallet
+     * @param {string} [baseUrl]
+     */
+    constructor(wallet, baseUrl) {
+        this.baseUrl = baseUrl ? baseUrl.replace(/^http/, 'ws') : undefined;
+        this.wallet = wallet;
+    }
+
+    async _resolveBaseUrl() {
+        if (this.baseUrl) return;
+        const config = await fetchPublicConfig();
+        const rootUrl = config.ROOT_API_ADMIN_URL;
+        if (!rootUrl) {
+            throw new Error("ROOT_API_ADMIN_URL not found in public config");
+        }
+        this.baseUrl = rootUrl.replace(/^http/, 'ws');
+    }
+
+    /**
+     * Abstract method to handle protocol-specific signing
+     * @protected
+     * @returns {Promise<any>}
+     */
+    async _performSigning(typedData, walletDescriptor) {
+        throw new Error("_performSigning must be implemented by subclass");
+    }
+
+    async _handleAuth(ws, message, walletDescriptor) {
+        if (message.schema === 'api_admin_gateway_message_to_be_signed') {
+            const { message: typedData } = message;
+            const authResponse = await this._performSigning(typedData, walletDescriptor);
+            ws.send(JSON.stringify(authResponse));
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * @param {WalletDescriptor} walletDescriptor
+     * @param {Currency} currency
+     */
+    async createAsset(walletDescriptor, currency) {
+        await this._resolveBaseUrl();
+        if (!(walletDescriptor instanceof WalletDescriptor)) {
+            throw new Error('walletDescriptor must be an instance of WalletDescriptor');
+        }
+        if (!(currency instanceof Currency)) {
+            throw new Error('currency must be an instance of Currency');
+        }
+
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(`${this.baseUrl}/create`);
+
+            ws.on('open', () => {
+                ws.send(JSON.stringify({
+                    owner: walletDescriptor.toJson(),
+                    currency: {
+                        code: currency.code,
+                        scale: currency.scale,
+                        issuer: currency.tokenAddress
+                    }
+                }));
+            });
+
+            ws.on('message', async (data) => {
+                const message = JSON.parse(data.toString());
+
+                try {
+                    if (await this._handleAuth(ws, message, walletDescriptor)) {
+                        return;
+                    }
+
+                    if (message.schema === 'api_admin_gateway_request_wallet_json') {
+                        ws.send(JSON.stringify({
+                            schema: 'api_admin_gateway_wallet_json_response',
+                            wallet: walletDescriptor.toJson()
+                        }));
+                    } else if (message.schema === 'api_admin_gateway_create_successful') {
+                        resolve(message);
+                        ws.close();
+                    } else if (message.qr_code_url) {
+                        console.log('Scan this QR code to authenticate:', message.qr_code_url);
+                    } else if (message.error) {
+                        reject(new Error(message.error));
+                        ws.close();
+                    }
+                } catch (err) {
+                    reject(err);
+                    ws.close();
+                }
+            });
+
+            ws.on('error', (error) => {
+                reject(error);
+            });
+
+            ws.on('close', (code, reason) => {
+                if (code !== 1000 && code !== 1005) {
+                    reject(new Error(`WebSocket closed with code ${code}: ${reason}`));
+                }
+            });
+        });
+    }
+
+    /**
+     * @param {string} dhaliId
+     * @param {WalletDescriptor} walletDescriptor
+     * @param {AssetUpdates} updates
+     */
+    async updateAsset(dhaliId, walletDescriptor, updates) {
+        await this._resolveBaseUrl();
+        if (!(walletDescriptor instanceof WalletDescriptor)) {
+            throw new Error('walletDescriptor must be an instance of WalletDescriptor');
+        }
+        if (!(updates instanceof AssetUpdates)) {
+            throw new Error('updates must be an instance of AssetUpdates');
+        }
+
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(`${this.baseUrl}/${dhaliId}/update`);
+
+            ws.on('message', async (data) => {
+                const message = JSON.parse(data.toString());
+
+                try {
+                    if (await this._handleAuth(ws, message, walletDescriptor)) {
+                        return;
+                    }
+
+                    if (message.schema === 'api_admin_gateway_request_wallet_json') {
+                        ws.send(JSON.stringify({
+                            schema: 'api_admin_gateway_wallet_json_response',
+                            wallet: walletDescriptor.toJson()
+                        }));
+                    } else if (message.schema === 'api_admin_gateway_authentication_successful') {
+                        ws.send(JSON.stringify({
+                            schema: 'api_admin_gateway_prefill_request',
+                            schema_version: '1.0'
+                        }));
+                    } else if (message.schema === 'api_admin_gateway_prefill_response') {
+                        ws.send(JSON.stringify({
+                            schema: 'api_admin_gateway_update_request',
+                            schema_version: '1.0',
+                            updates: updates.toGatewayFormat()
+                        }));
+                    } else if (message.schema === 'api_admin_gateway_update_response') {
+                        resolve(message);
+                        ws.close();
+                    } else if (message.qr_code_url) {
+                        console.log('Scan this QR code to authenticate:', message.qr_code_url);
+                    } else if (message.error || message.status === 'failed') {
+                        reject(new Error(message.error || 'Update failed'));
+                        ws.close();
+                    }
+                } catch (err) {
+                    reject(err);
+                    ws.close();
+                }
+            });
+
+            ws.on('error', (error) => {
+                reject(error);
+            });
+
+            ws.on('close', (code, reason) => {
+                if (code !== 1000 && code !== 1005) {
+                    reject(new Error(`WebSocket closed with code ${code}: ${reason}`));
+                }
+            });
+        });
+    }
+}
+
+module.exports = { BaseAssetManager };

package/src/dhali/DhaliAssetManager.js

@@ -0,0 +1,25 @@
+const { DhaliXrplAssetManager } = require('./DhaliXrplAssetManager');
+const { DhaliEthAssetManager } = require('./DhaliEthAssetManager');
+
+/**
+ * Factory for creating asset managers.
+ */
+const DhaliAssetManager = {
+    /**
+     * @param {import("xrpl").Wallet} wallet
+     * @returns {DhaliXrplAssetManager}
+     */
+    xrpl: (wallet) => {
+        return new DhaliXrplAssetManager(wallet);
+    },
+
+    /**
+     * @param {import("viem").WalletClient} walletClient
+     * @returns {DhaliEthAssetManager}
+     */
+    evm: (walletClient) => {
+        return new DhaliEthAssetManager(walletClient);
+    }
+};
+
+module.exports = { DhaliAssetManager };

package/src/dhali/DhaliEthAssetManager.js

@@ -0,0 +1,35 @@
+const { BaseAssetManager } = require('./BaseAssetManager');
+
+/**
+ * DhaliAssetManager for EVM protocol.
+ */
+class DhaliEthAssetManager extends BaseAssetManager {
+    /**
+     * @param {import("viem").WalletClient} walletClient
+     * @param {string} [baseUrl]
+     */
+    constructor(walletClient, baseUrl) {
+        super(walletClient, baseUrl);
+    }
+
+    /**
+     * @protected
+     */
+    async _performSigning(typedData, walletDescriptor) {
+        const [account] = await this.wallet.getAddresses();
+        const signature = await this.wallet.signTypedData({
+            account: this.wallet.account || account,
+            domain: typedData.domain,
+            types: typedData.types,
+            primaryType: typedData.primaryType,
+            message: typedData.message
+        });
+
+        return {
+            schema: 'api_admin_gateway_signed_message_response',
+            signature: signature
+        };
+    }
+}
+
+module.exports = { DhaliEthAssetManager };

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/DhaliXrplAssetManager.js

@@ -0,0 +1,32 @@
+const { BaseAssetManager } = require('./BaseAssetManager');
+const { sign: signClaim } = require("ripple-keypairs");
+
+/**
+ * DhaliAssetManager for XRPL protocol.
+ */
+class DhaliXrplAssetManager extends BaseAssetManager {
+    /**
+     * @param {import("xrpl").Wallet} wallet
+     * @param {string} [baseUrl]
+     */
+    constructor(wallet, baseUrl) {
+        super(wallet, baseUrl);
+    }
+
+    /**
+     * @protected
+     */
+    async _performSigning(typedData, walletDescriptor) {
+        // The backend expects the message as a JSON string for XRPL
+        const messageToSign = JSON.stringify(typedData);
+        const signature = signClaim(Buffer.from(messageToSign).toString('hex'), this.wallet.privateKey);
+
+        return {
+            schema: 'api_admin_gateway_signed_message_response',
+            signature: signature.toUpperCase(),
+            public_key: this.wallet.publicKey
+        };
+    }
+}
+
+module.exports = { DhaliXrplAssetManager };

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/WalletDescriptor.js

@@ -0,0 +1,27 @@
+class WalletDescriptor {
+    /**
+     * @param {string} address - The classic address of the wallet
+     * @param {string} protocol - The network protocol (e.g., 'XRPL.TESTNET', 'ETHEREUM')
+     * @param {string} [type='Dhali-js'] - The type of wallet (defaults to 'Dhali-js')
+     */
+    constructor(address, protocol, type = 'Dhali-js') {
+        this.address = address;
+        this.protocol = protocol;
+        this.type = type;
+    }
+
+    /**
+     * Converts to JSON format expected by Dhali backend
+     * @returns {Object}
+     */
+    toJson() {
+        return {
+            address: this.address,
+            wallet_id: this.address, // Backward compatibility or specific gateway requirement
+            type: this.type,
+            protocol: this.protocol
+        };
+    }
+}
+
+module.exports = { WalletDescriptor };

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/src/index.js

@@ -1,9 +1,15 @@
 const { DhaliChannelManager } = require("./dhali/DhaliChannelManager");
-const { DhaliXrplChannelManager, ChannelNotFound } = require("./dhali/DhaliXrplChannelManager");
+const { DhaliXrplChannelManager } = require("./dhali/DhaliXrplChannelManager");
 const { DhaliEthChannelManager } = require("./dhali/DhaliEthChannelManager");
+const { DhaliAssetManager } = require("./dhali/DhaliAssetManager");
+const { BaseAssetManager } = require("./dhali/BaseAssetManager");
+const { DhaliXrplAssetManager } = require("./dhali/DhaliXrplAssetManager");
+const { DhaliEthAssetManager } = require("./dhali/DhaliEthAssetManager");
+const { WalletDescriptor } = require("./dhali/WalletDescriptor");
+const { AssetUpdates } = require("./dhali/AssetUpdates");
 const Currency = require("./dhali/Currency");
-const { getAvailableDhaliCurrencies } = require("./dhali/configUtils");
-const { wrapAsX402PaymentPayload } = require("./dhali/utils");
+const { fetchPublicConfig, retrieveChannelIdFromFirestoreRest, notifyAdminGateway, getAvailableDhaliCurrencies } = require("./dhali/configUtils");
+const { wrapAsX402PaymentPayload, ChannelNotFound } = require("./dhali/utils");
 
 module.exports = {
   DhaliChannelManager,
@@ -12,5 +18,14 @@ module.exports = {
   ChannelNotFound,
   Currency,
   getAvailableDhaliCurrencies,
-  wrapAsX402PaymentPayload
+  DhaliAssetManager,
+  BaseAssetManager,
+  DhaliXrplAssetManager,
+  DhaliEthAssetManager,
+  WalletDescriptor,
+  AssetUpdates,
+  fetchPublicConfig,
+  retrieveChannelIdFromFirestoreRest,
+  notifyAdminGateway,
+  wrapAsX402PaymentPayload,
 };

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

@@ -0,0 +1,338 @@
+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');
+
+// Secrets from environment variables
+const XRPL_SECRET = process.env.XRPL_TESTNET_SECRET;
+const SEPOLIA_SECRET = process.env.SEPOLIA_TESTNET_SECRET; // Should be 0x prefixed
+
+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 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);
+
+        // 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');
+        const assetUuid = createResult.uuid;
+        console.log(`Asset created with UUID: ${assetUuid}`);
+
+        // 3. Update Asset
+        console.log("Updating XRPL asset...");
+        const updates = new AssetUpdates({
+            name: "Comprehensive Integration Test Asset XRPL",
+            earning_rate: 100,
+            earning_type: "per_request"
+        });
+        const updateResult = await assetManager.updateAsset(assetUuid, walletDescriptor, updates);
+        expect(updateResult.schema).toBe('api_admin_gateway_update_response');
+        console.log("Asset updated successfully");
+
+        // 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");
+
+        // 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 walletDescriptor = new WalletDescriptor(account.address, "SEPOLIA");
+        const currency = new Currency("SEPOLIA", "ETH", 18);
+
+        // 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');
+        const assetUuid = createResult.uuid;
+        console.log(`EVM Asset created with UUID: ${assetUuid}`);
+
+        // 3. Update Asset
+        console.log("Updating EVM asset...");
+        const updates = new AssetUpdates({
+            name: "Comprehensive Integration Test Asset EVM",
+            earning_rate: 0.001,
+            earning_type: "per_request"
+        });
+        const updateResult = await assetManager.updateAsset(assetUuid, walletDescriptor, updates);
+        expect(updateResult.schema).toBe('api_admin_gateway_update_response');
+        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);
+});