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

package/dist/minter/getApy.js

@@ -1,28 +1,64 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
-const contracts_1 = require("../utils/contracts");
-const artifacts_1 = require("../utils/artifacts");
+const _helpers_1 = require("./_helpers");
+const SECONDS_PER_YEAR = 365n * 24n * 60n * 60n;
+/**
+ * Compute APY against current RAAC supply using the new time-based emission
+ * schedule. The minter no longer has a flat `emissionRate` — emissions follow a
+ * geometric schedule (see `EmissionSchedule.sol`). We derive the per-second
+ * emission from `calculateScheduledMintableAmount(now, now + 1)` and the yearly
+ * emission from `calculateScheduledMintableAmount(now, now + 1y)`, then divide
+ * by current total RAAC supply.
+ *
+ * Returns zeros if minting hasn't been activated or supply is 0.
+ */
 async function getApy(chainId, provider) {
-    if (!provider) {
-        throw new Error("Wallet not connected");
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, provider);
+    const [mintingStart, raacTokenAddress] = await Promise.all([
+        contract.mintingStartAtTimestamp(),
+        contract.raacToken(),
+    ]);
+    if (mintingStart === 0n) {
+        return {
+            emissionPerSecond: 0n,
+            yearlyEmission: 0n,
+            totalSupply: 0n,
+            apy: 0,
+            apyBps: 0n,
+        };
     }
-    try {
-        const raacMinterAddress = (0, contracts_1.getContractAddress)(chainId, "raacminter");
-        const raacMinterABI = (0, artifacts_1.getABI)("raacminter");
-        const raacMinterContract = new ethers_1.ethers.Contract(raacMinterAddress, raacMinterABI, provider);
-        const result = { emissionRate: 0n, BLOCKS_PER_DAY: 0n };
-        result.emissionRate = await raacMinterContract.emissionRate();
-        result.BLOCKS_PER_DAY = await raacMinterContract.BLOCKS_PER_DAY();
-        // APY:
-        const blocksPerYear = result.BLOCKS_PER_DAY * 365n;
-        const emissionRatePerYear = result.emissionRate * blocksPerYear;
-        // TODO: Needs to be fixed
-        const apy = (emissionRatePerYear * 10000n);
-        return apy;
+    const runner = contract.runner;
+    if (!runner || !runner.provider) {
+        throw new Error("getApy: minter contract has no provider");
     }
-    catch (error) {
-        throw new Error(`Error calculating RAAC rewards: ${error.message}`);
+    const block = await runner.provider.getBlock("latest");
+    if (!block)
+        throw new Error("getApy: could not fetch latest block");
+    const now = BigInt(block.timestamp);
+    const erc20 = new ethers_1.ethers.Contract(raacTokenAddress, ["function totalSupply() view returns (uint256)"], runner);
+    const [yearlyEmission, totalSupplyResult, perSecond] = await Promise.all([
+        contract.calculateScheduledMintableAmount(now, now + SECONDS_PER_YEAR),
+        erc20.totalSupply(),
+        contract.calculateScheduledMintableAmount(now, now + 1n),
+    ]);
+    const totalSupply = totalSupplyResult;
+    if (totalSupply === 0n) {
+        return {
+            emissionPerSecond: perSecond,
+            yearlyEmission,
+            totalSupply,
+            apy: 0,
+            apyBps: 0n,
+        };
     }
+    const apyBps = (yearlyEmission * 10000n) / totalSupply;
+    return {
+        emissionPerSecond: perSecond,
+        yearlyEmission,
+        totalSupply,
+        apy: Number(apyBps) / 100,
+        apyBps,
+    };
 }
 exports.default = getApy;

package/dist/minter/getDistributionPools.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDistributionPools = void 0;
+const ethers_1 = require("ethers");
+const _helpers_1 = require("./_helpers");
+/**
+ * Returns full distribution-pool table along with each pool's share of
+ * `totalWeight`. Iterates `distributionPools(i)` until it reverts (mirrors how
+ * the contract stores the dynamic array) and reads `poolInfo(pool)` for each.
+ */
+const getDistributionPools = async (chainId, provider) => {
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, provider);
+    const totalWeight = await contract.totalWeight();
+    const pools = [];
+    for (let i = 0;; i++) {
+        try {
+            pools.push(await contract.distributionPools(i));
+        }
+        catch {
+            break;
+        }
+    }
+    return Promise.all(pools.map(async (pool) => {
+        const info = await contract.poolInfo(pool);
+        const weight = info.weight ?? info[0];
+        const exists = info.exists ?? info[1];
+        const pendingRewards = info.pendingRewards ?? info[3];
+        const weightShare = totalWeight === 0n ? 0 : Number((weight * 10000n) / totalWeight) / 10000;
+        return {
+            pool,
+            weight,
+            pendingRewards: ethers_1.ethers.formatEther(pendingRewards),
+            pendingRewardsRaw: pendingRewards,
+            exists,
+            weightShare,
+        };
+    }));
+};
+exports.getDistributionPools = getDistributionPools;

package/dist/minter/getEmissionPerSecond.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEmissionPerSecond = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Returns the current per-second RAAC emission. Derived by sampling
+ * `calculateScheduledMintableAmount(now, now + 1)` at the latest block timestamp.
+ * Returns 0 if minting hasn't been activated yet.
+ */
+const getEmissionPerSecond = async (chainId, provider) => {
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, provider);
+    const mintingStart = await contract.mintingStartAtTimestamp();
+    if (mintingStart === 0n)
+        return 0n;
+    const runner = contract.runner;
+    if (!runner || !runner.provider) {
+        throw new Error("getEmissionPerSecond: minter contract has no provider");
+    }
+    const block = await runner.provider.getBlock("latest");
+    if (!block)
+        throw new Error("getEmissionPerSecond: could not fetch latest block");
+    const now = BigInt(block.timestamp);
+    return contract.calculateScheduledMintableAmount(now, now + 1n);
+};
+exports.getEmissionPerSecond = getEmissionPerSecond;

