dhali-js 1.0.4 → 2.0.0

package/.github/workflows/tests.yaml

@@ -27,3 +27,6 @@ jobs:
 
       - name: Run tests
         run: npm test
+
+      - name: Run lint
+        run: npx tsc src/dhali/*.js --allowJs --checkJs --noEmit --moduleResolution node --module commonjs --target esnext

package/README.md

@@ -4,8 +4,9 @@
 
 # dhali-js
 
-A JavaScript library for managing XRPL payment channels and generating auth tokens for use with [Dhali](https://dhali.io) APIs.  
-Leverages [xrpl.js](https://github.com/XRPLF/xrpl.js) and **only ever performs local signing**—your private key never leaves your environment.
+A JavaScript library for managing payment channels (XRPL & Ethereum) and generating auth tokens for use with [Dhali](https://dhali.io) APIs. 
+
+Includes support for **Machine-to-Machine (M2M) payments** using seamless off-chain claims.
 
 ---
 
@@ -17,105 +18,112 @@ npm install dhali-js
 
 ---
 
-## Quick Start
+## Quick Start: Machine-to-Machine Payments
+
+### 1. XRPL
+
+Uses `xrpl.js` for local signing.
 
 ```js
-// ==== 0. Common setup ====
-const { Wallet } = require('xrpl')
-const { DhaliChannelManager, ChannelNotFound } = require('dhali-js')
+const { Client, Wallet } = require('xrpl')
+const { DhaliChannelManager, ChannelNotFound, Currency } = require('dhali-js')
 
-const seed    = "sXXX"
+const seed    = "sXXX..."
 const wallet  = Wallet.fromSeed(seed)
-const manager = new DhaliChannelManager(wallet)
-```
+const client  = new Client("wss://s.altnet.rippletest.net:51233")
+await client.connect()
 
+const currency = new Currency("XRP", 6)
 
-### 1. Create a Payment Claim
+// Use Factory
+const manager = DhaliChannelManager.xrpl(wallet, client, "XRPL.TESTNET", currency)
 
-```js
-let token
+// Generate Claim
+let token;
 try {
-  token = await manager.getAuthToken()
-} catch (err) {
-  if (err instanceof ChannelNotFound) {
-    await manager.deposit(1_000_000)       // deposit 1 XRP
-    token = await manager.getAuthToken()   // 🔑 regenerate after deposit
-  } else throw err
+    token = await manager.getAuthToken();
+} catch (error) {
+    if (error.name === "ChannelNotFound") {
+       await manager.deposit(1000000); // Deposit 1 XRP
+       token = await manager.getAuthToken();
+    } else {
+       throw error;
+    }
 }
-console.log('New channel token:', token)
-```
-
----
-
-### 2. Top Up Later (and Regenerate)
-
-```js
-await manager.deposit(2_000_000)            // add 2 XRP
-const updatedToken = await manager.getAuthToken()
-console.log('Updated token:', updatedToken)
+console.log('XRPL Token:', token);
 ```
 
----
+### 2. Ethereum (EVM)
 
-### 3. Using APIs and Handling 402 "Payment Required" Errors
+Uses `ethers` (v6) for EIP-712 signing.
 
 ```js
-const fetchWithClaim = async (maxRetries = 5) => {
-  for (let i = 1; i <= maxRetries; i++) {
-    const token = await manager.getAuthToken()
-    const url   = `https://xrplcluster.dhali.io?payment-claim=${token}`
-    const resp  = await fetch(url, { /* …RPC call… */ })
-
-    if (resp.status !== 402) return resp.json()
-
-    console.warn(`Attempt ${i}: topping up…`)
-    await manager.deposit(1_000_000)         // deposit 1 XRP
-  }
-  throw new Error(`402 after ${maxRetries} retries`)
+const { ethers } = require('ethers')
+const { DhaliChannelManager, getAvailableDhaliCurrencies } = require('dhali-js')
+
+// 1. Setup Signer
+const provider = new ethers.JsonRpcProvider("https://rpc.ankr.com/eth_sepolia")
+const signer   = new ethers.Wallet("0x...", provider)
+
+// 2. Fetch Available Currencies
+const configs = await getAvailableDhaliCurrencies()
+const sepoliaUsdc = configs["SEPOLIA"]["USDC"]
+
+// 3. Instantiate Manager with Dynamic Config
+const manager = DhaliChannelManager.evm(
+    signer,
+    provider,
+    "SEPOLIA",
+    sepoliaUsdc.currency
+)
+
+// 4. Generate Claim
+// 4. Generate Claim
+let token;
+try {
+    token = await manager.getAuthToken(1000000); // 1.00 USDC
+} catch (error) {
+    if (error.name === "ChannelNotFound") {
+       await manager.deposit(1000000); // Deposit 1.00 USDC
+       token = await manager.getAuthToken(1000000);
+    } else {
+       throw error;
+    }
 }
