@raac/rpc 2.0.0-beta.3 → 2.0.0-beta.5

package/dist/contracts/lockers/botLocker/getLocks.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLocksByOwner = exports.getLocks = void 0;
+exports.getLocksByOwner = exports.getLock = exports.getLocks = void 0;
+const ethers_1 = require("ethers");
 const _helpers_1 = require("./_helpers");
 const normalize = (l) => ({
     owner: l.owner ?? l[0],
@@ -16,6 +17,15 @@ const getLocks = async (chainId, provider) => {
     return results.map(normalize);
 };
 exports.getLocks = getLocks;
+/**
+ * Returns the lock of a single NFT, or null when it is not locked.
+ */
+const getLock = async (chainId, tokenId, provider) => {
+    const contract = await (0, _helpers_1.getBotLockerContract)(chainId, provider);
+    const lock = normalize(await contract.locks(tokenId));
+    return lock.owner === ethers_1.ZeroAddress ? null : lock;
+};
+exports.getLock = getLock;
 /**
  * Returns every active NFT lock owned by `owner`.
  */

package/dist/contracts/lockers/botLocker/getRoles.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRoles = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Gets the access-control role identifiers used by the bot locker.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The bytes32 role identifiers.
+ */
+const getRoles = async (chainId, provider) => {
+    const contract = await (0, _helpers_1.getBotLockerContract)(chainId, provider);
+    const [defaultAdminRole, pauserRole, managerRole, distributorRole] = await Promise.all([
+        contract.DEFAULT_ADMIN_ROLE(),
+        contract.PAUSER_ROLE(),
+        contract.MANAGER_ROLE(),
+        contract.DISTRIBUTOR_ROLE(),
+    ]);
+    return { defaultAdminRole, pauserRole, managerRole, distributorRole };
+};
+exports.getRoles = getRoles;

package/dist/contracts/lockers/botLocker/getUnlockWindow.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnlockWindow = exports.BOT_LOCKER_LOCK_DURATION_EPOCHS = exports.BOT_LOCKER_EPOCH_DURATION = void 0;
+/** EPOCH_DURATION on RAACBotLocker, seconds. */
+exports.BOT_LOCKER_EPOCH_DURATION = 7 * 24 * 60 * 60;
+/** LOCK_DURATION_IN_EPOCH on RAACBotLocker. */
+exports.BOT_LOCKER_LOCK_DURATION_EPOCHS = 4;
+/**
+ * Unlock window of a locked NFT, computed locally without an RPC call.
+ *
+ * The contract allows `unlockAndClaim` when `floor((now - lockedAt) / epochDuration)` is a non-zero multiple of `lockDurationEpochs`, so windows are `[lockedAt + k * cycle, lockedAt + k * cycle + epochDuration)` for `k >= 1`, where `cycle = lockDurationEpochs * epochDuration`. They are relative to each NFT's own `lockedAt`, not to a global epoch, and a missed window reopens one cycle later.
+ *
+ * @param lockedAt - Lock timestamp of the NFT, unix seconds (`locks(tokenId).lockedAt`, or `lockedAt` from the subgraph).
+ * @param now - Current time, unix seconds. Use the latest block timestamp to match the contract exactly.
+ * @param epochDuration - Epoch length, seconds. Defaults to the contract constant.
+ * @param lockDurationEpochs - Epochs per lock cycle. Defaults to the contract constant.
+ * @returns Whether the NFT can unlock now and the bounds of the current or next window.
+ */
+const getUnlockWindow = (lockedAt, now, epochDuration = exports.BOT_LOCKER_EPOCH_DURATION, lockDurationEpochs = exports.BOT_LOCKER_LOCK_DURATION_EPOCHS) => {
+    const epochs = Math.floor((now - lockedAt) / epochDuration);
+    if (epochs > 0 && epochs % lockDurationEpochs === 0) {
+        const opensAt = lockedAt + epochs * epochDuration;
+        return { unlockable: true, opensAt, closesAt: opensAt + epochDuration };
+    }
+    const cycle = Math.floor(Math.max(epochs, 0) / lockDurationEpochs) + 1;
+    const opensAt = lockedAt + cycle * lockDurationEpochs * epochDuration;
+    return { unlockable: false, opensAt, closesAt: opensAt + epochDuration };
+};
+exports.getUnlockWindow = getUnlockWindow;

package/dist/contracts/lockers/botLocker/grantRole.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.revokeRole = exports.grantRole = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Grant a bot locker role. DEFAULT_ADMIN_ROLE only.
+ *
+ * @param chainId - The chain/network to use.
+ * @param role - The bytes32 role identifier (see `getRoles`).
+ * @param account - The address to grant the role to.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+const grantRole = async (chainId, role, account, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getBotLockerContract)(chainId, signer);
+    const tx = await contract.grantRole(role, account);
+    await tx.wait();
+    return tx;
+};
+exports.grantRole = grantRole;
+/**
+ * Revoke a bot locker role. DEFAULT_ADMIN_ROLE only.
+ *
+ * @param chainId - The chain/network to use.
+ * @param role - The bytes32 role identifier (see `getRoles`).
+ * @param account - The address to revoke the role from.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+const revokeRole = async (chainId, role, account, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getBotLockerContract)(chainId, signer);
+    const tx = await contract.revokeRole(role, account);
+    await tx.wait();
+    return tx;
+};
+exports.revokeRole = revokeRole;

package/dist/contracts/lockers/botLocker/hasRole.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasRole = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Checks whether an account holds a bot locker role.
+ *
+ * @param chainId - The chain/network to use.
+ * @param role - The bytes32 role identifier (see `getRoles`).
+ * @param account - The address to check.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns True if the account holds the role.
+ */
+const hasRole = async (chainId, role, account, provider) => {
+    const contract = await (0, _helpers_1.getBotLockerContract)(chainId, provider);
+    return contract.hasRole(role, account);
+};
+exports.hasRole = hasRole;

package/dist/contracts/lockers/botLocker/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");
+/** Pause lock, unlockAndClaim and claim. PAUSER_ROLE only. */
+const pause = async (chainId, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getBotLockerContract)(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.getBotLockerContract)(chainId, signer);
+    const tx = await contract.unpause();
+    await tx.wait();
+    return tx;
+};
+exports.unpause = unpause;