package/dist/minter/getPoolInfo.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPoolInfo = void 0;
+const ethers_1 = require("ethers");
+const _helpers_1 = require("./_helpers");
+/**
+ * Read the per-pool record from the minter's `poolInfo` mapping.
+ */
+const getPoolInfo = async (chainId, pool, provider) => {
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, provider);
+    const info = await contract.poolInfo(pool);
+    const weight = info.weight ?? info[0];
+    const exists = info.exists ?? info[1];
+    const pendingRewards = info.pendingRewards ?? info[3];
+    return {
+        pool,
+        weight,
+        pendingRewards: ethers_1.ethers.formatEther(pendingRewards),
+        pendingRewardsRaw: pendingRewards,
+        exists,
+    };
+};
+exports.getPoolInfo = getPoolInfo;

package/dist/minter/isPaused.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPaused = void 0;
+const _helpers_1 = require("./_helpers");
+const isPaused = async (chainId, provider) => {
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, provider);
+    return contract.paused();
+};
+exports.isPaused = isPaused;

package/dist/minter/manageDistributionPool.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manageDistributionPool = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Set the weight of an existing pool, or register a new pool with the given weight.
+ * UPDATER_ROLE only. Pass `weight = 0` to deactivate (still registered, just stops
+ * receiving emissions). Calls `tick()` first to distribute pending emissions.
+ */
+const manageDistributionPool = async (chainId, pool, weight, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, signer);
+    const tx = await contract.manageDistributionPool(pool, weight);
+    await tx.wait();
+    return tx;
+};
+exports.manageDistributionPool = manageDistributionPool;

package/dist/minter/pause.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unpause = exports.pause = void 0;
+const _helpers_1 = require("./_helpers");
+/** PAUSER_ROLE only. */
+const pause = async (chainId, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, signer);
+    const tx = await contract.pause();
+    await tx.wait();
+    return tx;
+};
+exports.pause = pause;
+/** PAUSER_ROLE only. */
+const unpause = async (chainId, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, signer);
+    const tx = await contract.unpause();
+    await tx.wait();
+    return tx;
+};
+exports.unpause = unpause;

