@1delta/margin-fetcher 0.0.277 → 0.0.279

package/README.md

@@ -195,3 +195,107 @@ Lista is a Morpho Blue fork with additional per-market fields. Uses a 357-byte b
 | `broker` | address | Authorized broker contract |
 
 User data also includes per-market whitelist flags prepended before the balance records.
+
+### Fixed-term broker (`LendingBroker`)
+
+Some Lista markets register a **`LendingBroker`** — the mandatory debt-side gateway of a Moolah
+(Morpho-fork) market. Collateral supply/withdraw still go through the normal Moolah path, but
+**borrow and repay run through the broker**, which overlays a richer debt model on top of the raw
+Moolah position. The on-chain broker is an ERC1967 proxy (e.g. BNB `0x1Fa2…8b54` → impl `0xb680…58bb`),
+verified source `LendingBroker.sol` / `BrokerMath.sol`. Fetcher support lives in
+[`lending/public-data/lista/listaBroker.ts`](src/lending/public-data/lista/listaBroker.ts); the composer
+encoders live in `contracts-delegation` (`ListaBrokerLending.sol`, `CalldataLib.encodeListaBroker*`).
+
+**Two debt buckets per user.** A brokered market has **no flexible/variable borrowing** at the
+Moolah layer — instead each user holds:
+
+- **N fixed-term positions** — each a `{posId, principal, apr, start, end, …}` tranche with a *locked*
+  APR and a maturity. Identified by `posId`.
+- **One dynamic position** — a variable-rate position, the catch-all bucket. Targeted on repay by the
+  sentinel `posId == type(uint128).max` (`LISTA_BROKER_DYNAMIC_POS`).
+
+`broker.getUserTotalDebt(user)` is the authoritative total (fixed + dynamic + all interest).
+
+#### Borrow
+
+The composer calls `borrow(amount, termId, user, receiver)`. `user` (the position owner) is **always
+the authenticated caller** and must have authorized the composer in Moolah (`setAuthorization`) — debt
+can never be opened against someone else. The broker borrows from Moolah and forwards the loan token to
+`receiver`.
+
+> **Native:** the broker *can* unwrap WBNB→BNB, but only on its EOA-direct `borrow(amount)` /
+> `borrow(amount, termId)` overloads that pay `msg.sender`. The `receiver`-variant the composer must use
+> (Moolah requires `receiver == broker` when a broker is registered) **always sends ERC20 WBNB, never
+> native**. To deliver native BNB, chain an unwrap step after the borrow.
+
+#### Repay
+
+`encodeListaBrokerRepay(loanToken, assets, native, broker, posId, onBehalf)` →
+`repay(amount, posId, onBehalf)` (fixed) or `repay(amount, onBehalf)` (dynamic, sentinel `posId`).
+
+- **Interest-first, then principal.**
+- **`onBehalf`** is taken straight from calldata (exactly like Morpho's repay `onBehalfOf`) — repaying
+  only ever pays debt down and refunds excess to the composer, so **repay-on-behalf is permissionless**.
+  Must be non-zero (broker reverts `ZeroAddress`); there is no caller fallback.
+- **`assets == 0`** repays the composer's full balance (`balanceOf` / `selfbalance`); the broker refunds
+  any excess. The clean "close it out" pattern: over-fund slightly, repay with `assets == 0`, take the dust.
+- **Native:** both repay overloads are `payable` and wrap `msg.value` internally (gated on
+  `LOAN_TOKEN == WBNB`, else `NativeNotSupported`). The composer's native path forwards the value and
+  skips the ERC20 approve. Excess refunds as native BNB to the composer (un-swept on explicit amounts).
+
+#### Early-repayment penalty
+
+Repaying a fixed position's **principal before `end`** incurs a penalty
+(`BrokerMath.getPenaltyForFixedPosition`):
+
+```
+penalty = ceil( ceil(repayPrincipal × aprPerSecond / RATE_SCALE) × timeLeft / 2 )
+```
+
+≈ **half the interest that principal would still accrue over the remaining term**. It's skimmed off the
+principal payment and supplied to the Moolah vault as revenue, so it is **additive** — on top of
+`outstanding + accruedInterest`. Penalty is **0 once matured** (`block.timestamp > end`). The fetcher
+surfaces it per loan as `earlyRepayPenalty` (computed for the *full outstanding principal*; scale linearly
+for partials). Use the broker's `previewRepayFixedLoanPosition(user, amount, posId)` for the exact
+`(interest, penalty, principal)` split.
+
+#### Maturity & refinancing
+
+A fixed position's **interest freezes at `end`** (`getAccruedInterestForFixedPosition` caps at
+`position.end`); after maturity it accrues no further fixed interest and carries no penalty.
+
+`refinanceMaturedFixedPositions(user, posIds)` is a **bot-only** function (`onlyRole(BOT)`) — users and
+the composer **cannot** call it, so it is **not** exposed as an SDK/composer op. It migrates matured fixed
+positions into the dynamic bucket: net principal + frozen interest are normalized at the current dynamic
+rate and added to the dynamic position, and the fixed position is **deleted**. The window between maturity
+and the bot's call is interest-free (the protocol absorbs it).
+
+#### Repaying late
+
+| When | Target | Cost |
+|------|--------|------|
+| Before `end` | fixed `posId` | principal + accrued interest + **early penalty** |
+| After `end`, before bot refinances | fixed `posId` | principal + **frozen** interest, **no penalty** — cheapest |
+| After bot refinances | **dynamic** sentinel | principal + interest captured at refinance + **dynamic-rate interest since** |
+
+> **Refinance is a race.** A repay targeting a matured `posId` **reverts** (`position not found`) if the
+> bot refinances first; fall back to the dynamic repay. The matured-but-not-yet-refinanced window
+> (`isMatured: true`, `earlyRepayPenalty: '0'`) is the cheapest time to repay.
+
+#### Data shape
+
+Brokered markets emit **no variable debt** — the position's `debt` is `0`, the authoritative total sits in
+`debtStable`, and each fixed loan is itemized in a `terms[]` array (`ListaTermLoan`):
+
+| Field | Description |
+|-------|-------------|
+| `loanId` | `posId` — the repay target for the `LISTA_BROKER_REPAY` composer op |
+| `debt` | outstanding (principal + accrued interest), loan-token units |
+| `aprFraction` | locked fixed APR as a fraction |
+| `maturity` / `termDays` | unix maturity timestamp / term length |
+| `accruedInterest` | outstanding accrued interest |
+| `earlyRepayPenalty` | penalty to close the loan now; `0` once matured |
+| `isMatured` | `now >= end` |
+
+> **Note:** `terms[]` currently itemizes only fixed loans. The dynamic position (post-refinance) is
+> included in the `debtStable` total but not yet surfaced as its own repayable term.