-
-;(async () => {
-  const result = await fetchWithClaim()
-  console.log(result)
-})()
+console.log('EVM Token:', token);
 ```
 
 ---
 
-## Class reference
+## Integration
 
-### `new DhaliChannelManager(wallet: xrpl.Wallet)`
+Pass the token in your API calls to Dhali-enabled services.
 
-* **wallet**: an `xrpl.js` `Wallet` instance (e.g. `Wallet.fromSeed`).
-
----
-
-### `async deposit(amountDrops: number) → Promise<object>`
-
-* **amountDrops**: Number of XRP drops (e.g. `1_000_000` = 1 XRP).
-* **Returns**: The JSON result of the `PaymentChannelCreate` or `PaymentChannelFund` transaction.
+```js
+const url = `https://xrplcluster.dhali.io?payment-claim=${token}`
+const response = await fetch(url, { method: 'POST', body: ... })
+```
 
 ---
 
-### `async getAuthToken(amountDrops?: number) → Promise<string>`
-
-* **amountDrops** (optional): How many drops to authorize; defaults to full channel balance.
-* **Returns**: A base64-encoded JSON string containing your signed claim.
-* **Throws**:
+## API Reference
 
-  * `ChannelNotFound` if there is no open channel.
-  * `Error` if `amountDrops` exceeds channel capacity.
+### `DhaliChannelManager`
 
----
-
-## Errors
+* `.xrpl(wallet, client, protocol, currency)`: Returns `DhaliXrplChannelManager`.
+* `.evm(signer, provider, protocol, currency)`: Returns `DhaliEthChannelManager`.
 
-* **ChannelNotFound**
-  Thrown when `getAuthToken` finds no channel from your wallet to Dhali’s receiver.
-
----
+### `getAvailableDhaliCurrencies()`
 
-## Security
+Returns a Promise resolving to:
+```js
+{
+    "SEPOLIA": {
+        "USDC": { currency: ..., destinationAddress: ... },
+        ...
+    },
+    ...
+}
+```
 
-All XRPL interactions and claim-signatures are done locally via `xrpl.js` + `ripple-keypairs`.
-Your private key never leaves your machine.
+---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dhali-js",
-  "version": "1.0.4",
+  "version": "2.0.0",
   "description": "A JavaScript library for managing XRPL payment channels and generating auth tokens for Dhali APIs",
   "main": "src/index.js",
   "type": "commonjs",
@@ -16,11 +16,13 @@
   ],
   "license": "MIT",
   "dependencies": {
+    "ethers": "^6.0.0",
     "ripple-keypairs": "^2.0.0",
     "xrpl": "^4.0.0"
   },
   "devDependencies": {
-    "jest": "^29.0.0",
-    "prettier": "^3.5.3"
+    "jest": "^29.7.0",
+    "prettier": "^3.5.3",
+    "typescript": "^5.9.3"
   }
 }

package/src/dhali/Currency.js

@@ -0,0 +1,9 @@
+class Currency {
+    constructor(code, scale, tokenAddress = null) {
+        this.code = code;
+        this.scale = scale;
+        this.tokenAddress = tokenAddress;
+    }
+}
+
+module.exports = Currency;

package/src/dhali/DhaliChannelManager.js

@@ -1,110 +1,39 @@
-const { Client } = require("xrpl");
-const { buildPaychanAuthHexStringToBeSigned } = require("./createSignedClaim");
-const { sign: signClaim } = require("ripple-keypairs");
-
-class ChannelNotFound extends Error {}
-
-/**
- * A management tool for generating payment claims for use with Dhali APIs.
- */
-class DhaliChannelManager {
-  /**
-   * @param {xrpl.Wallet} wallet
-   */
-  constructor(wallet) {
-    this.client = new Client("wss://s1.ripple.com:51234/");
-    this.ready = this.client.connect();
-    this.wallet = wallet;
-    this.destination = "rLggTEwmTe3eJgyQbCSk4wQazow2TeKrtR";
-    this.protocol = "XRPL.MAINNET";
-  }
-
-  async _findChannel() {
-    await this.ready;
-    const resp = await this.client.request({
-      command: "account_channels",
-      account: this.wallet.classicAddress,
-      destination_account: this.destination,
-      ledger_index: "validated",
-    });
-    const channels = resp.result.channels || [];
-    if (channels.length === 0) {
-      throw new ChannelNotFound(
-        `No open payment channel from ${this.wallet.classicAddress} to ${this.destination}`,
-      );
-    }
-    return channels[0];
-  }
+const { DhaliXrplChannelManager } = require("./DhaliXrplChannelManager");
+const { DhaliEthChannelManager } = require("./DhaliEthChannelManager");
 
+const DhaliChannelManager = {
   /**
-   * Create or fund a payment channel.
-   * @param {number} amountDrops
-   * @returns {Promise<object>}
+   * @param {import("xrpl").Wallet} wallet
+   * @param {import("xrpl").Client} client
+   * @param {string} protocol
+   * @param {import("./Currency")} currency
+   * @param {typeof fetch} [httpClient] - Injected HTTP client
+   * @param {object} [publicConfig]
+   * @returns {DhaliXrplChannelManager}
    */
-  async deposit(amountDrops) {
-    await this.ready;
-    let tx;
-    try {
-      const ch = await this._findChannel();
-      tx = {
-        TransactionType: "PaymentChannelFund",
-        Account: this.wallet.classicAddress,
-        Channel: ch.channel_id,
-        Amount: amountDrops.toString(),
-      };
-    } catch (err) {
-      if (!(err instanceof ChannelNotFound)) throw err;
-      tx = {
-        TransactionType: "PaymentChannelCreate",
-        Account: this.wallet.classicAddress,
-        Destination: this.destination,
-        Amount: amountDrops.toString(),
-        SettleDelay: 86400 * 14,
-        PublicKey: this.wallet.publicKey,
-      };
-    }
-    // autofill sequence, fee, etc.
-    const prepared = await this.client.autofill(tx);
-    // sign
-    const signed = this.wallet.sign(prepared);
-    const txBlob = signed.tx_blob || signed.signedTransaction;
-    // submit & wait
-    const result = await this.client.submitAndWait(txBlob);
-    return result.result;
-  }
+  xrpl: (wallet, client, protocol, currency, httpClient, publicConfig) => {
+    return new DhaliXrplChannelManager(wallet, client, protocol, currency, httpClient, publicConfig);
+  },
 
   /**
-   * Generate a base64-encoded payment claim.
-   * @param {number=} amountDrops
-   * @returns {Promise<string>}
+   * @param {import("ethers").Signer} signer
+   * @param {import("ethers").Provider} provider
+   * @param {string} protocol
+   * @param {import("./Currency")} currency
+   * @param {typeof fetch} [httpClient] - Injected HTTP client
+   * @param {object} [publicConfig]
+   * @returns {DhaliEthChannelManager}
    */
-  async getAuthToken(amountDrops) {
-    await this.ready;
-    const ch = await this._findChannel();
-    const total = BigInt(ch.amount);
-    const allowed = amountDrops != null ? BigInt(amountDrops) : total;
-    if (allowed > total) {
-      throw new Error(
-        `Requested auth ${allowed} exceeds channel capacity ${total}`,
-      );
-    }
-    const claimHex = buildPaychanAuthHexStringToBeSigned(
-      ch.channel_id,
-      allowed.toString(),
+  evm: (signer, provider, protocol, currency, httpClient, publicConfig) => {
+    return new DhaliEthChannelManager(
+      signer,
+      provider,
+      protocol,
+      currency,
+      httpClient,
+      publicConfig
     );
-    const signature = signClaim(claimHex, this.wallet.privateKey);
-    const claim = {
-      version: "2",
-      account: this.wallet.classicAddress,
-      protocol: this.protocol,
-      currency: { code: "XRP", scale: 6 },
-      destination_account: this.destination,
-      authorized_to_claim: allowed.toString(),
-      channel_id: ch.channel_id,
-      signature,
-    };
-    return Buffer.from(JSON.stringify(claim)).toString("base64");
   }
-}
+};
 
-module.exports = { DhaliChannelManager, ChannelNotFound };
+module.exports = { DhaliChannelManager };