@wildcatfi/wildcat-sdk 3.0.77-beta → 3.1.2-beta

package/dist/market.js

@@ -1,83 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Market = void 0;
-const viem_1 = require("viem");
+const ethers_1 = require("ethers");
+const abstract_signer_1 = require("@ethersproject/abstract-signer");
+const typechain_1 = require("./typechain");
 const constants_1 = require("./constants");
-const arch_controller_1 = require("./internal/arch-controller");
-const market_lens_1 = require("./internal/market-lens");
 const token_1 = require("./token");
 const types_1 = require("./types");
+const utils_1 = require("ethers/lib/utils");
 const account_1 = require("./account");
-const utils_1 = require("./utils");
+const utils_2 = require("./utils");
 const access_1 = require("./access");
-const abi_1 = require("./abi");
-const viem_write_1 = require("./internal/viem-write");
-const ethers_signer_1 = require("./internal/ethers-signer");
-const hasUnifiedLatestLensForDirectReads = (chainId) => {
-    return (0, constants_1.hasDeploymentAddress)(chainId, "MarketLensV2_5");
-};
-const toUnifiedMarketDataV2 = (data) => {
-    if ("market" in data) {
-        return data;
-    }
-    return {
-        market: data,
-        commitmentFeeBips: {
-            isPresent: false,
-            value: 0n
-        },
-        drawnAmount: {
-            isPresent: false,
-            value: 0n
-        }
-    };
-};
-const hasSubgraphMarketTotals = (data) => "totalBorrowed" in data;
-const hasSubgraphMarketRecords = (data) => "depositRecords" in data;
 class Market extends types_1.ContractWrapper {
+    get _contractAddress() {
+        return this.address;
+    }
     constructor({ provider, ...args }) {
         super(provider);
+        this.contractFactory = typechain_1.WildcatMarket__factory;
         const { address, name, symbol, decimals } = args.marketToken;
         Object.assign(this, {
             address,
             name,
             symbol,
-            decimals,
-            contract: {
-                address,
-                interface: {
-                    encodeFunctionData: (functionName, args = []) => (0, viem_1.encodeFunctionData)({
-                        abi: abi_1.wildcatMarketAbi,
-                        functionName,
-                        args
-                    })
-                }
-            }
+            decimals
         });
         Object.assign(this, args);
-        this.depositRecords = (args.depositRecords ?? []).map((log) => (0, utils_1.parseMarketRecord)(this.underlyingToken, log));
-        this.repaymentRecords = (args.repaymentRecords ?? []).map((log) => (0, utils_1.parseMarketRecord)(this.underlyingToken, log));
-        this.borrowRecords = (args.borrowRecords ?? []).map((log) => (0, utils_1.parseMarketRecord)(this.underlyingToken, log));
+        this.depositRecords = (args.depositRecords ?? []).map((log) => (0, utils_2.parseMarketRecord)(this.underlyingToken, log));
+        this.repaymentRecords = (args.repaymentRecords ?? []).map((log) => (0, utils_2.parseMarketRecord)(this.underlyingToken, log));
+        this.borrowRecords = (args.borrowRecords ?? []).map((log) => (0, utils_2.parseMarketRecord)(this.underlyingToken, log));
         this.feeCollectionRecords = (args.feeCollectionRecords ?? []).map(({ feesCollected, __typename, ...rest }) => ({
             ...rest,
             __typename: "FeesCollected",
             amount: this.underlyingToken.getAmount(feesCollected)
         }));
     }
-    toJSON() {
-        return {
-            type: "Market",
-            chainId: this.chainId,
-            address: this.address,
-            name: this.name,
-            symbol: this.symbol,
-            decimals: this.decimals,
-            version: this.version,
-            marketType: this.marketType,
-            hooksFactory: this.hooksFactory,
-            borrower: this.borrower
-        };
-    }
     /* -------------------------------------------------------------------------- */
     /*                              Property Getters                              */
     /* -------------------------------------------------------------------------- */
@@ -93,86 +50,47 @@ class Market extends types_1.ContractWrapper {
         const fixedTermEndTime = config.fixedTermEndTime;
         return fixedTermEndTime >= Date.now() / 1000;
     }
+    get isPeriodicWithdrawalWindowOpen() {
+        if (this.version !== types_1.MarketVersion.V2)
+            return false;
+        const config = this.hooksConfig;
+        if (!config || config.kind !== types_1.HooksKind.PeriodicTerm)
+            return false;
+        if (this.isClosed || config.periodicTermClosed)
+            return true;
+        if (config.periodDuration === 0)
+            return false;
+        const now = Math.floor(Date.now() / 1000);
+        if (now < config.firstWithdrawalWindowStart)
+            return false;
+        return ((now - config.firstWithdrawalWindowStart) % config.periodDuration <
+            config.withdrawalWindowDuration);
+    }
+    get currentOrNextPeriodicWithdrawalWindowStart() {
+        if (this.version !== types_1.MarketVersion.V2)
+            return undefined;
+        const config = this.hooksConfig;
+        if (!config || config.kind !== types_1.HooksKind.PeriodicTerm || config.periodDuration === 0) {
+            return undefined;
+        }
+        const now = Math.floor(Date.now() / 1000);
+        if (now < config.firstWithdrawalWindowStart)
+            return config.firstWithdrawalWindowStart;
+        const timeInPeriod = (now - config.firstWithdrawalWindowStart) % config.periodDuration;
+        const windowStart = now - timeInPeriod;
+        return timeInPeriod < config.withdrawalWindowDuration
+            ? windowStart
+            : windowStart + config.periodDuration;
+    }
     /** @returns Percentage growth of the market since it was created */
     get allTimeGrowth() {
         // 27 - 2 to convert to percentage
-        return +(0, utils_1.formatFixedBigint)(this.scaleFactor, 25, 25);
+        return +(0, utils_1.formatUnits)(this.scaleFactor, 25);
     }
     /** @returns Maximum amount of underlying token that can be deposited */
     get maximumDeposit() {
         return this.underlyingToken.getAmount(this.maxTotalSupply.satsub(this.totalSupply.raw));
     }
-    get currentRevolvingAprMetrics() {
-        const commitmentFeeBips = this.commitmentFeeBips;
-        const drawnAmount = this.drawnAmount;
-        if (commitmentFeeBips == null || drawnAmount == null) {
-            return undefined;
-        }
-        const totalSupply = this.totalSupply.raw;
-        const drawnAmountRaw = drawnAmount.raw > totalSupply ? totalSupply : drawnAmount.raw;
-        const utilizationBips = totalSupply > 0n ? Number((drawnAmountRaw * utils_1.BIP_BIGINT) / totalSupply) : 0;
-        const utilizationAprBips = totalSupply > 0n
-            ? Number((drawnAmountRaw * BigInt(this.annualInterestBips)) / totalSupply)
-            : 0;
-        const blendedBaseAprBips = commitmentFeeBips + utilizationAprBips;
-        const protocolAprBips = Number((BigInt(blendedBaseAprBips) * BigInt(this.protocolFeeBips)) / utils_1.BIP_BIGINT);
-        const penaltyAprBips = this.isIncurringPenalties ? this.delinquencyFeeBips : 0;
-        return {
-            commitmentFeeBips,
-            drawnAmount,
-            utilizationBips,
-            utilizationAprBips,
-            blendedBaseAprBips,
-            protocolAprBips,
-            penaltyAprBips,
-            effectiveLenderAprBips: blendedBaseAprBips + penaltyAprBips
-        };
-    }
-    get currentBaseLenderAprBips() {
-        return this.currentRevolvingAprMetrics?.blendedBaseAprBips ?? this.annualInterestBips;
-    }
-    get currentAprDisplayBips() {
-        const revolvingMetrics = this.currentRevolvingAprMetrics;
-        if (revolvingMetrics) {
-            return {
-                isRevolving: true,
-                marketType: this.marketType,
-                configuredAprKind: "utilization",
-                configuredAprBips: this.annualInterestBips,
-                configuredAnnualInterestBips: this.annualInterestBips,
-                configuredUtilizationAprBips: this.annualInterestBips,
-                commitmentAprBips: revolvingMetrics.commitmentFeeBips,
-                utilizationBips: revolvingMetrics.utilizationBips,
-                currentUtilizationAprBips: revolvingMetrics.utilizationAprBips,
-                currentBaseLenderAprBips: revolvingMetrics.blendedBaseAprBips,
-                currentProtocolAprBips: revolvingMetrics.protocolAprBips,
-                currentPenaltyAprBips: revolvingMetrics.penaltyAprBips,
-                currentEffectiveLenderAprBips: revolvingMetrics.effectiveLenderAprBips
-            };
-        }
-        const currentProtocolAprBips = Number((BigInt(this.annualInterestBips) * BigInt(this.protocolFeeBips)) / utils_1.BIP_BIGINT);
-        const currentPenaltyAprBips = this.isIncurringPenalties ? this.delinquencyFeeBips : 0;
-        return {
-            isRevolving: false,
-            marketType: this.marketType,
-            configuredAprKind: "annualInterest",
-            configuredAprBips: this.annualInterestBips,
-            configuredAnnualInterestBips: this.annualInterestBips,
-            currentBaseLenderAprBips: this.annualInterestBips,
-            currentProtocolAprBips,
-            currentPenaltyAprBips,
-            currentEffectiveLenderAprBips: this.annualInterestBips + currentPenaltyAprBips
-        };
-    }
-    get currentBaseLenderAPR() {
-        return (0, utils_1.bipToRayBigint)(this.currentBaseLenderAprBips);
-    }
-    get currentPenaltyAPR() {
-        return this.isIncurringPenalties ? (0, utils_1.bipToRayBigint)(this.delinquencyFeeBips) : 0n;
-    }
-    get currentProtocolAPR() {
-        return (0, utils_1.bipMulBigint)(this.currentBaseLenderAPR, this.protocolFeeBips);
-    }
     /** @returns Whether the borrower is in penalized delinquency */
     get isIncurringPenalties() {
         return this.timeDelinquent > this.delinquencyGracePeriod;
@@ -218,7 +136,7 @@ class Market extends types_1.ContractWrapper {
         const targetRatio = this.reserveRatioBips / 100;
         const actualRatio = this.totalSupply.eq(0)
             ? 100
-            : +(0, utils_1.formatFixedBigint)((this.totalAssets.raw * utils_1.RAY_BIGINT) / this.totalSupply.raw, 25, 25);
+            : +(0, utils_1.formatUnits)(this.totalAssets.raw.mul(utils_2.RAY).div(this.totalSupply.raw), 25);
         if (this.temporaryReserveRatio) {
             return {
                 targetRatio,
@@ -231,7 +149,7 @@ class Market extends types_1.ContractWrapper {
         return { targetRatio, actualRatio };
     }
     get normalizedPendingWithdrawals() {
-        return this.underlyingToken.getAmount((0, utils_1.rayMulBigint)(this.scaledPendingWithdrawals, this.scaleFactor));
+        return this.underlyingToken.getAmount((0, utils_2.rayMul)(this.scaledPendingWithdrawals, this.scaleFactor));
     }
     /** @returns Whether the borrower can change the APR */
     get canReduceAPR() {
@@ -247,7 +165,7 @@ class Market extends types_1.ContractWrapper {
         return this.totalAssets.satsub(unavailableAssets);
     }
     get minimumReserves() {
-        return this.outstandingTotalSupply.bipMul(this.reserveRatioBips);
+        return this.underlyingToken.getAmount((0, utils_2.bipMul)(this.outstandingTotalSupply.raw, ethers_1.BigNumber.from(this.reserveRatioBips)));
     }
     get borrowableAssets() {
         return this.totalAssets.satsub(this.coverageLiquidity);
@@ -285,59 +203,63 @@ class Market extends types_1.ContractWrapper {
         };
     }
     normalizeAmount(amount) {
-        return (0, utils_1.rayMulBigint)(amount, this.scaleFactor);
+        return (0, utils_2.rayMul)(amount, this.scaleFactor);
     }
     scaleAmount(amount) {
-        return (0, utils_1.rayDivBigint)(amount, this.scaleFactor);
+        return (0, utils_2.rayDiv)(amount, this.scaleFactor);
     }
     get secondsBeforeDelinquency() {
         if (this.willBeDelinquent || this.totalDebts.eq(0))
             return 0;
         const scaledBase = this.scaledTotalSupply;
-        const basePrincipal = this.underlyingToken.getAmount((0, utils_1.rayMulBigint)(scaledBase, this.scaleFactor));
-        const baseAPRRay = this.currentBaseLenderAPR;
-        const protocolFeeAPRRay = this.currentProtocolAPR;
-        const delinquencyFeeAPRRay = this.currentPenaltyAPR;
+        const basePrincipal = this.underlyingToken.getAmount((0, utils_2.rayMul)(scaledBase, this.scaleFactor));
+        const baseAPRRay = (0, utils_2.bipToRay)(this.annualInterestBips);
+        const protocolFeeAPRRay = (0, utils_2.bipMul)(baseAPRRay, ethers_1.BigNumber.from(this.protocolFeeBips));
+        const delinquencyFeeAPRRay = this.timeDelinquent > this.delinquencyGracePeriod
+            ? (0, utils_2.bipToRay)(this.delinquencyFeeBips)
+            : ethers_1.BigNumber.from(0);
         // lender APR portion
         const lenderRequirementGrowthPerSecond = basePrincipal
-            .rayMul(baseAPRRay + delinquencyFeeAPRRay)
-            .div(utils_1.SECONDS_IN_365_DAYS)
+            .rayMul(baseAPRRay.add(delinquencyFeeAPRRay))
+            .div(utils_2.SECONDS_IN_365_DAYS)
             .bipMul(this.reserveRatioBips);
         // protocol fee portion
         const protocolRequirementGrowthPerSecond = basePrincipal
             .rayMul(protocolFeeAPRRay)
-            .div(utils_1.SECONDS_IN_365_DAYS);
+            .div(utils_2.SECONDS_IN_365_DAYS);
         const totalRequirementGrowthPerSecond = lenderRequirementGrowthPerSecond.add(protocolRequirementGrowthPerSecond.raw);
         // essentially if  apr=0 and rr=0 then bips alone wont move us to delinquency
-        if (totalRequirementGrowthPerSecond.raw === 0n)
+        if (totalRequirementGrowthPerSecond.raw.isZero())
             return Number.MAX_SAFE_INTEGER;
         const buffer = this.liquidReserves.sub(this.minimumReserves);
-        if (buffer.raw <= 0n)
+        if (buffer.raw.lte(0))
             return 0; // we are delinquent
-        return Number(buffer.div(totalRequirementGrowthPerSecond, true).raw); // seconds until the party
+        return buffer.div(totalRequirementGrowthPerSecond, true).raw.toNumber(); // seconds until the party
     }
     getSecondsBeforeDelinquencyForBorrowedAmount(borrowAmount) {
         if (this.isDelinquent || this.totalDebts.eq(0))
             return 0;
         const scaledBase = this.scaledTotalSupply;
-        const basePrincipal = this.underlyingToken.getAmount((0, utils_1.rayMulBigint)(scaledBase, this.scaleFactor));
-        const baseAPRRay = this.currentBaseLenderAPR;
-        const protocolFeeAPRRay = this.currentProtocolAPR;
-        const delinquencyFeeAPRRay = this.currentPenaltyAPR;
+        const basePrincipal = this.underlyingToken.getAmount((0, utils_2.rayMul)(scaledBase, this.scaleFactor));
+        const baseAPRRay = (0, utils_2.bipToRay)(this.annualInterestBips);
+        const protocolFeeAPRRay = (0, utils_2.bipMul)(baseAPRRay, ethers_1.BigNumber.from(this.protocolFeeBips));
+        const delinquencyFeeAPRRay = this.timeDelinquent > this.delinquencyGracePeriod
+            ? (0, utils_2.bipToRay)(this.delinquencyFeeBips)
+            : ethers_1.BigNumber.from(0);
         const lenderRequirementGrowthPerSecond = basePrincipal
-            .rayMul(baseAPRRay + delinquencyFeeAPRRay)
-            .div(utils_1.SECONDS_IN_365_DAYS)
+            .rayMul(baseAPRRay.add(delinquencyFeeAPRRay))
+            .div(utils_2.SECONDS_IN_365_DAYS)
             .bipMul(this.reserveRatioBips);
         const protocolRequirementGrowthPerSecond = basePrincipal
             .rayMul(protocolFeeAPRRay)
-            .div(utils_1.SECONDS_IN_365_DAYS);
+            .div(utils_2.SECONDS_IN_365_DAYS);
         const totalRequirementGrowthPerSecond = lenderRequirementGrowthPerSecond.add(protocolRequirementGrowthPerSecond.raw);
-        if (totalRequirementGrowthPerSecond.raw === 0n)
+        if (totalRequirementGrowthPerSecond.raw.isZero())
             return Number.MAX_SAFE_INTEGER;
         const postBorrowBuffer = this.liquidReserves.sub(this.minimumReserves).sub(borrowAmount);
-        if (postBorrowBuffer.raw <= 0n)
+        if (postBorrowBuffer.raw.lte(0))
             return 0;
-        return Number(postBorrowBuffer.div(totalRequirementGrowthPerSecond, true).raw);
+        return postBorrowBuffer.div(totalRequirementGrowthPerSecond, true).raw.toNumber();
     }
     /**
      * @dev Calculate token amount to be repayed by borrower for a given duration
@@ -345,20 +267,22 @@ class Market extends types_1.ContractWrapper {
      * @return token amount to be repayed
      **/
     repayRequiredForDuration(timeToPayInSeconds) {
-        const scaledBase = this.scaledTotalSupply - this.scaledPendingWithdrawals;
-        if (scaledBase <= 0n)
+        const scaledBase = this.scaledTotalSupply.sub(this.scaledPendingWithdrawals);
+        if (scaledBase.lte(0))
             return this.underlyingToken.getAmount(0);
-        const basePrincipal = this.underlyingToken.getAmount((0, utils_1.rayMulBigint)(scaledBase, this.scaleFactor));
-        const baseAPRRay = this.currentBaseLenderAPR;
-        const protocolFeeAPRRay = this.currentProtocolAPR;
-        const delinquencyFeeAPRRay = this.currentPenaltyAPR;
+        const basePrincipal = this.underlyingToken.getAmount((0, utils_2.rayMul)(scaledBase, this.scaleFactor));
+        const baseAPRRay = (0, utils_2.bipToRay)(this.annualInterestBips);
+        const protocolFeeAPRRay = (0, utils_2.bipMul)(baseAPRRay, ethers_1.BigNumber.from(this.protocolFeeBips));
+        const delinquencyFeeAPRRay = this.timeDelinquent > this.delinquencyGracePeriod
+            ? (0, utils_2.bipToRay)(this.delinquencyFeeBips)
+            : ethers_1.BigNumber.from(0);
         const lenderRequirementGrowthPerSecond = basePrincipal
-            .rayMul(baseAPRRay + delinquencyFeeAPRRay)
-            .div(utils_1.SECONDS_IN_365_DAYS)
+            .rayMul(baseAPRRay.add(delinquencyFeeAPRRay))
+            .div(utils_2.SECONDS_IN_365_DAYS)
             .bipMul(this.reserveRatioBips);
         const protocolRequirementGrowthPerSecond = basePrincipal
             .rayMul(protocolFeeAPRRay)
-            .div(utils_1.SECONDS_IN_365_DAYS);
+            .div(utils_2.SECONDS_IN_365_DAYS);
         const totalRequirementGrowthPerSecond = lenderRequirementGrowthPerSecond.add(protocolRequirementGrowthPerSecond.raw);
         return totalRequirementGrowthPerSecond.mul(timeToPayInSeconds);
     }
@@ -369,12 +293,13 @@ class Market extends types_1.ContractWrapper {
      *
      * @return apr paid by borrower in ray
      */
-    // Preserve ethers-era consumers whose formatting helpers typed APR rays as BigNumber.
-    // Runtime remains bigint, with BigInt compatibility methods installed by token.ts.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     get effectiveBorrowerAPR() {
-        return ((0, utils_1.bipMulBigint)(this.currentBaseLenderAPR, utils_1.BIP_BIGINT + BigInt(this.protocolFeeBips)) +
-            this.currentPenaltyAPR);
+        // apr + (apr * protocolFee)
+        let apr = (0, utils_2.bipMul)((0, utils_2.bipToRay)(this.annualInterestBips), utils_2.BIP.add(this.protocolFeeBips));
+        if (this.timeDelinquent > this.delinquencyGracePeriod) {
+            apr = apr.add((0, utils_2.bipToRay)(this.delinquencyFeeBips));
+        }
+        return apr;
     }
     /**
      * @dev Calculate effective interest rate currently earned by lenders.
@@ -382,41 +307,36 @@ class Market extends types_1.ContractWrapper {
      *
      * @return apr earned by lender in ray
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     get effectiveLenderAPR() {
-        return this.currentBaseLenderAPR + this.currentPenaltyAPR;
+        let apr = this.annualInterestBips;
+        if (this.timeDelinquent > this.delinquencyGracePeriod) {
+            apr += this.delinquencyFeeBips;
+        }
+        return (0, utils_2.bipToRay)(apr);
     }
     /* -------------------------------------------------------------------------- */
     /*                            Withdrawal Execution                            */
     /* -------------------------------------------------------------------------- */
     async executeWithdrawal({ lender, expiry }) {
-        return (0, viem_write_1.submitPreparedTransaction)(this.signer, (0, utils_1.prepareTransaction)({
-            to: this.address,
-            abi: abi_1.wildcatMarketAbi,
-            functionName: "executeWithdrawal",
-            args: [lender, expiry]
-        }));
+        return this.contract.executeWithdrawal(lender, expiry);
     }
     async executeWithdrawals(withdrawals) {
         const lenders = withdrawals.map((w) => w.lender);
         const expiries = withdrawals.map((w) => w.expiry);
-        return (0, viem_write_1.submitPreparedTransaction)(this.signer, (0, utils_1.prepareTransaction)({
-            to: this.address,
-            abi: abi_1.wildcatMarketAbi,
-            functionName: "executeWithdrawals",
-            args: [lenders, expiries]
-        }));
+        return this.contract.executeWithdrawals(lenders, expiries);
     }
     populateRepayAndProcessUnpaidWithdrawalBatches(amount, maxBatches = 10) {
-        return (0, utils_1.prepareTransaction)({
+        return {
             to: this.address,
-            abi: abi_1.wildcatMarketAbi,
-            functionName: "repayAndProcessUnpaidWithdrawalBatches",
-            args: [amount.raw, maxBatches]
-        });
+            data: this.contract.interface.encodeFunctionData("repayAndProcessUnpaidWithdrawalBatches", [
+                amount.raw,
+                maxBatches
+            ]),
+            value: "0"
+        };
     }
     async repayAndProcessUnpaidWithdrawalBatches(amount, maxBatches = 10) {
-        return (0, viem_write_1.submitPreparedTransaction)(this.signer, this.populateRepayAndProcessUnpaidWithdrawalBatches(amount, maxBatches));
+        return this.contract.repayAndProcessUnpaidWithdrawalBatches(amount.raw, maxBatches);
     }
     /* -------------------------------------------------------------------------- */
     /*                                   Set APR                                  */
@@ -432,8 +352,7 @@ class Market extends types_1.ContractWrapper {
         if (annualInterestBips < originalAnnualInterestBips) {
             let doubleRelativeDiff;
             if (this.version === types_1.MarketVersion.V2) {
-                const relativeDiff = Number((10000n * BigInt(originalAnnualInterestBips - annualInterestBips)) /
-                    BigInt(originalAnnualInterestBips));
+                const relativeDiff = (0, utils_2.mulDiv)((0, token_1.toBn)(10000), (0, token_1.toBn)(originalAnnualInterestBips - annualInterestBips), (0, token_1.toBn)(originalAnnualInterestBips)).toNumber();
                 if (relativeDiff <= 2500) {
                     // In v2, if the relative diff is 25% or less, the reserve ratio is not changed
                     return originalReserveRatioBips;
@@ -441,8 +360,7 @@ class Market extends types_1.ContractWrapper {
                 doubleRelativeDiff = 2 * relativeDiff;
             }
             else {
-                doubleRelativeDiff = Number((20000n * BigInt(originalAnnualInterestBips - annualInterestBips)) /
-                    BigInt(originalAnnualInterestBips));
+                doubleRelativeDiff = (0, utils_2.mulDiv)((0, token_1.toBn)(20000), (0, token_1.toBn)(originalAnnualInterestBips - annualInterestBips), (0, token_1.toBn)(originalAnnualInterestBips)).toNumber();
             }
             const boundRelativeDiff = Math.min(10000, doubleRelativeDiff);
             return Math.max(boundRelativeDiff, originalReserveRatioBips);
@@ -454,11 +372,10 @@ class Market extends types_1.ContractWrapper {
         return originalReserveRatioBips;
     }
     calculateLiquidityCoverageForReserveRatio(reserveRatio) {
-        const scaledRequiredReserves = (0, utils_1.bipMulBigint)(this.scaledTotalSupply - this.scaledPendingWithdrawals, reserveRatio) +
-            this.scaledPendingWithdrawals;
-        return this.underlyingToken.getAmount((0, utils_1.rayMulBigint)(scaledRequiredReserves, this.scaleFactor) +
-            this.lastAccruedProtocolFees.raw +
-            this.normalizedUnclaimedWithdrawals.raw);
+        const scaledRequiredReserves = (0, utils_2.bipMul)(this.scaledTotalSupply.sub(this.scaledPendingWithdrawals), (0, token_1.toBn)(reserveRatio)).add(this.scaledPendingWithdrawals);
+        return this.underlyingToken.getAmount((0, utils_2.rayMul)(scaledRequiredReserves, this.scaleFactor)
+            .add(this.lastAccruedProtocolFees.raw)
+            .add(this.normalizedUnclaimedWithdrawals.raw));
     }
     canChangeAPR(annualInterestBips) {
         const originalAnnualInterestBips = this.temporaryReserveRatio
@@ -488,186 +405,89 @@ class Market extends types_1.ContractWrapper {
     /*                                   Updates                                  */
     /* -------------------------------------------------------------------------- */
     async update() {
-        if (this.version === types_1.MarketVersion.V2) {
-            if (hasUnifiedLatestLensForDirectReads(this.chainId)) {
-                try {
-                    const market = await (0, market_lens_1.getUnifiedMarketDataV2)(this.chainId, this.provider, this.address);
-                    this.updateWith(market);
-                    return;
-                }
-                catch (_) {
-                    // Fall back to the pre-2.5 V2 lens until unified lens deployment is reliable.
-                }
-            }
-            const market = await (0, market_lens_1.getV2MarketData)(this.chainId, this.provider, this.address);
-            this.updateWith(market);
-            return;
-        }
-        const market = await (0, market_lens_1.getLegacyMarketData)(this.chainId, this.provider, this.address);
+        const market = await (0, constants_1.getLensContract)(this.chainId, this.provider).getMarketData(this.address);
         this.updateWith(market);
     }
     updateWith(data) {
-        const baseData = "market" in data ? data.market : data;
-        const nextScaleFactor = (0, token_1.toRawAmount)(baseData.scaleFactor);
-        const nextScaledTotalSupply = (0, token_1.toRawAmount)(baseData.scaledTotalSupply);
-        const nextScaledPendingWithdrawals = (0, token_1.toRawAmount)(baseData.scaledPendingWithdrawals);
-        const nextLastAccruedProtocolFees = (0, token_1.toRawAmount)(baseData.lastAccruedProtocolFees);
         // Note: this adds all the interest accrued to the base interest accrued, since the lens
         // doesn't give us any way to distinguish between base interest and delinquency fees.
-        if (this.scaledTotalSupply === nextScaledTotalSupply &&
-            nextScaleFactor > this.scaleFactor &&
+        if (this.scaledTotalSupply.eq(data.scaledTotalSupply) &&
+            data.scaleFactor.gt(this.scaleFactor) &&
             this.totalBaseInterestAccrued) {
-            const lastTotalValue = (0, utils_1.rayMulBigint)(this.scaledTotalSupply, this.scaleFactor);
-            const currentTotalValue = (0, utils_1.rayMulBigint)(this.scaledTotalSupply, nextScaleFactor);
-            const baseInterestAccrued = currentTotalValue - lastTotalValue;
+            const lastTotalValue = (0, utils_2.rayMul)(this.scaledTotalSupply, this.scaleFactor);
+            const currentTotalValue = (0, utils_2.rayMul)(this.scaledTotalSupply, data.scaleFactor);
+            const baseInterestAccrued = currentTotalValue.sub(lastTotalValue);
             this.totalBaseInterestAccrued = this.totalBaseInterestAccrued.add(baseInterestAccrued);
         }
-        if (nextLastAccruedProtocolFees > this.lastAccruedProtocolFees.raw &&
+        if (data.lastAccruedProtocolFees.gt(this.lastAccruedProtocolFees.raw) &&
             this.totalProtocolFeesAccrued) {
-            this.totalProtocolFeesAccrued = this.totalProtocolFeesAccrued.add(nextLastAccruedProtocolFees - this.lastAccruedProtocolFees.raw);
-        }
-        this.feeRecipient = baseData.feeRecipient;
-        this.protocolFeeBips = (0, utils_1.toNumber)(baseData.protocolFeeBips);
-        this.delinquencyFeeBips = (0, utils_1.toNumber)(baseData.delinquencyFeeBips);
-        this.delinquencyGracePeriod = (0, utils_1.toNumber)(baseData.delinquencyGracePeriod);
-        this.withdrawalBatchDuration = (0, utils_1.toNumber)(baseData.withdrawalBatchDuration);
-        this.reserveRatioBips = (0, utils_1.toNumber)(baseData.reserveRatioBips);
-        this.annualInterestBips = (0, utils_1.toNumber)(baseData.annualInterestBips);
-        this.temporaryReserveRatio = baseData.temporaryReserveRatio;
-        this.originalAnnualInterestBips = (0, utils_1.toNumber)(baseData.originalAnnualInterestBips);
-        this.originalReserveRatioBips = (0, utils_1.toNumber)(baseData.originalReserveRatioBips);
-        this.temporaryReserveRatioExpiry = (0, utils_1.toNumber)(baseData.temporaryReserveRatioExpiry);
-        this.isClosed = baseData.isClosed;
-        this.scaleFactor = nextScaleFactor;
-        this.totalSupply = this.marketToken.getAmount(baseData.totalSupply);
-        this.maxTotalSupply = this.marketToken.getAmount(baseData.maxTotalSupply);
-        this.scaledTotalSupply = nextScaledTotalSupply;
-        this.totalAssets = this.underlyingToken.getAmount(baseData.totalAssets);
-        this.lastAccruedProtocolFees = this.underlyingToken.getAmount(baseData.lastAccruedProtocolFees);
-        this.normalizedUnclaimedWithdrawals = this.underlyingToken.getAmount(baseData.normalizedUnclaimedWithdrawals);
-        this.scaledPendingWithdrawals = nextScaledPendingWithdrawals;
-        this.pendingWithdrawalExpiry = (0, utils_1.toNumber)(baseData.pendingWithdrawalExpiry);
-        this.isDelinquent = baseData.isDelinquent;
-        this.timeDelinquent = (0, utils_1.toNumber)(baseData.timeDelinquent);
-        this.lastInterestAccruedTimestamp = (0, utils_1.toNumber)(baseData.lastInterestAccruedTimestamp);
-        this.unpaidWithdrawalBatchExpiries = baseData.unpaidWithdrawalBatchExpiries.map(utils_1.toNumber);
-        this.coverageLiquidity = this.underlyingToken.getAmount(baseData.coverageLiquidity);
-        if ("hooksFactory" in baseData) {
-            this.hooksFactory = baseData.hooksFactory;
-            this.marketType = (0, constants_1.getMarketTypeForHooksFactory)(this.chainId, baseData.hooksFactory);
-        }
-        if ("hooksConfig" in baseData) {
-            (0, utils_1.assert)(this.version === types_1.MarketVersion.V2, `Can not push V2 lens data to V1 market!`);
-            const config = this.hooksConfig;
-            (0, utils_1.assert)(config !== undefined, `V2 market has no hooksConfig!`);
-            config.minimumDeposit = this.underlyingToken.getAmount(baseData.hooksConfig.minimumDeposit);
-            if (config.kind === types_1.HooksKind.FixedTerm) {
-                config.fixedTermEndTime = (0, utils_1.toNumber)(baseData.hooksConfig.fixedTermEndTime);
-            }
-        }
-        else {
-            (0, utils_1.assert)(this.version === types_1.MarketVersion.V1, `Can not push V1 lens data to V2 market!`);
-        }
-        if ("market" in data) {
-            this.commitmentFeeBips = data.commitmentFeeBips.isPresent
-                ? (0, utils_1.toNumber)(data.commitmentFeeBips.value)
-                : undefined;
-            this.drawnAmount = data.drawnAmount.isPresent
-                ? this.underlyingToken.getAmount(data.drawnAmount.value)
-                : undefined;
-        }
-        else {
-            this.commitmentFeeBips = undefined;
-            this.drawnAmount = undefined;
-        }
-    }
-    updateWithLiveData(data) {
-        (0, utils_1.assert)(data.market.toLowerCase() === this.address.toLowerCase(), `Live market data address mismatch`);
-        const nextScaleFactor = (0, token_1.toRawAmount)(data.scaleFactor);
-        const nextScaledTotalSupply = (0, token_1.toRawAmount)(data.scaledTotalSupply);
-        const nextScaledPendingWithdrawals = (0, token_1.toRawAmount)(data.scaledPendingWithdrawals);
-        const nextLastAccruedProtocolFees = (0, token_1.toRawAmount)(data.lastAccruedProtocolFees);
-        if (this.scaledTotalSupply === nextScaledTotalSupply &&
-            nextScaleFactor > this.scaleFactor &&
-            this.totalBaseInterestAccrued) {
-            const lastTotalValue = (0, utils_1.rayMulBigint)(this.scaledTotalSupply, this.scaleFactor);
-            const currentTotalValue = (0, utils_1.rayMulBigint)(this.scaledTotalSupply, nextScaleFactor);
-            this.totalBaseInterestAccrued = this.totalBaseInterestAccrued.add(currentTotalValue - lastTotalValue);
-        }
-        if (nextLastAccruedProtocolFees > this.lastAccruedProtocolFees.raw &&
-            this.totalProtocolFeesAccrued) {
-            this.totalProtocolFeesAccrued = this.totalProtocolFeesAccrued.add(nextLastAccruedProtocolFees - this.lastAccruedProtocolFees.raw);
-        }
-        this.protocolFeeBips = (0, utils_1.toNumber)(data.protocolFeeBips);
-        this.reserveRatioBips = (0, utils_1.toNumber)(data.reserveRatioBips);
-        this.annualInterestBips = (0, utils_1.toNumber)(data.annualInterestBips);
+            this.totalProtocolFeesAccrued = this.totalProtocolFeesAccrued.add(data.lastAccruedProtocolFees.sub(this.lastAccruedProtocolFees.raw));
+        }
+        this.feeRecipient = data.feeRecipient;
+        this.protocolFeeBips = data.protocolFeeBips.toNumber();
+        this.delinquencyFeeBips = data.delinquencyFeeBips.toNumber();
+        this.delinquencyGracePeriod = data.delinquencyGracePeriod.toNumber();
+        this.withdrawalBatchDuration = data.withdrawalBatchDuration.toNumber();
+        this.reserveRatioBips = data.reserveRatioBips.toNumber();
+        this.annualInterestBips = data.annualInterestBips.toNumber();
+        this.temporaryReserveRatio = data.temporaryReserveRatio;
+        this.originalAnnualInterestBips = data.originalAnnualInterestBips.toNumber();
+        this.originalReserveRatioBips = data.originalReserveRatioBips.toNumber();
+        this.temporaryReserveRatioExpiry = data.temporaryReserveRatioExpiry.toNumber();
         this.isClosed = data.isClosed;
-        this.scaleFactor = nextScaleFactor;
+        this.scaleFactor = data.scaleFactor;
         this.totalSupply = this.marketToken.getAmount(data.totalSupply);
         this.maxTotalSupply = this.marketToken.getAmount(data.maxTotalSupply);
-        this.scaledTotalSupply = nextScaledTotalSupply;
+        this.scaledTotalSupply = data.scaledTotalSupply;
         this.totalAssets = this.underlyingToken.getAmount(data.totalAssets);
         this.lastAccruedProtocolFees = this.underlyingToken.getAmount(data.lastAccruedProtocolFees);
         this.normalizedUnclaimedWithdrawals = this.underlyingToken.getAmount(data.normalizedUnclaimedWithdrawals);
-        this.scaledPendingWithdrawals = nextScaledPendingWithdrawals;
-        this.pendingWithdrawalExpiry = (0, utils_1.toNumber)(data.pendingWithdrawalExpiry);
+        this.scaledPendingWithdrawals = data.scaledPendingWithdrawals;
+        this.pendingWithdrawalExpiry = data.pendingWithdrawalExpiry.toNumber();
         this.isDelinquent = data.isDelinquent;
-        this.timeDelinquent = (0, utils_1.toNumber)(data.timeDelinquent);
-        this.lastInterestAccruedTimestamp = (0, utils_1.toNumber)(data.lastInterestAccruedTimestamp);
+        this.timeDelinquent = data.timeDelinquent.toNumber();
+        this.lastInterestAccruedTimestamp = data.lastInterestAccruedTimestamp.toNumber();
+        this.unpaidWithdrawalBatchExpiries = data.unpaidWithdrawalBatchExpiries;
         this.coverageLiquidity = this.underlyingToken.getAmount(data.coverageLiquidity);
-        this.commitmentFeeBips = data.commitmentFeeBips.isPresent
-            ? (0, utils_1.toNumber)(data.commitmentFeeBips.value)
-            : undefined;
-        this.drawnAmount = data.drawnAmount.isPresent
-            ? this.underlyingToken.getAmount(data.drawnAmount.value)
-            : undefined;
+        if ("hooksConfig" in data) {
+            (0, utils_2.assert)(this.version === types_1.MarketVersion.V2, `Can not push V2 lens data to V1 market!`);
+            const config = this.hooksConfig;
+            (0, utils_2.assert)(config !== undefined, `V2 market has no hooksConfig!`);
+            config.minimumDeposit = this.underlyingToken.getAmount(data.hooksConfig.minimumDeposit);
+            if (config.kind === types_1.HooksKind.FixedTerm) {
+                config.fixedTermEndTime = data.hooksConfig.fixedTermEndTime;
+            }
+            else if (config.kind === types_1.HooksKind.PeriodicTerm) {
+                config.firstWithdrawalWindowStart = data.hooksConfig.firstWithdrawalWindowStart;
+                config.periodDuration = data.hooksConfig.periodDuration;
+                config.withdrawalWindowDuration = data.hooksConfig.withdrawalWindowDuration;
+                config.periodicTermClosed = data.hooksConfig.periodicTermClosed;
+            }
+        }
+        else {
+            (0, utils_2.assert)(this.version === types_1.MarketVersion.V1, `Can not push V1 lens data to V2 market!`);
+        }
     }
     /* -------------------------------------------------------------------------- */
     /*                            Class Builder Methods                           */
     /* -------------------------------------------------------------------------- */
     static fromSubgraphMarketData(chainId, provider, data, signerAddress) {
         const underlyingToken = token_1.Token.fromSubgraphToken(chainId, data._asset, provider);
-        const marketToken = new token_1.Token(chainId, data.id, data.name, data.symbol, data.decimals, false, provider);
-        const hasTotals = hasSubgraphMarketTotals(data);
-        const hasRecords = hasSubgraphMarketRecords(data);
-        const scaledTotalSupply = (0, token_1.toRawAmount)(data.scaledTotalSupply);
-        const scaleFactor = (0, token_1.toRawAmount)(data.scaleFactor);
-        const scaledWithdrawals = (0, token_1.toRawAmount)(data.scaledPendingWithdrawals);
-        const scaledRequiredReserves = (0, utils_1.bipMulBigint)(scaledTotalSupply - scaledWithdrawals, data.reserveRatioBips) +
-            scaledWithdrawals;
-        const coverageLiquidity = (0, utils_1.rayMulBigint)(scaledRequiredReserves, scaleFactor) +
-            (0, token_1.toRawAmount)(data.pendingProtocolFees) +
-            (0, token_1.toRawAmount)(data.normalizedUnclaimedWithdrawals);
+        const marketToken = token_1.Token.fromSubgraphMarketData(chainId, data, provider);
+        const scaledTotalSupply = ethers_1.BigNumber.from(data.scaledTotalSupply);
+        const scaleFactor = ethers_1.BigNumber.from(data.scaleFactor);
+        const scaledWithdrawals = ethers_1.BigNumber.from(data.scaledPendingWithdrawals);
+        const scaledRequiredReserves = (0, utils_2.bipMul)(scaledTotalSupply.sub(scaledWithdrawals), ethers_1.BigNumber.from(data.reserveRatioBips)).add(scaledWithdrawals);
+        const coverageLiquidity = (0, utils_2.rayMul)(scaledRequiredReserves, scaleFactor)
+            .add(data.pendingProtocolFees)
+            .add(data.normalizedUnclaimedWithdrawals);
         let hooksConfig;
-        let hooksFactory;
         if (data.version === types_1.MarketVersion.V2) {
-            (0, utils_1.assert)(!!data.hooks, `V2 markets require hooks`);
-            (0, utils_1.assert)(!!data.hooksConfig, `V2 markets require hooksConfig`);
-            const { minimumDeposit: _minimumDeposit, depositRequiresAccess, transferRequiresAccess, queueWithdrawalRequiresAccess, allowClosureBeforeTerm, allowTermReduction, fixedTermEndTime, transfersDisabled } = data.hooksConfig;
-            const flags = {
-                useOnDeposit: data.hooksConfig.useOnDeposit,
-                useOnQueueWithdrawal: data.hooksConfig.useOnQueueWithdrawal,
-                useOnExecuteWithdrawal: data.hooksConfig.useOnExecuteWithdrawal,
-                useOnTransfer: data.hooksConfig.useOnTransfer,
-                useOnBorrow: data.hooksConfig.useOnBorrow,
-                useOnRepay: data.hooksConfig.useOnRepay,
-                useOnCloseMarket: data.hooksConfig.useOnCloseMarket,
-                useOnNukeFromOrbit: data.hooksConfig.useOnNukeFromOrbit,
-                useOnSetMaxTotalSupply: data.hooksConfig.useOnSetMaxTotalSupply,
-                useOnSetAnnualInterestAndReserveRatioBips: data.hooksConfig.useOnSetAnnualInterestAndReserveRatioBips,
-                useOnSetProtocolFeeBips: data.hooksConfig.useOnSetProtocolFeeBips
-            };
-            const { id } = data.hooks;
-            const templateData = data.hooks.factoryHooksTemplate.name
-                ? data.hooks.factoryHooksTemplate
-                : {
-                    ...data.hooks.factoryHooksTemplate,
-                    // Older subgraph deployments can contain placeholder factory-template rows
-                    // created before HooksTemplateAdded populated the template name.
-                    name: fixedTermEndTime > 0 ? "FixedTermHooks" : "OpenTermHooks"
-                };
-            const template = (0, access_1.hooksTemplateFromSubgraph)(chainId, provider, templateData);
-            hooksFactory = template.hooksFactory;
+            (0, utils_2.assert)(!!data.hooks, `V2 markets require hooks`);
+            (0, utils_2.assert)(!!data.hooksConfig, `V2 markets require hooksConfig`);
+            const { __typename: _, minimumDeposit: _minimumDeposit, depositRequiresAccess, transferRequiresAccess, queueWithdrawalRequiresAccess, allowClosureBeforeTerm, allowForceBuyBacks, allowTermReduction, fixedTermEndTime, firstWithdrawalWindowStart, periodDuration, withdrawalWindowDuration, periodicTermClosed, pendingAnnualInterestBips, pendingAnnualInterestProposalTimestamp, pendingAnnualInterestResponseWindowStart, pendingAnnualInterestResponseWindowEnd, transfersDisabled, ...flags } = data.hooksConfig;
+            const { id, hooksTemplate: hooksTemplateData } = data.hooks;
+            const template = (0, access_1.hooksTemplateFromSubgraph)(chainId, provider, hooksTemplateData);
             const minimumDeposit = _minimumDeposit
                 ? underlyingToken.getAmount(_minimumDeposit)
                 : undefined;
@@ -680,7 +500,7 @@ class Market extends types_1.ContractWrapper {
                     minimumDeposit,
                     transferRequiresAccess,
                     depositRequiresAccess,
-                    allowForceBuyBacks: false,
+                    allowForceBuyBacks,
                     transfersDisabled
                 };
             }
@@ -695,19 +515,38 @@ class Market extends types_1.ContractWrapper {
                     depositRequiresAccess,
                     queueWithdrawalRequiresAccess,
                     allowClosureBeforeTerm,
-                    allowForceBuyBacks: false,
+                    allowForceBuyBacks,
                     allowTermReduction,
                     fixedTermEndTime,
                     transfersDisabled
                 };
             }
+            else if (template.kind === types_1.HooksKind.PeriodicTerm) {
+                hooksConfig = {
+                    kind: types_1.HooksKind.PeriodicTerm,
+                    hooksAddress: id,
+                    template,
+                    flags,
+                    minimumDeposit,
+                    transferRequiresAccess,
+                    depositRequiresAccess,
+                    queueWithdrawalRequiresAccess,
+                    transfersDisabled,
+                    firstWithdrawalWindowStart,
+                    periodDuration,
+                    withdrawalWindowDuration,
+                    periodicTermClosed,
+                    pendingAnnualInterestBips,
+                    pendingAnnualInterestProposalTimestamp,
+                    pendingAnnualInterestResponseWindowStart,
+                    pendingAnnualInterestResponseWindowEnd
+                };
+            }
         }
         return new Market({
             chainId,
             provider,
             version: data.version,
-            hooksFactory,
-            marketType: hooksFactory ? (0, constants_1.getMarketTypeForHooksFactory)(chainId, hooksFactory) : undefined,
             hooksConfig,
             marketToken,
             underlyingToken,
@@ -725,32 +564,30 @@ class Market extends types_1.ContractWrapper {
             originalReserveRatioBips: data.originalReserveRatioBips,
             temporaryReserveRatioExpiry: data.temporaryReserveRatioExpiry,
             isClosed: data.isClosed,
-            scaleFactor,
-            totalSupply: marketToken.getAmount((0, utils_1.rayMulBigint)(scaledTotalSupply, scaleFactor)),
+            scaleFactor: ethers_1.BigNumber.from(data.scaleFactor),
+            totalSupply: marketToken.getAmount((0, utils_2.rayMul)(scaledTotalSupply, scaleFactor)),
             maxTotalSupply: marketToken.getAmount(data.maxTotalSupply),
             scaledTotalSupply: scaledTotalSupply,
             totalAssets: underlyingToken.getAmount(0),
             lastAccruedProtocolFees: underlyingToken.getAmount(data.pendingProtocolFees),
             normalizedUnclaimedWithdrawals: underlyingToken.getAmount(data.normalizedUnclaimedWithdrawals),
-            scaledPendingWithdrawals: scaledWithdrawals,
+            scaledPendingWithdrawals: ethers_1.BigNumber.from(data.scaledPendingWithdrawals),
             pendingWithdrawalExpiry: +data.pendingWithdrawalExpiry,
             isDelinquent: data.isDelinquent,
             timeDelinquent: data.timeDelinquent,
             lastInterestAccruedTimestamp: data.lastInterestAccruedTimestamp,
             unpaidWithdrawalBatchExpiries: [] /* data.unpaidWithdrawalBatchExpiries */,
             coverageLiquidity: underlyingToken.getAmount(coverageLiquidity),
-            commitmentFeeBips: data.commitmentFeeBips != null ? Number(data.commitmentFeeBips) : undefined,
-            drawnAmount: data.drawnAmount != null ? underlyingToken.getAmount(data.drawnAmount) : undefined,
-            totalBorrowed: underlyingToken.getAmount(hasTotals ? data.totalBorrowed : 0),
-            totalRepaid: underlyingToken.getAmount(hasTotals ? data.totalRepaid : 0),
-            totalBaseInterestAccrued: underlyingToken.getAmount(hasTotals ? data.totalBaseInterestAccrued : 0),
-            totalDelinquencyFeesAccrued: underlyingToken.getAmount(hasTotals ? data.totalDelinquencyFeesAccrued : 0),
-            totalProtocolFeesAccrued: underlyingToken.getAmount(hasTotals ? data.totalProtocolFeesAccrued : 0),
-            totalDeposited: underlyingToken.getAmount(hasTotals ? data.totalDeposited : 0),
-            depositRecords: hasRecords ? data.depositRecords : undefined,
-            repaymentRecords: hasRecords ? data.repaymentRecords : undefined,
-            borrowRecords: hasRecords ? data.borrowRecords : undefined,
-            feeCollectionRecords: hasRecords ? data.feeCollectionRecords : undefined,
+            totalBorrowed: underlyingToken.getAmount(data.totalBorrowed),
+            totalRepaid: underlyingToken.getAmount(data.totalRepaid),
+            totalBaseInterestAccrued: underlyingToken.getAmount(data.totalBaseInterestAccrued),
+            totalDelinquencyFeesAccrued: underlyingToken.getAmount(data.totalDelinquencyFeesAccrued),
+            totalProtocolFeesAccrued: underlyingToken.getAmount(data.totalProtocolFeesAccrued),
+            totalDeposited: underlyingToken.getAmount(data.totalDeposited),
+            depositRecords: data.depositRecords,
+            repaymentRecords: data.repaymentRecords,
+            borrowRecords: data.borrowRecords,
+            feeCollectionRecords: data.feeCollectionRecords,
             deployedEvent: data.deployedEvent,
             eventIndex: data.eventIndex,
             numCollateralContracts: data.numCollateralContracts,
@@ -769,30 +606,30 @@ class Market extends types_1.ContractWrapper {
             borrower: data.borrower,
             controller: data.controller,
             feeRecipient: data.feeRecipient,
-            protocolFeeBips: (0, utils_1.toNumber)(data.protocolFeeBips),
-            delinquencyFeeBips: (0, utils_1.toNumber)(data.delinquencyFeeBips),
-            delinquencyGracePeriod: (0, utils_1.toNumber)(data.delinquencyGracePeriod),
-            withdrawalBatchDuration: (0, utils_1.toNumber)(data.withdrawalBatchDuration),
-            reserveRatioBips: (0, utils_1.toNumber)(data.reserveRatioBips),
-            annualInterestBips: (0, utils_1.toNumber)(data.annualInterestBips),
+            protocolFeeBips: data.protocolFeeBips.toNumber(),
+            delinquencyFeeBips: data.delinquencyFeeBips.toNumber(),
+            delinquencyGracePeriod: data.delinquencyGracePeriod.toNumber(),
+            withdrawalBatchDuration: data.withdrawalBatchDuration.toNumber(),
+            reserveRatioBips: data.reserveRatioBips.toNumber(),
+            annualInterestBips: data.annualInterestBips.toNumber(),
             temporaryReserveRatio: data.temporaryReserveRatio,
-            originalAnnualInterestBips: (0, utils_1.toNumber)(data.originalAnnualInterestBips),
-            originalReserveRatioBips: (0, utils_1.toNumber)(data.originalReserveRatioBips),
-            temporaryReserveRatioExpiry: (0, utils_1.toNumber)(data.temporaryReserveRatioExpiry),
+            originalAnnualInterestBips: data.originalAnnualInterestBips.toNumber(),
+            originalReserveRatioBips: data.originalReserveRatioBips.toNumber(),
+            temporaryReserveRatioExpiry: data.temporaryReserveRatioExpiry.toNumber(),
             isClosed: data.isClosed,
-            scaleFactor: (0, token_1.toRawAmount)(data.scaleFactor),
+            scaleFactor: data.scaleFactor,
             totalSupply: marketToken.getAmount(data.totalSupply),
             maxTotalSupply: marketToken.getAmount(data.maxTotalSupply),
-            scaledTotalSupply: (0, token_1.toRawAmount)(data.scaledTotalSupply),
+            scaledTotalSupply: data.scaledTotalSupply,
             totalAssets: underlyingToken.getAmount(data.totalAssets),
             lastAccruedProtocolFees: underlyingToken.getAmount(data.lastAccruedProtocolFees),
             normalizedUnclaimedWithdrawals: underlyingToken.getAmount(data.normalizedUnclaimedWithdrawals),
-            scaledPendingWithdrawals: (0, token_1.toRawAmount)(data.scaledPendingWithdrawals),
-            pendingWithdrawalExpiry: (0, utils_1.toNumber)(data.pendingWithdrawalExpiry),
+            scaledPendingWithdrawals: data.scaledPendingWithdrawals,
+            pendingWithdrawalExpiry: data.pendingWithdrawalExpiry.toNumber(),
             isDelinquent: data.isDelinquent,
-            timeDelinquent: (0, utils_1.toNumber)(data.timeDelinquent),
-            lastInterestAccruedTimestamp: (0, utils_1.toNumber)(data.lastInterestAccruedTimestamp),
-            unpaidWithdrawalBatchExpiries: data.unpaidWithdrawalBatchExpiries.map(utils_1.toNumber),
+            timeDelinquent: data.timeDelinquent.toNumber(),
+            lastInterestAccruedTimestamp: data.lastInterestAccruedTimestamp.toNumber(),
+            unpaidWithdrawalBatchExpiries: data.unpaidWithdrawalBatchExpiries,
             coverageLiquidity: underlyingToken.getAmount(data.coverageLiquidity),
             totalBorrowed: undefined,
             totalRepaid: undefined,
@@ -809,13 +646,13 @@ class Market extends types_1.ContractWrapper {
             signerAddress: signerAddress
         });
     }
-    static fromMarketDataV2(chainId, provider, { hooks, hooksConfig: hooksConfigData, ...data }, signerAddress) {
+    static fromMarketDataV2(chainId, provider, { hooks, hooksConfig: hooksConfigData, ...data }) {
         const marketToken = token_1.Token.fromTokenMetadata(chainId, data.marketToken, provider);
         const underlyingToken = token_1.Token.fromTokenMetadata(chainId, data.underlyingToken, provider);
         const { hooksAddress } = hooks;
         let hooksConfig;
-        const hooksKind = (0, utils_1.toNumber)(hooksConfigData.kind);
-        if (hooksKind === 1) {
+        const allowForceBuyBacks = hooksConfigData.allowForceBuyBacks ?? false;
+        if (hooksConfigData.kind === 1) {
             hooksConfig = {
                 kind: types_1.HooksKind.OpenTerm,
                 hooksAddress: hooksAddress,
@@ -824,10 +661,10 @@ class Market extends types_1.ContractWrapper {
                 transferRequiresAccess: hooksConfigData.transferRequiresAccess,
                 transfersDisabled: hooksConfigData.transfersDisabled,
                 minimumDeposit: underlyingToken.getAmount(hooksConfigData.minimumDeposit),
-                allowForceBuyBacks: false
+                allowForceBuyBacks
             };
         }
-        else if (hooksKind === 2) {
+        else if (hooksConfigData.kind === 2) {
             hooksConfig = {
                 kind: types_1.HooksKind.FixedTerm,
                 hooksAddress: hooksAddress,
@@ -836,142 +673,73 @@ class Market extends types_1.ContractWrapper {
                 transferRequiresAccess: hooksConfigData.transferRequiresAccess,
                 transfersDisabled: hooksConfigData.transfersDisabled,
                 minimumDeposit: underlyingToken.getAmount(hooksConfigData.minimumDeposit),
-                fixedTermEndTime: (0, utils_1.toNumber)(hooksConfigData.fixedTermEndTime),
+                fixedTermEndTime: hooksConfigData.fixedTermEndTime,
                 queueWithdrawalRequiresAccess: hooksConfigData.withdrawalRequiresAccess,
                 allowTermReduction: hooksConfigData.allowTermReduction,
                 allowClosureBeforeTerm: hooksConfigData.allowClosureBeforeTerm,
-                allowForceBuyBacks: false
+                allowForceBuyBacks
             };
         }
-        else {
-            throw Error(`Unknown hooks kind: ${hooks.hooksTemplate.name}, version #${hooksKind}`);
-        }
-        return new Market({
-            provider,
-            hooksFactory: data.hooksFactory,
-            marketType: (0, constants_1.getMarketTypeForHooksFactory)(chainId, data.hooksFactory),
-            hooksConfig,
-            version: types_1.MarketVersion.V2,
-            chainId: chainId,
-            marketToken: marketToken,
-            underlyingToken: underlyingToken,
-            borrower: data.borrower,
-            feeRecipient: data.feeRecipient,
-            protocolFeeBips: (0, utils_1.toNumber)(data.protocolFeeBips),
-            delinquencyFeeBips: (0, utils_1.toNumber)(data.delinquencyFeeBips),
-            delinquencyGracePeriod: (0, utils_1.toNumber)(data.delinquencyGracePeriod),
-            withdrawalBatchDuration: (0, utils_1.toNumber)(data.withdrawalBatchDuration),
-            reserveRatioBips: (0, utils_1.toNumber)(data.reserveRatioBips),
-            annualInterestBips: (0, utils_1.toNumber)(data.annualInterestBips),
-            temporaryReserveRatio: data.temporaryReserveRatio,
-            originalAnnualInterestBips: (0, utils_1.toNumber)(data.originalAnnualInterestBips),
-            originalReserveRatioBips: (0, utils_1.toNumber)(data.originalReserveRatioBips),
-            temporaryReserveRatioExpiry: (0, utils_1.toNumber)(data.temporaryReserveRatioExpiry),
-            isClosed: data.isClosed,
-            scaleFactor: (0, token_1.toRawAmount)(data.scaleFactor),
-            totalSupply: marketToken.getAmount(data.totalSupply),
-            maxTotalSupply: marketToken.getAmount(data.maxTotalSupply),
-            scaledTotalSupply: (0, token_1.toRawAmount)(data.scaledTotalSupply),
-            totalAssets: underlyingToken.getAmount(data.totalAssets),
-            lastAccruedProtocolFees: underlyingToken.getAmount(data.lastAccruedProtocolFees),
-            normalizedUnclaimedWithdrawals: underlyingToken.getAmount(data.normalizedUnclaimedWithdrawals),
-            scaledPendingWithdrawals: (0, token_1.toRawAmount)(data.scaledPendingWithdrawals),
-            pendingWithdrawalExpiry: (0, utils_1.toNumber)(data.pendingWithdrawalExpiry),
-            isDelinquent: data.isDelinquent,
-            timeDelinquent: (0, utils_1.toNumber)(data.timeDelinquent),
-            lastInterestAccruedTimestamp: (0, utils_1.toNumber)(data.lastInterestAccruedTimestamp),
-            unpaidWithdrawalBatchExpiries: data.unpaidWithdrawalBatchExpiries.map(utils_1.toNumber),
-            coverageLiquidity: underlyingToken.getAmount(data.coverageLiquidity),
-            signerAddress
-            // borrowableAssets: underlyingToken.getAmount(data.borrowableAssets)
-        });
-    }
-    static fromMarketDataV2_5(chainId, provider, { market, commitmentFeeBips, drawnAmount }, allowForceBuyBacks, signerAddress) {
-        void allowForceBuyBacks;
-        const { hooks, hooksConfig: hooksConfigData, ...data } = market;
-        const marketToken = token_1.Token.fromTokenMetadata(chainId, data.marketToken, provider);
-        const underlyingToken = token_1.Token.fromTokenMetadata(chainId, data.underlyingToken, provider);
-        const { hooksAddress } = hooks;
-        let hooksConfig;
-        const hooksKind = (0, utils_1.toNumber)(hooksConfigData.kind);
-        if (hooksKind === 1) {
+        else if (hooksConfigData.kind === 3) {
             hooksConfig = {
-                kind: types_1.HooksKind.OpenTerm,
-                hooksAddress,
-                flags: { ...hooksConfigData.flags },
-                depositRequiresAccess: hooksConfigData.depositRequiresAccess,
-                transferRequiresAccess: hooksConfigData.transferRequiresAccess,
-                transfersDisabled: hooksConfigData.transfersDisabled,
-                minimumDeposit: underlyingToken.getAmount(hooksConfigData.minimumDeposit),
-                allowForceBuyBacks: false
-            };
-        }
-        else if (hooksKind === 2) {
-            hooksConfig = {
-                kind: types_1.HooksKind.FixedTerm,
-                hooksAddress,
+                kind: types_1.HooksKind.PeriodicTerm,
+                hooksAddress: hooksAddress,
                 flags: { ...hooksConfigData.flags },
                 depositRequiresAccess: hooksConfigData.depositRequiresAccess,
                 transferRequiresAccess: hooksConfigData.transferRequiresAccess,
                 transfersDisabled: hooksConfigData.transfersDisabled,
                 minimumDeposit: underlyingToken.getAmount(hooksConfigData.minimumDeposit),
-                fixedTermEndTime: (0, utils_1.toNumber)(hooksConfigData.fixedTermEndTime),
                 queueWithdrawalRequiresAccess: hooksConfigData.withdrawalRequiresAccess,
-                allowTermReduction: hooksConfigData.allowTermReduction,
-                allowClosureBeforeTerm: hooksConfigData.allowClosureBeforeTerm,
-                allowForceBuyBacks: false
+                firstWithdrawalWindowStart: hooksConfigData.firstWithdrawalWindowStart,
+                periodDuration: hooksConfigData.periodDuration,
+                withdrawalWindowDuration: hooksConfigData.withdrawalWindowDuration,
+                periodicTermClosed: hooksConfigData.periodicTermClosed,
+                pendingAnnualInterestBips: 0,
+                pendingAnnualInterestProposalTimestamp: 0,
+                pendingAnnualInterestResponseWindowStart: 0,
+                pendingAnnualInterestResponseWindowEnd: 0
             };
         }
         else {
-            throw Error(`Unknown hooks kind: ${hooks.hooksTemplate.name}, version #${hooksKind}`);
+            throw Error(`Unknown hooks kind: ${hooks.hooksTemplate.name}, version #${hooksConfigData.kind}`);
         }
         return new Market({
             provider,
-            hooksFactory: data.hooksFactory,
-            marketType: (0, constants_1.getMarketTypeForHooksFactory)(chainId, data.hooksFactory),
             hooksConfig,
             version: types_1.MarketVersion.V2,
-            chainId,
-            marketToken,
-            underlyingToken,
+            chainId: chainId,
+            marketToken: marketToken,
+            underlyingToken: underlyingToken,
             borrower: data.borrower,
             feeRecipient: data.feeRecipient,
-            protocolFeeBips: (0, utils_1.toNumber)(data.protocolFeeBips),
-            delinquencyFeeBips: (0, utils_1.toNumber)(data.delinquencyFeeBips),
-            delinquencyGracePeriod: (0, utils_1.toNumber)(data.delinquencyGracePeriod),
-            withdrawalBatchDuration: (0, utils_1.toNumber)(data.withdrawalBatchDuration),
-            reserveRatioBips: (0, utils_1.toNumber)(data.reserveRatioBips),
-            annualInterestBips: (0, utils_1.toNumber)(data.annualInterestBips),
+            protocolFeeBips: data.protocolFeeBips.toNumber(),
+            delinquencyFeeBips: data.delinquencyFeeBips.toNumber(),
+            delinquencyGracePeriod: data.delinquencyGracePeriod.toNumber(),
+            withdrawalBatchDuration: data.withdrawalBatchDuration.toNumber(),
+            reserveRatioBips: data.reserveRatioBips.toNumber(),
+            annualInterestBips: data.annualInterestBips.toNumber(),
             temporaryReserveRatio: data.temporaryReserveRatio,
-            originalAnnualInterestBips: (0, utils_1.toNumber)(data.originalAnnualInterestBips),
-            originalReserveRatioBips: (0, utils_1.toNumber)(data.originalReserveRatioBips),
-            temporaryReserveRatioExpiry: (0, utils_1.toNumber)(data.temporaryReserveRatioExpiry),
+            originalAnnualInterestBips: data.originalAnnualInterestBips.toNumber(),
+            originalReserveRatioBips: data.originalReserveRatioBips.toNumber(),
+            temporaryReserveRatioExpiry: data.temporaryReserveRatioExpiry.toNumber(),
             isClosed: data.isClosed,
-            scaleFactor: (0, token_1.toRawAmount)(data.scaleFactor),
+            scaleFactor: data.scaleFactor,
             totalSupply: marketToken.getAmount(data.totalSupply),
             maxTotalSupply: marketToken.getAmount(data.maxTotalSupply),
-            scaledTotalSupply: (0, token_1.toRawAmount)(data.scaledTotalSupply),
+            scaledTotalSupply: data.scaledTotalSupply,
             totalAssets: underlyingToken.getAmount(data.totalAssets),
             lastAccruedProtocolFees: underlyingToken.getAmount(data.lastAccruedProtocolFees),
             normalizedUnclaimedWithdrawals: underlyingToken.getAmount(data.normalizedUnclaimedWithdrawals),
-            scaledPendingWithdrawals: (0, token_1.toRawAmount)(data.scaledPendingWithdrawals),
-            pendingWithdrawalExpiry: (0, utils_1.toNumber)(data.pendingWithdrawalExpiry),
+            scaledPendingWithdrawals: data.scaledPendingWithdrawals,
+            pendingWithdrawalExpiry: data.pendingWithdrawalExpiry.toNumber(),
             isDelinquent: data.isDelinquent,
-            timeDelinquent: (0, utils_1.toNumber)(data.timeDelinquent),
-            lastInterestAccruedTimestamp: (0, utils_1.toNumber)(data.lastInterestAccruedTimestamp),
-            unpaidWithdrawalBatchExpiries: data.unpaidWithdrawalBatchExpiries.map(utils_1.toNumber),
-            coverageLiquidity: underlyingToken.getAmount(data.coverageLiquidity),
-            commitmentFeeBips: commitmentFeeBips.isPresent
-                ? (0, utils_1.toNumber)(commitmentFeeBips.value)
-                : undefined,
-            drawnAmount: drawnAmount.isPresent ? underlyingToken.getAmount(drawnAmount.value) : undefined,
-            signerAddress
+            timeDelinquent: data.timeDelinquent.toNumber(),
+            lastInterestAccruedTimestamp: data.lastInterestAccruedTimestamp.toNumber(),
+            unpaidWithdrawalBatchExpiries: data.unpaidWithdrawalBatchExpiries,
+            coverageLiquidity: underlyingToken.getAmount(data.coverageLiquidity)
+            // borrowableAssets: underlyingToken.getAmount(data.borrowableAssets)
         });
     }
-    static async fromUnifiedMarketData(chainId, provider, data, signerAddress) {
-        const marketData = toUnifiedMarketDataV2(data);
-        return Market.fromMarketDataV2_5(chainId, provider, marketData, false, signerAddress);
-    }
     /* -------------------------------------------------------------------------- */
     /*                               Static Queries                               */
     /* -------------------------------------------------------------------------- */
@@ -979,133 +747,53 @@ class Market extends types_1.ContractWrapper {
      * @returns `Market` instance for `market`
      */
     static async getMarket(chainId, market, provider) {
-        const signerAddress = await (0, ethers_signer_1.getEthersSignerAddress)(provider);
-        if (hasUnifiedLatestLensForDirectReads(chainId)) {
-            try {
-                const data = await (0, market_lens_1.getUnifiedMarketDataV2)(chainId, provider, market);
-                return Market.fromUnifiedMarketData(chainId, provider, data, signerAddress);
-            }
-            catch (_) {
-                // Fall back to the legacy lens for V1 markets and pre-unified deployments.
-            }
-        }
-        const data = await (0, market_lens_1.getLegacyMarketData)(chainId, provider, market);
-        return Market.fromMarketData(chainId, data, provider, signerAddress);
+        const lens = (0, constants_1.getLensContract)(chainId, provider);
+        const data = await lens.getMarketData(market);
+        return Market.fromMarketData(chainId, data, provider, abstract_signer_1.Signer.isSigner(provider) ? await provider.getAddress() : undefined);
     }
     /**
      * @returns `Market` instance for `market`
      */
     static async getMarketV2(chainId, market, provider) {
-        const signerAddress = await (0, ethers_signer_1.getEthersSignerAddress)(provider);
-        if (hasUnifiedLatestLensForDirectReads(chainId)) {
-            try {
-                const data = await (0, market_lens_1.getUnifiedMarketDataV2)(chainId, provider, market);
-                return Market.fromUnifiedMarketData(chainId, provider, data, signerAddress);
-            }
-            catch (_) {
-                // Fall back to the pre-2.5 V2 lens for chains that have not fully migrated.
-            }
-        }
-        const data = await (0, market_lens_1.getV2MarketData)(chainId, provider, market);
-        return Market.fromMarketDataV2(chainId, provider, data, signerAddress);
-    }
-    /**
-     * @returns V2 `Market` instances for `markets`, preserving V2.5/RCF fields
-     *          when the current lens exposes them.
-     */
-    static async getMarketsV2(chainId, markets, provider) {
-        const signerAddress = await (0, ethers_signer_1.getEthersSignerAddress)(provider);
-        if (hasUnifiedLatestLensForDirectReads(chainId)) {
-            try {
-                const data = await (0, market_lens_1.getUnifiedMarketsDataV2)(chainId, provider, markets);
-                return Promise.all(data.map((market) => Market.fromUnifiedMarketData(chainId, provider, market, signerAddress)));
-            }
-            catch (_) {
-                // Fall back to the pre-2.5 V2 lens for chains that have not fully migrated.
-            }
-        }
-        return Promise.all(markets.map(async (market) => {
-            const data = await (0, market_lens_1.getV2MarketData)(chainId, provider, market);
-            return Market.fromMarketDataV2(chainId, provider, data, signerAddress);
-        }));
-    }
-    /**
-     * Refresh existing V2 market instances with the focused live lens surface when available.
-     * Falls back to broad V2 market reads so callers can use this as a route-intent API.
-     */
-    static async refreshMarketsV2LiveData(chainId, markets, provider) {
-        if (markets.length === 0) {
-            return markets;
-        }
-        const marketAddresses = markets.map((market) => market.address);
-        if (hasUnifiedLatestLensForDirectReads(chainId)) {
-            try {
-                const updates = await (0, market_lens_1.getUnifiedMarketsLiveDataV2)(chainId, provider, marketAddresses);
-                updates.forEach((update, i) => {
-                    markets[i].updateWithLiveData(update);
-                });
-                return markets;
-            }
-            catch (_) {
-                // Fall back to broad reads for older unified lens deployments.
-            }
-        }
-        const refreshedMarkets = await Market.getMarketsV2(chainId, marketAddresses, provider);
-        refreshedMarkets.forEach((market, i) => {
-            Object.assign(markets[i], market);
-        });
-        return markets;
+        const lens = (0, constants_1.getLensV2Contract)(chainId, provider);
+        const data = await lens.getMarketData(market);
+        return Market.fromMarketDataV2(chainId, provider, data);
     }
     /**
      * @returns `Market` instances for `markets`
      */
     static async getMarkets(chainId, markets, provider) {
-        const signerAddress = await (0, ethers_signer_1.getEthersSignerAddress)(provider);
-        if (hasUnifiedLatestLensForDirectReads(chainId)) {
-            try {
-                const data = await (0, market_lens_1.getUnifiedMarketsDataV2)(chainId, provider, markets);
-                return Promise.all(data.map((market) => Market.fromUnifiedMarketData(chainId, provider, market, signerAddress)));
-            }
-            catch (_) {
-                return Promise.all(markets.map((market) => Market.getMarket(chainId, market, provider)));
-            }
-        }
-        const data = await (0, market_lens_1.getLegacyMarketsData)(chainId, provider, markets);
+        const lens = (0, constants_1.getLensContract)(chainId, provider);
+        const data = await lens.getMarketsData(markets);
+        const signerAddress = abstract_signer_1.Signer.isSigner(provider) ? await provider.getAddress() : undefined;
         return data.map((market) => Market.fromMarketData(chainId, market, provider, signerAddress));
     }
     /**
      * @return All deployed markets
      */
     static async getAllMarkets(chainId, provider) {
-        const markets = await (0, arch_controller_1.getRegisteredMarkets)(chainId, provider);
-        if (!markets.length) {
-            return [];
-        }
-        return Market.getMarkets(chainId, markets, provider);
+        const lens = (0, constants_1.getLensContract)(chainId, provider);
+        const signerAddress = abstract_signer_1.Signer.isSigner(provider) ? await provider.getAddress() : undefined;
+        return lens
+            .getAllMarketsData()
+            .then((data) => data.map((market) => Market.fromMarketData(chainId, market, provider, signerAddress)));
     }
     /**
      * @dev Get a paginated list of deployed markets.
      */
     static async getPaginatedMarkets(chainId, provider, start = 0, count) {
-        if (count <= 0) {
-            return [];
-        }
-        const totalMarkets = await (0, arch_controller_1.getRegisteredMarketsCount)(chainId, provider);
-        if (start >= totalMarkets) {
-            return [];
-        }
-        const end = Math.min(start + count, totalMarkets);
-        const markets = await (0, arch_controller_1.getRegisteredMarketsPage)(chainId, provider, start, end);
-        if (!markets.length) {
-            return [];
-        }
-        return Market.getMarkets(chainId, markets, provider);
+        const signerAddress = abstract_signer_1.Signer.isSigner(provider) ? await provider.getAddress() : undefined;
+        const lens = (0, constants_1.getLensContract)(chainId, provider);
+        return lens
+            .getPaginatedMarketsData(start, count)
+            .then((data) => data.map((market) => Market.fromMarketData(chainId, market, provider, signerAddress)));
     }
     /**
      * @return Total number of deployed markets.
      */
     static async getMarketsCount(chainId, provider) {
-        return (0, arch_controller_1.getRegisteredMarketsCount)(chainId, provider);
+        const lens = (0, constants_1.getLensContract)(chainId, provider);
+        return lens.getMarketsCount().then((count) => count.toNumber());
     }
 }
 exports.Market = Market;