@raac/rpc 1.2.0-beta.14 → 1.2.0-beta.16

package/dist/configs/chains/11155111.json

@@ -124,6 +124,12 @@
                     "name": "r-rpmdepmUSD (RpmUSD/DEpmUSD LP)",
                     "contract": "0x79c9b8b1E679c1e1bD09a56Fde6a61aa8C0014Aa",
                     "stakingToken": "0x421E9431E751c8fC02E53F8e54a1772aE6021BeD"
+                },
+                {
+                    "id": "r-ireetpmUSD",
+                    "name": "r-ireetpmUSD (iREET/pmUSD LP)",
+                    "contract": "0x084D7252d83AD886348EC58f4b1e5261Ab7f67c9",
+                    "stakingToken": "0x7F7d0924C9082F4C3F0D5D97bF9a26C3D3DEf706"
                 }
             ]
         },

package/dist/contracts/lockers/liquidLocker/checkAccountHealth.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAccountHealth = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Whether a user's position is currently overcollateralised.
+ *
+ * Reserved collateral is scheduled to leave and so is netted out before the check, which is
+ * why a position can go unhealthy on requestUnlock alone, without any new borrowing.
+ */
+const checkAccountHealth = async (chainId, account, provider) => {
+    const contract = await (0, _helpers_1.getLiquidLockerContract)(chainId, provider);
+    return contract.checkAccountHealth(account);
+};
+exports.checkAccountHealth = checkAccountHealth;

package/dist/contracts/lockers/liquidLocker/getUserLocks.js

@@ -5,21 +5,29 @@ const ethers_1 = require("ethers");
 const _helpers_1 = require("./_helpers");
 const EPOCH_DURATION = 7 * 24 * 60 * 60;
 /**
- * Returns the user's pending (future) unlock entries.
+ * Returns the user's pending (future) unlock buckets.
+ *
+ * Reservations are partial: a bucket can be wholly open, wholly reserved, or split between
+ * the two, so `reserved` alone does not say how much of it is leaving. Use `openAmount` for
+ * what is still reservable via requestUnlock and `reservedAmount` for what is already scheduled.
  */
 const getUserLocks = async (chainId, account, provider) => {
     const contract = await (0, _helpers_1.getLiquidLockerContract)(chainId, provider);
     const result = await contract.getUserLocks(account);
     return result.map((entry) => {
-        const pendingUnlock = entry.pendingUnlock ?? entry[0];
-        const unlockEpoch = entry.unlockEpoch ?? entry[1];
-        const reserved = entry.reserved ?? entry[2];
+        const pendingUnlock = entry.pendingUnlock;
+        const reservedAmount = entry.reservedAmount;
+        const unlockEpoch = entry.unlockEpoch;
+        const openAmount = pendingUnlock > reservedAmount ? pendingUnlock - reservedAmount : BigInt(0);
         return {
             pendingUnlock: ethers_1.ethers.formatEther(pendingUnlock),
+            reservedAmount: ethers_1.ethers.formatEther(reservedAmount),
+            openAmount: ethers_1.ethers.formatEther(openAmount),
             unlockEpoch: Number(unlockEpoch),
             unlockTimestamp: Number(unlockEpoch) * EPOCH_DURATION,
-            reserved,
-            raw: { pendingUnlock, unlockEpoch, reserved },
+            reserved: reservedAmount > BigInt(0),
+            fullyReserved: reservedAmount >= pendingUnlock && pendingUnlock > BigInt(0),
+            raw: { pendingUnlock, reservedAmount, openAmount, unlockEpoch },
         };
     });
 };

package/dist/contracts/lockers/liquidLocker/previewWithdraw.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewWithdraw = void 0;
+const ethers_1 = require("ethers");
+const _helpers_1 = require("./_helpers");
+/**
+ * Projects how the caller's matured reservations would split on withdrawUnlocked.
+ *
+ * A withdrawal never leaves the debt undercollateralised: whatever the position is short of
+ * the collateral the debt requires is relocked rather than paid out. Mirrors the same split
+ * withdrawUnlocked applies, so the preview cannot drift from the transaction.
+ */
+const previewWithdraw = async (chainId, account, provider) => {
+    const contract = await (0, _helpers_1.getLiquidLockerContract)(chainId, provider);
+    const [payout, relock] = await contract.previewWithdraw(account);
+    return {
+        payout: ethers_1.ethers.formatEther(payout),
+        relock: ethers_1.ethers.formatEther(relock),
+        raw: { payout, relock },
+    };
+};
+exports.previewWithdraw = previewWithdraw;

package/dist/contracts/lockers/liquidLocker/requestUnlock.js

