dhali-js 1.0.4 → 2.1.0

package/src/dhali/configUtils.js

@@ -0,0 +1,203 @@
+const Currency = require("./Currency");
+
+/**
+ * @typedef {Object} NetworkCurrencyConfig
+ * @property {Currency} currency
+ * @property {string} destinationAddress
+ */
+
+/**
+ * Fetches and parses available Dhali currencies and configurations.
+ * @returns {Promise<Object.<string, Object.<string, NetworkCurrencyConfig>>>}
+ */
+/**
+ * @param {typeof fetch} [httpClient]
+ * @returns {Promise<Object>}
+ */
+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}`);
+        }
+        data = await response.json();
+    } catch (e) {
+        throw new Error(`Failed to fetch Dhali configuration: ${e.message}`);
+    }
+
+    const publicAddresses = data.DHALI_PUBLIC_ADDRESSES || {};
+    /** @type {Object.<string, Object.<string, NetworkCurrencyConfig>>} */
+    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;
+            const destination = details.wallet_id;
+
+            if (!destination) continue;
+
+            const curr = new Currency(code, scale, tokenAddress);
+
+            result[network][code] = {
+                currency: curr,
+                destinationAddress: destination
+            };
+        }
+    }
+    return result;
+}
+
+/**
+ * Fetches the raw Dhali public configuration JSON.
+ * @returns {Promise<Object>}
+ */
+async function fetchPublicConfig(httpClient = fetch) {
+    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();
+    } catch (e) {
+        throw new Error(`Failed to fetch Dhali configuration: ${e.message}`);
+    }
+}
+
+/**
+ * Proactively notifies the Dhali Admin Gateway about a new payment channel.
+ * @param {string} protocol 
+ * @param {string} currencyIdentifier 
+ * @param {string} accountAddress 
+ * @param {string} channelId 
+ * @param {typeof fetch} [httpClient]
+ */
+async function notifyAdminGateway(protocol, currencyIdentifier, accountAddress, channelId, httpClient = fetch) {
+    const config = await fetchPublicConfig(httpClient);
+    const rootUrl = config.ROOT_API_ADMIN_URL;
+    if (!rootUrl) return;
+
+    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
+    };
+
+    try {
+        await httpClient(url, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(payload)
+        });
+    } catch (e) {
+        // Best effort notification
+    }
+}
+
+
+
+const FIREBASE_CONFIG = {
+    apiKey: "AIzaSyBro8QN3zyJwyo92lYUMPwsyRVPLLGOTcs",
+    authDomain: "dhali-prod.firebaseapp.com",
+    projectId: "dhali-prod",
+    storageBucket: "dhali-prod.firebasestorage.app",
+    messagingSenderId: "1042340549063",
+    appId: "1:1042340549063:web:3dc69cffe6d3c0746189e2",
+    measurementId: "G-6TPZFK7NQ6",
+};
+
+/**
+ * Queries Firestore via REST API using the public API key.
+ * @param {string} protocol 
+ * @param {import("./Currency")} currency 
+ * @param {string} accountAddress 
+ * @param {typeof fetch} [httpClient]
+ * @returns {Promise<string|null>}
+ */
+async function retrieveChannelIdFromFirestoreRest(protocol, currency, accountAddress, httpClient = fetch) {
+    let currencyIdentifier = currency.code;
+    if (currency.tokenAddress) {
+        currencyIdentifier = `${currency.code}.${currency.tokenAddress}`;
+    }
+
+    const projectId = FIREBASE_CONFIG.projectId;
+    const apiKey = FIREBASE_CONFIG.apiKey;
+    const url = `https://firestore.googleapis.com/v1/projects/${projectId}/databases/(default)/documents/public_claim_info/${protocol}:runQuery?key=${apiKey}`;
+
+    const query = {
+        structuredQuery: {
+            from: [{ collectionId: currencyIdentifier }],
+            where: {
+                compositeFilter: {
+                    op: "AND",
+                    filters: [
+                        {
+                            fieldFilter: {
+                                field: { fieldPath: "account" },
+                                op: "EQUAL",
+                                value: { stringValue: accountAddress },
+                            }
+                        },
+                        {
+                            fieldFilter: {
+                                field: { fieldPath: "closed" },
+                                op: "NOT_EQUAL",
+                                value: { booleanValue: true },
+                            }
+                        },
+                    ],
+                }
+            },
+        }
+    };
+
+    try {
+        const response = await httpClient(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(query)
+        });
+
+        if (!response.ok) return null;
+
+        const results = await response.json();
+
+        for (const result of results) {
+            const doc = result.document;
+            if (!doc) continue;
+
+            const fields = doc.fields || {};
+            const closing = fields.closing ? fields.closing.booleanValue : false;
+            const closed = fields.closed ? fields.closed.booleanValue : false;
+
+            if (closing || closed) continue;
+
+            const channelId = fields.channel_id ? fields.channel_id.stringValue : null;
+            if (channelId) return channelId;
+        }
+    } catch (e) {
+        return null;
+    }
+    return null;
+}
+
+module.exports = {
+    getAvailableDhaliCurrencies,
+    fetchPublicConfig,
+    notifyAdminGateway,
+    retrieveChannelIdFromFirestoreRest
+};

