@agether/sdk 1.2.0 → 1.3.0

package/dist/index.mjs

@@ -79,6 +79,7 @@ var AGENT_ACCOUNT_ABI = [
   "function balanceOf(address token) view returns (uint256)",
   "function ethBalance() view returns (uint256)",
   "function execute(address target, uint256 value, bytes data) payable returns (bytes)",
+  "function executeBatch(address[] targets, uint256[] values, bytes[] datas) payable returns (bytes[])",
   "function drawCredit(address creditProvider, uint256 amount)",
   "function repayCredit(address creditProvider, uint256 amount)",
   "function fund(address token, uint256 amount)",
@@ -1127,7 +1128,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 ethers3.JsonRpcProvider(config.rpcUrl);
@@ -1176,6 +1177,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");
@@ -1336,6 +1340,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 ethers3.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 = ethers3.parseUnits("10", 6);
+    const drawAmount = deficit > minDraw ? deficit : minDraw;
+    console.log(`   [auto-draw] USDC balance $${ethers3.formatUnits(balance, 6)} < needed $${ethers3.formatUnits(needed, 6)}`);
+    const morpho = new ethers3.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 ethers3.Contract(accountAddr, _X402Client.AGENT_ACCOUNT_EXEC_ABI, this.wallet);
+    const morphoIface = new ethers3.Interface(_X402Client.MORPHO_DRAW_ABI);
+    const calldata = morphoIface.encodeFunctionData("drawWithCollateral", [collateralAddr, drawAmount]);
+    console.log(`   [auto-draw] Borrowing $${ethers3.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 {
@@ -1367,17 +1408,417 @@ 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/MorphoCreditClient.ts
+import { ethers as ethers4, Contract as Contract3 } from "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) {
+    // ── Batch helper ──
+    this.morphoIface = new ethers4.Interface(MORPHO_CREDIT_ABI);
+    this.erc20Iface = new ethers4.Interface(ERC20_ABI);
+    this.config = config;
+    const provider = new ethers4.JsonRpcProvider(config.rpcUrl);
+    this.signer = new ethers4.Wallet(config.privateKey, provider);
+    this.morpho = new Contract3(config.contracts.morphoCredit, MORPHO_CREDIT_ABI, this.signer);
+    this.factory = new Contract3(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 === ethers4.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 === ethers4.ZeroAddress) {
+      throw new Error(`No AgentAccount for agent #${agentId}`);
+    }
+    return addr;
+  }
+  async ensureCreditProvider(accountAddr) {
+    const account = new Contract3(accountAddr, AGENT_ACCOUNT_ABI, this.signer);
+    try {
+      const tx = await account.approveCreditProvider(this.config.contracts.morphoCredit);
+      await tx.wait();
+    } catch {
+    }
+  }
+  /**
+   * Approve ERC-20 token from EOA → MorphoCredit, then deposit for account.
+   * This is 2 EOA txs (approve + depositCollateralFor) — cannot be batched
+   * because both are called from EOA, not from AgentAccount.
+   */
+  async approveAndDeposit(accountAddr, tokenInfo, amount) {
+    const token = new Contract3(tokenInfo.address, ERC20_ABI, this.signer);
+    const balance = await token.balanceOf(this.signer.address);
+    if (balance < amount) {
+      throw new Error(
+        `Insufficient ${tokenInfo.symbol}: have ${ethers4.formatUnits(balance, tokenInfo.decimals)}, need ${ethers4.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;
+  }
+  /**
+   * Execute multiple calls via AgentAccount.executeBatch() in a single tx.
+   * Each call is { target, value, data }.
+   */
+  async batch(accountAddr, calls) {
+    const account = new Contract3(accountAddr, AGENT_ACCOUNT_ABI, this.signer);
+    const tx = await account.executeBatch(
+      calls.map((c) => c.target),
+      calls.map((c) => c.value),
+      calls.map((c) => c.data)
+    );
+    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 = ethers4.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 = ethers4.parseUnits(collateralAmount, tokenInfo.decimals);
+    const borrowWei = ethers4.parseUnits(borrowAmount, 6);
+    const accountAddr = await this.getAccountAddress();
+    const depositTxHash = await this.approveAndDeposit(accountAddr, tokenInfo, collateralWei);
+    await this.ensureCreditProvider(accountAddr);
+    const account = new Contract3(accountAddr, AGENT_ACCOUNT_ABI, this.signer);
+    const calldata = this.morphoIface.encodeFunctionData("drawWithCollateral", [tokenInfo.address, borrowWei]);
+    const borrowTx = await account.execute(this.config.contracts.morphoCredit, 0, calldata);
+    await borrowTx.wait();
+    const totalDebt = await this.morpho.getTotalDebt(accountAddr);
+    return {
+      depositTx: depositTxHash,
+      borrowTx: borrowTx.hash,
+      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 = ethers4.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.");
+    }
+    await this.ensureCreditProvider(accountAddr);
+    const account = new Contract3(accountAddr, AGENT_ACCOUNT_ABI, this.signer);
+    const calldata = this.morphoIface.encodeFunctionData("drawWithCollateral", [activeToken.address, borrowWei]);
+    const tx = await account.execute(this.config.contracts.morphoCredit, 0, calldata);
+    await tx.wait();
+    const totalDebt = await this.morpho.getTotalDebt(accountAddr);
+    return {
+      tx: tx.hash,
+      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 = ethers4.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 = ethers4.parseUnits(borrowAmount, 6);
+      try {
+        await this.ensureCreditProvider(accountAddr);
+        const account = new Contract3(accountAddr, AGENT_ACCOUNT_ABI, this.signer);
+        const calldata = this.morphoIface.encodeFunctionData("drawWithCollateral", [tokenInfo.address, borrowWei]);
+        const tx = await account.execute(this.config.contracts.morphoCredit, 0, calldata);
+        await tx.wait();
+        result.borrowTx = tx.hash;
+        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 = ethers4.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 Contract3(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: $${ethers4.formatUnits(balance, 6)}`);
+    }
+    const txHash = await this.batch(accountAddr, [
+      {
+        target: this.config.contracts.usdc,
+        value: 0n,
+        data: this.erc20Iface.encodeFunctionData("approve", [this.config.contracts.morphoCredit, amountWei])
+      },
+      {
+        target: this.config.contracts.morphoCredit,
+        value: 0n,
+        data: this.morphoIface.encodeFunctionData("repayWithCollateral", [collateralAddr, amountWei])
+      }
+    ]);
+    const totalDebt = await this.morpho.getTotalDebt(accountAddr);
+    return { tx: txHash, 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 : ethers4.parseUnits(amount, tokenInfo.decimals);
+    if (withdrawAmount > pos.collateralAmount) {
+      throw new Error(
+        `Cannot withdraw more than deposited: max ${ethers4.formatUnits(pos.collateralAmount, tokenInfo.decimals)} ${tokenSymbol}`
+      );
+    }
+    const txHash = await this.batch(accountAddr, [
+      {
+        target: this.config.contracts.morphoCredit,
+        value: 0n,
+        data: this.morphoIface.encodeFunctionData("withdrawCollateral", [tokenInfo.address, withdrawAmount])
+      },
+      {
+        target: tokenInfo.address,
+        value: 0n,
+        data: this.erc20Iface.encodeFunctionData("transfer", [this.signer.address, withdrawAmount])
+      }
+    ]);
+    const newPos = await this.morpho.getPosition(accountAddr, tokenInfo.address);
+    return {
+      tx: txHash,
+      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 Contract3(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
-import { ethers as ethers4, Contract as Contract3, Wallet } from "ethers";
+import { ethers as ethers5, Contract as Contract4, Wallet } from "ethers";
 var WalletClient = class {
   constructor(config) {
     this.privateKey = null;
     this.factoryAddress = config.factoryAddress;
-    this.usdcAddress = config.usdcAddress || ethers4.ZeroAddress;
+    this.usdcAddress = config.usdcAddress || ethers5.ZeroAddress;
     this.chainId = config.chainId;
     this.rpcUrl = config.rpcUrl;
-    this.provider = new ethers4.JsonRpcProvider(config.rpcUrl);
+    this.provider = new ethers5.JsonRpcProvider(config.rpcUrl);
     this.privateKey = config.privateKey || null;
   }
   /**
@@ -1387,20 +1828,20 @@ var WalletClient = class {
     if (!this.privateKey) {
       throw new Error("Signer not configured - provide privateKey");
     }
-    const freshProvider = new ethers4.JsonRpcProvider(this.rpcUrl);
+    const freshProvider = new ethers5.JsonRpcProvider(this.rpcUrl);
     return new Wallet(this.privateKey, freshProvider);
   }
   getFactoryContract() {
     if (this.privateKey) {
-      return new Contract3(this.factoryAddress, ACCOUNT_FACTORY_ABI, this.getFreshSigner());
+      return new Contract4(this.factoryAddress, ACCOUNT_FACTORY_ABI, this.getFreshSigner());
     }
-    return new Contract3(this.factoryAddress, ACCOUNT_FACTORY_ABI, this.provider);
+    return new Contract4(this.factoryAddress, ACCOUNT_FACTORY_ABI, this.provider);
   }
   getAccountContract(accountAddress) {
     if (this.privateKey) {
-      return new Contract3(accountAddress, AGENT_ACCOUNT_ABI, this.getFreshSigner());
+      return new Contract4(accountAddress, AGENT_ACCOUNT_ABI, this.getFreshSigner());
     }
-    return new Contract3(accountAddress, AGENT_ACCOUNT_ABI, this.provider);
+    return new Contract4(accountAddress, AGENT_ACCOUNT_ABI, this.provider);
   }
   getChainId() {
     return this.chainId;
@@ -1413,7 +1854,7 @@ var WalletClient = class {
   async getAccount(agentId) {
     const factory = this.getFactoryContract();
     const address = await factory.getAccount(agentId);
-    if (address === ethers4.ZeroAddress) {
+    if (address === ethers5.ZeroAddress) {
       return null;
     }
     return address;
@@ -1448,7 +1889,7 @@ var WalletClient = class {
       account.ethBalance()
     ]);
     let usdcBalance = 0n;
-    if (this.usdcAddress !== ethers4.ZeroAddress) {
+    if (this.usdcAddress !== ethers5.ZeroAddress) {
       usdcBalance = await account.balanceOf(this.usdcAddress);
     }
     return {
@@ -1460,7 +1901,7 @@ var WalletClient = class {
     };
   }
   async getProviderStatus(accountAddress, creditProvider) {
-    const provider = new Contract3(
+    const provider = new Contract4(
       creditProvider,
       CREDIT_PROVIDER_ABI,
       this.provider
@@ -1483,11 +1924,11 @@ var WalletClient = class {
       throw new Error("Signer not configured");
     }
     const signer = this.getFreshSigner();
-    const token = new Contract3(tokenAddress, ERC20_ABI, signer);
+    const token = new Contract4(tokenAddress, ERC20_ABI, signer);
     const approveTx = await token.approve(accountAddress, amount);
     await approveTx.wait();
     const signer2 = this.getFreshSigner();
-    const account = new Contract3(accountAddress, AGENT_ACCOUNT_ABI, signer2);
+    const account = new Contract4(accountAddress, AGENT_ACCOUNT_ABI, signer2);
     const tx = await account.fund(tokenAddress, amount);
     const receipt = await tx.wait();
     return receipt.hash;
@@ -1533,8 +1974,8 @@ var WalletClient = class {
   }
   // ============ Utility ============
   generatePaymentMessageHash(accountAddress, recipient, amount, nonce, deadline, chainId) {
-    return ethers4.keccak256(
-      ethers4.AbiCoder.defaultAbiCoder().encode(
+    return ethers5.keccak256(
+      ethers5.AbiCoder.defaultAbiCoder().encode(
         ["address", "uint256", "uint256", "uint256", "uint256", "address"],
         [recipient, amount, nonce, deadline, chainId, accountAddress]
       )
@@ -1600,6 +2041,7 @@ export {
   InsufficientCreditError,
   LP_VAULT_ABI,
   MORPHO_CREDIT_ABI,
+  MorphoCreditClient,
   REPUTATION_CREDIT_ABI,
   ScoringClient,
   ScoringRejectedError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agether/sdk",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "TypeScript SDK for Agether - autonomous credit for AI agents on Base",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/dist/cli.d.mts

@@ -1,2 +0,0 @@
-
-export {  }

package/dist/cli.d.ts

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-/**
- * Agether CLI — Direct On-Chain Credit for AI Agents
- *
- * All commands sign transactions directly with the agent's private key.
- * No simulation routes. No mocks. Production-grade.
- *
- * Usage:
- *   agether init <private-key>                # Initialize with private key
- *   agether register [--name] [--code-url]    # Register on real ERC-8004 + KYA
- *   agether apply --limit 10000               # Apply for $10,000 credit (on-chain)
- *   agether draw --amount 1000                # Draw $1,000 (on-chain)
- *   agether repay --amount 500                # Repay $500 (on-chain)
- *   agether status                            # Check credit line status (on-chain)
- *   agether score                             # Get credit score (backend)
- *   agether balance                           # Check ETH + USDC balances (on-chain)
- */
-export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;GAeG"}