package/dist/minter/removeDistributionPool.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDistributionPool = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Remove a distribution pool. UPDATER_ROLE only.
+ * If `excludeTick` is false (default), `tick()` is called first to drain pending
+ * rewards; the call reverts with `PoolPendingRewardsNotCleared` if pending
+ * rewards remain after that. If `excludeTick` is true, any pending rewards on
+ * the pool roll back into `excessTokens` for future distribution.
+ */
+const removeDistributionPool = async (chainId, pool, excludeTick, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, signer);
+    const tx = await contract.removeDistributionPool(pool, excludeTick);
+    await tx.wait();
+    return tx;
+};
+exports.removeDistributionPool = removeDistributionPool;

package/dist/minter/tick.js

@@ -1,29 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ethers_1 = require("ethers");
-const contracts_1 = require("../utils/contracts");
-const artifacts_1 = require("../utils/artifacts");
+const _helpers_1 = require("./_helpers");
+/**
+ * Permissionless: triggers minting and pool distribution. Will silently no-op
+ * if `mintingStartAtTimestamp == 0` or `totalSupply >= MAX_SUPPLY`.
+ */
 async function tick(chainId, signer) {
-    if (!signer) {
-        throw new Error("Wallet not connected");
-    }
-    try {
-        const raacMinterAddress = (0, contracts_1.getContractAddress)(chainId, "raacminter");
-        const raacMinterABI = (0, artifacts_1.getABI)("raacminter");
-        const raacMinterContract = new ethers_1.ethers.Contract(raacMinterAddress, raacMinterABI, signer);
-        // const { maxFeePerGas } = await estimateGasPrice(signer);
-        // console.log({ maxFeePerGas });
-        const tick = await raacMinterContract.tick({
-            // maxFeePerGas,
-            nonce: await signer.getNonce(),
-        });
-        if (tick.wait) {
-            await tick.wait();
-        }
-        return tick;
-    }
-    catch (error) {
-        throw new Error(`Error calculating RAAC rewards: ${error.message}`);
-    }
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getMinterContract)(chainId, signer);
+    const tx = await contract.tick({ nonce: await signer.getNonce() });
+    if (tx.wait)
+        await tx.wait();
+    return tx;
 }
 exports.default = tick;

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";
@@ -96,35 +106,9 @@ import { getWithdrawRequestInfo as getStabilityPoolWithdrawRequestInfo } from ".
 import { requestWithdraw as requestStabilityPoolWithdraw } from "./pools/stabilityPool/requestWithdraw";
 import { getABI } from "./utils/artifacts";
 import { decodeErrorName, getErrorInfo, attachDecodedError, decodeErrorMessage, attachDecodedErrorMessage } from "./utils/errorDecoder";
