dhali-js 2.1.0 → 3.0.1

package/.github/workflows/tests.yaml

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

package/README.md

@@ -16,6 +16,9 @@ Includes support for **Machine-to-Machine (M2M) payments** using seamless off-ch
 npm install dhali-js
 ```
 
+> [!TIP]
+> The examples below use CommonJS (`require`). Because they use `await`, the code is wrapped in an `async function main() { ... }` which is called immediately. To run these, simply save them to a `.js` file and run `node document.js`.
+
 ---
 
 ## Quick Start: Machine-to-Machine Payments
@@ -28,69 +31,85 @@ Uses `xrpl.js` for local signing.
 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 {
-       throw error;
+async function main() {
+    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("XRPL.TESTNET", "XRP", 6)
+
+    // Use Factory
+    const manager = DhaliChannelManager.xrpl(wallet, client, 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 {
+           throw error;
+        }
     }
+    console.log('XRPL Token:', token);
 }
-console.log('XRPL Token:', token);
+
+main();
 ```
 
 ### 2. Ethereum (EVM)
 
-Uses `ethers` (v6) for EIP-712 signing.
+Uses `viem` for EIP-712 signing.
 
 ```js
-const { ethers } = require('ethers')
+const { createWalletClient, createPublicClient, http } = require('viem')
+const { privateKeyToAccount } = require('viem/accounts')
+const { mainnet, sepolia } = require('viem/chains')
 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 function main() {
+    // 1. Setup Clients
+    const account = privateKeyToAccount('0x...')
+    const publicClient = createPublicClient({
+      chain: sepolia,
+      transport: http()
+    })
+    const walletClient = createWalletClient({
+      account,
+      chain: sepolia,
+      transport: http()
+    })
+
+    // 2. Fetch Available Currencies
+    const currencies = await getAvailableDhaliCurrencies()
+    const sepoliaUsdc = currencies.find(c => c.network === "SEPOLIA" && c.code === "USDC")
+
+    // 3. Instantiate Manager with Dynamic Config
+    const manager = DhaliChannelManager.evm(
+        walletClient,
+        publicClient,
+        sepoliaUsdc
+    )
+
+    // 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);
 }
-console.log('EVM Token:', token);
+
+main();
 ```
 
 ---
@@ -104,26 +123,64 @@ const url = `https://xrplcluster.dhali.io?payment-claim=${token}`
 const response = await fetch(url, { method: 'POST', body: ... })
 ```
 
+## Standardized x402 Payments
+
+For APIs that follow the x402 standard, you may need to wrap your auth token with the payment requirement (retrieved from the `payment-required` header of a 402 response).
+
+```js
+const { wrapAsX402PaymentPayload } = require('dhali-js');
+
+async function main() {
+    // 1. Get your token as usual
+    const token = await manager.getAuthToken();
+
+    // 2. Get the payment requirement from the 'payment-required' header of a 402 response
+    const paymentRequirement = response.headers.get("payment-required");
+
+    // 3. Wrap into an x402 payload
+    const x402Payload = wrapAsX402PaymentPayload(token, paymentRequirement);
+
+    // 4. Use 'x402Payload' in the 'Payment' header
+}
+
+main();
+```
+
 ---
 
 ## API Reference
 
-### `DhaliChannelManager`
+### `DhaliChannelManager` (Factory)
+
+* `.xrpl(wallet, client, currency)`: Returns `DhaliXrplChannelManager`.
+* `.evm(walletClient, publicClient, currency)`: Returns `DhaliEthChannelManager`.
 
-* `.xrpl(wallet, client, protocol, currency)`: Returns `DhaliXrplChannelManager`.
-* `.evm(signer, provider, protocol, currency)`: Returns `DhaliEthChannelManager`.
+### `DhaliEthChannelManager` & `DhaliXrplChannelManager`
+
+Both managers provide the following core methods:
+
+* `async deposit(amount)`: Deposits funds into a payment channel. For EVM/XRPL, `amount` is in base units (wei/drops, etc). If no channel exists, it creates one; if it exists, it funds it.
+* `async getAuthToken(amount = null)`: Generates a base64-encoded payment claim. If `amount` is provided, the claim is authorized up to that value. Defaults to total channel capacity if `amount` is `null`.
 
 ### `getAvailableDhaliCurrencies()`
 
-Returns a Promise resolving to:
+Returns a Promise resolving to an array of `Currency` objects:
 ```js