@@ -3,14 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.requestUnlock = void 0;
 const _helpers_1 = require("./_helpers");
 /**
- * Reserve `numLocks` of the caller's pending future-locks for unlock at their existing maturity epoch(s).
- * Health is checked against (totalLocked - newUnlock) and current debt.
+ * Schedule `amount` (in wei) of the caller's locked RAAC for unlock.
+ *
+ * The locker reserves against the caller's future unlock buckets soonest-maturing first,
+ * partial-reserving the boundary bucket. When the remainder left in that bucket would fall
+ * below veRAAC's minimum lock, the whole bucket is taken instead — so the amount actually
+ * scheduled can exceed `amount` by up to that minimum. Scheduling less than `amount`
+ * (open capacity is short) reverts with InsufficientToUnlock.
+ *
+ * Health is checked against (totalLocked - alreadyReserved - amount) and current debt,
+ * reverting with InsufficientCollateral when the remaining collateral would not back the debt.
  */
-const requestUnlock = async (chainId, numLocks, signer) => {
+const requestUnlock = async (chainId, amount, signer) => {
     if (!signer)
         throw new Error("Signer is required");
     const contract = await (0, _helpers_1.getLiquidLockerContract)(chainId, signer);
-    const tx = await contract.requestUnlock(numLocks);
+    const tx = await contract.requestUnlock(amount);
     await tx.wait();
     return tx;
 };

package/dist/contracts/tokens/veRAAC/getMinLockAmount.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMinLockAmount = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const getContractAddress_1 = require("../../getContractAddress");
+const artifacts_1 = require("../../../utils/artifacts");
+/**
+ * Gets the smallest lock veRAAC will accept, in wei.
+ *
+ * Consumers that schedule unlocks need this: the liquid locker refuses to leave a remainder
+ * below this threshold in a bucket, taking the whole bucket instead, so an unlock request can
+ * be rounded up by as much as this amount.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The minimum lock amount in wei.
+ */
+const getMinLockAmount = async (chainId, provider) => {
+    if (!provider) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        provider = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    const contractAddress = (0, getContractAddress_1.getContractAddress)(chainId, "veraac");
+    const abi = (0, artifacts_1.getABI)("veraac");
+    // Not cast to VeRAACToken: the checked-in typechain declaration predates
+    // getMinLockAmount, though the ABI this resolves carries it.
+    const contract = new ethers_1.ethers.Contract(contractAddress, abi, provider);
+    return (await contract.getMinLockAmount());
+};
+exports.getMinLockAmount = getMinLockAmount;

package/dist/contracts/tokens/veRAAC/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.distributeRewards = exports.finalizeRagequit = exports.ragequitLock = exports.ragequitAll = exports.claimReward = exports.withdraw = exports.extend = exports.increaseWithApproval = exports.increase = exports.lockWithApproval = exports.lock = exports.getMaxUnclaimedDistributions = exports.getRagequitEpochs = exports.getRagequitRequest = exports.getCheckpoint = exports.getUserPointHistory = exports.getEarned = exports.getClaimable = exports.getClaimed = exports.getRawTotalSupply = exports.getRawBalanceOf = exports.getTotalSupplyAtTime = exports.getTotalSupplyAt = exports.getBalanceAtTime = exports.getBalanceAt = exports.getEffectiveLockEnd = exports.getMinLockEnd = exports.getMaxLockEnd = exports.getGlobalLockInfo = exports.getLocks = exports.getLockedBalance = exports.getTotalSupply = exports.getBalance = void 0;
+exports.distributeRewards = exports.finalizeRagequit = exports.ragequitLock = exports.ragequitAll = exports.claimReward = exports.withdraw = exports.extend = exports.increaseWithApproval = exports.increase = exports.lockWithApproval = exports.lock = exports.getMaxUnclaimedDistributions = exports.getRagequitEpochs = exports.getRagequitRequest = exports.getCheckpoint = exports.getUserPointHistory = exports.getEarned = exports.getClaimable = exports.getClaimed = exports.getRawTotalSupply = exports.getRawBalanceOf = exports.getTotalSupplyAtTime = exports.getTotalSupplyAt = exports.getBalanceAtTime = exports.getBalanceAt = exports.getEffectiveLockEnd = exports.getMinLockAmount = exports.getMinLockEnd = exports.getMaxLockEnd = exports.getGlobalLockInfo = exports.getLocks = exports.getLockedBalance = exports.getTotalSupply = exports.getBalance = void 0;
 var getBalance_1 = require("./getBalance");
 Object.defineProperty(exports, "getBalance", { enumerable: true, get: function () { return getBalance_1.getBalance; } });
 var getTotalSupply_1 = require("./getTotalSupply");
@@ -15,6 +15,8 @@ var getMaxLockEnd_1 = require("./getMaxLockEnd");
 Object.defineProperty(exports, "getMaxLockEnd", { enumerable: true, get: function () { return getMaxLockEnd_1.getMaxLockEnd; } });
 var getMinLockEnd_1 = require("./getMinLockEnd");
 Object.defineProperty(exports, "getMinLockEnd", { enumerable: true, get: function () { return getMinLockEnd_1.getMinLockEnd; } });
+var getMinLockAmount_1 = require("./getMinLockAmount");
+Object.defineProperty(exports, "getMinLockAmount", { enumerable: true, get: function () { return getMinLockAmount_1.getMinLockAmount; } });
 var getEffectiveLockEnd_1 = require("./getEffectiveLockEnd");
 Object.defineProperty(exports, "getEffectiveLockEnd", { enumerable: true, get: function () { return getEffectiveLockEnd_1.getEffectiveLockEnd; } });
 var getBalanceAt_1 = require("./getBalanceAt");

package/dist/types/RPCLibrary.d.ts

@@ -182,6 +182,7 @@ import { getRawBalanceOf as getVeRAACRawBalanceOf } from "./contracts/tokens/veR
 import { getRawTotalSupply as getVeRAACRawTotalSupply } from "./contracts/tokens/veRAAC/getRawTotalSupply";
 import { getEffectiveLockEnd as getVeRAACEffectiveLockEnd } from "./contracts/tokens/veRAAC/getEffectiveLockEnd";
 import { getMinLockEnd as getVeRAACMinLockEnd } from "./contracts/tokens/veRAAC/getMinLockEnd";
+import { getMinLockAmount as getVeRAACMinLockAmount } from "./contracts/tokens/veRAAC/getMinLockAmount";
 import { getMaxUnclaimedDistributions as getVeRAACMaxUnclaimedDistributions } from "./contracts/tokens/veRAAC/getMaxUnclaimedDistributions";
 import { getBalance as getRAACBalance } from "./contracts/tokens/RAAC/getBalance";
 import { getTotalSupply as getRAACTotalSupply } from "./contracts/tokens/RAAC/getTotalSupply";
@@ -202,6 +203,8 @@ import { getUserLocks as getUserLocksLiquidLocker } from "./contracts/lockers/li
 import { getGlobalInfo as getGlobalInfoLiquidLocker } from "./contracts/lockers/liquidLocker/getGlobalInfo";
 import { getConfig as getConfigLiquidLocker } from "./contracts/lockers/liquidLocker/getConfig";
 import { isKeeper as isKeeperLiquidLocker } from "./contracts/lockers/liquidLocker/isKeeper";
+import { previewWithdraw as previewWithdrawLiquidLocker } from "./contracts/lockers/liquidLocker/previewWithdraw";
+import { checkAccountHealth as checkAccountHealthLiquidLocker } from "./contracts/lockers/liquidLocker/checkAccountHealth";
 import { deposit as depositMaturityVault } from "./contracts/lockers/maturityVault/deposit";
 import { depositFor as depositForMaturityVault } from "./contracts/lockers/maturityVault/depositFor";
 import { withdraw as withdrawMaturityVault } from "./contracts/lockers/maturityVault/withdraw";
@@ -440,6 +443,7 @@ declare class RPCLibrary {
             getRawTotalSupply: typeof getVeRAACRawTotalSupply;
             getEffectiveLockEnd: typeof getVeRAACEffectiveLockEnd;
             getMinLockEnd: typeof getVeRAACMinLockEnd;
+            getMinLockAmount: typeof getVeRAACMinLockAmount;
             getMaxUnclaimedDistributions: typeof getVeRAACMaxUnclaimedDistributions;
         };
         crvUSD: {
@@ -487,6 +491,8 @@ declare class RPCLibrary {
             getGlobalInfo: typeof getGlobalInfoLiquidLocker;
             getConfig: typeof getConfigLiquidLocker;
             isKeeper: typeof isKeeperLiquidLocker;
+            previewWithdraw: typeof previewWithdrawLiquidLocker;
+            checkAccountHealth: typeof checkAccountHealthLiquidLocker;
         };
         maturityVault: {
             deposit: typeof depositMaturityVault;

package/dist/types/contracts/lockers/liquidLocker/checkAccountHealth.d.ts

@@ -0,0 +1,9 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Whether a user's position is currently overcollateralised.
+ *
+ * Reserved collateral is scheduled to leave and so is netted out before the check, which is
+ * why a position can go unhealthy on requestUnlock alone, without any new borrowing.
+ */
+export declare const checkAccountHealth: (chainId: ChainId, account: string, provider?: Provider) => Promise<boolean>;

package/dist/types/contracts/lockers/liquidLocker/getUserLocks.d.ts

@@ -1,17 +1,30 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
 export interface PendingUnlockInfo {
+    /** Total RAAC held in this bucket, maturing at the start of `unlockEpoch`. */
     pendingUnlock: string;
+    /** The portion of `pendingUnlock` already scheduled to unlock. */
+    reservedAmount: string;
+    /** The portion still open, which auto-relocks at maturity unless reserved first. */
+    openAmount: string;
     unlockEpoch: number;
     unlockTimestamp: number;
+    /** Any part of this bucket is scheduled to unlock. */
     reserved: boolean;
+    /** The whole bucket is scheduled to unlock; nothing here will relock. */
+    fullyReserved: boolean;
     raw: {
         pendingUnlock: bigint;
+        reservedAmount: bigint;
+        openAmount: bigint;
         unlockEpoch: bigint;
-        reserved: boolean;
     };
 }
 /**
- * Returns the user's pending (future) unlock entries.
+ * Returns the user's pending (future) unlock buckets.
+ *
+ * Reservations are partial: a bucket can be wholly open, wholly reserved, or split between
+ * the two, so `reserved` alone does not say how much of it is leaving. Use `openAmount` for
+ * what is still reservable via requestUnlock and `reservedAmount` for what is already scheduled.
  */
 export declare const getUserLocks: (chainId: ChainId, account: string, provider?: Provider) => Promise<PendingUnlockInfo[]>;

package/dist/types/contracts/lockers/liquidLocker/previewWithdraw.d.ts

@@ -0,0 +1,20 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface LiquidLockerWithdrawPreview {
+    /** RAAC that would be paid out to the user. */
+    payout: string;
+    /** RAAC that would be relocked instead, to keep the outstanding debt backed. */
+    relock: string;
+    raw: {
+        payout: bigint;
+        relock: bigint;
+    };
+}
+/**
+ * Projects how the caller's matured reservations would split on withdrawUnlocked.
+ *
+ * A withdrawal never leaves the debt undercollateralised: whatever the position is short of
+ * the collateral the debt requires is relocked rather than paid out. Mirrors the same split
+ * withdrawUnlocked applies, so the preview cannot drift from the transaction.
+ */
+export declare const previewWithdraw: (chainId: ChainId, account: string, provider?: Provider) => Promise<LiquidLockerWithdrawPreview>;

package/dist/types/contracts/lockers/liquidLocker/requestUnlock.d.ts

@@ -1,7 +1,15 @@
 import { Signer } from "ethers";
 import { ChainId } from "../../../configs/chains";
 /**
- * Reserve `numLocks` of the caller's pending future-locks for unlock at their existing maturity epoch(s).
- * Health is checked against (totalLocked - newUnlock) and current debt.
+ * Schedule `amount` (in wei) of the caller's locked RAAC for unlock.
+ *
+ * The locker reserves against the caller's future unlock buckets soonest-maturing first,
+ * partial-reserving the boundary bucket. When the remainder left in that bucket would fall
+ * below veRAAC's minimum lock, the whole bucket is taken instead — so the amount actually
+ * scheduled can exceed `amount` by up to that minimum. Scheduling less than `amount`
+ * (open capacity is short) reverts with InsufficientToUnlock.
+ *
+ * Health is checked against (totalLocked - alreadyReserved - amount) and current debt,
+ * reverting with InsufficientCollateral when the remaining collateral would not back the debt.
  */
-export declare const requestUnlock: (chainId: ChainId, numLocks: number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+export declare const requestUnlock: (chainId: ChainId, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/tokens/veRAAC/getMinLockAmount.d.ts

@@ -0,0 +1,14 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Gets the smallest lock veRAAC will accept, in wei.
+ *
+ * Consumers that schedule unlocks need this: the liquid locker refuses to leave a remainder
+ * below this threshold in a bucket, taking the whole bucket instead, so an unlock request can
+ * be rounded up by as much as this amount.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The minimum lock amount in wei.
+ */
+export declare const getMinLockAmount: (chainId: ChainId, provider?: Provider) => Promise<bigint>;

package/dist/types/contracts/tokens/veRAAC/index.d.ts

@@ -5,6 +5,7 @@ export { getLocks, type LockedBalance } from "./getLocks";
 export { getGlobalLockInfo, type GlobalLockInfo } from "./getGlobalLockInfo";
 export { getMaxLockEnd } from "./getMaxLockEnd";
 export { getMinLockEnd } from "./getMinLockEnd";
+export { getMinLockAmount } from "./getMinLockAmount";
 export { getEffectiveLockEnd } from "./getEffectiveLockEnd";
 export { getBalanceAt } from "./getBalanceAt";
 export { getBalanceAtTime } from "./getBalanceAtTime";