@wildcatfi/wildcat-sdk 2.0.83 → 3.0.2

package/dist/{account.js → account/index.js}

@@ -1,12 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MarketAccount = exports.LenderRole = void 0;
 const ethers_1 = require("ethers");
-const token_1 = require("./token");
-const market_1 = require("./market");
-const utils_1 = require("./utils");
-const constants_1 = require("./constants");
-const withdrawal_status_1 = require("./withdrawal-status");
+const token_1 = require("../token");
+const market_1 = require("../market");
+const typechain_1 = require("../typechain");
+const utils_1 = require("../utils");
+const constants_1 = require("../constants");
+const types_1 = require("../types");
+const withdrawal_status_1 = require("../withdrawal-status");
+const validation_1 = require("./validation");
+__exportStar(require("./validation"), exports);
 var LenderRole;
 (function (LenderRole) {
     LenderRole[LenderRole["Null"] = 0] = "Null";
@@ -14,9 +32,7 @@ var LenderRole;
     LenderRole[LenderRole["WithdrawOnly"] = 2] = "WithdrawOnly";
     LenderRole[LenderRole["DepositAndWithdraw"] = 3] = "DepositAndWithdraw";
 })(LenderRole = exports.LenderRole || (exports.LenderRole = {}));
-const isMarketInstanceArray = (markets) => {
-    return typeof markets[0] !== "string";
-};
+const NullProviderIndex = ethers_1.BigNumber.from(2).pow(24).sub(1).toNumber();
 /**
  * Class to provide information about a market user's account
  * and to wrap interactions.
@@ -26,21 +42,9 @@ const isMarketInstanceArray = (markets) => {
  *
  */
 class MarketAccount {
-    constructor(account, isAuthorizedOnController, role, scaledMarketBalance, marketBalance, underlyingBalance, underlyingApproval, market, deposits = [], totalDeposited, lastScaleFactor, lastUpdatedTimestamp, totalInterestEarned, numPendingWithdrawalBatches) {
-        this.account = account;
-        this.isAuthorizedOnController = isAuthorizedOnController;
-        this.role = role;
-        this.scaledMarketBalance = scaledMarketBalance;
-        this.marketBalance = marketBalance;
-        this.underlyingBalance = underlyingBalance;
-        this.underlyingApproval = underlyingApproval;
-        this.market = market;
-        this.deposits = deposits;
-        this.totalDeposited = totalDeposited;
-        this.lastScaleFactor = lastScaleFactor;
-        this.lastUpdatedTimestamp = lastUpdatedTimestamp;
-        this.totalInterestEarned = totalInterestEarned;
-        this.numPendingWithdrawalBatches = numPendingWithdrawalBatches;
+    constructor(args) {
+        Object.assign(this, args);
+        this.depositRecords = (args.deposits ?? []).map((log) => (0, utils_1.parseMarketRecord)(this.market.underlyingToken, log));
     }
     get chainId() {
         return this.market.chainId;
@@ -54,42 +58,108 @@ class MarketAccount {
     get isBorrower() {
         return this.market.borrower.toLowerCase() === this.account.toLowerCase();
     }
-    get canDeposit() {
-        return (this.role === LenderRole.DepositAndWithdraw ||
-            (this.role === LenderRole.Null && this.isAuthorizedOnController));
+    get credentialExpiry() {
+        if (this.credential && this.credential.lastProvider) {
+            return this.credential.lastApprovalTimestamp + this.credential.lastProvider.timeToLive;
+        }
+        return undefined;
+    }
+    get hasValidCredential() {
+        const expiry = this.credentialExpiry;
+        return expiry !== undefined && expiry >= Date.now() / 1000;
+    }
+    get depositAvailability() {
+        if (this.market.isClosed)
+            return validation_1.DepositStatus.MarketClosed;
+        if (this.market.version === types_1.MarketVersion.V1) {
+            if (this.role === LenderRole.Blocked)
+                return validation_1.DepositStatus.Blocked;
+            if (this.role === LenderRole.DepositAndWithdraw ||
+                (this.role === LenderRole.Null && !!this.isAuthorizedOnController)) {
+                return validation_1.DepositStatus.Ready;
+            }
+            return validation_1.DepositStatus.InsufficientRole;
+        }
+        else {
+            const config = this.market.hooksConfig;
+            (0, utils_1.assert)(config !== undefined, `V2 market missing hooksConfig`);
+            // Can deposit if the market does not use the onDeposit hook
+            if (!config.flags.useOnDeposit)
+                return validation_1.DepositStatus.Ready;
+            // Can not deposit if the lender is blocked
+            if (this.credential?.isBlockedFromDeposits)
+                return validation_1.DepositStatus.Blocked;
+            // Can deposit if lender has credential or market does not require one
+            if (config.depositRequiresAccess && !this.hasValidCredential) {
+                return validation_1.DepositStatus.RequiresAccess;
+            }
+            return validation_1.DepositStatus.Ready;
+        }
     }
-    get canWithdraw() {
-        return (this.role === LenderRole.WithdrawOnly ||
-            this.role === LenderRole.DepositAndWithdraw ||
-            (this.role === LenderRole.Null && this.isAuthorizedOnController));
+    get withdrawalAvailability() {
+        if (this.market.version === types_1.MarketVersion.V1) {
+            if (this.role === LenderRole.WithdrawOnly ||
+                this.role === LenderRole.DepositAndWithdraw ||
+                (this.role === LenderRole.Null && !!this.isAuthorizedOnController)) {
+                return validation_1.QueueWithdrawalStatus.Ready;
+            }
+            return validation_1.QueueWithdrawalStatus.InsufficientRole;
+        }
+        else {
+            const config = this.market.hooksConfig;
+            (0, utils_1.assert)(config !== undefined, `V2 market missing hooksConfig`);
+            // Can withdraw if market does not use wd hook
+            if (!config.flags.useOnQueueWithdrawal)
+                return validation_1.QueueWithdrawalStatus.Ready;
+            // Can not withdraw if market in fixed term
+            if (this.market.isInFixedTerm)
+                return validation_1.QueueWithdrawalStatus.MarketInClosedTerm;
+            // Can not withdraw if market requires access and lender has no credential and is not a known lender
+            if (config.flags.useOnQueueWithdrawal &&
+                (config.kind === types_1.HooksKind.FixedTerm
+                    ? config.queueWithdrawalRequiresAccess
+                    : config.flags.useOnQueueWithdrawal) &&
+                !(this.hasValidCredential || this.isKnownLender)) {
+                return validation_1.QueueWithdrawalStatus.RequiresAccess;
+            }
+            return validation_1.QueueWithdrawalStatus.Ready;
+        }
     }
     canChangeAPR(apr) {
         return this.isBorrower && apr > 0 && apr <= 10000 && this.market.canChangeAPR(apr);
     }
-    checkCloseMarketStep() {
+    previewCloseMarket() {
         if (!this.isBorrower)
-            return { status: "NotBorrower" };
+            return { status: validation_1.CloseMarketStatus.NotBorrower };
+        if (this.market.version === types_1.MarketVersion.V2) {
+            const config = this.market.hooksConfig;
+            (0, utils_1.assert)(config !== undefined, `V2 market missing hooksConfig`);
+            if (this.market.isInFixedTerm &&
+                config.kind === types_1.HooksKind.FixedTerm &&
+                config.allowClosureBeforeTerm) {
+                return { status: validation_1.CloseMarketStatus.EarlyClosureNotAllowed };
+            }
+        }
         // add 0.1% to account for interest
         const amount = this.market.underlyingToken.getAmount((0, utils_1.bipMul)(this.market.outstandingDebt.raw, (0, token_1.toBn)(10010)));
         if (amount.gt(this.underlyingBalance)) {
-            return { status: "InsufficientBalance" };
+            return { status: validation_1.CloseMarketStatus.InsufficientBalance, outstanding: amount };
         }
         if (this.market.unpaidWithdrawalBatchExpiries.length > 0) {
-            return { status: "UnpaidWithdrawalBatches" };
+            return { status: validation_1.CloseMarketStatus.UnpaidWithdrawalBatches };
         }
-        if (!this.isApprovedFor(this.market.underlyingToken.getAmount((0, utils_1.bipMul)(this.market.outstandingDebt.raw, (0, token_1.toBn)(10006))))) {
-            return {
-                status: "InsufficientAllowance",
-                remainder: amount
-            };
+        if (
+        // @todo proper calculation
+        !this.isApprovedFor(this.market.underlyingToken.getAmount((0, utils_1.bipMul)(this.market.outstandingDebt.raw, (0, token_1.toBn)(10006))))) {
+            return { status: validation_1.CloseMarketStatus.InsufficientAllowance, outstanding: amount };
         }
-        return { status: "Ready" };
+        return { status: validation_1.CloseMarketStatus.Ready };
     }
-    checkSetAPRStep(apr) {
+    previewSetAPR(apr) {
         if (!this.isBorrower)
-            return { status: "NotBorrower" };
+            return { status: validation_1.SetAprStatus.NotBorrower };
         if (!(apr > 0 && apr <= 10000))
-            return { status: "InvalidApr" };
+            return { status: validation_1.SetAprStatus.InvalidApr };
         const [originalReserveRatioBips, originalAnnualInterestBips] = this.market.originalReserveRatioAndAnnualInterestBips;
         const newReserveRatioBips = this.market.getReserveRatioForNewAPR(apr);
         const willChangeReserveRatio = newReserveRatioBips !== this.market.reserveRatioBips;
@@ -103,7 +173,7 @@ class MarketAccount {
             const newCoverageLiquidity = this.market.calculateLiquidityCoverageForReserveRatio(reserveRatioThatMustNotBeDelinquent);
             if (this.market.totalAssets.lt(newCoverageLiquidity)) {
                 return {
-                    status: "InsufficientReserves",
+                    status: validation_1.SetAprStatus.InsufficientReserves,
                     newCoverageLiquidity,
                     newReserveRatio: newReserveRatioBips,
                     missingReserves: newCoverageLiquidity.sub(this.market.totalAssets),
@@ -112,7 +182,7 @@ class MarketAccount {
             }
             else {
                 return {
-                    status: "Ready",
+                    status: validation_1.SetAprStatus.Ready,
                     willChangeReserveRatio: true,
                     newCoverageLiquidity,
                     newReserveRatio: newReserveRatioBips,
@@ -122,50 +192,74 @@ class MarketAccount {
         }
         else {
             return {
-                status: "Ready",
+                status: validation_1.SetAprStatus.Ready,
                 willChangeReserveRatio: false
             };
         }
     }
+    previewSetMaxTotalSupply(amount) {
+        if (!this.isBorrower)
+            return { status: validation_1.SetMaxTotalSupplyStatus.NotBorrower };
+        if (this.market.version === types_1.MarketVersion.V1 && amount.lt(this.market.totalSupply)) {
+            return { status: validation_1.SetMaxTotalSupplyStatus.BelowCurrentSupply };
+        }
+        return { status: validation_1.SetMaxTotalSupplyStatus.Ready };
+    }
     /* -------------------------------------------------------------------------- */
     /*                             Management Actions                             */
     /* -------------------------------------------------------------------------- */
     async closeMarket() {
-        const { status } = this.checkCloseMarketStep();
-        if (status !== "Ready") {
-            throw Error(`Cannot close market: ${status}`);
+        const { status } = this.previewCloseMarket();
+        (0, utils_1.assert)(status === validation_1.CloseMarketStatus.Ready, `Cannot close market: ${status}`);
+        if (this.market.version === types_1.MarketVersion.V1) {
+            (0, utils_1.assert)(this.market.controller !== undefined, "Controller address is required for V1 markets");
+            const controller = (0, constants_1.getControllerContract)(this.market.signer, this.market.controller);
+            return controller.closeMarket(this.market.address);
         }
-        const controller = (0, constants_1.getControllerContract)(this.market.signer, this.market.controller);
-        return controller.closeMarket(this.market.address);
+        return this.market.contract.closeMarket();
     }
     async populateCloseMarket() {
-        const { status } = this.checkCloseMarketStep();
-        if (status !== "Ready") {
-            throw Error(`Cannot close market: ${status}`);
+        const { status } = this.previewCloseMarket();
+        (0, utils_1.assert)(status === validation_1.CloseMarketStatus.Ready, `Cannot close market: ${status}`);
+        if (this.market.version === types_1.MarketVersion.V1) {
+            (0, utils_1.assert)(this.market.controller !== undefined, "Controller address is required for V1 markets");
+            const controller = (0, constants_1.getControllerContract)(this.market.signer, this.market.controller);
+            return {
+                to: controller.address,
+                data: controller.interface.encodeFunctionData("closeMarket", [this.market.address]),
+                value: "0"
+            };
         }
-        const controller = (0, constants_1.getControllerContract)(this.market.signer, this.market.controller);
         return {
-            to: controller.address,
-            data: controller.interface.encodeFunctionData("closeMarket", [this.market.address]),
+            to: this.market.address,
+            data: this.market.contract.interface.encodeFunctionData("closeMarket"),
             value: "0"
         };
     }
     async setMaxTotalSupply(amount) {
-        (0, utils_1.assert)(this.isBorrower, "Only borrower can set maxTotalSupply");
-        if (amount.lt(this.market.totalSupply)) {
-            throw Error("New max total supply must be at least current total supply");
+        const { status } = this.previewSetMaxTotalSupply(amount);
+        (0, utils_1.assert)(status === validation_1.SetMaxTotalSupplyStatus.Ready, `Cannot close market: ${status}`);
+        if (this.market.version === types_1.MarketVersion.V1) {
+            (0, utils_1.assert)(this.market.controller !== undefined, "Controller address is required for V1 markets");
+            const controller = (0, constants_1.getControllerContract)(this.market.signer, this.market.controller);
+            return controller.setMaxTotalSupply(this.market.address, amount.raw);
+        }
+        else {
+            return this.market.contract.setMaxTotalSupply(amount.raw);
         }
-        const controller = (0, constants_1.getControllerContract)(this.market.signer, this.market.controller);
-        return controller.setMaxTotalSupply(this.market.address, amount.raw);
     }
     async setAnnualInterestBips(newAprBips) {
-        const { status } = this.checkSetAPRStep(newAprBips);
-        if (status !== "Ready") {
-            throw Error(`Cannot set new APR of ${newAprBips / 10000}%: ${status}`);
+        const { status } = this.previewSetAPR(newAprBips);
+        (0, utils_1.assert)(status === validation_1.SetAprStatus.Ready, `Cannot set new APR of ${newAprBips / 10000}%: ${status}`);
+        if (this.market.version === types_1.MarketVersion.V1) {
+            (0, utils_1.assert)(this.market.controller !== undefined, "Controller address is required for V1 markets");
+            const controller = (0, constants_1.getControllerContract)(this.market.provider, this.market.controller);
+            return controller.setAnnualInterestBips(this.market.address, newAprBips);
+        }
+        else {
+            const contract = typechain_1.WildcatMarketV2__factory.connect(this.market.address, this.market.signer);
+            return contract.setAnnualInterestAndReserveRatioBips(newAprBips, this.market.reserveRatioBips);
         }
-        const controller = (0, constants_1.getControllerContract)(this.market.provider, this.market.controller);
-        (0, utils_1.assert)(this.market.controller === controller.address, "Unexpected controller address");
-        return controller.setAnnualInterestBips(this.market.address, newAprBips);
     }
     /* -------------------------------------------------------------------------- */
     /*                                  Approval                                  */
@@ -173,22 +267,12 @@ class MarketAccount {
     isApprovedFor(amount) {
         return this.underlyingApproval.gte(amount.raw);
     }
-    /**
-     * @returns Amount of underlying token user must approve
-     *          market to spend to make a deposit.
-     */
-    getAllowanceRemainder(amount) {
-        return this.underlyingApproval.gte(amount.raw)
-            ? this.market.underlyingToken.getAmount(0)
-            : amount;
-    }
-    async approveAllowanceRemainder(amount) {
+    async approveMarket(amount) {
         const token = this.market.underlyingToken;
         const signer = await token.signer.getAddress();
         if (signer.toLowerCase() !== this.account.toLowerCase()) {
             throw Error(`MarketAccount signer ${signer} does not match ${this.account}`);
         }
-        amount = this.getAllowanceRemainder(amount);
         return token.contract.approve(this.market.address, amount.raw);
     }
     async populateApproveMarket(amount) {
@@ -197,7 +281,6 @@ class MarketAccount {
         if (signer.toLowerCase() !== this.account.toLowerCase()) {
             throw Error(`MarketAccount signer ${signer} does not match ${this.account}`);
         }
-        amount = this.getAllowanceRemainder(amount);
         return {
             to: token.address,
             data: token.contract.interface.encodeFunctionData("approve", [
@@ -224,66 +307,56 @@ class MarketAccount {
     getDepositAmount(amount) {
         return (0, token_1.minTokenAmount)(amount, this.maximumDeposit);
     }
-    /**
-     * @returns Status for deposit
-     */
-    checkDepositStep(amount) {
-        if (!this.canDeposit) {
-            return { status: "InsufficientRole" };
-        }
+    previewDeposit(amount) {
+        const status = this.depositAvailability;
+        if (status !== validation_1.DepositStatus.Ready)
+            return { status };
         if (amount.gt(this.market.maximumDeposit)) {
-            return { status: "ExceedsMaximumDeposit" };
+            return { status: validation_1.DepositStatus.ExceedsMaximumDeposit };
         }
         if (amount.gt(this.underlyingBalance)) {
-            return { status: "InsufficientBalance" };
+            return { status: validation_1.DepositStatus.InsufficientBalance };
         }
         if (!this.isApprovedFor(amount)) {
-            return {
-                status: "InsufficientAllowance",
-                remainder: this.getAllowanceRemainder(amount)
-            };
+            return { status: validation_1.DepositStatus.InsufficientAllowance };
         }
-        return { status: "Ready" };
+        return { status: validation_1.DepositStatus.Ready };
     }
     async populateDeposit(amount) {
+        const { status } = this.previewDeposit(amount);
+        (0, utils_1.assert)(status === validation_1.DepositStatus.Ready, `Cannot deposit: ${status}`);
         const signer = await this.market.signer.getAddress();
         if (signer.toLowerCase() !== this.account.toLowerCase()) {
             throw Error(`MarketAccount signer ${signer} does not match ${this.account}`);
         }
-        if (amount.gt(this.underlyingBalance)) {
-            throw Error("Insufficient balance");
-        }
         return {
             to: this.market.address,
             data: this.market.contract.interface.encodeFunctionData("deposit", [amount.raw]),
             value: "0"
         };
     }
-    // TODO: Add support for depositUpTo
     async deposit(amount) {
+        const { status } = this.previewDeposit(amount);
+        (0, utils_1.assert)(status === validation_1.DepositStatus.Ready, `Cannot deposit: ${status}`);
         const signer = await this.market.signer.getAddress();
         if (signer.toLowerCase() !== this.account.toLowerCase()) {
             throw Error(`MarketAccount signer ${signer} does not match ${this.account}`);
         }
-        if (amount.gt(this.underlyingBalance)) {
-            throw Error("Insufficient balance");
-        }
         return this.market.contract.deposit(amount.raw);
     }
     /* ------ Withdrawals ------ */
-    checkQueueWithdrawalStep(amount) {
-        if (!this.canWithdraw) {
-            return { status: "InsufficientRole" };
-        }
+    previewQueueWithdrawal(amount) {
+        const status = this.withdrawalAvailability;
+        if (status !== validation_1.QueueWithdrawalStatus.Ready)
+            return { status };
         if (amount.gt(this.marketBalance)) {
-            return { status: "InsufficientBalance" };
+            return { status: validation_1.QueueWithdrawalStatus.InsufficientBalance };
         }
-        return { status: "Ready" };
+        return { status: validation_1.QueueWithdrawalStatus.Ready };
     }
     async queueWithdrawal(amount) {
-        if (!this.canWithdraw) {
-            throw Error(`Lender role insufficient to withdraw`);
-        }
+        const { status } = this.previewQueueWithdrawal(amount);
+        (0, utils_1.assert)(status === validation_1.QueueWithdrawalStatus.Ready, `Cannot queue withdrawal: ${status}`);
         const signer = await this.market.signer.getAddress();
         if (signer.toLowerCase() !== this.account.toLowerCase()) {
             throw Error(`MarketAccount signer ${signer} does not match ${this.account}`);
@@ -292,9 +365,8 @@ class MarketAccount {
         const receipt = await transaction.wait();
         const queuedWithdrawalTopic = this.market.contract.interface.getEventTopic("WithdrawalQueued");
         const queuedWithdrawalTransaction = toQueueWithdrawalTransaction(this.market.underlyingToken, receipt.events.find((e) => e.topics[0] === queuedWithdrawalTopic));
-        if (!queuedWithdrawalTransaction) {
+        if (!queuedWithdrawalTransaction)
             throw Error("No queued withdrawal event found");
-        }
         const withdrawal = await withdrawal_status_1.LenderWithdrawalStatus.getWithdrawalForLender(this.market, queuedWithdrawalTransaction.expiry, this.account);
         return {
             withdrawal,
@@ -321,29 +393,24 @@ class MarketAccount {
     getRepayAmount(amount) {
         return (0, token_1.minTokenAmount)(amount, this.maximumRepay);
     }
-    /**
-     * @returns Status for deposit
-     */
-    checkRepayStep(amount) {
+    previewRepay(amount) {
+        if (this.market.isClosed)
+            return { status: validation_1.RepayStatus.MarketClosed };
         if (amount.gt(this.underlyingBalance)) {
-            return { status: "InsufficientBalance" };
+            return { status: validation_1.RepayStatus.InsufficientBalance };
         }
         if (!this.isApprovedFor(amount)) {
-            return {
-                status: "InsufficientAllowance",
-                remainder: this.getAllowanceRemainder(amount)
-            };
+            return { status: validation_1.RepayStatus.InsufficientAllowance };
         }
-        return { status: "Ready" };
+        return { status: validation_1.RepayStatus.Ready };
     }
     async repay(amount) {
         const signer = await this.market.signer.getAddress();
         if (signer.toLowerCase() !== this.account.toLowerCase()) {
             throw Error(`MarketAccount signer ${signer} does not match ${this.account}`);
         }
-        if (!this.isBorrower) {
+        if (!this.isBorrower)
             throw Error("Only borrower can repay");
-        }
         return this.market.contract.repay(amount);
     }
     async populateRepay(amount) {
@@ -351,9 +418,8 @@ class MarketAccount {
         if (signer.toLowerCase() !== this.account.toLowerCase()) {
             throw Error(`MarketAccount signer ${signer} does not match ${this.account}`);
         }
-        if (!this.isBorrower) {
+        if (!this.isBorrower)
             throw Error("Only borrower can repay");
-        }
         return {
             to: this.market.address,
             data: this.market.contract.interface.encodeFunctionData("repay", [amount]),
@@ -361,23 +427,27 @@ class MarketAccount {
         };
     }
     async repayOutstandingDebt() {
+        if (this.market.version !== types_1.MarketVersion.V1) {
+            throw Error(`Only V1 supports repayOutstandingDebt`);
+        }
+        if (!this.isBorrower)
+            throw Error("Only borrower can repay");
         const signer = await this.market.signer.getAddress();
         if (signer.toLowerCase() !== this.account.toLowerCase()) {
             throw Error(`MarketAccount signer ${signer} does not match ${this.account}`);
         }
-        if (!this.isBorrower) {
-            throw Error("Only borrower can repay");
-        }
         return this.market.contract.repayOutstandingDebt();
     }
     async populateRepayOutstandingDebt() {
+        if (this.market.version !== types_1.MarketVersion.V1) {
+            throw Error(`Only V1 supports repayOutstandingDebt`);
+        }
+        if (!this.isBorrower)
+            throw Error("Only borrower can repay");
         const signer = await this.market.signer.getAddress();
         if (signer.toLowerCase() !== this.account.toLowerCase()) {
             throw Error(`MarketAccount signer ${signer} does not match ${this.account}`);
         }
-        if (!this.isBorrower) {
-            throw Error("Only borrower can repay");
-        }
         return {
             to: this.market.address,
             data: this.market.contract.interface.encodeFunctionData("repayOutstandingDebt"),
@@ -385,23 +455,27 @@ class MarketAccount {
         };
     }
     async repayDelinquentDebt() {
+        if (this.market.version !== types_1.MarketVersion.V1) {
+            throw Error(`Only V1 supports repayDelinquentDebt`);
+        }
+        if (!this.isBorrower)
+            throw Error("Only borrower can repay");
         const signer = await this.market.signer.getAddress();
         if (signer.toLowerCase() !== this.account.toLowerCase()) {
             throw Error(`MarketAccount signer ${signer} does not match ${this.account}`);
         }
-        if (!this.isBorrower) {
-            throw Error("Only borrower can repay");
-        }
         return this.market.contract.repayDelinquentDebt();
     }
     async populateRepayDelinquentDebt() {
+        if (this.market.version !== types_1.MarketVersion.V1) {
+            throw Error(`Only V1 supports repayDelinquentDebt`);
+        }
+        if (!this.isBorrower)
+            throw Error("Only borrower can repay");
         const signer = await this.market.signer.getAddress();
         if (signer.toLowerCase() !== this.account.toLowerCase()) {
             throw Error(`MarketAccount signer ${signer} does not match ${this.account}`);
         }
-        if (!this.isBorrower) {
-            throw Error("Only borrower can repay");
-        }
         return {
             to: this.market.address,
             data: this.market.contract.interface.encodeFunctionData("repayDelinquentDebt"),
@@ -419,12 +493,11 @@ class MarketAccount {
     }
     async borrow(amount) {
         const signer = await this.market.signer.getAddress();
+        if (!this.isBorrower)
+            throw Error("Only borrower can borrow");
         if (signer.toLowerCase() !== this.account.toLowerCase()) {
             throw Error(`MarketAccount signer ${signer} does not match ${this.account}`);
         }
-        if (!this.isBorrower) {
-            throw Error("Only borrower can borrow");
-        }
         if (amount.gt(this.market.borrowableAssets)) {
             throw Error("Insufficient borrowable assets");
         }
@@ -438,8 +511,29 @@ class MarketAccount {
         this.updateWith(acccountMarketInfo);
     }
     updateWith(info) {
-        this.isAuthorizedOnController = info.isAuthorizedOnController;
-        this.role = info.role;
+        if ("isAuthorizedOnController" in info) {
+            (0, utils_1.assert)(this.market.version === types_1.MarketVersion.V1, "V2 market can not be updated with V1 lens data");
+            this.isAuthorizedOnController = info.isAuthorizedOnController;
+            this.role = info.role;
+        }
+        else {
+            (0, utils_1.assert)(this.market.version === types_1.MarketVersion.V2, "V1 market can not be updated with V2 lens data");
+            this.credential = {
+                canRefresh: info.canRefresh,
+                isBlockedFromDeposits: info.isBlockedFromDeposits,
+                lastApprovalTimestamp: info.lastApprovalTimestamp,
+                lastProvider: {
+                    isApproved: true,
+                    providerAddress: info.lastProvider.providerAddress,
+                    isPullProvider: info.lastProvider.pullProviderIndex !== NullProviderIndex,
+                    isPushProvider: info.lastProvider.pushProviderIndex !== NullProviderIndex,
+                    pullProviderIndex: info.lastProvider.pullProviderIndex,
+                    pushProviderIndex: info.lastProvider.pushProviderIndex,
+                    timeToLive: info.lastProvider.timeToLive
+                }
+            };
+            this.isKnownLender = info.isKnownLender;
+        }
         this.scaledMarketBalance = info.scaledBalance;
         this.marketBalance = this.market.marketToken.getAmount(info.normalizedBalance);
         this.underlyingBalance = this.market.underlyingToken.getAmount(info.underlyingBalance);
@@ -479,18 +573,87 @@ class MarketAccount {
             DepositAndWithdraw: LenderRole.DepositAndWithdraw
         };
         const scaledBalance = ethers_1.BigNumber.from(data.scaledBalance);
-        const account = new MarketAccount(data.address, data.controllerAuthorization.authorized, RolesMap[data.role], scaledBalance, market.marketToken.getAmount((0, utils_1.rayMul)(scaledBalance, market.scaleFactor)), market.underlyingToken.getAmount(0), ethers_1.BigNumber.from(0), market, data.deposits, market.underlyingToken.getAmount(data.totalDeposited), ethers_1.BigNumber.from(data.lastScaleFactor), data.lastUpdatedTimestamp, market.underlyingToken.getAmount(data.totalInterestEarned), data.numPendingWithdrawalBatches);
+        const account = new MarketAccount({
+            account: data.address,
+            isAuthorizedOnController: data.controllerAuthorization?.authorized ?? false,
+            role: RolesMap[data.role],
+            scaledMarketBalance: scaledBalance,
+            marketBalance: market.marketToken.getAmount((0, utils_1.rayMul)(scaledBalance, market.scaleFactor)),
+            underlyingBalance: market.underlyingToken.getAmount(0),
+            underlyingApproval: ethers_1.BigNumber.from(0),
+            market,
+            deposits: data.deposits,
+            totalDeposited: market.underlyingToken.getAmount(data.totalDeposited),
+            lastScaleFactor: ethers_1.BigNumber.from(data.lastScaleFactor),
+            lastUpdatedTimestamp: data.lastUpdatedTimestamp,
+            totalInterestEarned: market.underlyingToken.getAmount(data.totalInterestEarned),
+            numPendingWithdrawalBatches: data.numPendingWithdrawalBatches,
+            credential: data.hooksAccess ? toCredential(data.hooksAccess) : undefined,
+            isKnownLender: !!data.knownLenderStatus?.id
+        });
         account.processInterestAccrued();
         return account;
     }
     static fromMarketLenderStatus(account, info, market) {
-        return new MarketAccount(account, info.isAuthorizedOnController, info.role, info.scaledBalance, market.marketToken.getAmount(info.normalizedBalance), market.underlyingToken.getAmount(info.underlyingBalance), info.underlyingApproval, market);
+        return new MarketAccount({
+            account,
+            isAuthorizedOnController: info.isAuthorizedOnController,
+            role: info.role,
+            scaledMarketBalance: info.scaledBalance,
+            marketBalance: market.marketToken.getAmount(info.normalizedBalance),
+            underlyingBalance: market.underlyingToken.getAmount(info.underlyingBalance),
+            underlyingApproval: info.underlyingApproval,
+            market
+        });
+    }
+    static fromLenderAccountData(market, data) {
+        return new MarketAccount({
+            account: data.lender,
+            market,
+            role: LenderRole.Null,
+            marketBalance: market.marketToken.getAmount(data.normalizedBalance),
+            scaledMarketBalance: data.scaledBalance,
+            underlyingApproval: data.underlyingApproval,
+            underlyingBalance: market.underlyingToken.getAmount(data.underlyingBalance),
+            isAuthorizedOnController: false,
+            isKnownLender: data.isKnownLender,
+            credential: {
+                canRefresh: data.canRefresh,
+                isBlockedFromDeposits: data.isBlockedFromDeposits,
+                lastApprovalTimestamp: data.lastApprovalTimestamp,
+                lastProvider: {
+                    isApproved: true,
+                    providerAddress: data.lastProvider.providerAddress,
+                    isPullProvider: data.lastProvider.pullProviderIndex !== NullProviderIndex,
+                    pullProviderIndex: data.lastProvider.pullProviderIndex,
+                    isPushProvider: data.lastProvider.pushProviderIndex !== NullProviderIndex,
+                    pushProviderIndex: data.lastProvider.pushProviderIndex,
+                    timeToLive: data.lastProvider.timeToLive
+                }
+            }
+        });
     }
     static fromMarketDataWithLenderStatus(chainId, provider, account, info) {
-        return MarketAccount.fromMarketLenderStatus(account, info.lenderStatus, market_1.Market.fromMarketData(chainId, info.market, provider));
+        if ("controller" in info.market) {
+            info = info;
+            return MarketAccount.fromMarketLenderStatus(account, info.lenderStatus, market_1.Market.fromMarketData(chainId, info.market, provider));
+        }
+        else {
+            info = info;
+            return MarketAccount.fromLenderAccountData(market_1.Market.fromMarketDataV2(chainId, provider, info.market), info.lenderStatus);
+        }
     }
     static fromMarketDataOnly(market, account, isAuthorizedOnController) {
-        return new MarketAccount(account, isAuthorizedOnController, LenderRole.Null, ethers_1.BigNumber.from(0), market.marketToken.getAmount(0), market.underlyingToken.getAmount(0), ethers_1.BigNumber.from(0), market);
+        return new MarketAccount({
+            account,
+            isAuthorizedOnController,
+            role: LenderRole.Null,
+            scaledMarketBalance: ethers_1.BigNumber.from(0),
+            marketBalance: market.marketToken.getAmount(0),
+            underlyingBalance: market.underlyingToken.getAmount(0),
+            underlyingApproval: ethers_1.BigNumber.from(0),
+            market
+        });
     }
     /**
      * Get a `MarketAccount` for a given account and existing `Market` instance.
@@ -509,6 +672,23 @@ class MarketAccount {
                 .then((info) => MarketAccount.fromMarketDataWithLenderStatus(chainId, provider, account, info));
         }
     }
+    /**
+     * Get a `MarketAccount` for a given account and existing `Market` instance.
+     * If `market` is a string, the market data will be fetched in the same call as the account data.
+     */
+    static async getMarketAccountV2(chainId, provider, account, market) {
+        const lens = (0, constants_1.getLensV2Contract)(chainId, provider);
+        if (market instanceof market_1.Market) {
+            return lens
+                .getMarketDataWithLenderStatus(account, market.address)
+                .then((info) => MarketAccount.fromMarketDataWithLenderStatus(chainId, provider, account, info));
+        }
+        else {
+            return lens
+                .getMarketDataWithLenderStatus(account, market)
+                .then((info) => MarketAccount.fromMarketDataWithLenderStatus(chainId, provider, account, info));
+        }
+    }
     /**
      * Get multiple `MarketAccount`s given an account and existing list of `Market`
      * instances or market addresses. If `markets` is an array of strings, the market
@@ -519,7 +699,7 @@ class MarketAccount {
         if (markets.length === 0) {
             return [];
         }
-        if (isMarketInstanceArray(markets)) {
+        if ((0, validation_1.isMarketInstanceArray)(markets)) {
             return lens
                 .getMarketsLenderStatus(account, markets.map((v) => v.address))
                 .then((infos) => infos.map((info, i) => MarketAccount.fromMarketLenderStatus(account, info, markets[i])));
@@ -562,4 +742,21 @@ const toQueueWithdrawalTransaction = (underlyingToken, log) => ({
     scaledAmount: log.args.scaledAmount,
     originalAmount: underlyingToken.getAmount(log.args.normalizedAmount)
 });
-//# sourceMappingURL=account.js.map
+const toCredential = ({ canRefresh, isBlockedFromDeposits, lastApprovalTimestamp, lender, lastProvider }) => {
+    const { isApproved, providerAddress, isPullProvider, pullProviderIndex, isPushProvider, pushProviderIndex, timeToLive } = lastProvider;
+    return {
+        canRefresh,
+        isBlockedFromDeposits,
+        lastApprovalTimestamp,
+        lastProvider: {
+            isApproved,
+            providerAddress,
+            isPullProvider,
+            pullProviderIndex,
+            isPushProvider,
+            pushProviderIndex,
+            timeToLive
+        }
+    };
+};
+//# sourceMappingURL=index.js.map