@agether/sdk 1.2.0 → 1.2.1

package/dist/index.js

@@ -45,6 +45,7 @@ __export(index_exports, {
   InsufficientCreditError: () => InsufficientCreditError,
   LP_VAULT_ABI: () => LP_VAULT_ABI,
   MORPHO_CREDIT_ABI: () => MORPHO_CREDIT_ABI,
+  MorphoCreditClient: () => MorphoCreditClient,
   REPUTATION_CREDIT_ABI: () => REPUTATION_CREDIT_ABI,
   ScoringClient: () => ScoringClient,
   ScoringRejectedError: () => ScoringRejectedError,
@@ -1197,7 +1198,7 @@ function chainIdFromNetwork(network) {
   const m = network.match(/^eip155:(\d+)$/);
   return m ? Number(m[1]) : 1;
 }
-var X402Client = class {
+var _X402Client = class _X402Client {
   constructor(config) {
     this.config = config;
     const provider = new import_ethers4.ethers.JsonRpcProvider(config.rpcUrl);
@@ -1246,6 +1247,9 @@ var X402Client = class {
       console.log(`         amount  : ${requirements.amount} (atomic)`);
       console.log(`         asset   : ${requirements.asset}`);
       console.log(`         payTo   : ${requirements.payTo}`);
+      if (this.config.autoDraw && this.config.accountAddress && this.config.morphoCreditAddress) {
+        await this.ensureBalance(BigInt(requirements.amount));
+      }
       console.log("   [3/4] Signing EIP-3009 transferWithAuthorization\u2026");
       const paymentPayload = await this.buildPaymentPayload(requirements, resource, url);
       const paymentB64 = Buffer.from(JSON.stringify(paymentPayload)).toString("base64");
@@ -1406,6 +1410,43 @@ var X402Client = class {
       }
     };
   }
+  async ensureBalance(requiredAmount) {
+    const accountAddr = this.config.accountAddress;
+    const morphoAddr = this.config.morphoCreditAddress;
+    const provider = this.wallet.provider;
+    const usdcAddr = USDC_DOMAINS["eip155:8453"]?.address || USDC_DOMAINS["eip155:1"].address;
+    const usdc = new import_ethers4.ethers.Contract(usdcAddr, _X402Client.ERC20_BALANCE_ABI, provider);
+    const balance = await usdc.balanceOf(accountAddr);
+    const needed = requiredAmount + requiredAmount / 10n;
+    if (balance >= needed) return;
+    const deficit = needed - balance;
+    const minDraw = import_ethers4.ethers.parseUnits("10", 6);
+    const drawAmount = deficit > minDraw ? deficit : minDraw;
+    console.log(`   [auto-draw] USDC balance $${import_ethers4.ethers.formatUnits(balance, 6)} < needed $${import_ethers4.ethers.formatUnits(needed, 6)}`);
+    const morpho = new import_ethers4.ethers.Contract(morphoAddr, _X402Client.MORPHO_DRAW_ABI, provider);
+    let collateralAddr = null;
+    for (const addr of _X402Client.AUTO_DRAW_COLLATERALS) {
+      try {
+        const pos = await morpho.getPosition(accountAddr, addr);
+        if (pos.collateralAmount > 0n) {
+          collateralAddr = addr;
+          break;
+        }
+      } catch {
+        continue;
+      }
+    }
+    if (!collateralAddr) {
+      throw new Error("autoDraw failed: no collateral deposited in Morpho. Deposit collateral first.");
+    }
+    const account = new import_ethers4.ethers.Contract(accountAddr, _X402Client.AGENT_ACCOUNT_EXEC_ABI, this.wallet);
+    const morphoIface = new import_ethers4.ethers.Interface(_X402Client.MORPHO_DRAW_ABI);
+    const calldata = morphoIface.encodeFunctionData("drawWithCollateral", [collateralAddr, drawAmount]);
+    console.log(`   [auto-draw] Borrowing $${import_ethers4.ethers.formatUnits(drawAmount, 6)} from Morpho...`);
+    const tx = await account.execute(morphoAddr, 0, calldata);
+    await tx.wait();
+    console.log(`   [auto-draw] \u2713 Borrowed (tx: ${tx.hash.slice(0, 14)}\u2026)`);
+  }
   // ──────────── Risk check via our backend ────────────
   async riskCheck(paymentPayload, reqs) {
     try {
@@ -1437,17 +1478,387 @@ var X402Client = class {
     }
   }
 };
+// ──────────── Auto-draw (Flow 9) ────────────
+//
+// When autoDraw is enabled and the AgentAccount has insufficient USDC,
+// automatically borrow from Morpho credit line to cover the payment.
+_X402Client.MORPHO_DRAW_ABI = [
+  "function drawWithCollateral(address collateralToken, uint256 amount)",
+  "function getPosition(address account, address collateralToken) view returns (tuple(uint256 collateralAmount, uint256 borrowedAmount, uint256 borrowShares, bool isActive))"
+];
+_X402Client.AGENT_ACCOUNT_EXEC_ABI = [
+  "function execute(address target, uint256 value, bytes data) payable returns (bytes)"
+];
+_X402Client.ERC20_BALANCE_ABI = [
+  "function balanceOf(address) view returns (uint256)"
+];
+_X402Client.AUTO_DRAW_COLLATERALS = [
+  "0x4200000000000000000000000000000000000006",
+  // WETH
+  "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
+  // wstETH
+  "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22"
+  // cbETH
+];
+var X402Client = _X402Client;
 
-// src/clients/WalletClient.ts
+// src/clients/MorphoCreditClient.ts
 var import_ethers5 = require("ethers");
+var BASE_COLLATERALS = {
+  WETH: { symbol: "WETH", address: "0x4200000000000000000000000000000000000006", decimals: 18 },
+  wstETH: { symbol: "wstETH", address: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452", decimals: 18 },
+  cbETH: { symbol: "cbETH", address: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22", decimals: 18 }
+};
+var MorphoCreditClient = class {
+  constructor(config, collaterals) {
+    this.config = config;
+    const provider = new import_ethers5.ethers.JsonRpcProvider(config.rpcUrl);
+    this.signer = new import_ethers5.ethers.Wallet(config.privateKey, provider);
+    this.morpho = new import_ethers5.Contract(config.contracts.morphoCredit, MORPHO_CREDIT_ABI, this.signer);
+    this.factory = new import_ethers5.Contract(config.contracts.accountFactory, ACCOUNT_FACTORY_ABI, this.signer);
+    this.collaterals = collaterals || BASE_COLLATERALS;
+  }
+  // ── Helpers ──
+  resolveToken(tokenSymbol) {
+    const token = this.collaterals[tokenSymbol];
+    if (!token) {
+      throw new Error(`Unsupported collateral token: ${tokenSymbol}. Supported: ${Object.keys(this.collaterals).join(", ")}`);
+    }
+    return token;
+  }
+  /**
+   * Get the AgentAccount address for the configured agentId.
+   */
+  async getAccountAddress() {
+    if (this.accountAddress) return this.accountAddress;
+    const addr = await this.factory.getAccount(this.config.agentId.toString());
+    if (addr === import_ethers5.ethers.ZeroAddress) {
+      throw new Error("No AgentAccount found. Register first.");
+    }
+    this.accountAddress = addr;
+    return addr;
+  }
+  /**
+   * Get the AgentAccount address for any agentId.
+   */
+  async getAccountForAgent(agentId) {
+    const addr = await this.factory.getAccount(agentId.toString());
+    if (addr === import_ethers5.ethers.ZeroAddress) {
+      throw new Error(`No AgentAccount for agent #${agentId}`);
+    }
+    return addr;
+  }
+  async ensureCreditProvider(accountAddr) {
+    const account = new import_ethers5.Contract(accountAddr, AGENT_ACCOUNT_ABI, this.signer);
+    try {
+      const tx = await account.approveCreditProvider(this.config.contracts.morphoCredit);
+      await tx.wait();
+    } catch {
+    }
+  }
+  async approveAndDeposit(accountAddr, tokenInfo, amount) {
+    const token = new import_ethers5.Contract(tokenInfo.address, ERC20_ABI, this.signer);
+    const balance = await token.balanceOf(this.signer.address);
+    if (balance < amount) {
+      throw new Error(
+        `Insufficient ${tokenInfo.symbol}: have ${import_ethers5.ethers.formatUnits(balance, tokenInfo.decimals)}, need ${import_ethers5.ethers.formatUnits(amount, tokenInfo.decimals)}`
+      );
+    }
+    const approveTx = await token.approve(this.config.contracts.morphoCredit, amount);
+    await approveTx.wait();
+    const depositTx = await this.morpho.depositCollateralFor(accountAddr, tokenInfo.address, amount);
+    await depositTx.wait();
+    return depositTx.hash;
+  }
+  async executeBorrow(accountAddr, collateralAddr, borrowAmount) {
+    const account = new import_ethers5.Contract(accountAddr, AGENT_ACCOUNT_ABI, this.signer);
+    const iface = new import_ethers5.ethers.Interface(MORPHO_CREDIT_ABI);
+    const calldata = iface.encodeFunctionData("drawWithCollateral", [collateralAddr, borrowAmount]);
+    const tx = await account.execute(this.config.contracts.morphoCredit, 0, calldata);
+    await tx.wait();
+    return tx.hash;
+  }
+  // ══════════════════════════════════════════
+  //  Flow 3: Deposit collateral only
+  // ══════════════════════════════════════════
+  /**
+   * Deposit collateral from EOA into Morpho for own AgentAccount.
+   * Does NOT borrow — use `borrow()` or `depositAndBorrow()` for that.
+   *
+   * @param tokenSymbol - Collateral token (WETH, wstETH, cbETH)
+   * @param amount - Human-readable amount (e.g. "0.05")
+   */
+  async deposit(tokenSymbol, amount) {
+    const tokenInfo = this.resolveToken(tokenSymbol);
+    const amountWei = import_ethers5.ethers.parseUnits(amount, tokenInfo.decimals);
+    const accountAddr = await this.getAccountAddress();
+    const txHash = await this.approveAndDeposit(accountAddr, tokenInfo, amountWei);
+    await this.ensureCreditProvider(accountAddr);
+    const pos = await this.morpho.getPosition(accountAddr, tokenInfo.address);
+    return {
+      tx: txHash,
+      amount: amountWei,
+      token: tokenSymbol,
+      agentAccount: accountAddr,
+      totalCollateral: pos.collateralAmount
+    };
+  }
+  // ══════════════════════════════════════════
+  //  Flow 2: Deposit + borrow in one call
+  // ══════════════════════════════════════════
+  /**
+   * Deposit collateral AND borrow USDC in a single SDK call.
+   * USDC lands in the AgentAccount.
+   *
+   * @param tokenSymbol - Collateral token (WETH, wstETH, cbETH)
+   * @param collateralAmount - Human-readable collateral amount (e.g. "0.05")
+   * @param borrowAmount - Human-readable USDC amount to borrow (e.g. "50")
+   */
+  async depositAndBorrow(tokenSymbol, collateralAmount, borrowAmount) {
+    const tokenInfo = this.resolveToken(tokenSymbol);
+    const collateralWei = import_ethers5.ethers.parseUnits(collateralAmount, tokenInfo.decimals);
+    const borrowWei = import_ethers5.ethers.parseUnits(borrowAmount, 6);
+    const accountAddr = await this.getAccountAddress();
+    const depositTxHash = await this.approveAndDeposit(accountAddr, tokenInfo, collateralWei);
+    await this.ensureCreditProvider(accountAddr);
+    const borrowTxHash = await this.executeBorrow(accountAddr, tokenInfo.address, borrowWei);
+    const totalDebt = await this.morpho.getTotalDebt(accountAddr);
+    return {
+      depositTx: depositTxHash,
+      borrowTx: borrowTxHash,
+      collateral: { amount: collateralWei, token: tokenSymbol },
+      borrowed: borrowWei,
+      agentAccount: accountAddr,
+      totalDebt
+    };
+  }
+  // ══════════════════════════════════════════
+  //  Flow 8: Borrow against existing collateral
+  // ══════════════════════════════════════════
+  /**
+   * Borrow USDC against already-deposited collateral.
+   * Auto-detects which collateral token has a position.
+   * USDC lands in AgentAccount — ready for x402 payments.
+   *
+   * @param amount - Human-readable USDC amount (e.g. "100")
+   */
+  async borrow(amount) {
+    const borrowWei = import_ethers5.ethers.parseUnits(amount, 6);
+    const accountAddr = await this.getAccountAddress();
+    let activeToken = null;
+    for (const info of Object.values(this.collaterals)) {
+      const pos = await this.morpho.getPosition(accountAddr, info.address);
+      if (pos.collateralAmount > 0n) {
+        activeToken = info;
+        break;
+      }
+    }
+    if (!activeToken) {
+      throw new Error("No collateral deposited. Use deposit() or depositAndBorrow() first.");
+    }
+    const txHash = await this.executeBorrow(accountAddr, activeToken.address, borrowWei);
+    const totalDebt = await this.morpho.getTotalDebt(accountAddr);
+    return {
+      tx: txHash,
+      amount: borrowWei,
+      agentAccount: accountAddr,
+      totalDebt,
+      collateralToken: activeToken.symbol
+    };
+  }
+  // ══════════════════════════════════════════
+  //  Flows 4-7: Sponsor (deposit for another agent)
+  // ══════════════════════════════════════════
+  /**
+   * Deposit collateral for another agent. Caller pays from their wallet.
+   * Optionally borrow USDC for the agent (only works if caller owns the AgentAccount).
+   *
+   * Supports both agentId lookup and direct address.
+   *
+   * @param target - `{ agentId: "17676" }` or `{ address: "0x..." }`
+   * @param tokenSymbol - Collateral token
+   * @param amount - Human-readable collateral amount
+   * @param borrowAmount - Optional: USDC to borrow (only if caller is owner)
+   */
+  async sponsor(target, tokenSymbol, amount, borrowAmount) {
+    const tokenInfo = this.resolveToken(tokenSymbol);
+    const collateralWei = import_ethers5.ethers.parseUnits(amount, tokenInfo.decimals);
+    let accountAddr;
+    let targetAgentId;
+    if ("agentId" in target) {
+      targetAgentId = target.agentId.toString();
+      accountAddr = await this.getAccountForAgent(target.agentId);
+    } else {
+      accountAddr = target.address;
+    }
+    const depositTxHash = await this.approveAndDeposit(accountAddr, tokenInfo, collateralWei);
+    const result = {
+      depositTx: depositTxHash,
+      targetAccount: accountAddr,
+      targetAgentId,
+      collateral: { amount: collateralWei, token: tokenSymbol },
+      totalCollateral: 0n,
+      totalDebt: 0n
+    };
+    if (borrowAmount) {
+      const borrowWei = import_ethers5.ethers.parseUnits(borrowAmount, 6);
+      try {
+        await this.ensureCreditProvider(accountAddr);
+        const borrowTxHash = await this.executeBorrow(accountAddr, tokenInfo.address, borrowWei);
+        result.borrowTx = borrowTxHash;
+        result.borrowed = borrowWei;
+      } catch (e) {
+        throw new Error(`Borrow failed (caller may not own this AgentAccount): ${e.message}`);
+      }
+    }
+    const pos = await this.morpho.getPosition(accountAddr, tokenInfo.address);
+    result.totalCollateral = pos.collateralAmount;
+    result.totalDebt = pos.borrowedAmount;
+    return result;
+  }
+  // ══════════════════════════════════════════
+  //  Repay & Withdraw
+  // ══════════════════════════════════════════
+  /**
+   * Repay borrowed USDC from AgentAccount back to Morpho.
+   *
+   * @param amount - Human-readable USDC amount (e.g. "50")
+   */
+  async repay(amount) {
+    const amountWei = import_ethers5.ethers.parseUnits(amount, 6);
+    const accountAddr = await this.getAccountAddress();
+    let collateralAddr = null;
+    for (const info of Object.values(this.collaterals)) {
+      const pos = await this.morpho.getPosition(accountAddr, info.address);
+      if (pos.borrowedAmount > 0n) {
+        collateralAddr = info.address;
+        break;
+      }
+    }
+    if (!collateralAddr) throw new Error("No Morpho debt to repay.");
+    const usdc = new import_ethers5.Contract(this.config.contracts.usdc, ERC20_ABI, this.signer.provider);
+    const balance = await usdc.balanceOf(accountAddr);
+    if (balance < amountWei) {
+      throw new Error(`Insufficient USDC in AgentAccount: $${import_ethers5.ethers.formatUnits(balance, 6)}`);
+    }
+    const account = new import_ethers5.Contract(accountAddr, AGENT_ACCOUNT_ABI, this.signer);
+    const erc20Iface = new import_ethers5.ethers.Interface(ERC20_ABI);
+    const morphoIface = new import_ethers5.ethers.Interface(MORPHO_CREDIT_ABI);
+    const approveData = erc20Iface.encodeFunctionData("approve", [this.config.contracts.morphoCredit, amountWei]);
+    const approveTx = await account.execute(this.config.contracts.usdc, 0, approveData);
+    await approveTx.wait();
+    const repayData = morphoIface.encodeFunctionData("repayWithCollateral", [collateralAddr, amountWei]);
+    const tx = await account.execute(this.config.contracts.morphoCredit, 0, repayData);
+    await tx.wait();
+    const totalDebt = await this.morpho.getTotalDebt(accountAddr);
+    return { tx: tx.hash, amount: amountWei, remainingDebt: totalDebt };
+  }
+  /**
+   * Withdraw collateral from Morpho back to EOA.
+   *
+   * @param tokenSymbol - Collateral token
+   * @param amount - Human-readable amount or "all"
+   */
+  async withdraw(tokenSymbol, amount) {
+    const tokenInfo = this.resolveToken(tokenSymbol);
+    const accountAddr = await this.getAccountAddress();
+    const pos = await this.morpho.getPosition(accountAddr, tokenInfo.address);
+    if (pos.collateralAmount === 0n) {
+      throw new Error(`No ${tokenSymbol} collateral deposited.`);
+    }
+    const withdrawAmount = amount.toLowerCase() === "all" ? pos.collateralAmount : import_ethers5.ethers.parseUnits(amount, tokenInfo.decimals);
+    if (withdrawAmount > pos.collateralAmount) {
+      throw new Error(
+        `Cannot withdraw more than deposited: max ${import_ethers5.ethers.formatUnits(pos.collateralAmount, tokenInfo.decimals)} ${tokenSymbol}`
+      );
+    }
+    const account = new import_ethers5.Contract(accountAddr, AGENT_ACCOUNT_ABI, this.signer);
+    const morphoIface = new import_ethers5.ethers.Interface(MORPHO_CREDIT_ABI);
+    const withdrawData = morphoIface.encodeFunctionData("withdrawCollateral", [tokenInfo.address, withdrawAmount]);
+    const tx1 = await account.execute(this.config.contracts.morphoCredit, 0, withdrawData);
+    await tx1.wait();
+    const erc20Iface = new import_ethers5.ethers.Interface(ERC20_ABI);
+    const transferData = erc20Iface.encodeFunctionData("transfer", [this.signer.address, withdrawAmount]);
+    const tx2 = await account.execute(tokenInfo.address, 0, transferData);
+    await tx2.wait();
+    const newPos = await this.morpho.getPosition(accountAddr, tokenInfo.address);
+    return {
+      tx: tx1.hash,
+      amount: withdrawAmount,
+      token: tokenSymbol,
+      destination: this.signer.address,
+      remainingCollateral: newPos.collateralAmount
+    };
+  }
+  // ══════════════════════════════════════════
+  //  View methods
+  // ══════════════════════════════════════════
+  /**
+   * Get position for a specific collateral token.
+   */
+  async getPosition(tokenSymbol) {
+    const tokenInfo = this.resolveToken(tokenSymbol);
+    const accountAddr = await this.getAccountAddress();
+    const pos = await this.morpho.getPosition(accountAddr, tokenInfo.address);
+    return {
+      token: tokenSymbol,
+      collateralAmount: pos.collateralAmount,
+      borrowedAmount: pos.borrowedAmount,
+      borrowShares: pos.borrowShares,
+      isActive: pos.isActive
+    };
+  }
+  /**
+   * Get all active positions across all collateral tokens.
+   */
+  async getAllPositions() {
+    const accountAddr = await this.getAccountAddress();
+    const positions = [];
+    for (const [symbol, info] of Object.entries(this.collaterals)) {
+      const pos = await this.morpho.getPosition(accountAddr, info.address);
+      if (pos.isActive || pos.collateralAmount > 0n || pos.borrowedAmount > 0n) {
+        positions.push({
+          token: symbol,
+          collateralAmount: pos.collateralAmount,
+          borrowedAmount: pos.borrowedAmount,
+          borrowShares: pos.borrowShares,
+          isActive: pos.isActive
+        });
+      }
+    }
+    return positions;
+  }
+  /**
+   * Get total debt across all positions.
+   */
+  async getTotalDebt() {
+    const accountAddr = await this.getAccountAddress();
+    return this.morpho.getTotalDebt(accountAddr);
+  }
+  /**
+   * Get USDC balance in the AgentAccount.
+   */
+  async getAccountUSDC() {
+    const accountAddr = await this.getAccountAddress();
+    const usdc = new import_ethers5.Contract(this.config.contracts.usdc, ERC20_ABI, this.signer.provider);
+    return usdc.balanceOf(accountAddr);
+  }
+  /** Get the wallet (signer) address */
+  getAddress() {
+    return this.signer.address;
+  }
+};
+
+// src/clients/WalletClient.ts
+var import_ethers6 = require("ethers");
 var WalletClient = class {
   constructor(config) {
     this.privateKey = null;
     this.factoryAddress = config.factoryAddress;
-    this.usdcAddress = config.usdcAddress || import_ethers5.ethers.ZeroAddress;
+    this.usdcAddress = config.usdcAddress || import_ethers6.ethers.ZeroAddress;
     this.chainId = config.chainId;
     this.rpcUrl = config.rpcUrl;
-    this.provider = new import_ethers5.ethers.JsonRpcProvider(config.rpcUrl);
+    this.provider = new import_ethers6.ethers.JsonRpcProvider(config.rpcUrl);
     this.privateKey = config.privateKey || null;
   }
   /**
@@ -1457,20 +1868,20 @@ var WalletClient = class {
     if (!this.privateKey) {
       throw new Error("Signer not configured - provide privateKey");
     }
-    const freshProvider = new import_ethers5.ethers.JsonRpcProvider(this.rpcUrl);
-    return new import_ethers5.Wallet(this.privateKey, freshProvider);
+    const freshProvider = new import_ethers6.ethers.JsonRpcProvider(this.rpcUrl);
+    return new import_ethers6.Wallet(this.privateKey, freshProvider);
   }
   getFactoryContract() {
     if (this.privateKey) {
-      return new import_ethers5.Contract(this.factoryAddress, ACCOUNT_FACTORY_ABI, this.getFreshSigner());
+      return new import_ethers6.Contract(this.factoryAddress, ACCOUNT_FACTORY_ABI, this.getFreshSigner());
     }
-    return new import_ethers5.Contract(this.factoryAddress, ACCOUNT_FACTORY_ABI, this.provider);
+    return new import_ethers6.Contract(this.factoryAddress, ACCOUNT_FACTORY_ABI, this.provider);
   }
   getAccountContract(accountAddress) {
     if (this.privateKey) {
-      return new import_ethers5.Contract(accountAddress, AGENT_ACCOUNT_ABI, this.getFreshSigner());
+      return new import_ethers6.Contract(accountAddress, AGENT_ACCOUNT_ABI, this.getFreshSigner());
     }
-    return new import_ethers5.Contract(accountAddress, AGENT_ACCOUNT_ABI, this.provider);
+    return new import_ethers6.Contract(accountAddress, AGENT_ACCOUNT_ABI, this.provider);
   }
   getChainId() {
     return this.chainId;
@@ -1483,7 +1894,7 @@ var WalletClient = class {
   async getAccount(agentId) {
     const factory = this.getFactoryContract();
     const address = await factory.getAccount(agentId);
-    if (address === import_ethers5.ethers.ZeroAddress) {
+    if (address === import_ethers6.ethers.ZeroAddress) {
       return null;
     }
     return address;
@@ -1518,7 +1929,7 @@ var WalletClient = class {
       account.ethBalance()
     ]);
     let usdcBalance = 0n;
-    if (this.usdcAddress !== import_ethers5.ethers.ZeroAddress) {
+    if (this.usdcAddress !== import_ethers6.ethers.ZeroAddress) {
       usdcBalance = await account.balanceOf(this.usdcAddress);
     }
     return {
@@ -1530,7 +1941,7 @@ var WalletClient = class {
     };
   }
   async getProviderStatus(accountAddress, creditProvider) {
-    const provider = new import_ethers5.Contract(
+    const provider = new import_ethers6.Contract(
       creditProvider,
       CREDIT_PROVIDER_ABI,
       this.provider
@@ -1553,11 +1964,11 @@ var WalletClient = class {
       throw new Error("Signer not configured");
     }
     const signer = this.getFreshSigner();
-    const token = new import_ethers5.Contract(tokenAddress, ERC20_ABI, signer);
+    const token = new import_ethers6.Contract(tokenAddress, ERC20_ABI, signer);
     const approveTx = await token.approve(accountAddress, amount);
     await approveTx.wait();
     const signer2 = this.getFreshSigner();
-    const account = new import_ethers5.Contract(accountAddress, AGENT_ACCOUNT_ABI, signer2);
+    const account = new import_ethers6.Contract(accountAddress, AGENT_ACCOUNT_ABI, signer2);
     const tx = await account.fund(tokenAddress, amount);
     const receipt = await tx.wait();
     return receipt.hash;
@@ -1603,8 +2014,8 @@ var WalletClient = class {
   }
   // ============ Utility ============
   generatePaymentMessageHash(accountAddress, recipient, amount, nonce, deadline, chainId) {
-    return import_ethers5.ethers.keccak256(
-      import_ethers5.ethers.AbiCoder.defaultAbiCoder().encode(
+    return import_ethers6.ethers.keccak256(
+      import_ethers6.ethers.AbiCoder.defaultAbiCoder().encode(
         ["address", "uint256", "uint256", "uint256", "uint256", "address"],
         [recipient, amount, nonce, deadline, chainId, accountAddress]
       )
@@ -1671,6 +2082,7 @@ function rateToBps(rate) {
   InsufficientCreditError,
   LP_VAULT_ABI,
   MORPHO_CREDIT_ABI,
+  MorphoCreditClient,
   REPUTATION_CREDIT_ABI,
   ScoringClient,
   ScoringRejectedError,