dhali-js 3.0.1 → 3.0.4

package/README.md

@@ -43,12 +43,13 @@ async function main() {
     const manager = DhaliChannelManager.xrpl(wallet, client, currency)
 
     // Generate Claim
+    const amount = Math.floor(1.0 * Math.pow(10, currency.scale)); // 1 XRP
     let token;
     try {
         token = await manager.getAuthToken();
     } catch (error) {
         if (error.name === "ChannelNotFound") {
-           await manager.deposit(1000000); // Deposit 1 XRP
+           await manager.deposit(amount);
            token = await manager.getAuthToken();
         } else {
            throw error;
@@ -95,13 +96,14 @@ async function main() {
     )
 
     // 4. Generate Claim
+    const amount = Math.floor(0.1 * Math.pow(10, sepoliaUsdc.scale)); // 0.10 USDC
     let token;
     try {
-        token = await manager.getAuthToken(1000000); // 1.00 USDC
+        token = await manager.getAuthToken(amount);
     } catch (error) {
         if (error.name === "ChannelNotFound") {
-           await manager.deposit(1000000); // Deposit 1.00 USDC
-           token = await manager.getAuthToken(1000000);
+           await manager.deposit(amount);
+           token = await manager.getAuthToken(amount);
         } else {
            throw error;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dhali-js",
-  "version": "3.0.1",
+  "version": "3.0.4",
   "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

@@ -8,6 +8,7 @@ const {
 const crypto = require("crypto");
 
 const { fetchPublicConfig, notifyAdminGateway, retrieveChannelIdFromFirestoreRest } = require("./configUtils");
+const { ChannelNotFound } = require("./utils");
 
 class DhaliEthChannelManager {
   /**
@@ -29,11 +30,11 @@ class DhaliEthChannelManager {
   }
 
   _getChainIdFromProtocol(protocol) {
-    switch (protocol) {
+    switch (protocol.toUpperCase()) {
       case "ETHEREUM": return 1;
       case "SEPOLIA": return 11155111;
       case "HOLESKY": return 17000;
-      case "LOCALHOST": return 31337;
+      case "HARDHAT": return 31337;
       default: throw new Error(`Unsupported protocol: ${protocol}`);
     }
   }
@@ -282,7 +283,7 @@ class DhaliEthChannelManager {
     // Poll Firestore if not found (setupBalanceListener simulation)
     const channelIdRaw = await this._retrieveChannelIdFromFirestoreWithPolling(10);
     if (!channelIdRaw) {
-      throw new Error("No open payment channel found in Firestore. Please deposit first.");
+      throw new ChannelNotFound("No open payment channel found in Firestore. Please deposit first.");
     }
 
     let channelId = channelIdRaw;
@@ -324,7 +325,7 @@ class DhaliEthChannelManager {
 
     const claim = {
       version: "2",
-      account: accountString,
+      account: accountString.toLowerCase(),
       protocol: this.currency.network,
       currency: {
         code: this.currency.code,

package/src/dhali/DhaliXrplChannelManager.js

@@ -4,7 +4,7 @@ const { sign: signClaim } = require("ripple-keypairs");
 
 const { fetchPublicConfig, notifyAdminGateway, retrieveChannelIdFromFirestoreRest } = require("./configUtils");
 
-class ChannelNotFound extends Error { }
+const { ChannelNotFound } = require("./utils");
 
 /**
  * A management tool for generating payment claims for use with Dhali APIs (XRPL).

package/src/dhali/utils.js

@@ -39,6 +39,14 @@ function wrapAsX402PaymentPayload(claimBase64, paymentRequirementBase64) {
     return Buffer.from(JSON.stringify(x402Payload)).toString("base64");
 }
 
+class ChannelNotFound extends Error {
+    constructor(message = "No open payment channel found.") {
+        super(message);
+        this.name = "ChannelNotFound";
+    }
+}
+
 module.exports = {
     wrapAsX402PaymentPayload,
+    ChannelNotFound
 };

package/tests/DhaliChannelManager.test.js

@@ -147,4 +147,26 @@ describe("DhaliChannelManager", () => {
       );
     });
   });
+
+  describe("Casing", () => {
+    test("queries Firestore with original XRPL address casing", async () => {
+      const mockHttp = jest.fn();
+      wallet.address = "rMixedCaseAddress";
+      manager = new DhaliXrplChannelManager(
+        wallet,
+        mockClient,
+        currency,
+        mockHttp,
+      );
+
+      await manager._retrieveChannelIdFromFirestore();
+
+      expect(configUtils.retrieveChannelIdFromFirestoreRest).toHaveBeenCalledWith(
+        "XRPL.MAINNET",
+        currency,
+        "rMixedCaseAddress", // Should NOT be lower-cased
+        mockHttp,
+      );
+    });
+  });
 });

package/tests/DhaliEthChannelManager.test.js

@@ -2,6 +2,7 @@ const { DhaliEthChannelManager } = require("../src/dhali/DhaliEthChannelManager"
 const Currency = require("../src/dhali/Currency");
 const { keccak256, encodeAbiParameters, parseAbiParameters } = require("viem");
 const configUtils = require("../src/dhali/configUtils");
+const { ChannelNotFound } = require("../src/dhali/utils");
 
 jest.mock("../src/dhali/configUtils");
 
@@ -138,7 +139,9 @@ describe("DhaliEthChannelManager", () => {
         const originalTimeout = global.setTimeout;
         global.setTimeout = (cb) => cb();
 
-        await expect(manager.getAuthToken(100)).rejects.toThrow(/No open payment channel found in Firestore/);
+        const promise = manager.getAuthToken(100);
+        await expect(promise).rejects.toThrow(ChannelNotFound);
+        await expect(promise).rejects.toThrow(/No open payment channel found in Firestore/);
 
         global.setTimeout = originalTimeout;
     });
@@ -255,4 +258,68 @@ describe("DhaliEthChannelManager", () => {
             fetch
         );
     });
+
+    test("performs lower-casing on EVM addresses consistently", async () => {
+        const mixedAddr = "0x71C7656EC7ab88b098defB751B7401B5f6d8976F";
+        const lowerAddr = mixedAddr.toLowerCase();
+
+        const mockHttp = jest.fn();
+        const manager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, mockHttp, publicConfig);
+        mockWalletClient.getAddresses.mockResolvedValue([mixedAddr]);
+
+        // 1. Check firestore retrieval
+        configUtils.retrieveChannelIdFromFirestoreRest.mockResolvedValue("0xid");
+        await manager._retrieveChannelIdFromFirestore();
+        expect(configUtils.retrieveChannelIdFromFirestoreRest).toHaveBeenCalledWith(
+            expect.anything(),
+            expect.anything(),
+            lowerAddr,
+            mockHttp
+        );
+
+        // 2. Check gateway notification during deposit (Open Channel path)
+        configUtils.retrieveChannelIdFromFirestoreRest.mockResolvedValue(null);
+        manager._generateNonce = jest.fn().mockReturnValue(1n);
+        manager._calculateChannelId = jest.fn().mockReturnValue("0xid");
+        mockWalletClient.sendTransaction.mockResolvedValue("0xhash");
+        mockPublicClient.waitForTransactionReceipt.mockResolvedValue({ status: "success" });
+        manager._retrieveChannelIdFromFirestoreWithPolling = jest.fn().mockResolvedValue("0xid");
+
+        await manager.deposit(100);
+        expect(configUtils.notifyAdminGateway).toHaveBeenCalledWith(
+            expect.anything(),
+            expect.anything(),
+            lowerAddr,
+            expect.anything(),
+            mockHttp
+        );
+    });
+
+    test("getAuthToken preserves destination_account casing", async () => {
+        const mixedCaseDestination = "0x71C7656EC7ab88b098defB751B7401B5f6d8976F";
+        const mixedCaseConfig = {
+            DHALI_PUBLIC_ADDRESSES: {
+                ETHEREUM: {
+                    ETH: { wallet_id: mixedCaseDestination }
+                }
+            },
+            CONTRACTS: {
+                ETHEREUM: { contract_address: "0x0000000000000000000000000000000000000003" }
+            }
+        };
+
+        const localManager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, null, mixedCaseConfig);
+
+        // Mock required dependencies for getAuthToken
+        configUtils.retrieveChannelIdFromFirestoreRest.mockResolvedValue("0xChannelId");
+        const amountHex = BigInt(1000).toString(16).padStart(64, '0');
+        mockPublicClient.call = jest.fn().mockResolvedValue({ data: "0x" + "0".repeat(64 * 4) + amountHex });
+        mockWalletClient.signTypedData.mockResolvedValue("0xSignature");
+
+        const token = await localManager.getAuthToken(100);
+        const decoded = JSON.parse(Buffer.from(token, "base64").toString("utf8"));
+
+        expect(decoded.destination_account).toBe(mixedCaseDestination);
+        expect(decoded.destination_account).not.toBe(mixedCaseDestination.toLowerCase());
+    });
 });