-import { deposit as depositDistributor } from "./contracts/governance/distributor/deposit";
-import { getAvailableBalance as getAvailableBalanceDistributor } from "./contracts/governance/distributor/getAvailableBalance";
-import { getTransferableBalance as getTransferableBalanceDistributor } from "./contracts/governance/distributor/getTransferableBalance";
-import { getRewardTokenInfo as getRewardTokenInfoDistributor } from "./contracts/governance/distributor/getRewardTokenInfo";
-import { getRewardTokens as getRewardTokensDistributor } from "./contracts/governance/distributor/getRewardTokens";
-import { isRewardTokenApproved as isRewardTokenApprovedDistributor } from "./contracts/governance/distributor/isRewardTokenApproved";
-import { isTokenApproved as isTokenApprovedDistributor } from "./contracts/governance/distributor/isTokenApproved";
-import { getGaugeRewardTokens as getGaugeRewardTokensDistributor } from "./contracts/governance/distributor/getGaugeRewardTokens";
-import { claimReward as claimRewardGauge } from "./contracts/governance/gauge/claimReward";
-import { claimRewardToken as claimRewardTokenGauge } from "./contracts/governance/gauge/claimRewardToken";
-import { getAllEarnedRewards as getAllEarnedRewardsGauge } from "./contracts/governance/gauge/getAllEarnedRewards";
-import { getAllPendingRewards as getAllPendingRewardsGauge } from "./contracts/governance/gauge/getAllPendingRewards";
-import { getBalanceOf as getBalanceOfGauge } from "./contracts/governance/gauge/getBalanceOf";
-import { getRawBalanceOf as getRawBalanceOfGauge } from "./contracts/governance/gauge/getRawBalanceOf";
-import { getRawTotalSupply as getRawTotalSupplyGauge } from "./contracts/governance/gauge/getRawTotalSupply";
-import { getTotalSupply as getTotalSupplyGauge } from "./contracts/governance/gauge/getTotalSupply";
-import { syncRewardTokens as syncRewardTokensGauge } from "./contracts/governance/gauge/syncRewardTokens";
-import { stake as stakeGauge } from "./contracts/governance/gauge/stake";
-import { withdraw as withdrawGauge } from "./contracts/governance/gauge/withdraw";
-import { getPeriodDuration as getPeriodDurationGauge } from "./contracts/governance/gauge/getPeriodDuration";
-import { getPeriodBoundaries as getPeriodBoundariesGauge } from "./contracts/governance/gauge/getPeriodBoundaries";
-import { calculateBoost as calculateBoostGaugeController } from "./contracts/governance/gaugeController/calculateBoost";
-import { getGaugeWeight as getGaugeWeightGaugeController } from "./contracts/governance/gaugeController/getGaugeWeight";
-import { getTotalWeight as getTotalWeightGaugeController } from "./contracts/governance/gaugeController/getTotalWeight";
-import { isGauge as isGaugeGaugeController } from "./contracts/governance/gaugeController/isGauge";
-import { checkpointGauge as checkpointGaugeGaugeController } from "./contracts/governance/gaugeController/checkpointGauge";
-import { getUserGaugeVoteWeight as getUserGaugeVoteWeightGaugeController } from "./contracts/governance/gaugeController/getUserGaugeVoteWeight";
-import { getUserVotePowerRemaining as getUserVotePowerRemainingGaugeController } from "./contracts/governance/gaugeController/getUserVotePowerRemaining";
-import { vote as voteGaugeController } from "./contracts/governance/gaugeController/vote";
+import * as distributorMethods from "./contracts/governance/distributor";
+import * as gaugeMethods from "./contracts/governance/gauge";
+import * as controllerMethods from "./contracts/governance/gaugeController";
 import { cancel as cancelProposals } from "./contracts/governance/proposals/cancel";
 import { getProposalData as getProposalDataProposals } from "./contracts/governance/proposals/getProposalData";
 import { getQuorumNumerator as getQuorumNumeratorProposals } from "./contracts/governance/proposals/getQuorumNumerator";