package/dist/contracts/lockers/botLocker/rescueTokens.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rescueTokens = void 0;
+const _helpers_1 = require("./_helpers");
+/**
+ * Send the locker's entire balance of `token` to `recipient`. DEFAULT_ADMIN_ROLE only.
+ * This includes rewards lockers have not claimed yet, so later claims of that token revert until it is refilled.
+ *
+ * @param chainId - The chain/network to use.
+ * @param token - ERC20 address to rescue.
+ * @param recipient - Address receiving the balance.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+const rescueTokens = async (chainId, token, recipient, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const contract = await (0, _helpers_1.getBotLockerContract)(chainId, signer);
+    const tx = await contract.rescueTokens(token, recipient);
+    await tx.wait();
+    return tx;
+};
+exports.rescueTokens = rescueTokens;

package/dist/nfts/getNFTBalance.js

@@ -0,0 +1,29 @@
+"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 rpcError_1 = require("../utils/rpcError");
+/**
+ * Get how many tokens of an NFT contract an address holds
+ * @param chainId - The chain ID
+ * @param nftContractName - The NFT contract name from configs
+ * @param owner - The address to check
+ * @param provider - The provider to use for the contract call
+ * @returns The number of tokens held
+ */
+async function getNFTBalance(chainId, nftContractName, owner, provider) {
+    if (!provider) {
+        throw new Error("Provider not available");
+    }
+    const nftAddress = (0, contracts_1.getContractAddress)(chainId, nftContractName);
+    try {
+        const nftABI = (0, artifacts_1.getABI)(nftContractName);
+        const nftContract = new ethers_1.ethers.Contract(nftAddress, nftABI, provider);
+        return await nftContract.balanceOf(owner);
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("nfts.getNFTBalance", error, { chainId, address: nftAddress });
+    }
+}
+exports.default = getNFTBalance;

package/dist/nfts/transferNFT.js