-{
-    "SEPOLIA": {
-        "USDC": { currency: ..., destinationAddress: ... },
-        ...
-    },
+[
+    { network: "SEPOLIA", code: "USDC", scale: 6, tokenAddress: "..." },
     ...
-}
+]
 ```
 
+---
+
+## Utilities
+
+### `wrapAsX402PaymentPayload(token, paymentRequirement)`
+
+Wraps an auth token and a payment requirement (retrieved from a 402 response header) into a base64-encoded x402-compliant payload.
+
+* **`token`**: The base64-encoded claim generated by `getAuthToken()`.
+* **`paymentRequirement`**: The base64-encoded requirement string from the `payment-required` header.
+
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dhali-js",
-  "version": "2.1.0",
+  "version": "3.0.1",
   "description": "A JavaScript library for managing XRPL payment channels and generating auth tokens for Dhali APIs",
   "main": "src/index.js",
   "type": "commonjs",
@@ -16,8 +16,8 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "ethers": "^6.0.0",
     "ripple-keypairs": "^2.0.0",
+    "viem": "^2.23.5",
     "xrpl": "^4.0.0"
   },
   "devDependencies": {

package/src/dhali/Currency.js

@@ -1,5 +1,6 @@
 class Currency {
-    constructor(code, scale, tokenAddress = null) {
+    constructor(network, code, scale, tokenAddress = null) {
+        this.network = network;
         this.code = code;
         this.scale = scale;
         this.tokenAddress = tokenAddress;

package/src/dhali/DhaliChannelManager.js

@@ -5,30 +5,27 @@ const DhaliChannelManager = {
   /**
    * @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}
    */
-  xrpl: (wallet, client, protocol, currency, httpClient, publicConfig) => {
-    return new DhaliXrplChannelManager(wallet, client, protocol, currency, httpClient, publicConfig);
+  xrpl: (wallet, client, currency, httpClient, publicConfig) => {
+    return new DhaliXrplChannelManager(wallet, client, currency, httpClient, publicConfig);
   },
 
   /**
-   * @param {import("ethers").Signer} signer
-   * @param {import("ethers").Provider} provider
-   * @param {string} protocol
+   * @param {import("viem").WalletClient} walletClient
+   * @param {import("viem").PublicClient} publicClient
    * @param {import("./Currency")} currency
    * @param {typeof fetch} [httpClient] - Injected HTTP client
    * @param {object} [publicConfig]
    * @returns {DhaliEthChannelManager}
    */
-  evm: (signer, provider, protocol, currency, httpClient, publicConfig) => {
+  evm: (walletClient, publicClient, currency, httpClient, publicConfig) => {
     return new DhaliEthChannelManager(
-      signer,
-      provider,
-      protocol,
+      walletClient,
+      publicClient,
       currency,
       httpClient,
       publicConfig

package/src/dhali/DhaliEthChannelManager.js

@@ -1,331 +1,344 @@
 const { getEthereumClaimTypedData } = require("./createSignedClaim");
-const { ethers } = require("ethers");
+const {
+  keccak256,
+  encodeAbiParameters,
+  parseAbiParameters,
+  toHex
+} = require("viem");
+const crypto = require("crypto");
 
 const { fetchPublicConfig, notifyAdminGateway, retrieveChannelIdFromFirestoreRest } = require("./configUtils");
 
 class DhaliEthChannelManager {
-    /**
-    * @param {ethers.Signer} signer
-    * @param {import("ethers").Provider} rpc_client
-    * @param {string} protocol
-    * @param {import("./Currency")} currency
-    * @param {typeof fetch} [httpClient] - Injected HTTP client
-    * @param {object} [public_config] - Dhali public configuration
-    */
-    constructor(signer, rpc_client, protocol, currency, httpClient = fetch, public_config) {
-        this.signer = signer;
-        this.rpc_client = rpc_client;
-        this.protocol = protocol;
-        this.currency = currency;
-        this.httpClient = httpClient || fetch;
-        this.public_config = public_config;
-        this.chainId = this._getChainIdFromProtocol(protocol);
-        this.destinationAddress = undefined;
-        this.contractAddress = undefined;
+  /**
+  * @param {import("viem").WalletClient} walletClient
+  * @param {import("viem").PublicClient} publicClient
+  * @param {import("./Currency")} currency
+  * @param {typeof fetch} [httpClient] - Injected HTTP client
+  * @param {object} [public_config] - Dhali public configuration
+  */
+  constructor(walletClient, publicClient, currency, httpClient = fetch, public_config) {
+    this.walletClient = walletClient;
+    this.publicClient = publicClient;
+    this.currency = currency;
+    this.httpClient = httpClient || fetch;
+    this.public_config = public_config;
+    this.chainId = this._getChainIdFromProtocol(this.currency.network);
+    this.destinationAddress = undefined;
+    this.contractAddress = undefined;
+  }
+
+  _getChainIdFromProtocol(protocol) {
+    switch (protocol) {
+      case "ETHEREUM": return 1;
+      case "SEPOLIA": return 11155111;
+      case "HOLESKY": return 17000;
+      case "LOCALHOST": return 31337;
+      default: throw new Error(`Unsupported protocol: ${protocol}`);
     }
+  }
 
-    _getChainIdFromProtocol(protocol) {
-        switch (protocol) {
-            case "ETHEREUM": return 1;
-            case "SEPOLIA": return 11155111;
-            case "HOLESKY": return 17000;
-            case "LOCALHOST": return 31337;
-            default: throw new Error(`Unsupported protocol: ${protocol}`);
-        }
-    }
 
-    _getProtocolName() {
-        return this.protocol;
-    }
+  async _resolveAddresses() {
+    if (this.destinationAddress && this.contractAddress) return;
 
-    async _resolveAddresses() {
-        if (this.destinationAddress && this.contractAddress) return;
-
-        if (!this.public_config) {
-            this.public_config = await fetchPublicConfig(this.httpClient);
-        }
-
-        if (!this.destinationAddress) {
-            try {
-                this.destinationAddress = this.public_config.DHALI_PUBLIC_ADDRESSES[this.protocol][this.currency.code].wallet_id;
-            } catch (e) {
-                throw new Error("Destination address not found in public_config for this protocol/currency: " + e.message);
-            }
-        }
-
-        if (!this.contractAddress) {
-            try {
-                // @ts-ignore
-                this.contractAddress = this.public_config.CONTRACTS[this.protocol].contract_address;
-            } catch (e) {
-                throw new Error("Contract address not found in public_config for this protocol: " + e.message);
-            }
-        }
-
-        if (!this.contractAddress) {
-            throw new Error("Contract address must be provided or resolved for this chainId");
-        }
+    if (!this.public_config) {
+      this.public_config = await fetchPublicConfig(this.httpClient);
     }
 
-    /**
-     * Queries Firestore for an existing open channel.
-     * Path: public_claim_info/<protocol>/<currency_identifier>
-     * Filter: account == my_address, closed != true
-     */
-    async _retrieveChannelIdFromFirestore() {
-        const address = (await this.signer.getAddress()).toLowerCase();
-        return await retrieveChannelIdFromFirestoreRest(
-            this.protocol,
-            this.currency,
-            address,
-            this.httpClient
-        );
+    if (!this.destinationAddress) {
+      try {
+        this.destinationAddress = this.public_config.DHALI_PUBLIC_ADDRESSES[this.currency.network][this.currency.code].wallet_id;
+      } catch (e) {
+        throw new Error("Destination address not found in public_config for this protocol/currency: " + e.message);
+      }
     }
 
-    async _retrieveChannelIdFromFirestoreWithPolling(timeoutSeconds = 30) {
-        const startTime = Date.now();
-        while (Date.now() - startTime < timeoutSeconds * 1000) {
-            const channelId = await this._retrieveChannelIdFromFirestore();
-            if (channelId) return channelId;
-            await new Promise(resolve => setTimeout(resolve, 2000));
-        }
-        return null;
+    if (!this.contractAddress) {
+      try {
+        // @ts-ignore
+        this.contractAddress = this.public_config.CONTRACTS[this.currency.network].contract_address;
+      } catch (e) {
+        throw new Error("Contract address not found in public_config for this protocol: " + e.message);
+      }
     }
 
-    async _calculateChannelId(receiver, tokenAddress, nonce) {
-        // Matches Dhali-wallet: keccak256(abi.encode(sender, receiver, token, nonce))
-        const sender = await this.signer.getAddress();
-        return ethers.keccak256(
-            ethers.AbiCoder.defaultAbiCoder().encode(
-                ["address", "address", "address", "uint256"],
-                [sender, receiver, tokenAddress, nonce]
-            )
-        );
+    if (!this.contractAddress) {
+      throw new Error("Contract address must be provided or resolved for this chainId");
     }
-
-    _encodeAddress(address) {
-        return address.toLowerCase().replace("0x", "").padStart(64, '0');
+  }
+
+  /**
+   * Queries Firestore for an existing open channel.
+   * Path: public_claim_info/<protocol>/<currency_identifier>
+   * Filter: account == my_address, closed != true
+   */
+  async _retrieveChannelIdFromFirestore() {
+    const [address] = await this.walletClient.getAddresses();
+    return await retrieveChannelIdFromFirestoreRest(
+      this.currency.network,
+      this.currency,
+      address.toLowerCase(),
+      this.httpClient
+    );
+  }
+
+  async _retrieveChannelIdFromFirestoreWithPolling(timeoutSeconds = 30) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutSeconds * 1000) {
+      const channelId = await this._retrieveChannelIdFromFirestore();
+      if (channelId) return channelId;
+      await new Promise(resolve => setTimeout(resolve, 2000));
     }
-
-    _encodeUint(value) {
-        return BigInt(value).toString(16).padStart(64, '0');
+    return null;
+  }
+
+  async _calculateChannelId(receiver, tokenAddress, nonce) {
+    // Matches Dhali-wallet: keccak256(abi.encode(sender, receiver, token, nonce))
+    const [sender] = await this.walletClient.getAddresses();
+    return keccak256(
+      encodeAbiParameters(
+        parseAbiParameters("address, address, address, uint256"),
+        [sender, receiver, tokenAddress, nonce]
+      )
+    );
+  }
+
+  _encodeAddress(address) {
+    return address.toLowerCase().replace("0x", "").padStart(64, '0');
+  }
+
+  _encodeUint(value) {
+    return BigInt(value).toString(16).padStart(64, '0');
+  }
+
+  _encodeBool(value) {
+    return value ? "1".padStart(64, '0') : "0".padStart(64, '0');
+  }
+
+  _encodeBytes32(value) {
+    return value.replace("0x", "").padStart(64, '0');
+  }
+
+  async _buildTx(to, data, value) {
+    const accountString = (await this.walletClient.getAddresses())[0];
+    const account = this.walletClient.account || accountString;
+    const gasPrice = await this.publicClient.getGasPrice();
+    // Add 10% buffer to gas price
+    const gasPriceWithBuffer = (gasPrice * BigInt(110)) / BigInt(100);
+
+    /** @type {any} */
+    const txParams = {
+      account: account,
+      to: to,
+      value: value,
+      data: data,
+      gasPrice: gasPriceWithBuffer,
+      nonce: await this.publicClient.getTransactionCount({ address: accountString, blockTag: "pending" }),
+      chain: { id: this.chainId }
+    };
+
+    // Estimate gas
+    const gasLimit = await this.publicClient.estimateGas(txParams);
+    // Add 10% buffer to gas limit
+    txParams.gas = (gasLimit * BigInt(110)) / BigInt(100);
+
+    return txParams;
+  }
+
+  /**
+   * Deposits funds into a payment channel.
+   * If an open channel exists, funds it.
+   * If not, opens a new one.
+   * @param {string|number} amount Amount in base units (wei/drops)
+   * @returns {Promise<import("viem").TransactionReceipt>}
+   */
+  async deposit(amount) {
+    await this._resolveAddresses();
+    const existingChannelId = await this._retrieveChannelIdFromFirestore();
+    const tokenAddress = this.currency.tokenAddress || "0x0000000000000000000000000000000000000000";
+    const isNative = (tokenAddress === "0x0000000000000000000000000000000000000000");
+    const amountBig = BigInt(amount);
+
+    const OPEN_CHANNEL_SELECTOR = "3cd880a5";
+    const DEPOSIT_SELECTOR = "264d06c8";
+    const SETTLE_DELAY = 1209600n; // 2 weeks
+
+    if (existingChannelId) {
+      // Deposit
+      const calldata = "0x" +
+        DEPOSIT_SELECTOR +
+        this._encodeBytes32(existingChannelId) +
+        this._encodeUint(amountBig) +
+        this._encodeBool(true); // renew
+
+      if (!isNative) {
+        await this._approveToken(tokenAddress, this.contractAddress, amountBig);
+      }
+
+      const txParams = await this._buildTx(this.contractAddress, calldata, isNative ? amountBig : 0n);
+      const hash = await this.walletClient.sendTransaction(txParams);
+      return await this.publicClient.waitForTransactionReceipt({ hash });
+
+    } else {
+      // Open Channel
+      const receiver = this.destinationAddress;
+      const nonce = this._generateNonce();
+      const dummySigner = "0x0000000000000000000000000000000000000000";
+
+      const calldata = "0x" +
+        OPEN_CHANNEL_SELECTOR +
+        this._encodeAddress(receiver) +
+        this._encodeAddress(tokenAddress) +
+        this._encodeUint(amountBig) +
+        this._encodeUint(SETTLE_DELAY) +
+        this._encodeUint(nonce) +
+        this._encodeAddress(dummySigner);
+
+      if (!isNative) {
+        await this._approveToken(tokenAddress, this.contractAddress, amountBig);
+      }
+
+      const txParams = await this._buildTx(this.contractAddress, calldata, isNative ? amountBig : 0n);
+      const hash = await this.walletClient.sendTransaction(txParams);
+      const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+
+      // Calculate channel ID and notify gateway
+      const calculatedChannelId = await this._calculateChannelId(receiver, tokenAddress, nonce);
+
+      let currencyIdentifier = this.currency.code;
+      if (this.currency.tokenAddress) {
+        currencyIdentifier = `${this.currency.code}.${this.currency.tokenAddress}`;
+      }
+
+      const [address] = await this.walletClient.getAddresses();
+      // Proactive notification
+      await notifyAdminGateway(
+        this.currency.network,
+        currencyIdentifier,
+        address.toLowerCase(),
+        calculatedChannelId,
+        this.httpClient
+      );
+
+      // Poll Firestore to match setupBalanceListener behavior
+      await this._retrieveChannelIdFromFirestoreWithPolling(30);
+
+      return receipt;
     }
-
-    _encodeBool(value) {
-        return value ? "1".padStart(64, '0') : "0".padStart(64, '0');
+  }
+
+  _generateNonce() {
+    const bytes = crypto.randomBytes(32);
+    return BigInt(toHex(bytes));
+  }
+
+  async _approveToken(tokenAddress, spender, amount) {
+    const APPROVE_SELECTOR = "095ea7b3";
+    const calldata = "0x" +
+      APPROVE_SELECTOR +
+      this._encodeAddress(spender) +
+      this._encodeUint(amount);
+
+    const txParams = await this._buildTx(tokenAddress, calldata, 0n);
+    const hash = await this.walletClient.sendTransaction(txParams);
+    await this.publicClient.waitForTransactionReceipt({ hash });
+  }
+  async _getOnChainChannelAmount(channelId) {
+    const cleanId = channelId.replace("0x", "").padStart(64, "0");
+    const calldata = "0x831c2b82" + cleanId;
+
+    try {
+      const result = await this.publicClient.call({
+        to: this.contractAddress,
+        data: calldata
+      });
+
+      if (!result || result.data === "0x" || result.data.length < 322) {
+        throw new Error("Invalid getChannel response length");
+      }
+
+      // The amount is the 5th 32-byte word (index 4).
+      // Result is a hex string "0x...".
+      // Word 0: 2 to 66
+      // Word 1: 66 to 130
+      // Word 2: 130 to 194
+      // Word 3: 194 to 258
+      // Word 4: 258 to 322
+      const amountHex = "0x" + result.data.substring(258, 322);
+      return BigInt(amountHex).toString();
+    } catch (e) {
+      throw new Error(`Failed to retrieve on-chain channel amount: ${e.message}`);
     }
-
-    _encodeBytes32(value) {
-        return value.replace("0x", "").padStart(64, '0');
+  }
+
+  /**
+   * Generate a base64-encoded payment claim.
+   * @param {number|string|null} amount - Defaults to total channel capacity if null
+   * @returns {Promise<string>}
+   */
+  async getAuthToken(amount = null) {
+    await this._resolveAddresses();
+    // 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.");
     }
 
-    async _buildTx(to, data, value) {
-        const feeData = await this.rpc_client.getFeeData();
-        // Add 10% buffer to gas price
-        const gasPrice = (feeData.gasPrice * BigInt(110)) / BigInt(100);
-
-        const txParams = {
-            from: await this.signer.getAddress(),
-            to: to,
-            value: value,
-            data: data,
-            gasPrice: gasPrice,
-            // Use pending nonce
-            nonce: await this.signer.getNonce("pending"),
-            chainId: this.chainId
-        };
-
-        // Estimate gas
-        const gasLimit = await this.signer.estimateGas(txParams);
-        // Add 10% buffer to gas limit
-        txParams.gasLimit = (gasLimit * BigInt(110)) / BigInt(100);
-
-        return txParams;
+    let channelId = channelIdRaw;
+    if (!channelId.startsWith("0x")) {
+      channelId = "0x" + channelId;
     }
 
-    /**
-     * Deposits funds into a payment channel.
-     * If an open channel exists, funds it.
-     * If not, opens a new one.
-     * @param {string|number} amount Amount in base units (wei/drops)
-     * @returns {Promise<ethers.TransactionReceipt>}
-     */
-    async deposit(amount) {
-        await this._resolveAddresses();
-        const existingChannelId = await this._retrieveChannelIdFromFirestore();
-        const tokenAddress = this.currency.tokenAddress || "0x0000000000000000000000000000000000000000";
-        const isNative = (tokenAddress === "0x0000000000000000000000000000000000000000");
-        const amountBig = BigInt(amount);
-
-        const OPEN_CHANNEL_SELECTOR = "3cd880a5";
-        const DEPOSIT_SELECTOR = "264d06c8";
-        const SETTLE_DELAY = 1209600; // 2 weeks
-
-        if (existingChannelId) {
-            // Deposit
-            const calldata = "0x" +
-                DEPOSIT_SELECTOR +
-                this._encodeBytes32(existingChannelId) +
-                this._encodeUint(amountBig) +
-                this._encodeBool(true); // renew
-
-            if (!isNative) {
-                await this._approveToken(tokenAddress, this.contractAddress, amountBig);
-            }
-
-            const txParams = await this._buildTx(this.contractAddress, calldata, isNative ? amountBig : 0);
-            const tx = await this.signer.sendTransaction(txParams);
-            return await tx.wait();
-
-        } else {
-            // Open Channel
-            const receiver = this.destinationAddress;
-            const nonce = this._generateNonce();
-            const dummySigner = "0x0000000000000000000000000000000000000000";
-
-            const calldata = "0x" +
-                OPEN_CHANNEL_SELECTOR +
-                this._encodeAddress(receiver) +
-                this._encodeAddress(tokenAddress) +
-                this._encodeUint(amountBig) +
-                this._encodeUint(SETTLE_DELAY) +
-                this._encodeUint(nonce) +
-                this._encodeAddress(dummySigner);
-
-            if (!isNative) {
-                await this._approveToken(tokenAddress, this.contractAddress, amountBig);
-            }
-
-            const txParams = await this._buildTx(this.contractAddress, calldata, isNative ? amountBig : 0);
-            const tx = await this.signer.sendTransaction(txParams);
-            const receipt = await tx.wait();
-
-            // Calculate channel ID and notify gateway
-            const calculatedChannelId = await this._calculateChannelId(receiver, tokenAddress, nonce);
-
-            let currencyIdentifier = this.currency.code;
-            if (this.currency.tokenAddress) {
-                currencyIdentifier = `${this.currency.code}.${this.currency.tokenAddress}`;
-            }
-
-            // Proactive notification
-            await notifyAdminGateway(
-                this.protocol,
-                currencyIdentifier,
-                await this.signer.getAddress(),
-                calculatedChannelId,
-                this.httpClient
-            );
-
-            // Poll Firestore to match setupBalanceListener behavior
-            await this._retrieveChannelIdFromFirestoreWithPolling(30);
-
-            return receipt;
-        }
-    }
+    const totalAmount = await this._getOnChainChannelAmount(channelId);
+    const allowed = amount !== null ? amount.toString() : totalAmount;
 
-    _generateNonce() {
-        const bytes = ethers.randomBytes(32);
-        return BigInt(ethers.hexlify(bytes));
+    // BigInt comparison if needed, but for now simple check if it exceeds
+    if (BigInt(allowed) > BigInt(totalAmount)) {
+      throw new Error(`Requested auth ${allowed} exceeds channel capacity ${totalAmount}`);
     }
 
-    async _approveToken(tokenAddress, spender, amount) {
-        const APPROVE_SELECTOR = "095ea7b3";
-        const calldata = "0x" +
-            APPROVE_SELECTOR +
-            this._encodeAddress(spender) +
-            this._encodeUint(amount);
-
-        const txParams = await this._buildTx(tokenAddress, calldata, 0);
-        const tx = await this.signer.sendTransaction(txParams);
-        await tx.wait();
-    }
-    async _getOnChainChannelAmount(channelId) {
-        const cleanId = channelId.replace("0x", "").padStart(64, "0");
-        const calldata = "0x831c2b82" + cleanId;
-
-        try {
-            const result = await this.rpc_client.call({
-                to: this.contractAddress,
-                data: calldata
-            });
-
-            if (result === "0x" || result.length < 322) {
-                throw new Error("Invalid getChannel response length");
-            }
-
-            // The amount is the 5th 32-byte word (index 4).
-            // Result is a hex string "0x...".
-            // Word 0: 2 to 66
-            // Word 1: 66 to 130
-            // Word 2: 130 to 194
-            // Word 3: 194 to 258
-            // Word 4: 258 to 322
-            const amountHex = "0x" + result.substring(258, 322);
-            return BigInt(amountHex).toString();
-        } catch (e) {
-            throw new Error(`Failed to retrieve on-chain channel amount: ${e.message}`);
-        }
+    if (!channelId.startsWith("0x")) {
+      channelId = "0x" + channelId;
     }
 
-    /**
-     * Generate a base64-encoded payment claim.
-     * @param {number|string|null} amount - Defaults to total channel capacity if null
-     * @returns {Promise<string>}
-     */
-    async getAuthToken(amount = null) {
-        await this._resolveAddresses();
-        // 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.");
-        }
-
-        let channelId = channelIdRaw;
-        if (!channelId.startsWith("0x")) {
-            channelId = "0x" + channelId;
-        }
-
-        const totalAmount = await this._getOnChainChannelAmount(channelId);
-        const allowed = amount !== null ? amount.toString() : totalAmount;
-
-        // BigInt comparison if needed, but for now simple check if it exceeds
-        if (BigInt(allowed) > BigInt(totalAmount)) {
-            throw new Error(`Requested auth ${allowed} exceeds channel capacity ${totalAmount}`);
-        }
-
-        if (!channelId.startsWith("0x")) {
-            channelId = "0x" + channelId;
-        }
-
-        const token = this.currency.tokenAddress || "0x0000000000000000000000000000000000000000";
-
-        const { domain, types, value } = getEthereumClaimTypedData(
-            channelId,
-            token,
-            allowed,
-            this.chainId,
-            this.contractAddress
-        );
-
-        const signature = await this.signer.signTypedData(domain, types, value);
-
-        const claim = {
-            version: "2",
-            account: await this.signer.getAddress(),
-            protocol: this.protocol,
-            currency: {
-                code: this.currency.code,
-                scale: this.currency.scale,
-                issuer: this.currency.tokenAddress || null
-            },
-            destination_account: this.destinationAddress,
-            authorized_to_claim: allowed,
-            channel_id: channelId,
-            signature: signature
-        };
-        return Buffer.from(JSON.stringify(claim)).toString("base64");
-    }
+    const token = this.currency.tokenAddress || "0x0000000000000000000000000000000000000000";
+
+    const { domain, types, value } = getEthereumClaimTypedData(
+      channelId,
+      token,
+      BigInt(allowed),
+      this.chainId,
+      this.contractAddress
+    );
+
+    const accountString = (await this.walletClient.getAddresses())[0];
+    const account = this.walletClient.account || accountString;
+    const signature = await this.walletClient.signTypedData({
+      account,
+      domain,
+      types,
+      primaryType: 'DhaliClaim',
+      message: value
+    });
+
+    const claim = {
+      version: "2",
+      account: accountString,
+      protocol: this.currency.network,
+      currency: {
+        code: this.currency.code,
+        scale: this.currency.scale,
+        issuer: this.currency.tokenAddress || null
+      },
+      destination_account: this.destinationAddress,
+      authorized_to_claim: allowed,
+      channel_id: channelId,
+      signature: signature
+    };
+    return Buffer.from(JSON.stringify(claim)).toString("base64");
+  }
 }
 
 module.exports = { DhaliEthChannelManager };
+

package/src/dhali/DhaliXrplChannelManager.js

@@ -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/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(

package/tests/DhaliEthChannelManager.test.js

@@ -1,27 +1,31 @@
 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");
 
 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 +37,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 +70,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 +78,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 +102,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 +116,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,7 +133,7 @@ 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();
@@ -148,18 +146,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 +166,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 +209,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 +228,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 +242,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();