package/src/dhali/createSignedClaim.js

@@ -59,8 +59,42 @@ function buildPaychanAuthHexStringToBeSigned(channelIdHex, amountStr) {
   return msg.toString("hex").toUpperCase();
 }
 
+/**
+ * Get Typed Data structure for EIP-712 signing
+ */
+function getEthereumClaimTypedData(channelId, tokenAddress, maxAmount, chainId, contractAddress) {
+  const domain = {
+    name: "DhaliPaymentChannel",
+    version: "2.1.0",
+    chainId: chainId,
+    verifyingContract: contractAddress,
+  };
+
+  const types = {
+    DhaliClaim: [
+      { name: "channelId", type: "bytes32" },
+      { name: "token", type: "address" },
+      { name: "maxAmount", type: "uint256" },
+    ],
+  };
+
+  if (typeof channelId === "string" && !channelId.startsWith("0x")) {
+    channelId = "0x" + channelId;
+  }
+
+  const value = {
+    channelId: channelId,
+    token: tokenAddress,
+    maxAmount: maxAmount
+  };
+
+  return { domain, types, value };
+}
+
+
 module.exports = {
   buildPaychanAuthHexStringToBeSigned,
   // exposed for testing
   _serializePaychanAuthorization,
+  getEthereumClaimTypedData
 };

package/src/dhali/utils.js

@@ -0,0 +1,44 @@
+/**
+ * Wraps a base64 encoded claim and a base64 encoded requirement into an x402 compliant payload.
+ *
+ * @param {string} claimBase64 - The base64 encoded claim object.
+ * @param {string} paymentRequirementBase64 - The base64 encoded payment requirement object.
+ * @returns {string} The base64 encoded x402 payment payload.
+ */
+function wrapAsX402PaymentPayload(claimBase64, paymentRequirementBase64) {
+    const decodedClaim = JSON.parse(
+        Buffer.from(claimBase64, "base64").toString("utf-8")
+    );
+    let req = JSON.parse(
+        Buffer.from(paymentRequirementBase64, "base64").toString("utf-8")
+    );
+
+    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 || "",
+        asset: req.asset || (req.price ? req.price.asset : "") || "",
+        amount: String(req.amount || (req.price ? req.price.amount : "0")),
+        payTo: req.payTo || req.pay_to || "",
+        maxTimeoutSeconds: parseInt(
+            req.maxTimeoutSeconds || req.max_timeout_seconds || 1209600
+        ),
+        extra: req.extra || {},
+    };
+
+    const x402Payload = {
+        x402Version: 2,
+        payload: decodedClaim,
+        accepted: normalizedReq,
+    };
+
+    return Buffer.from(JSON.stringify(x402Payload)).toString("base64");
+}
+
+module.exports = {
+    wrapAsX402PaymentPayload,
+};

package/src/index.js