@@ -190,6 +174,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 +306,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;
@@ -288,41 +346,9 @@ declare class RPCLibrary {
         };
     };
     governance: {
-        distributor: {
-            deposit: typeof depositDistributor;
-            getAvailableBalance: typeof getAvailableBalanceDistributor;
-            getTransferableBalance: typeof getTransferableBalanceDistributor;
-            getRewardTokenInfo: typeof getRewardTokenInfoDistributor;
-            getRewardTokens: typeof getRewardTokensDistributor;
-            isRewardTokenApproved: typeof isRewardTokenApprovedDistributor;
-            isTokenApproved: typeof isTokenApprovedDistributor;
-            getGaugeRewardTokens: typeof getGaugeRewardTokensDistributor;
-        };
-        gauge: {
-            getBalanceOf: typeof getBalanceOfGauge;
-            getRawBalanceOf: typeof getRawBalanceOfGauge;
-            getRawTotalSupply: typeof getRawTotalSupplyGauge;
-            getTotalSupply: typeof getTotalSupplyGauge;
-            syncRewardTokens: typeof syncRewardTokensGauge;
-            stake: typeof stakeGauge;
-            withdraw: typeof withdrawGauge;
-            claimReward: typeof claimRewardGauge;
-            claimRewardToken: typeof claimRewardTokenGauge;
-            getAllEarnedRewards: typeof getAllEarnedRewardsGauge;
-            getAllPendingRewards: typeof getAllPendingRewardsGauge;
-            getPeriodDuration: typeof getPeriodDurationGauge;
-            getPeriodBoundaries: typeof getPeriodBoundariesGauge;
-        };
-        controller: {
-            calculateBoost: typeof calculateBoostGaugeController;
-            getGaugeWeight: typeof getGaugeWeightGaugeController;
-            getTotalWeight: typeof getTotalWeightGaugeController;
-            isGauge: typeof isGaugeGaugeController;
-            checkpointGauge: typeof checkpointGaugeGaugeController;
-            getUserGaugeVoteWeight: typeof getUserGaugeVoteWeightGaugeController;
-            getUserVotePowerRemaining: typeof getUserVotePowerRemainingGaugeController;
-            vote: typeof voteGaugeController;
-        };
+        distributor: typeof distributorMethods;
+        gauge: typeof gaugeMethods;
+        controller: typeof controllerMethods;
         proposals: {
             cancel: typeof cancelProposals;
             getProposalData: typeof getProposalDataProposals;
@@ -406,6 +432,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/governance/distributor/claimAll.d.ts

@@ -0,0 +1,11 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Claims accrued rewards for multiple gauges in a single transaction.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gauges - Array of gauge addresses.
+ * @param signer - An ethers.js Signer instance (required).
+ * @returns Transaction after it has been mined.
+ */
+export declare const claimAll: (chainId: ChainId, gauges: string[], signer: Signer) => Promise<any>;

package/dist/types/contracts/governance/distributor/claimForGauge.d.ts

@@ -0,0 +1,12 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Claims accrued rewards for a gauge.
+ * Note: only callable by the gauge contract itself (msg.sender must == gauge).
+ *
+ * @param chainId - The chain/network to use.
+ * @param gauge - Address of the gauge.
+ * @param signer - An ethers.js Signer instance (required).
+ * @returns Transaction after it has been mined.
+ */
+export declare const claimForGauge: (chainId: ChainId, gauge: string, signer: Signer) => Promise<any>;

package/dist/types/contracts/governance/distributor/deposit.d.ts

@@ -1,14 +1,13 @@
 import { Signer } from "ethers";
-import configs from "../../../configs/chains";
+import { ChainId } from "../../../configs/chains";
 /**
  * Deposits reward tokens into the distributor.
- * Anyone can call this, but only for approved tokens.
- * Rewards are distributed to gauges based on their weights.
+ * The reward token must be pre-approved by the caller before calling.
  *
  * @param chainId - The chain/network to use.
- * @param tokenAddress - Address of the reward token.
+ * @param token - Address of the reward token.
  * @param amount - Amount of reward tokens to deposit.
- * @param signer - An ethers.js Signer instance (must be connected to wallet).
- * @returns Transaction receipt after the deposit is made.
+ * @param signer - An ethers.js Signer instance (required).
+ * @returns Transaction after it has been mined.
  */
-export declare const deposit: (chainId: keyof typeof configs, tokenAddress: string, amount: string | number | bigint, signer: Signer) => Promise<any>;
+export declare const deposit: (chainId: ChainId, token: string, amount: string | number | bigint, signer: Signer) => Promise<any>;

package/dist/types/contracts/governance/distributor/getClaimableForGauge.d.ts

@@ -0,0 +1,11 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Gets the amount of rewards currently claimable for a gauge.
+ *
+ * @param chainId - The chain/network to use.
+ * @param gauge - Address of the gauge.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns Claimable reward amount (bigint).
+ */
+export declare const getClaimableForGauge: (chainId: ChainId, gauge: string, provider?: Provider) => Promise<bigint>;