dhali-js 2.1.0 → 3.0.3

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).
@@ -13,15 +13,13 @@ class DhaliXrplChannelManager {
   /**
    * @param {import("xrpl").Wallet} wallet
    * @param {import("xrpl").Client} rpc_client
-   * @param {string} protocol
    * @param {import("./Currency")} currency
    * @param {typeof fetch} [httpClient]
    * @param {object} [public_config]
    */
-  constructor(wallet, rpc_client, protocol, currency, httpClient = fetch, public_config) {
+  constructor(wallet, rpc_client, currency, httpClient = fetch, public_config) {
     this.wallet = wallet;
     this.rpc_client = rpc_client;
-    this.protocol = protocol;
     this.currency = currency;
     this.httpClient = httpClient || fetch;
     this.public_config = public_config;
@@ -38,7 +36,7 @@ class DhaliXrplChannelManager {
 
     if (!this.destination) {
       try {
-        this.destination = this.public_config.DHALI_PUBLIC_ADDRESSES[this.protocol][this.currency.code].wallet_id;
+        this.destination = this.public_config.DHALI_PUBLIC_ADDRESSES[this.currency.network][this.currency.code].wallet_id;
       } catch (e) {
         // Fallback to default if needed, or throw
         this.destination = "rJiAX3Xk2Fq3KJrjsGajrB5LENZq7VCwAd";
@@ -53,7 +51,7 @@ class DhaliXrplChannelManager {
    */
   async _retrieveChannelIdFromFirestore() {
     return await retrieveChannelIdFromFirestoreRest(
-      this.protocol,
+      this.currency.network,
       this.currency,
       this.wallet.address,
       this.httpClient
@@ -147,7 +145,7 @@ class DhaliXrplChannelManager {
               currencyIdentifier = `${this.currency.code}.${this.currency.tokenAddress}`;
             }
             await notifyAdminGateway(
-              this.protocol,
+              this.currency.network,
               currencyIdentifier,
               this.wallet.classicAddress,
               channelId,
@@ -185,7 +183,7 @@ class DhaliXrplChannelManager {
     const claim = {
       version: "2",
       account: this.wallet.classicAddress,
-      protocol: this.protocol,
+      protocol: this.currency.network,
       currency: { code: "XRP", scale: 6 },
       destination_account: this.destination,
       authorized_to_claim: allowed.toString(),

package/src/dhali/configUtils.js

@@ -8,11 +8,8 @@ const Currency = require("./Currency");
 
 /**
  * Fetches and parses available Dhali currencies and configurations.
- * @returns {Promise<Object.<string, Object.<string, NetworkCurrencyConfig>>>}
- */
-/**
  * @param {typeof fetch} [httpClient]
- * @returns {Promise<Object>}
+ * @returns {Promise<Currency[]>}
  */
 async function getAvailableDhaliCurrencies(httpClient = fetch) {
     const url = "https://raw.githubusercontent.com/Dhali-org/Dhali-config/master/public.prod.json";
@@ -28,11 +25,10 @@ async function getAvailableDhaliCurrencies(httpClient = fetch) {
     }
 
     const publicAddresses = data.DHALI_PUBLIC_ADDRESSES || {};
-    /** @type {Object.<string, Object.<string, NetworkCurrencyConfig>>} */
-    const result = {};
+    /** @type {Currency[]} */
+    const result = [];
 
     for (const [network, currencies] of Object.entries(publicAddresses)) {
-        result[network] = {};
         for (const [code, details] of Object.entries(currencies)) {
             const tokenAddress = details.issuer || null;
             const scale = details.scale || 6;
@@ -40,12 +36,8 @@ async function getAvailableDhaliCurrencies(httpClient = fetch) {
 
             if (!destination) continue;
 
-            const curr = new Currency(code, scale, tokenAddress);
-
-            result[network][code] = {
-                currency: curr,
-                destinationAddress: destination
-            };
+            const curr = new Currency(network, code, scale, tokenAddress);
+            result.push(curr);
         }
     }
     return result;

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

@@ -1,7 +1,7 @@
 const { DhaliChannelManager } = require("./dhali/DhaliChannelManager");
 const { DhaliXrplChannelManager, ChannelNotFound } = require("./dhali/DhaliXrplChannelManager");
 const { DhaliEthChannelManager } = require("./dhali/DhaliEthChannelManager");
-const { Currency } = require("./dhali/Currency");
+const Currency = require("./dhali/Currency");
 const { getAvailableDhaliCurrencies } = require("./dhali/configUtils");
 const { wrapAsX402PaymentPayload } = require("./dhali/utils");
 

package/tests/DhaliChannelManager.test.js

@@ -53,11 +53,11 @@ describe("DhaliChannelManager", () => {
       submitAndWait: jest.fn(),
       autofill: jest.fn().mockResolvedValue({}),
     };
-    currency = new Currency("XRP", 6);
+    currency = new Currency("XRPL.MAINNET", "XRP", 6);
 
     const mockHttp = jest.fn();
     configUtils.retrieveChannelIdFromFirestoreRest.mockResolvedValue("CHAN123");
-    manager = new DhaliXrplChannelManager(wallet, mockClient, "XRPL.MAINNET", currency, mockHttp);
+    manager = new DhaliXrplChannelManager(wallet, mockClient, currency, mockHttp);
   });
 
   afterEach(() => {
@@ -82,7 +82,7 @@ describe("DhaliChannelManager", () => {
     test("throws ChannelNotFound if firestore returns null", async () => {
       const mockHttp = jest.fn();
       configUtils.retrieveChannelIdFromFirestoreRest.mockResolvedValue(null);
-      manager = new DhaliXrplChannelManager(wallet, mockClient, "XRPL.MAINNET", currency, mockHttp);
+      manager = new DhaliXrplChannelManager(wallet, mockClient, currency, mockHttp);
       await expect(manager.getAuthToken(100)).rejects.toThrow(ChannelNotFound);
       await expect(manager.getAuthToken(100)).rejects.toThrow(/No open payment channel from/);
       expect(configUtils.retrieveChannelIdFromFirestoreRest).toHaveBeenCalledWith(
@@ -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

@@ -1,27 +1,32 @@
 const { DhaliEthChannelManager } = require("../src/dhali/DhaliEthChannelManager");
 const Currency = require("../src/dhali/Currency");
-const { ethers } = require("ethers");
+const { keccak256, encodeAbiParameters, parseAbiParameters } = require("viem");
 const configUtils = require("../src/dhali/configUtils");
+const { ChannelNotFound } = require("../src/dhali/utils");
 
 jest.mock("../src/dhali/configUtils");
 
 describe("DhaliEthChannelManager", () => {
-    let mockSigner;
-    let mockProvider;
+    let mockWalletClient;
+    let mockPublicClient;
     let currency;
     let publicConfig;
     let manager;
 
     beforeEach(() => {
-        mockSigner = {
-            getAddress: jest.fn().mockResolvedValue("0x0000000000000000000000000000000000000001"),
-            getNonce: jest.fn(),
-            estimateGas: jest.fn(),
-            signTypedData: jest.fn(),
-            sendTransaction: jest.fn()
+        mockWalletClient = {
+            getAddresses: jest.fn().mockResolvedValue(["0x0000000000000000000000000000000000000001"]),
+            sendTransaction: jest.fn(),
+            signTypedData: jest.fn()
         };
-        mockProvider = {};
-        currency = new Currency("ETH", 18);
+        mockPublicClient = {
+            getGasPrice: jest.fn().mockResolvedValue(BigInt(1000000000)),
+            estimateGas: jest.fn().mockResolvedValue(BigInt(21000)),
+            getTransactionCount: jest.fn().mockResolvedValue(10),
+            waitForTransactionReceipt: jest.fn(),
+            call: jest.fn()
+        };
+        currency = new Currency("ETHEREUM", "ETH", 18);
         publicConfig = {
             DHALI_PUBLIC_ADDRESSES: {
                 ETHEREUM: {
@@ -33,30 +38,30 @@ describe("DhaliEthChannelManager", () => {
             }
         };
         configUtils.fetchPublicConfig.mockResolvedValue(publicConfig);
-        manager = new DhaliEthChannelManager(mockSigner, mockProvider, "ETHEREUM", currency, null, publicConfig);
+        manager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, null, publicConfig);
         jest.clearAllMocks();
     });
 
     test("initializes without default http client", () => {
-        const localManager = new DhaliEthChannelManager(mockSigner, mockProvider, "ETHEREUM", currency, null, publicConfig);
+        const localManager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, null, publicConfig);
         expect(localManager.httpClient).toBe(fetch);
         expect(localManager.chainId).toBe(1);
     });
 
     test("initializes with provided http client", () => {
         const mockHttp = jest.fn();
-        const manager = new DhaliEthChannelManager(mockSigner, mockProvider, "ETHEREUM", currency, mockHttp, publicConfig);
+        const manager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, mockHttp, publicConfig);
         expect(manager.httpClient).toBe(mockHttp);
     });
 
     test("initializes without config or addresses (lazy resolution)", () => {
-        const manager = new DhaliEthChannelManager(mockSigner, mockProvider, "ETHEREUM", currency, null);
+        const manager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, null);
         expect(manager.destinationAddress).toBeUndefined();
         expect(manager.contractAddress).toBeUndefined();
     });
 
     test("resolves addresses lazily", async () => {
-        const manager = new DhaliEthChannelManager(mockSigner, mockProvider, "ETHEREUM", currency, null);
+        const manager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, null);
 
         await manager._resolveAddresses();
 
@@ -66,7 +71,7 @@ describe("DhaliEthChannelManager", () => {
     });
 
     test("resolves destination and contract addresses from provided config", async () => {
-        const manager = new DhaliEthChannelManager(mockSigner, mockProvider, "ETHEREUM", currency, null, publicConfig);
+        const manager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, null, publicConfig);
         await manager._resolveAddresses();
         expect(manager.destinationAddress).toBe("0x0000000000000000000000000000000000000002");
         expect(manager.contractAddress).toBe("0x0000000000000000000000000000000000000003");
@@ -74,16 +79,16 @@ describe("DhaliEthChannelManager", () => {
     });
 
     test("calculates channel ID correctly", async () => {
-        const manager = new DhaliEthChannelManager(mockSigner, mockProvider, "ETHEREUM", currency, null, publicConfig);
-        mockSigner.address = "0x0000000000000000000000000000000000000001";
+        const manager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, null, publicConfig);
+        const sender = "0x0000000000000000000000000000000000000001";
         const receiver = "0x0000000000000000000000000000000000000002";
         const token = "0x0000000000000000000000000000000000000003";
         const nonce = 12345n;
 
-        const expectedId = ethers.keccak256(
-            ethers.AbiCoder.defaultAbiCoder().encode(
-                ["address", "address", "address", "uint256"],
-                ["0x0000000000000000000000000000000000000001", receiver, token, nonce]
+        const expectedId = keccak256(
+            encodeAbiParameters(
+                parseAbiParameters("address, address, address, uint256"),
+                [sender, receiver, token, nonce]
             )
         );
 
@@ -98,18 +103,12 @@ describe("DhaliEthChannelManager", () => {
             .mockResolvedValueOnce(null) // First poll
             .mockResolvedValueOnce("0x0000000000000000000000000000000000000000000000000000000000000004"); // Second poll
 
-        const localManager = new DhaliEthChannelManager(mockSigner, mockProvider, "ETHEREUM", currency, mockHttp, publicConfig);
+        const localManager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, mockHttp, publicConfig);
         localManager._generateNonce = jest.fn().mockReturnValue(54321n);
         localManager._calculateChannelId = jest.fn().mockReturnValue("0xCalculatedId");
 
-        mockSigner.getAddress.mockResolvedValue("0x0000000000000000000000000000000000000001");
-        mockSigner.getNonce.mockResolvedValue(10);
-        mockSigner.estimateGas.mockResolvedValue(BigInt(21000));
-        mockSigner.sendTransaction.mockResolvedValue({
-            wait: jest.fn().mockResolvedValue({ status: 1 })
-        });
-
-        mockProvider.getFeeData = jest.fn().mockResolvedValue({ gasPrice: BigInt(1000000000) });
+        mockWalletClient.sendTransaction.mockResolvedValue("0xTxHash");
+        mockPublicClient.waitForTransactionReceipt.mockResolvedValue({ status: "success" });
 
         configUtils.notifyAdminGateway.mockResolvedValue();
 
@@ -118,7 +117,7 @@ describe("DhaliEthChannelManager", () => {
 
         const receipt = await localManager.deposit(100);
 
-        expect(receipt.status).toBe(1);
+        expect(receipt.status).toBe("success");
         expect(configUtils.notifyAdminGateway).toHaveBeenCalledWith(
             "ETHEREUM",
             "ETH",
@@ -135,12 +134,14 @@ describe("DhaliEthChannelManager", () => {
     test("getAuthToken throws if channel not found after polling (REST)", async () => {
         const mockHttp = jest.fn();
         configUtils.retrieveChannelIdFromFirestoreRest.mockResolvedValue(null);
-        const manager = new DhaliEthChannelManager(mockSigner, mockProvider, "ETHEREUM", currency, mockHttp, publicConfig);
+        const manager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, mockHttp, publicConfig);
 
         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;
     });
@@ -148,18 +149,17 @@ describe("DhaliEthChannelManager", () => {
     test("getAuthToken defaults to channel capacity if amount is null", async () => {
         const mockHttp = jest.fn();
         configUtils.retrieveChannelIdFromFirestoreRest.mockResolvedValue("0x0000000000000000000000000000000000000000000000000000000000000005");
-        const manager = new DhaliEthChannelManager(mockSigner, mockProvider, "ETHEREUM", currency, mockHttp, publicConfig);
+        const manager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, mockHttp, publicConfig);
 
         // Mock on-chain response for getChannel
         // Selector (4) + 5 words (5 * 32 bytes = 160 bytes = 320 chars)
         // Amount is word 4 (index 4).
         // 0x + 64*4 chars of padding + 5000 in hex (padded to 64 chars)
         const amountHex = BigInt(5000).toString(16).padStart(64, '0');
-        const mockResult = "0x" + "0".repeat(64 * 4) + amountHex;
-        mockProvider.call = jest.fn().mockResolvedValue(mockResult);
+        const mockResult = { data: "0x" + "0".repeat(64 * 4) + amountHex };
+        mockPublicClient.call = jest.fn().mockResolvedValue(mockResult);
 
-        mockSigner.getAddress.mockResolvedValue("0x0000000000000000000000000000000000000001");
-        mockSigner.signTypedData.mockResolvedValue("0xSignature");
+        mockWalletClient.signTypedData.mockResolvedValue("0xSignature");
 
         const originalTimeout = global.setTimeout;
         global.setTimeout = (cb) => cb();
@@ -169,11 +169,42 @@ describe("DhaliEthChannelManager", () => {
 
         expect(decoded.authorized_to_claim).toBe("5000");
         expect(decoded.channel_id).toBe("0x0000000000000000000000000000000000000000000000000000000000000005");
-        expect(mockProvider.call).toHaveBeenCalled();
+        expect(mockPublicClient.call).toHaveBeenCalled();
 
         global.setTimeout = originalTimeout;
     });
 
+    test("deposit notifies admin gateway with lowercase address", async () => {
+        const mockHttp = jest.fn();
+        const manager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, mockHttp, publicConfig);
+
+        // Setup state for new channel creation
+        manager._retrieveChannelIdFromFirestore = jest.fn().mockResolvedValue(null);
+        // Provide a valid mixed-case 40-character EIP-55 Ethereum address
+        mockWalletClient.getAddresses.mockResolvedValue(["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]);
+        mockWalletClient.sendTransaction = jest.fn().mockResolvedValue("0xhash");
+        mockPublicClient.waitForTransactionReceipt = jest.fn().mockResolvedValue({ status: 1 });
+
+        // Mock polling so deposit finishes
+        manager._retrieveChannelIdFromFirestoreWithPolling = jest.fn().mockResolvedValue("0xnewid");
+
+        // Mock crypto so we can predict channel id or at least verify it's called
+        const originalBytes = crypto.randomBytes;
+        crypto.randomBytes = jest.fn().mockReturnValue(Buffer.from("00".repeat(32), "hex"));
+
+        await manager.deposit(100);
+
+        expect(configUtils.notifyAdminGateway).toHaveBeenCalledWith(
+            "ETHEREUM",
+            "ETH",
+            "0x71c7656ec7ab88b098defb751b7401b5f6d8976f", // Expect perfect lowercase
+            expect.any(String),
+            mockHttp
+        );
+
+        crypto.randomBytes = originalBytes;
+    });
+
     test("getAuthToken polls Firestore (REST)", async () => {
         const mockHttp = jest.fn();
         configUtils.retrieveChannelIdFromFirestoreRest
@@ -181,12 +212,11 @@ describe("DhaliEthChannelManager", () => {
             .mockResolvedValueOnce("0x0000000000000000000000000000000000000000000000000000000000000005"); // Second poll
 
         const amountHex = BigInt(1000).toString(16).padStart(64, '0');
-        const mockResult = "0x" + "0".repeat(64 * 4) + amountHex;
-        mockProvider.call = jest.fn().mockResolvedValue(mockResult);
+        const mockResult = { data: "0x" + "0".repeat(64 * 4) + amountHex };
+        mockPublicClient.call = jest.fn().mockResolvedValue(mockResult);
 
-        const manager = new DhaliEthChannelManager(mockSigner, mockProvider, "ETHEREUM", currency, mockHttp, publicConfig);
-        mockSigner.getAddress.mockResolvedValue("0x0000000000000000000000000000000000000001");
-        mockSigner.signTypedData.mockResolvedValue("0xSignature");
+        const manager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, mockHttp, publicConfig);
+        mockWalletClient.signTypedData.mockResolvedValue("0xSignature");
 
         const originalTimeout = global.setTimeout;
         global.setTimeout = (cb) => cb();
@@ -201,8 +231,8 @@ describe("DhaliEthChannelManager", () => {
 
     test("queries Firestore with lowercase address (REST)", async () => {
         const mockHttp = jest.fn();
-        const manager = new DhaliEthChannelManager(mockSigner, mockProvider, "ETHEREUM", currency, mockHttp, publicConfig);
-        mockSigner.getAddress.mockResolvedValue("0xMixEdCaSeAdDrEsS");
+        const manager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, mockHttp, publicConfig);
+        mockWalletClient.getAddresses.mockResolvedValue(["0xMixEdCaSeAdDrEsS"]);
 
         await manager._retrieveChannelIdFromFirestore();
 
@@ -215,8 +245,8 @@ describe("DhaliEthChannelManager", () => {
     });
 
     test("uses default REST if no function provided", async () => {
-        const manager = new DhaliEthChannelManager(mockSigner, mockProvider, "ETHEREUM", currency, null, publicConfig);
-        mockSigner.getAddress.mockResolvedValue("0xMyAddr");
+        const manager = new DhaliEthChannelManager(mockWalletClient, mockPublicClient, currency, null, publicConfig);
+        mockWalletClient.getAddresses.mockResolvedValue(["0xMyAddr"]);
         configUtils.retrieveChannelIdFromFirestoreRest.mockResolvedValue("0xRestId");
 
         const id = await manager._retrieveChannelIdFromFirestore();
@@ -228,4 +258,40 @@ 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
+        );
+    });
 });