@@ -1,15 +1,16 @@
-const {
-  buildPaychanAuthHexStringToBeSigned,
-  _serializePaychanAuthorization,
-} = require("./dhali/createSignedClaim");
-const {
-  DhaliChannelManager,
-  ChannelNotFound,
-} = require("./dhali/DhaliChannelManager");
+const { DhaliChannelManager } = require("./dhali/DhaliChannelManager");
+const { DhaliXrplChannelManager, ChannelNotFound } = require("./dhali/DhaliXrplChannelManager");
+const { DhaliEthChannelManager } = require("./dhali/DhaliEthChannelManager");
+const { Currency } = require("./dhali/Currency");
+const { getAvailableDhaliCurrencies } = require("./dhali/configUtils");
+const { wrapAsX402PaymentPayload } = require("./dhali/utils");
 
 module.exports = {
-  buildPaychanAuthHexStringToBeSigned,
-  _serializePaychanAuthorization,
   DhaliChannelManager,
+  DhaliXrplChannelManager,
+  DhaliEthChannelManager,
   ChannelNotFound,
+  Currency,
+  getAvailableDhaliCurrencies,
+  wrapAsX402PaymentPayload
 };

package/tests/DhaliChannelManager.test.js

@@ -1,193 +1,128 @@
-// tests/DhaliChannelManager.test.js
+const {
+  DhaliXrplChannelManager,
+  ChannelNotFound,
+} = require("../src/dhali/DhaliXrplChannelManager");
+const createSignedClaim = require("../src/dhali/createSignedClaim");
+const rippleKeypairs = require("ripple-keypairs");
+const Currency = require("../src/dhali/Currency");
 
-// 1) MOCK xrpl.js BEFORE importing any code that instantiates Client
 jest.mock("xrpl", () => {
-  // Return an object with the Client class stubbed
   return {
-    Client: jest.fn().mockImplementation(() => {
-      return {
-        // connect() returns a resolved Promise so await this.ready never hangs
-        connect: () => Promise.resolve(),
-        // stubbed methods your code calls:
-        request: jest.fn(),
-        autofill: jest.fn(),
-        submitAndWait: jest.fn(),
-        disconnect: jest.fn(),
-        // preserve .url for the constructor test
-        url: "wss://s1.ripple.com:51234/",
-      };
-    }),
+    Client: jest.fn().mockImplementation(() => ({
+      connect: jest.fn().mockResolvedValue(),
+      request: jest.fn(),
+      submitAndWait: jest.fn(),
+      autofill: jest.fn().mockResolvedValue({}),
+    })),
+    Wallet: {
+      fromSeed: jest.fn(),
+    },
   };
 });
 
-// 2) MOCK ripple-keypairs BEFORE importing DhaliChannelManager
 jest.mock("ripple-keypairs", () => ({
-  // We'll override this mock's behavior inside individual tests
   sign: jest.fn(),
 }));
 
-jest.mock("../src/dhali/createSignedClaim", () => ({
-  buildPaychanAuthHexStringToBeSigned: jest.fn(),
-  // If you need to expose _serializePaychanAuthorization, add it here too:
-  // _serializePaychanAuthorization: jest.fn(),
-}));
 