@@ -0,0 +1,34 @@
+"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 rpcError_1 = require("../utils/rpcError");
+/**
+ * Transfer an NFT from the signer to another address with safeTransferFrom
+ * Do not use it to put a Bot NFT into the bot locker: the locker only records NFTs deposited through `lockers.botLocker.lock`.
+ * @param chainId - The chain ID
+ * @param nftContractName - The NFT contract name from configs
+ * @param to - The recipient address
+ * @param tokenId - The token ID to transfer
+ * @param signer - The signer that owns the token
+ * @returns Transaction receipt
+ */
+async function transferNFT(chainId, nftContractName, to, tokenId, signer) {
+    if (!signer) {
+        throw new Error("Wallet not connected");
+    }
+    const nftAddress = (0, contracts_1.getContractAddress)(chainId, nftContractName);
+    try {
+        const nftABI = (0, artifacts_1.getABI)(nftContractName);
+        const nftContract = new ethers_1.ethers.Contract(nftAddress, nftABI, signer);
+        const from = await signer.getAddress();
+        const tx = await nftContract["safeTransferFrom(address,address,uint256)"](from, to, tokenId);
+        const receipt = await tx.wait();
+        return receipt;
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("nfts.transferNFT", error, { chainId, address: nftAddress });
+    }
+}
+exports.default = transferNFT;

package/dist/types/RPCLibrary.d.ts

@@ -106,6 +106,8 @@ import getNFTApproval from "./nfts/getNFTApproval";
 import getApprovedForAll from "./nfts/getApprovalForAll";
 import setApprovalForAll from "./nfts/setApprovalForAll";
 import approveNFT from "./nfts/approveNFT";
+import getNFTBalance from "./nfts/getNFTBalance";
+import transferNFT from "./nfts/transferNFT";
 import vaultOpened from "./pools/lendingPool/vaultOpened";
 import { getWithdrawRequestInfo as getStabilityPoolWithdrawRequestInfo } from "./pools/stabilityPool/getWithdrawRequestInfo";
 import { getWithdrawTimelockConfig as getStabilityPoolWithdrawTimelockConfig } from "./pools/stabilityPool/getWithdrawTimelockConfig";
@@ -242,8 +244,17 @@ import { getClaimables as getClaimablesBotLocker } from "./contracts/lockers/bot
 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 { getLocks as getLocksBotLocker, getLock as getLockBotLocker, getLocksByOwner as getLocksByOwnerBotLocker } from "./contracts/lockers/botLocker/getLocks";
 import { getLockedTokenIds as getLockedTokenIdsBotLocker } from "./contracts/lockers/botLocker/getLockedTokenIds";
+import { getConfig as getConfigBotLocker } from "./contracts/lockers/botLocker/getConfig";
+import { getUnlockWindow as getUnlockWindowBotLocker } from "./contracts/lockers/botLocker/getUnlockWindow";
+import { getRoles as getRolesBotLocker } from "./contracts/lockers/botLocker/getRoles";
+import { hasRole as hasRoleBotLocker } from "./contracts/lockers/botLocker/hasRole";
+import { grantRole as grantRoleBotLocker, revokeRole as revokeRoleBotLocker } from "./contracts/lockers/botLocker/grantRole";
+import { addRewardTokens as addRewardTokensBotLocker } from "./contracts/lockers/botLocker/addRewardTokens";
+import { distributeRewardToken as distributeRewardTokenBotLocker } from "./contracts/lockers/botLocker/distributeRewardToken";
+import { pause as pauseBotLocker, unpause as unpauseBotLocker } from "./contracts/lockers/botLocker/pause";
+import { rescueTokens as rescueTokensBotLocker } from "./contracts/lockers/botLocker/rescueTokens";
 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";
