dhali-js 1.0.3 → 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

@@ -1,7 +1,12 @@
+[![Package Tests](https://github.com/Dhali-org/Dhali-js/actions/workflows/tests.yaml/badge.svg)](https://github.com/Dhali-org/Dhali-js/actions/workflows/tests.yaml)
+[![Release](https://github.com/Dhali-org/Dhali-js/actions/workflows/publish.yaml/badge.svg)](https://github.com/Dhali-org/Dhali-js/actions/workflows/publish.yaml)
+
+
 # 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.
 
 ---
 
@@ -9,87 +14,116 @@ Leverages [xrpl.js](https://github.com/XRPLF/xrpl.js) and **only ever performs l
 
 ```bash
 npm install dhali-js
-````
+```
 
 ---
 
-## Quick Start
+## Quick Start: Machine-to-Machine Payments
+
+### 1. XRPL
+
+Uses `xrpl.js` for local signing.
 
 ```js
-const { Wallet } = require('xrpl')
-const { DhaliChannelManager, ChannelNotFound } = require('dhali-js')
-
-const seed = "sXXX"
-
-;(async () => {
-  const wallet = Wallet.fromSeed(seed)
-  const manager = new DhaliChannelManager(wallet)
-  
-  let token
-  try {
-    token = await manager.getAuthToken()
-  } catch (err) {
-    if (err instanceof ChannelNotFound) {
-      await manager.deposit(1_000_000)
-      token = await manager.getAuthToken()
+const { Client, Wallet } = require('xrpl')
+const { DhaliChannelManager, ChannelNotFound, Currency } = require('dhali-js')
+
+const seed    = "sXXX..."
+const wallet  = Wallet.fromSeed(seed)
+const client  = new Client("wss://s.altnet.rippletest.net:51233")
+await client.connect()
+
+const currency = new Currency("XRP", 6)
+
+// Use Factory
+const manager = DhaliChannelManager.xrpl(wallet, client, "XRPL.TESTNET", currency)
+
+// Generate Claim
+let token;
+try {
+    token = await manager.getAuthToken();
+} catch (error) {
+    if (error.name === "ChannelNotFound") {
+       await manager.deposit(1000000); // Deposit 1 XRP
+       token = await manager.getAuthToken();
     } else {
-      console.error(err)
-      process.exit(1)
+       throw error;
     }
-  }
-
-  const url = `https://xrplcluster.dhali.io?payment-claim=${token}`
-  const resp = await fetch(url, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      method: 'account_info',
-      params: [{ account: wallet.classicAddress, ledger_index: 'validated' }],
-      id: 1,
-    }),
-  })
-  const result = await resp.json()
-  console.log(result)
-})()
-
+}
+console.log('XRPL Token:', token);
 ```
 
----
-
-## API
+### 2. Ethereum (EVM)
 
-### `new DhaliChannelManager(wallet: xrpl.Wallet)`
-
-* **wallet**: an `xrpl.js` `Wallet` instance (e.g. `Wallet.fromSeed`).
-
----
+Uses `ethers` (v6) for EIP-712 signing.
 
-### `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 { 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;
+    }
+}
+console.log('EVM Token:', token);
+```
 
 ---
 
-### `async getAuthToken(amountDrops?: number) → Promise<string>`
+## Integration
 
-* **amountDrops** (optional): How many drops to authorize; defaults to full channel balance.
-* **Returns**: A base64-encoded JSON string containing your signed claim.
-* **Throws**:
+Pass the token in your API calls to Dhali-enabled services.
 
-  * `ChannelNotFound` if there is no open channel.
-  * `Error` if `amountDrops` exceeds channel capacity.
+```js
+const url = `https://xrplcluster.dhali.io?payment-claim=${token}`
+const response = await fetch(url, { method: 'POST', body: ... })
+```
 
 ---
 
-## Errors
+## API Reference
 
-* **ChannelNotFound**
-  Thrown when `getAuthToken` finds no channel from your wallet to Dhali’s receiver.
+### `DhaliChannelManager`
 
----
+* `.xrpl(wallet, client, protocol, currency)`: Returns `DhaliXrplChannelManager`.
+* `.evm(signer, provider, protocol, currency)`: Returns `DhaliEthChannelManager`.
+
+### `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.3",
+  "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 };