-// 3) Now import everything under test
-const createSignedClaim = require("../src/dhali/createSignedClaim");
-const { sign: mockRippleSign } = require("ripple-keypairs");
-const {
-  DhaliChannelManager,
-  ChannelNotFound,
-} = require("../src/dhali/DhaliChannelManager");
+
+const configUtils = require("../src/dhali/configUtils");
+jest.mock("../src/dhali/configUtils", () => ({
+  fetchPublicConfig: jest.fn().mockResolvedValue({}),
+  retrieveChannelIdFromFirestoreRest: jest.fn(),
+}));
 
 describe("DhaliChannelManager", () => {
-  const CHANNEL_ID = "AB".repeat(32);
-  let wallet;
   let manager;
+  let mockClient;
+  let wallet;
+  let currency;
+  const CHANNEL_ID = "0000000000000000000000000000000000000000000000000000000000000000";
 
   beforeEach(() => {
-    // 4) Create a minimal fake wallet
     wallet = {
-      classicAddress: "rTESTADDRESS",
-      publicKey: "PUBKEY",
-      privateKey: "PRIVKEY",
-      // sign() is used for transaction signing
-      sign: jest.fn().mockReturnValue({ signedTransaction: "TX_BLOB" }),
+      address: "rTestAddress",
+      classicAddress: "rTestAddress",
+      publicKey: "TEST_PUB_KEY",
+      privateKey: "TEST_PRIV_KEY",
+      sign: jest.fn().mockReturnValue({ tx_blob: "BLOB" }),
     };
-    // 5) Instantiate the manager. client.connect() is already stubbed.
-    manager = new DhaliChannelManager(wallet);
-    // 6) Short-circuit any `await this.ready` if your constructor awaits client.connect()
-    manager.ready = Promise.resolve();
-  });
+    mockClient = {
+      connect: jest.fn().mockResolvedValue(),
+      request: jest.fn(),
+      submitAndWait: jest.fn(),
+      autofill: jest.fn().mockResolvedValue({}),
+    };
+    currency = new Currency("XRP", 6);
 
-  afterEach(() => {
-    // 7) Restore any spies on createSignedClaim so tests remain isolated
-    if (createSignedClaim.buildPaychanAuthHexStringToBeSigned.mockRestore) {
-      createSignedClaim.buildPaychanAuthHexStringToBeSigned.mockRestore();
-    }
+    const mockHttp = jest.fn();
+    configUtils.retrieveChannelIdFromFirestoreRest.mockResolvedValue("CHAN123");
+    manager = new DhaliXrplChannelManager(wallet, mockClient, "XRPL.MAINNET", currency, mockHttp);
   });
 
-  test("constructor sets defaults", () => {
-    expect(manager.wallet).toBe(wallet);
-    expect(manager.protocol).toBe("XRPL.MAINNET");
-    expect(manager.destination).toBe("rLggTEwmTe3eJgyQbCSk4wQazow2TeKrtR");
-    // client.url comes from our mock above
-    expect(manager.client.url).toBe("wss://s1.ripple.com:51234/");
+  afterEach(() => {
+    jest.clearAllMocks();
   });
 
-  describe("_findChannel", () => {
-    test("returns first channel when present", async () => {
-      const fakeChannel = { channel_id: "CHAN123", amount: "1000" };
-      manager.client.request.mockResolvedValue({
-        result: { channels: [fakeChannel] },
+  describe("deposit", () => {
+    test("funds existing channel if found", async () => {
+      mockClient.rpc_client = { request: jest.fn() }; // not really how it works but let's see
+      mockClient.request.mockResolvedValue({
+        result: {
+          channels: [{ channel_id: CHANNEL_ID }],
+        },
       });
+      mockClient.submitAndWait.mockResolvedValue({ result: "SUCCESS" });
+      mockClient.autofill = jest.fn().mockResolvedValue({});
 
-      const ch = await manager._findChannel();
-      expect(ch).toBe(fakeChannel);
-      // verify the exact request payload
-      expect(manager.client.request).toHaveBeenCalledWith({
-        command: "account_channels",
-        account: wallet.classicAddress,
-        destination_account: manager.destination,
-        ledger_index: "validated",
-      });
+      const result = await manager.deposit(100);
+      expect(result).toBe("SUCCESS");
     });
 
-    test("throws ChannelNotFound when none", async () => {
-      manager.client.request.mockResolvedValue({ result: { channels: [] } });
-
-      await expect(manager._findChannel()).rejects.toThrow(ChannelNotFound);
-      await expect(manager._findChannel()).rejects.toThrow(
+    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);
+      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
       );
-      await expect(manager._findChannel()).rejects.toThrow(manager.destination);
     });
-  });
 
-  describe("deposit", () => {
-    test("funds existing channel", async () => {
-      // _findChannel resolves => fund path
-      const fakeChannel = { channel_id: "CHANID", amount: "500" };
-      manager._findChannel = jest.fn().mockResolvedValue(fakeChannel);
-
-      // stub autofill + submitAndWait from our Client mock
-      manager.client.autofill.mockResolvedValue({ foo: "bar" });
-      manager.client.submitAndWait.mockResolvedValue({
-        result: { status: "funded" },
+    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" }],
+        },
       });
 
-      const res = await manager.deposit(100);
-      expect(res).toEqual({ status: "funded" });
-
-      // ensure autofill got the correct PaymentChannelFund payload
-      expect(manager.client.autofill).toHaveBeenCalledWith({
-        TransactionType: "PaymentChannelFund",
-        Account: wallet.classicAddress,
-        Channel: fakeChannel.channel_id,
-        Amount: "100",
-      });
-      // ensure we submitted the signed blob returned by wallet.sign()
-      expect(manager.client.submitAndWait).toHaveBeenCalledWith("TX_BLOB");
-    });
-
-    test("creates channel if none exists", async () => {
-      // _findChannel rejects with ChannelNotFound => create path
-      manager._findChannel = jest
-        .fn()
-        .mockRejectedValue(new ChannelNotFound("nope"));
-
-      manager.client.autofill.mockResolvedValue({ baz: "qux" });
-      manager.client.submitAndWait.mockResolvedValue({
-        result: { status: "created" },
-      });
-
-      const res = await manager.deposit(200);
-      expect(res).toEqual({ status: "created" });
-
-      expect(manager.client.autofill).toHaveBeenCalledWith({
-        TransactionType: "PaymentChannelCreate",
-        Account: wallet.classicAddress,
-        Destination: manager.destination,
-        Amount: "200",
-        SettleDelay: 86400 * 14,
-        PublicKey: wallet.publicKey,
-      });
-      expect(manager.client.submitAndWait).toHaveBeenCalledWith("TX_BLOB");
+      await expect(manager.getAuthToken(100)).rejects.toThrow(ChannelNotFound);
+      await expect(manager.getAuthToken(100)).rejects.toThrow(/FIRESTORE_ID not found on-chain/);
     });
   });
 
   describe("getAuthToken", () => {
     test("success with default amount", async () => {
-      // stub channel lookup
       manager._findChannel = jest.fn().mockResolvedValue({
         channel_id: CHANNEL_ID,
         amount: "1001",
       });
 
-      // 8) SPY on the hex-builder instead of reassigning it
-      const claimSpy = jest
-        .spyOn(createSignedClaim, "buildPaychanAuthHexStringToBeSigned")
-        .mockReturnValue("CLAIMHEX");
-
-      // stub signature
-      mockRippleSign.mockReturnValue("SIGVALUE");
+      rippleKeypairs.sign.mockReturnValue("SIG");
 
       const token = await manager.getAuthToken();
       const decoded = JSON.parse(Buffer.from(token, "base64").toString("utf8"));
 
       expect(decoded).toMatchObject({
-        version: "2",
-        account: wallet.classicAddress,
-        protocol: manager.protocol,
-        currency: { code: "XRP", scale: 6 },
-        destination_account: manager.destination,
-        authorized_to_claim: "1001",
         channel_id: CHANNEL_ID,
-        signature: "SIGVALUE",
+        authorized_to_claim: "1001",
+        signature: "SIG",
       });
-
-      // ensure our spy was called with correct args
-      expect(claimSpy).toHaveBeenCalledWith(CHANNEL_ID, "1001");
     });
 
     test("success with specific amount", async () => {
@@ -195,16 +130,11 @@ describe("DhaliChannelManager", () => {
         channel_id: CHANNEL_ID,
         amount: "500",
       });
-
-      const claimSpy = jest
-        .spyOn(createSignedClaim, "buildPaychanAuthHexStringToBeSigned")
-        .mockReturnValue("CLAIMHEX2");
-      mockRippleSign.mockReturnValue("SIG2");
+      rippleKeypairs.sign.mockReturnValue("SIG2");
 
       const token = await manager.getAuthToken(200);
       const decoded = JSON.parse(Buffer.from(token, "base64").toString("utf8"));
       expect(decoded.authorized_to_claim).toBe("200");
-      expect(claimSpy).toHaveBeenCalledWith(CHANNEL_ID, "200");
     });
 
     test("throws if amount exceeds capacity", async () => {