@raac/rpc 1.2.0-beta.4 → 1.2.0-beta.5

package/dist/tests/liquidLocker.test.js

@@ -0,0 +1,262 @@
+"use strict";
+/**
+ * End-to-end test for the RAAC Liquid Locker RPC methods against a local
+ * hardhat node (chainId 8453).
+ *
+ * Prereqs:
+ *   1. Start the node:   cd ~/raac/contracts && npx hardhat node
+ *   2. Deploy lockers:   npx hardhat run deployment/lockers/deploy_lockers_local.js --network localhost
+ *   3. Make sure rpc/configs/chains/8453.json has the deployed locker/zap/asset addresses.
+ *
+ * Run:
+ *   cd ~/raac/rpc && node -r ts-node/register/transpile-only tests/liquidLocker.test.ts
+ *
+ * It exercises every method exposed under rpc.lockers.liquidLocker.* by driving
+ * a realistic flow: deposit -> borrow -> repay -> donate -> requestUnlock ->
+ * (time-travel) -> processVaultExpiredLocks -> withdrawUnlocked, plus the
+ * read methods and the role-gated methods (harvest / voteGauge / voteGovernance).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../configs/chains"));
+const getContractAddress_1 = require("../contracts/getContractAddress");
+const artifacts_1 = require("../utils/artifacts");
+const RPCLibrary_1 = __importDefault(require("../RPCLibrary"));
+const CHAIN_ID = 8453;
+const RPC_URL = chains_1.default[CHAIN_ID].rpcs[0];
+// Default hardhat mnemonic (publicly known dev accounts).
+const MNEMONIC = "test test test test test test test test test test test junk";
+// Account roles (must match deployment/lockers/deploy_lockers_local.js):
+//   0 = deployer, 1 = contracts wallet (owner + DEFAULT_ADMIN after handoff),
+//   2 = treasury, 3 = cleverFeeRecipient, 4 = governor.
+const IDX_ADMIN = 1;
+const IDX_TREASURY = 2;
+const IDX_USER = 6;
+const IDX_KEEPER = 7;
+const IDX_HARVESTER = 8;
+const EPOCH = 7 * 24 * 60 * 60;
+const MINIMAL_ERC20 = [
+    "function mint(address,uint256)",
+    "function approve(address,uint256) returns (bool)",
+    "function balanceOf(address) view returns (uint256)",
+    "function allowance(address,address) view returns (uint256)",
+];
+const LOCKER_ADMIN_ABI = [
+    "function updateWhitelist(address,bool)",
+    "function grantRole(bytes32,address)",
+    "function HARVEST_ROLE() view returns (bytes32)",
+    "function isKeeper(address) view returns (bool)",
+];
+const provider = new ethers_1.ethers.JsonRpcProvider(RPC_URL);
+// Wrap in a NonceManager so back-to-back txs from the same account against an
+// instant-mining node don't collide on nonces (mirrors the deploy scripts).
+function signer(i) {
+    const m = ethers_1.ethers.Mnemonic.fromPhrase(MNEMONIC);
+    const wallet = ethers_1.ethers.HDNodeWallet.fromMnemonic(m, `m/44'/60'/0'/0/${i}`).connect(provider);
+    return new ethers_1.ethers.NonceManager(wallet);
+}
+// Decode custom errors thrown by any contract in the locker stack so failures
+// are legible instead of "unknown custom error".
+const errIface = new ethers_1.ethers.Interface([
+    ...(0, artifacts_1.getABI)("raacliquidlocker"),
+    ...(0, artifacts_1.getABI)("veraac"),
+    ...(0, artifacts_1.getABI)("leraac"),
+].filter((f) => f.type === "error"));
+function decodeErr(e) {
+    const data = e?.data || e?.info?.error?.data || e?.error?.data;
+    if (typeof data === "string" && data.startsWith("0x") && data.length >= 10) {
+        try {
+            const parsed = errIface.parseError(data);
+            if (parsed)
+                return `${parsed.name}(${parsed.args.map((a) => a.toString()).join(",")})`;
+        }
+        catch { }
+    }
+    return e?.shortMessage || e?.reason || e?.message || String(e);
+}
+const fmt = (v) => ethers_1.ethers.formatEther(v);
+// ---- tiny test harness -------------------------------------------------
+let pass = 0;
+let failed = 0;
+let expectedRevert = 0;
+const lines = [];
+async function step(name, fn) {
+    try {
+        const detail = await fn();
+        pass++;
+        const msg = `  PASS  ${name}${detail ? "  ->  " + detail : ""}`;
+        console.log(msg);
+        lines.push(msg);
+    }
+    catch (e) {
+        failed++;
+        const reason = decodeErr(e);
+        const msg = `  FAIL  ${name}  ->  ${reason}`;
+        console.log(msg);
+        lines.push(msg);
+    }
+}
+// For methods we expect to revert in this minimal (no-rewards / no-gauge) setup.
+async function stepExpectRevert(name, fn) {
+    try {
+        await fn();
+        // If it did NOT revert, that's still fine (count as pass).
+        pass++;
+        const msg = `  PASS  ${name}  ->  executed (no revert)`;
+        console.log(msg);
+        lines.push(msg);
+    }
+    catch (e) {
+        expectedRevert++;
+        const reason = decodeErr(e);
+        const msg = `  OK*   ${name}  ->  reverted as expected: ${reason.slice(0, 120)}`;
+        console.log(msg);
+        lines.push(msg);
+    }
+}
+async function main() {
+    const net = await provider.getNetwork();
+    console.log(`\nConnected to ${RPC_URL} (chainId ${net.chainId})`);
+    const lockerAddr = (0, getContractAddress_1.getContractAddress)(CHAIN_ID, "raacliquidlocker");
+    const raacAddr = (0, getContractAddress_1.getContractAddress)(CHAIN_ID, "raactoken");
+    const leRAACAddr = (0, getContractAddress_1.getContractAddress)(CHAIN_ID, "leraac");
+    console.log(`Locker:  ${lockerAddr}`);
+    console.log(`RAAC:    ${raacAddr}`);
+    console.log(`leRAAC:  ${leRAACAddr}\n`);
+    const rpc = new RPCLibrary_1.default();
+    const ll = rpc.lockers.liquidLocker;
+    const admin = signer(IDX_ADMIN);
+    const treasury = signer(IDX_TREASURY);
+    const user = signer(IDX_USER);
+    const keeper = signer(IDX_KEEPER);
+    const harvester = signer(IDX_HARVESTER);
+    const userAddr = await user.getAddress();
+    const raacUser = new ethers_1.ethers.Contract(raacAddr, MINIMAL_ERC20, user);
+    const leRAACUser = new ethers_1.ethers.Contract(leRAACAddr, MINIMAL_ERC20, user);
+    const lockerAdmin = new ethers_1.ethers.Contract(lockerAddr, LOCKER_ADMIN_ABI, admin);
+    const DEPOSIT = ethers_1.ethers.parseEther("100000");
+    const BORROW = ethers_1.ethers.parseEther("30000"); // 30% of locked (< 50% reserve)
+    const DONATE = ethers_1.ethers.parseEther("5000");
+    console.log("=========== READ METHODS ===========");
+    await step("getConfig", async () => {
+        const c = await ll.getConfig(CHAIN_ID, provider);
+        if (c.raac.toLowerCase() !== raacAddr.toLowerCase())
+            throw new Error("raac mismatch");
+        return `lockEpochs=${c.lockDurationEpochs} reserveRate=${c.reserveRate} treasuryFee=${c.treasuryFeePercentage} paused=${c.paused}`;
+    });
+    await step("getGlobalInfo", async () => {
+        const g = await ll.getGlobalInfo(CHAIN_ID, provider);
+        return `totalLocked=${g.totalLockedGlobal} totalDebt=${g.totalDebtGlobal}`;
+    });
+    await step("getUserInfo (fresh user)", async () => {
+        const u = await ll.getUserInfo(CHAIN_ID, userAddr, provider);
+        return `deposited=${u.totalDeposited} borrowed=${u.totalBorrowed}`;
+    });
+    await step("getUserLocks (fresh user)", async () => {
+        const locks = await ll.getUserLocks(CHAIN_ID, userAddr, provider);
+        return `${locks.length} lock(s)`;
+    });
+    await step("isKeeper (fresh user)", async () => {
+        const k = await ll.isKeeper(CHAIN_ID, userAddr, provider);
+        return `isKeeper=${k}`;
+    });
+    console.log("\n=========== WRITE FLOW ===========");
+    // Fund the user with RAAC and approve the locker.
+    await step("setup: mint RAAC to user + approve locker", async () => {
+        await (await raacUser.mint(userAddr, DEPOSIT + DONATE + ethers_1.ethers.parseEther("1000"))).wait();
+        await (await raacUser.approve(lockerAddr, ethers_1.ethers.MaxUint256)).wait();
+        const bal = await raacUser.balanceOf(userAddr);
+        return `RAAC balance=${fmt(bal)}`;
+    });
+    await step("deposit", async () => {
+        await ll.deposit(CHAIN_ID, DEPOSIT, user);
+        const u = await ll.getUserInfo(CHAIN_ID, userAddr, provider);
+        if (u.raw.totalDeposited !== DEPOSIT)
+            throw new Error(`deposited=${u.totalDeposited}`);
+        return `totalDeposited=${u.totalDeposited}`;
+    });
+    await step("borrow", async () => {
+        await ll.borrow(CHAIN_ID, BORROW, false, user);
+        const u = await ll.getUserInfo(CHAIN_ID, userAddr, provider);
+        const leBal = await leRAACUser.balanceOf(userAddr);
+        if (u.raw.totalBorrowed !== BORROW)
+            throw new Error(`borrowed=${u.totalBorrowed}`);
+        return `totalBorrowed=${u.totalBorrowed} leRAAC=${fmt(leBal)}`;
+    });
+    await step("donate", async () => {
+        const g0 = await ll.getGlobalInfo(CHAIN_ID, provider);
+        await ll.donate(CHAIN_ID, DONATE, user);
+        const g1 = await ll.getGlobalInfo(CHAIN_ID, provider);
+        return `accRewardPerShare ${g0.accRewardPerShare} -> ${g1.accRewardPerShare}`;
+    });
+    await step("repay (full debt)", async () => {
+        await (await leRAACUser.approve(lockerAddr, ethers_1.ethers.MaxUint256)).wait();
+        const before = await ll.getUserInfo(CHAIN_ID, userAddr, provider);
+        await ll.repay(CHAIN_ID, before.raw.totalBorrowed, user);
+        const after = await ll.getUserInfo(CHAIN_ID, userAddr, provider);
+        return `debt ${before.totalBorrowed} -> ${after.totalBorrowed}`;
+    });
+    await step("requestUnlock", async () => {
+        await ll.requestUnlock(CHAIN_ID, 1, user);
+        const locks = await ll.getUserLocks(CHAIN_ID, userAddr, provider);
+        const reserved = locks.filter((l) => l.reserved).length;
+        return `${reserved} reserved lock(s)`;
+    });
+    console.log("\n=========== ROLE-GATED METHODS ===========");
+    await step("isKeeper after updateWhitelist(keeper)", async () => {
+        const keeperAddr = await keeper.getAddress();
+        await (await lockerAdmin.updateWhitelist(keeperAddr, true)).wait();
+        const k = await ll.isKeeper(CHAIN_ID, keeperAddr, provider);
+        if (!k)
+            throw new Error("keeper not whitelisted");
+        return `keeper ${keeperAddr.slice(0, 10)}… isKeeper=${k}`;
+    });
+    // Advance time past the lock duration so veRAAC locks expire and the
+    // user's reserved unlock matures.
+    await step("time-travel past lock duration", async () => {
+        const cfg = await ll.getConfig(CHAIN_ID, provider);
+        const secs = (cfg.lockDurationEpochs + 3) * EPOCH;
+        await provider.send("evm_increaseTime", [secs]);
+        await provider.send("evm_mine", []);
+        return `advanced ${cfg.lockDurationEpochs + 3} epochs`;
+    });
+    await step("processVaultExpiredLocks (keeper)", async () => {
+        await ll.processVaultExpiredLocks(CHAIN_ID, keeper);
+        const g = await ll.getGlobalInfo(CHAIN_ID, provider);
+        return `poolLockedUnderlying=${g.poolLockedUnderlying} totalRaacInPool=${g.totalRaacInPool}`;
+    });
+    await step("withdrawUnlocked (user)", async () => {
+        const before = await raacUser.balanceOf(userAddr);
+        await ll.withdrawUnlocked(CHAIN_ID, user);
+        const after = await raacUser.balanceOf(userAddr);
+        return `RAAC ${fmt(before)} -> ${fmt(after)}`;
+    });
+    console.log("\n=========== INTEGRATION-DEPENDENT (expected to revert in minimal setup) ===========");
+    await stepExpectRevert("harvest (needs veRAAC rewards + zap routes)", async () => {
+        const HARVEST_ROLE = await lockerAdmin.HARVEST_ROLE();
+        const harvesterAddr = await harvester.getAddress();
+        await (await lockerAdmin.grantRole(HARVEST_ROLE, harvesterAddr)).wait();
+        await ll.harvest(CHAIN_ID, harvesterAddr, 0, harvester);
+    });
+    await stepExpectRevert("voteGauge (treasury-only, needs gauge controller)", async () => {
+        const dummyController = await admin.getAddress();
+        const dummyGauge = await treasury.getAddress();
+        await ll.voteGauge(CHAIN_ID, dummyController, dummyGauge, 5000, treasury);
+    });
+    await stepExpectRevert("voteGovernance (treasury-only, needs governance)", async () => {
+        const dummyGov = await admin.getAddress();
+        await ll.voteGovernance(CHAIN_ID, dummyGov, 1, true, treasury);
+    });
+    console.log("\n=========================================");
+    console.log(`RESULT: ${pass} passed, ${expectedRevert} reverted-as-expected, ${failed} failed`);
+    console.log("=========================================");
+    if (failed > 0)
+        process.exit(1);
+}
+main().catch((e) => {
+    console.error("FATAL:", e);
+    process.exit(1);
+});

package/dist/tests/test.js

@@ -27,6 +27,6 @@ async function test() {
     rpc.provider = provider;
     rpc.chainId = chainId;
     console.log(await rpc.wallet.assets.getBalance(chainId, "rtoken", rpc.address, provider));
-    console.log(await rpc.contracts.minter.get(chainId, signer));
+    console.log(await rpc.contracts.minter.get(chainId, provider));
 }
 test();

package/dist/types/RPCLibrary.d.ts

@@ -47,6 +47,16 @@ import setOracle from "./contracts/housePrices/setOracle";
 import tick from "./minter/tick";
 import get from "./minter/get";
 import getApy from "./minter/getApy";
+import { activate as activateMinter } from "./minter/activate";
+import { addDistributionPool as addDistributionPoolMinter } from "./minter/addDistributionPool";
+import { removeDistributionPool as removeDistributionPoolMinter } from "./minter/removeDistributionPool";
+import { manageDistributionPool as manageDistributionPoolMinter } from "./minter/manageDistributionPool";
+import { pause as pauseMinter, unpause as unpauseMinter } from "./minter/pause";
+import { getDistributionPools as getDistributionPoolsMinter } from "./minter/getDistributionPools";
+import { getPoolInfo as getPoolInfoMinter } from "./minter/getPoolInfo";
+import { calculateScheduledMintableAmount as calculateScheduledMintableAmountMinter } from "./minter/calculateScheduledMintableAmount";
+import { getEmissionPerSecond as getEmissionPerSecondMinter } from "./minter/getEmissionPerSecond";
+import { isPaused as isPausedMinter } from "./minter/isPaused";
 import mintAsset from "./wallet/assets/mintAsset";
 import burnAsset from "./wallet/assets/burnAsset";
 import approveAsset from "./wallet/assets/approveAsset";
@@ -190,6 +200,69 @@ import { getBalance as getRAACBalance } from "./contracts/tokens/RAAC/getBalance
 import { getTotalSupply as getRAACTotalSupply } from "./contracts/tokens/RAAC/getTotalSupply";
 import { getBalance as getXPMBalance } from "./contracts/tokens/xPM/getBalance";
 import { getTotalSupply as getXPMTotalSupply } from "./contracts/tokens/xPM/getTotalSupply";
+import { deposit as depositLiquidLocker } from "./contracts/lockers/liquidLocker/deposit";
+import { borrow as borrowLiquidLocker } from "./contracts/lockers/liquidLocker/borrow";
+import { repay as repayLiquidLocker } from "./contracts/lockers/liquidLocker/repay";
+import { requestUnlock as requestUnlockLiquidLocker } from "./contracts/lockers/liquidLocker/requestUnlock";
+import { withdrawUnlocked as withdrawUnlockedLiquidLocker } from "./contracts/lockers/liquidLocker/withdrawUnlocked";
+import { donate as donateLiquidLocker } from "./contracts/lockers/liquidLocker/donate";
+import { harvest as harvestLiquidLocker } from "./contracts/lockers/liquidLocker/harvest";
+import { processVaultExpiredLocks as processVaultExpiredLocksLiquidLocker } from "./contracts/lockers/liquidLocker/processVaultExpiredLocks";
+import { voteGauge as voteGaugeLiquidLocker } from "./contracts/lockers/liquidLocker/voteGauge";
+import { voteGovernance as voteGovernanceLiquidLocker } from "./contracts/lockers/liquidLocker/voteGovernance";
+import { getUserInfo as getUserInfoLiquidLocker } from "./contracts/lockers/liquidLocker/getUserInfo";
+import { getUserLocks as getUserLocksLiquidLocker } from "./contracts/lockers/liquidLocker/getUserLocks";
+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 { 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";
+import { withdrawAll as withdrawAllMaturityVault } from "./contracts/lockers/maturityVault/withdrawAll";
+import { claim as claimMaturityVault } from "./contracts/lockers/maturityVault/claim";
+import { exit as exitMaturityVault } from "./contracts/lockers/maturityVault/exit";
+import { distribute as distributeMaturityVault } from "./contracts/lockers/maturityVault/distribute";
+import { harvest as harvestMaturityVault } from "./contracts/lockers/maturityVault/harvest";
+import { updatePendingDistribution as updatePendingDistributionMaturityVault } from "./contracts/lockers/maturityVault/updatePendingDistribution";
+import { getUserInfo as getUserInfoMaturityVault } from "./contracts/lockers/maturityVault/getUserInfo";
+import { getGlobalInfo as getGlobalInfoMaturityVault } from "./contracts/lockers/maturityVault/getGlobalInfo";
+import { getConfig as getConfigMaturityVault } from "./contracts/lockers/maturityVault/getConfig";
+import { isWhitelisted as isWhitelistedMaturityVault } from "./contracts/lockers/maturityVault/isWhitelisted";
+import { lock as lockBotLocker } from "./contracts/lockers/botLocker/lock";
+import { unlock as unlockBotLocker } from "./contracts/lockers/botLocker/unlock";
+import { unlockAndClaim as unlockAndClaimBotLocker } from "./contracts/lockers/botLocker/unlockAndClaim";
+import { claim as claimBotLocker } from "./contracts/lockers/botLocker/claim";
+import { getClaimable as getClaimableBotLocker } from "./contracts/lockers/botLocker/getClaimable";
+import { getClaimables as getClaimablesBotLocker } from "./contracts/lockers/botLocker/getClaimables";
+import { getClaimedRewards as getClaimedRewardsBotLocker } from "./contracts/lockers/botLocker/getClaimedRewards";
+import { getRewardTokens as getRewardTokensBotLocker } from "./contracts/lockers/botLocker/getRewardTokens";
+import { getRewardTokenCount as getRewardTokenCountBotLocker } from "./contracts/lockers/botLocker/getRewardTokenCount";
+import { getLocks as getLocksBotLocker, getLocksByOwner as getLocksByOwnerBotLocker } from "./contracts/lockers/botLocker/getLocks";
+import { getLockedTokenIds as getLockedTokenIdsBotLocker } from "./contracts/lockers/botLocker/getLockedTokenIds";
+import { getBalance as getLeRAACBalance } from "./contracts/tokens/leRAAC/getBalance";
+import { getTotalSupply as getLeRAACTotalSupply } from "./contracts/tokens/leRAAC/getTotalSupply";
+import { getAllowance as getLeRAACAllowance } from "./contracts/tokens/leRAAC/getAllowance";
+import { approve as approveLeRAAC } from "./contracts/tokens/leRAAC/approve";
+import { transfer as transferLeRAAC } from "./contracts/tokens/leRAAC/transfer";
+import { transferFrom as transferFromLeRAAC } from "./contracts/tokens/leRAAC/transferFrom";
+import { burn as burnLeRAAC } from "./contracts/tokens/leRAAC/burn";
+import { burnFrom as burnFromLeRAAC } from "./contracts/tokens/leRAAC/burnFrom";
+import { getMinterInfo as getMinterInfoLeRAAC } from "./contracts/tokens/leRAAC/getMinterInfo";
+import { getRoutes as getRoutesAladdin } from "./contracts/zap/aladdin/getRoutes";
+import { getCurvePoolToken as getCurvePoolTokenAladdin } from "./contracts/zap/aladdin/getCurvePoolToken";
+import { getPool2Token as getPool2TokenAladdin } from "./contracts/zap/aladdin/getPool2Token";
+import { getOwner as getOwnerAladdin } from "./contracts/zap/aladdin/getOwner";
+import { getVersion as getVersionAladdin } from "./contracts/zap/aladdin/getVersion";
+import { zap as zapAladdin } from "./contracts/zap/aladdin/zap";
+import { zapFrom as zapFromAladdin } from "./contracts/zap/aladdin/zapFrom";
+import { zapWithRoutes as zapWithRoutesAladdin } from "./contracts/zap/aladdin/zapWithRoutes";
+import { updateRoute as updateRouteAladdin } from "./contracts/zap/aladdin/updateRoute";
+import { updatePoolTokens as updatePoolTokensAladdin } from "./contracts/zap/aladdin/updatePoolTokens";
+import { rescue as rescueAladdin } from "./contracts/zap/aladdin/rescue";
+import { decodeRoute as decodeRouteAladdin, describeRoute as describeRouteAladdin } from "./contracts/zap/aladdin/decodeRoute";
+import { encodeRoute as encodeRouteAladdin } from "./contracts/zap/aladdin/encodeRoute";
+import { validateRoute as validateRouteAladdin, validateRoutes as validateRoutesAladdin } from "./contracts/zap/aladdin/validateRoute";
+import * as zapCodec from "./contracts/zap/codec";
 import getCollateralRatio from "./contracts/pmTreasury/getCollateralRatio";
 import getCurrentNav from "./contracts/pmTreasury/getCurrentNav";
 import getTotalBaseToken from "./contracts/pmTreasury/getTotalBaseToken";
@@ -259,6 +332,17 @@ declare class RPCLibrary {
             tick: typeof tick;
             get: typeof get;
             getApy: typeof getApy;
+            activate: typeof activateMinter;
+            addDistributionPool: typeof addDistributionPoolMinter;
+            removeDistributionPool: typeof removeDistributionPoolMinter;
+            manageDistributionPool: typeof manageDistributionPoolMinter;
+            pause: typeof pauseMinter;
+            unpause: typeof unpauseMinter;
+            getDistributionPools: typeof getDistributionPoolsMinter;
+            getPoolInfo: typeof getPoolInfoMinter;
+            calculateScheduledMintableAmount: typeof calculateScheduledMintableAmountMinter;
+            getEmissionPerSecond: typeof getEmissionPerSecondMinter;
+            isPaused: typeof isPausedMinter;
         };
         getContractAddress: typeof getContractAddress;
         getContract: typeof getContract;
@@ -406,6 +490,93 @@ declare class RPCLibrary {
             getBalance: typeof getXPMBalance;
             getTotalSupply: typeof getXPMTotalSupply;
         };
+        leRAAC: {
+            getBalance: typeof getLeRAACBalance;
+            getTotalSupply: typeof getLeRAACTotalSupply;
+            getAllowance: typeof getLeRAACAllowance;
+            approve: typeof approveLeRAAC;
+            transfer: typeof transferLeRAAC;
+            transferFrom: typeof transferFromLeRAAC;
+            burn: typeof burnLeRAAC;
+            burnFrom: typeof burnFromLeRAAC;
+            getMinterInfo: typeof getMinterInfoLeRAAC;
+        };
+    };
+    lockers: {
+        liquidLocker: {
+            deposit: typeof depositLiquidLocker;
+            borrow: typeof borrowLiquidLocker;
+            repay: typeof repayLiquidLocker;
+            requestUnlock: typeof requestUnlockLiquidLocker;
+            withdrawUnlocked: typeof withdrawUnlockedLiquidLocker;
+            donate: typeof donateLiquidLocker;
+            harvest: typeof harvestLiquidLocker;
+            processVaultExpiredLocks: typeof processVaultExpiredLocksLiquidLocker;
+            voteGauge: typeof voteGaugeLiquidLocker;
+            voteGovernance: typeof voteGovernanceLiquidLocker;
+            getUserInfo: typeof getUserInfoLiquidLocker;
+            getUserLocks: typeof getUserLocksLiquidLocker;
+            getGlobalInfo: typeof getGlobalInfoLiquidLocker;
+            getConfig: typeof getConfigLiquidLocker;
+            isKeeper: typeof isKeeperLiquidLocker;
+        };
+        maturityVault: {
+            deposit: typeof depositMaturityVault;
+            depositFor: typeof depositForMaturityVault;
+            withdraw: typeof withdrawMaturityVault;
+            withdrawAll: typeof withdrawAllMaturityVault;
+            claim: typeof claimMaturityVault;
+            exit: typeof exitMaturityVault;
+            distribute: typeof distributeMaturityVault;
+            harvest: typeof harvestMaturityVault;
+            updatePendingDistribution: typeof updatePendingDistributionMaturityVault;
+            getUserInfo: typeof getUserInfoMaturityVault;
+            getGlobalInfo: typeof getGlobalInfoMaturityVault;
+            getConfig: typeof getConfigMaturityVault;
+            isWhitelisted: typeof isWhitelistedMaturityVault;
+        };
+        botLocker: {
+            lock: typeof lockBotLocker;
+            unlock: typeof unlockBotLocker;
+            unlockAndClaim: typeof unlockAndClaimBotLocker;
+            claim: typeof claimBotLocker;
+            getClaimable: typeof getClaimableBotLocker;
+            getClaimables: typeof getClaimablesBotLocker;
+            getClaimedRewards: typeof getClaimedRewardsBotLocker;
+            getRewardTokens: typeof getRewardTokensBotLocker;
+            getRewardTokenCount: typeof getRewardTokenCountBotLocker;
+            getLocks: typeof getLocksBotLocker;
+            getLocksByOwner: typeof getLocksByOwnerBotLocker;
+            getLockedTokenIds: typeof getLockedTokenIdsBotLocker;
+        };
+    };
+    zap: {
+        codec: typeof zapCodec;
+        aladdin: {
+            getRoutes: typeof getRoutesAladdin;
+            getCurvePoolToken: typeof getCurvePoolTokenAladdin;
+            getPool2Token: typeof getPool2TokenAladdin;
+            getOwner: typeof getOwnerAladdin;
+            getVersion: typeof getVersionAladdin;
+            zap: typeof zapAladdin;
+            zapFrom: typeof zapFromAladdin;
+            zapWithRoutes: typeof zapWithRoutesAladdin;
+            updateRoute: typeof updateRouteAladdin;
+            updatePoolTokens: typeof updatePoolTokensAladdin;
+            rescue: typeof rescueAladdin;
+            decodeRoute: typeof decodeRouteAladdin;
+            describeRoute: typeof describeRouteAladdin;
+            encodeRoute: typeof encodeRouteAladdin;
+            validateRoute: typeof validateRouteAladdin;
+            validateRoutes: typeof validateRoutesAladdin;
+            encodePoolHintV2: typeof zapCodec.encodePoolHintV2;
+            encodePoolHintV3: typeof zapCodec.encodePoolHintV3;
+            decodePoolV2: typeof zapCodec.decodePoolV2;
+            decodePoolV3: typeof zapCodec.decodePoolV3;
+            PoolType: typeof zapCodec.PoolType;
+            PoolTypeV3: typeof zapCodec.PoolTypeV3;
+            Action: typeof zapCodec.Action;
+        };
     };
     pools: {
         stabilityPool: {

package/dist/types/contracts/lockers/botLocker/_helpers.d.ts

@@ -0,0 +1,4 @@
+import { Provider, Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { RAACBotLocker } from "../../../typechain-types";
+export declare function getBotLockerContract(chainId: ChainId, runner?: Provider | Signer): Promise<RAACBotLocker>;

package/dist/types/contracts/lockers/botLocker/claim.d.ts

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Claim all accrued reward tokens to `recipient`.
+ */
+export declare const claim: (chainId: ChainId, recipient: string, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/botLocker/getClaimable.d.ts

@@ -0,0 +1,6 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Claimable amount of a single reward token for `account`.
+ */
+export declare const getClaimable: (chainId: ChainId, account: string, token: string, provider?: Provider) => Promise<bigint>;

package/dist/types/contracts/lockers/botLocker/getClaimables.d.ts

@@ -0,0 +1,10 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface BotLockerClaimable {
+    token: string;
+    amount: bigint;
+}
+/**
+ * Claimable amounts across all registered reward tokens for `account`.
+ */
+export declare const getClaimables: (chainId: ChainId, account: string, provider?: Provider) => Promise<BotLockerClaimable[]>;

package/dist/types/contracts/lockers/botLocker/getClaimedRewards.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface BotLockerClaimedReward {
+    token: string;
+    amount: bigint;
+}
+export declare const getClaimedRewards: (chainId: ChainId, account: string, provider?: Provider) => Promise<BotLockerClaimedReward[]>;

package/dist/types/contracts/lockers/botLocker/getLockedTokenIds.d.ts

@@ -0,0 +1,3 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export declare const getLockedTokenIds: (chainId: ChainId, user: string, provider?: Provider) => Promise<bigint[]>;

package/dist/types/contracts/lockers/botLocker/getLocks.d.ts

@@ -0,0 +1,15 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface BotLockerNFTLock {
+    owner: string;
+    lockedAt: number;
+    tokenId: bigint;
+}
+/**
+ * Returns every active NFT lock across all owners.
+ */
+export declare const getLocks: (chainId: ChainId, provider?: Provider) => Promise<BotLockerNFTLock[]>;
+/**
+ * Returns every active NFT lock owned by `owner`.
+ */
+export declare const getLocksByOwner: (chainId: ChainId, owner: string, provider?: Provider) => Promise<BotLockerNFTLock[]>;

package/dist/types/contracts/lockers/botLocker/getRewardTokenCount.d.ts

@@ -0,0 +1,3 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export declare const getRewardTokenCount: (chainId: ChainId, provider?: Provider) => Promise<number>;

package/dist/types/contracts/lockers/botLocker/getRewardTokens.d.ts

@@ -0,0 +1,3 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export declare const getRewardTokens: (chainId: ChainId, provider?: Provider) => Promise<string[]>;

package/dist/types/contracts/lockers/botLocker/lock.d.ts

@@ -0,0 +1,7 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Lock RAAC Bot NFTs into the bot-locker. Each tokenId mints a share entitling the user to reward streams.
+ * Caller must have approved the locker on the NFT contract first (`setApprovalForAll`).
+ */
+export declare const lock: (chainId: ChainId, tokenIds: (string | number | bigint)[], signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/botLocker/unlock.d.ts

@@ -0,0 +1,7 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Unlock NFTs from the bot-locker. Each tokenId must satisfy the unlock-window check
+ * (locked duration is a non-zero multiple of LOCK_DURATION_IN_EPOCH * EPOCH_DURATION).
+ */
+export declare const unlock: (chainId: ChainId, tokenIds: (string | number | bigint)[], signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/lockers/botLocker/unlockAndClaim.d.ts

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Unlock NFTs and claim accrued rewards in one transaction.
+ */
+export declare const unlockAndClaim: (chainId: ChainId, tokenIds: (string | number | bigint)[], signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,4 @@
+import { Provider, Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { RAACLiquidLocker } from "../../../typechain-types";
+export declare function getLiquidLockerContract(chainId: ChainId, runner?: Provider | Signer): Promise<RAACLiquidLocker>;

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

@@ -0,0 +1,7 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Borrow leRAAC against the caller's locked RAAC collateral.
+ * If `depositToMaturityVault` is true, borrowed leRAAC is forwarded to the maturity vault for the caller.
+ */
+export declare const borrow: (chainId: ChainId, amount: string | number | bigint, depositToMaturityVault: boolean, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,7 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Deposit RAAC into the liquid locker; locks underlying RAAC into veRAAC for the locker.
+ * Caller must have approved the locker to spend RAAC beforehand.
+ */
+export declare const deposit: (chainId: ChainId, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Donate RAAC to be distributed pro-rata to all lockers.
+ */
+export declare const donate: (chainId: ChainId, amount: string | number | bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,27 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface LiquidLockerConfig {
+    raac: string;
+    leRAAC: string;
+    veRAAC: string;
+    maturityVault: string;
+    zap: string;
+    intermediateRewardToken: string;
+    treasury: string;
+    cleverFeeRecipient: string;
+    raacBotLocker: string;
+    lockDurationEpochs: number;
+    reserveRate: bigint;
+    repayFeePercentage: bigint;
+    harvestBountyPercentage: bigint;
+    treasuryFeePercentage: bigint;
+    feeSharesBots: bigint;
+    feeSharesClever: bigint;
+    feeSharesTreasury: bigint;
+    paused: boolean;
+}
+/**
+ * Read the locker's configuration parameters in a single call batch.
+ * Frontend setup screens / dashboards should call this to render fee % and linked addresses.
+ */
+export declare const getConfig: (chainId: ChainId, provider?: Provider) => Promise<LiquidLockerConfig>;