package/dist/abis/compound-v2/Comptroller.d.ts

@@ -12,5 +12,25 @@ export declare const ComptrollerAbi: readonly [{
     }];
     readonly stateMutability: "view";
     readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "closeFactorMantissa";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "liquidationIncentiveMantissa";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
 }];
 //# sourceMappingURL=Comptroller.d.ts.map

package/dist/abis/compound-v2/Comptroller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Comptroller.d.ts","sourceRoot":"","sources":["../../../src/abis/compound-v2/Comptroller.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;EAoBjB,CAAA"}
+{"version":3,"file":"Comptroller.d.ts","sourceRoot":"","sources":["../../../src/abis/compound-v2/Comptroller.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCjB,CAAA"}

package/dist/ccip-VFYF2C5F.js

@@ -0,0 +1,5 @@
+export { ccipRequest, offchainLookup, offchainLookupAbiItem, offchainLookupSignature } from './chunk-Z3MGRQJR.js';
+import './chunk-BYTNVMX7.js';
+import './chunk-PR4QN5HX.js';
+//# sourceMappingURL=ccip-VFYF2C5F.js.map
+//# sourceMappingURL=ccip-VFYF2C5F.js.map

package/dist/{ccip-XQNAHYUN.js.map → ccip-VFYF2C5F.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"ccip-XQNAHYUN.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"ccip-VFYF2C5F.js"}

package/dist/{chunk-H6U3H7VY.js → chunk-Z3MGRQJR.js}

@@ -2122,9 +2122,9 @@ var checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
 function checksumAddress(address_, chainId) {
   if (checksumAddressCache.has(`${address_}.${chainId}`))
     return checksumAddressCache.get(`${address_}.${chainId}`);
-  const hexAddress = address_.substring(2).toLowerCase();
+  const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
   const hash2 = keccak256(stringToBytes(hexAddress), "bytes");
-  const address = (hexAddress).split("");
+  const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
   for (let i = 0; i < 40; i += 2) {
     if (hash2[i >> 1] >> 4 >= 8 && address[i]) {
       address[i] = address[i].toUpperCase();
@@ -2137,6 +2137,11 @@ function checksumAddress(address_, chainId) {
   checksumAddressCache.set(`${address_}.${chainId}`, result);
   return result;
 }
+function getAddress(address, chainId) {
+  if (!isAddress(address, { strict: false }))
+    throw new InvalidAddressError({ address });
+  return checksumAddress(address, chainId);
+}
 
 // ../../node_modules/.pnpm/viem@2.45.3_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/errors/cursor.js
 var NegativeOffsetError = class extends BaseError3 {
@@ -3763,7 +3768,7 @@ async function call(client, args) {
     return { data: response };
   } catch (err) {
     const data2 = getRevertErrorData(err);
-    const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await import('./ccip-XQNAHYUN.js');
+    const { offchainLookup: offchainLookup2, offchainLookupSignature: offchainLookupSignature2 } = await import('./ccip-VFYF2C5F.js');
     if (client.ccipRead !== false && data2?.slice(0, 10) === offchainLookupSignature2 && to)
       return { data: await offchainLookup2(client, { data: data2, to }) };
     if (deploylessCall && data2?.slice(0, 10) === "0x101bb98d")
@@ -4144,6 +4149,6 @@ async function ccipRequest({ data, sender, urls }) {
   throw error;
 }
 
-export { AbiEncodingLengthMismatchError, BaseError3 as BaseError, BytesSizeMismatchError, InvalidAddressError, UnsupportedPackedAbiType, arrayRegex, boolToHex, bytesRegex2 as bytesRegex, ccipRequest, concatHex, decodeAbiParameters, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, formatEther, formatUnits, integerRegex2 as integerRegex, isAddress, keccak256, numberToHex, offchainLookup, offchainLookupAbiItem, offchainLookupSignature, pad2 as pad, parseAbi, stringToHex };
-//# sourceMappingURL=chunk-H6U3H7VY.js.map
-//# sourceMappingURL=chunk-H6U3H7VY.js.map
+export { AbiEncodingLengthMismatchError, BaseError3 as BaseError, BytesSizeMismatchError, InvalidAddressError, UnsupportedPackedAbiType, arrayRegex, boolToHex, bytesRegex2 as bytesRegex, ccipRequest, concatHex, decodeAbiParameters, decodeFunctionResult, encodeAbiParameters, encodeFunctionData, formatEther, formatUnits, getAddress, integerRegex2 as integerRegex, isAddress, keccak256, numberToHex, offchainLookup, offchainLookupAbiItem, offchainLookupSignature, pad2 as pad, parseAbi, stringToHex };
+//# sourceMappingURL=chunk-Z3MGRQJR.js.map
+//# sourceMappingURL=chunk-Z3MGRQJR.js.map