@@ -337,6 +348,8 @@ declare class RPCLibrary {
         getApprovedForAll: typeof getApprovedForAll;
         setApprovalForAll: typeof setApprovalForAll;
         approveNFT: typeof approveNFT;
+        getNFTBalance: typeof getNFTBalance;
+        transferNFT: typeof transferNFT;
     };
     contracts: {
         housePrices: {
@@ -549,8 +562,20 @@ declare class RPCLibrary {
             getRewardTokens: typeof getRewardTokensBotLocker;
             getRewardTokenCount: typeof getRewardTokenCountBotLocker;
             getLocks: typeof getLocksBotLocker;
+            getLock: typeof getLockBotLocker;
             getLocksByOwner: typeof getLocksByOwnerBotLocker;
             getLockedTokenIds: typeof getLockedTokenIdsBotLocker;
+            getConfig: typeof getConfigBotLocker;
+            getUnlockWindow: typeof getUnlockWindowBotLocker;
+            getRoles: typeof getRolesBotLocker;
+            hasRole: typeof hasRoleBotLocker;
+            grantRole: typeof grantRoleBotLocker;
+            revokeRole: typeof revokeRoleBotLocker;
+            addRewardTokens: typeof addRewardTokensBotLocker;
+            distributeRewardToken: typeof distributeRewardTokenBotLocker;
+            pause: typeof pauseBotLocker;
+            unpause: typeof unpauseBotLocker;
+            rescueTokens: typeof rescueTokensBotLocker;
         };
     };
     zap: {

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

@@ -0,0 +1,11 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Register reward tokens that can be distributed to lockers. MANAGER_ROLE only.
+ * Reverts if any token is the zero address or already registered.
+ *
+ * @param chainId - The chain/network to use.
+ * @param tokens - ERC20 addresses to register.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+export declare const addRewardTokens: (chainId: ChainId, tokens: string[], signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,13 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Distribute `amount` of a registered reward token across all currently locked NFTs. DISTRIBUTOR_ROLE only.
+ * The signer's tokens are pulled via transferFrom, so approve the locker for `amount` first.
+ * Reverts when nothing is locked.
+ *
+ * @param chainId - The chain/network to use.
+ * @param token - Address of a registered reward token.
+ * @param amount - Amount to distribute, in `token` base units.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+export declare const distributeRewardToken: (chainId: ChainId, token: string, amount: bigint, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,20 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface BotLockerConfig {
+    /** Address of the RAAC Bot NFT collection the locker accepts. */
+    nft: string;
+    /** Length of one epoch, seconds (EPOCH_DURATION). */
+    epochDuration: number;
+    /** Epochs per lock cycle; an NFT can unlock when its locked epochs are a non-zero multiple of this (LOCK_DURATION_IN_EPOCH). */
+    lockDurationEpochs: number;
+    rewardTokens: string[];
+    paused: boolean;
+}
+/**
+ * Read the locker's configuration in a single call batch.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The NFT collection, lock timing constants, reward tokens and pause state.
+ */
+export declare const getConfig: (chainId: ChainId, provider?: Provider) => Promise<BotLockerConfig>;

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

@@ -9,6 +9,10 @@ export interface BotLockerNFTLock {
  * Returns every active NFT lock across all owners.
  */
 export declare const getLocks: (chainId: ChainId, provider?: Provider) => Promise<BotLockerNFTLock[]>;
+/**
+ * Returns the lock of a single NFT, or null when it is not locked.
+ */
+export declare const getLock: (chainId: ChainId, tokenId: string | number | bigint, provider?: Provider) => Promise<BotLockerNFTLock | null>;
 /**
  * Returns every active NFT lock owned by `owner`.
  */

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

@@ -0,0 +1,20 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+export interface BotLockerRoles {
+    /** Grants and revokes roles, and calls `rescueTokens`. */
+    defaultAdminRole: string;
+    /** Calls `pause` and `unpause`. */
+    pauserRole: string;
+    /** Calls `addRewardTokens`. */
+    managerRole: string;
+    /** Calls `distributeRewardToken`; held by RAACLiquidLocker. */
+    distributorRole: string;
+}
+/**
+ * Gets the access-control role identifiers used by the bot locker.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The bytes32 role identifiers.
+ */
+export declare const getRoles: (chainId: ChainId, provider?: Provider) => Promise<BotLockerRoles>;

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

@@ -0,0 +1,24 @@
+/** EPOCH_DURATION on RAACBotLocker, seconds. */
+export declare const BOT_LOCKER_EPOCH_DURATION: number;
+/** LOCK_DURATION_IN_EPOCH on RAACBotLocker. */
+export declare const BOT_LOCKER_LOCK_DURATION_EPOCHS = 4;
+export interface BotLockerUnlockWindow {
+    /** True when `now` is inside an unlock window. */
+    unlockable: boolean;
+    /** Start of the current window when unlockable, otherwise of the next one, unix seconds. */
+    opensAt: number;
+    /** End (exclusive) of that window, unix seconds. */
+    closesAt: number;
+}
+/**
+ * Unlock window of a locked NFT, computed locally without an RPC call.
+ *
+ * The contract allows `unlockAndClaim` when `floor((now - lockedAt) / epochDuration)` is a non-zero multiple of `lockDurationEpochs`, so windows are `[lockedAt + k * cycle, lockedAt + k * cycle + epochDuration)` for `k >= 1`, where `cycle = lockDurationEpochs * epochDuration`. They are relative to each NFT's own `lockedAt`, not to a global epoch, and a missed window reopens one cycle later.
+ *
+ * @param lockedAt - Lock timestamp of the NFT, unix seconds (`locks(tokenId).lockedAt`, or `lockedAt` from the subgraph).
+ * @param now - Current time, unix seconds. Use the latest block timestamp to match the contract exactly.
+ * @param epochDuration - Epoch length, seconds. Defaults to the contract constant.
+ * @param lockDurationEpochs - Epochs per lock cycle. Defaults to the contract constant.
+ * @returns Whether the NFT can unlock now and the bounds of the current or next window.
+ */
+export declare const getUnlockWindow: (lockedAt: number, now: number, epochDuration?: number, lockDurationEpochs?: number) => BotLockerUnlockWindow;

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

@@ -0,0 +1,20 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Grant a bot locker role. DEFAULT_ADMIN_ROLE only.
+ *
+ * @param chainId - The chain/network to use.
+ * @param role - The bytes32 role identifier (see `getRoles`).
+ * @param account - The address to grant the role to.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+export declare const grantRole: (chainId: ChainId, role: string, account: string, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+/**
+ * Revoke a bot locker role. DEFAULT_ADMIN_ROLE only.
+ *
+ * @param chainId - The chain/network to use.
+ * @param role - The bytes32 role identifier (see `getRoles`).
+ * @param account - The address to revoke the role from.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+export declare const revokeRole: (chainId: ChainId, role: string, account: string, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,12 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Checks whether an account holds a bot locker role.
+ *
+ * @param chainId - The chain/network to use.
+ * @param role - The bytes32 role identifier (see `getRoles`).
+ * @param account - The address to check.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns True if the account holds the role.
+ */
+export declare const hasRole: (chainId: ChainId, role: string, account: string, provider?: Provider) => Promise<boolean>;

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

@@ -0,0 +1,6 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/** Pause lock, unlockAndClaim and claim. PAUSER_ROLE only. */
+export declare const pause: (chainId: ChainId, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;
+/** PAUSER_ROLE only. */
+export declare const unpause: (chainId: ChainId, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

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

@@ -0,0 +1,12 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../../configs/chains";
+/**
+ * Send the locker's entire balance of `token` to `recipient`. DEFAULT_ADMIN_ROLE only.
+ * This includes rewards lockers have not claimed yet, so later claims of that token revert until it is refilled.
+ *
+ * @param chainId - The chain/network to use.
+ * @param token - ERC20 address to rescue.
+ * @param recipient - Address receiving the balance.
+ * @param signer - An ethers.js Signer instance (required).
+ */
+export declare const rescueTokens: (chainId: ChainId, token: string, recipient: string, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/nfts/getNFTBalance.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../configs/chains/index";
+import { NftContractNames } from "./approveNFT";
+/**
+ * Get how many tokens of an NFT contract an address holds
+ * @param chainId - The chain ID
+ * @param nftContractName - The NFT contract name from configs
+ * @param owner - The address to check
+ * @param provider - The provider to use for the contract call
+ * @returns The number of tokens held
+ */
+declare function getNFTBalance(chainId: ChainId, nftContractName: NftContractNames, owner: string, provider: Provider): Promise<bigint>;
+export default getNFTBalance;

package/dist/types/nfts/transferNFT.d.ts

@@ -0,0 +1,15 @@
+import { ethers, Signer } from "ethers";
+import { ChainId } from "../configs/chains/index";
+import { NftContractNames } from "./approveNFT";
+/**
+ * Transfer an NFT from the signer to another address with safeTransferFrom
+ * Do not use it to put a Bot NFT into the bot locker: the locker only records NFTs deposited through `lockers.botLocker.lock`.
+ * @param chainId - The chain ID
+ * @param nftContractName - The NFT contract name from configs
+ * @param to - The recipient address
+ * @param tokenId - The token ID to transfer
+ * @param signer - The signer that owns the token
+ * @returns Transaction receipt
+ */
+declare function transferNFT(chainId: ChainId, nftContractName: NftContractNames, to: string, tokenId: string | number | bigint, signer: Signer): Promise<ethers.ContractTransactionReceipt>;
+export default transferNFT;

package/dist/types/utils/artifacts.d.ts

@@ -117,6 +117,56 @@ declare const ABIS: {
         type: string;
         anonymous?: undefined;
     })[];
+    raacbotnft: ({
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        name?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        anonymous?: undefined;
+        outputs?: undefined;
+    } | {
+        anonymous: boolean;
+        inputs: {
+            indexed: boolean;
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    })[];
     raactoken: ({
         inputs: {
             internalType: string;
@@ -4937,6 +4987,55 @@ declare const getABI: (name: keyof typeof ABIS) => any[] | ({
     stateMutability: string;
     type: string;
     anonymous?: undefined;
+})[] | ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
 })[] | ({
     inputs: any[];
     stateMutability: string;

package/dist/types/utils/errorDecoder.d.ts

@@ -26,3 +26,13 @@ export declare function decodeRevertWithAbi(abi: Interface | InterfaceAbi, data?
  * @returns The error name and its decoded arguments, or null if no known contract declares that selector.
  */
 export declare function decodeRevertWithAllAbis(data?: string): DecodedRevert | null;
+/**
+ * Names the custom error behind a bare 4-byte selector, for when a wallet or
+ * client surfaced the selector but not the full revert data (so the arguments
+ * cannot be decoded). Looks in `abi` first, then in every known ABI.
+ *
+ * @param selector The 4-byte error selector, e.g. "0x79db4619".
+ * @param abi The ABI of the contract that was called, when known.
+ * @returns The error name, or null if no known contract declares that selector.
+ */
+export declare function errorNameForSelector(selector: string, abi?: Interface | InterfaceAbi): string | null;

package/dist/utils/artifacts.js

@@ -52,6 +52,7 @@ const pmBlender_json_1 = __importDefault(require("../artifacts/core/pmBlender/pm
 const RAACLiquidLocker_json_1 = __importDefault(require("../artifacts/core/lockers/RAACLiquidLocker.sol/RAACLiquidLocker.json"));
 const RAACMaturityVault_json_1 = __importDefault(require("../artifacts/core/lockers/RAACMaturityVault.sol/RAACMaturityVault.json"));
 const RAACBotLocker_json_1 = __importDefault(require("../artifacts/core/lockers/RAACBotLocker.sol/RAACBotLocker.json"));
+const ERC721Mock_json_1 = __importDefault(require("../artifacts/mocks/core/tokens/ERC721Mock.sol/ERC721Mock.json"));
 // leRAAC token
 const LiquidEscrowedRAAC_json_1 = __importDefault(require("../artifacts/core/tokens/LeRAAC.sol/LiquidEscrowedRAAC.json"));
 // Zap
@@ -95,6 +96,8 @@ const ABIS = {
     xpm: XPM_ABI,
     // RAAC
     raacnft: RAACNFT_ABI,
+    // Standard OpenZeppelin ERC721 ABI; the Bot NFT is a plain ERC721 with no RAAC-specific functions
+    raacbotnft: ERC721Mock_json_1.default.abi,
     raactoken: RAACToken_ABI,
     veraac: VERAAC_ABI,
     // Pools tokens