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

package/dist/contracts/zeno/pause.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pause = pause;
+exports.unpause = unpause;
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Halts `buy` on an auction. PAUSER_ROLE only. A Dutch price keeps falling while paused.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param signer A PAUSER_ROLE holder.
+ * @returns The transaction receipt.
+ */
+async function pause(chainId, auction, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getAuctionContract)(chainId, auction, signer).pause();
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.pause", error, { chainId, address: auction });
+    }
+}
+/**
+ * Resumes `buy` on an auction. DEFAULT_ADMIN_ROLE only, so a compromised pauser cannot reopen buying.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param signer A DEFAULT_ADMIN_ROLE holder.
+ * @returns The transaction receipt.
+ */
+async function unpause(chainId, auction, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getAuctionContract)(chainId, auction, signer).unpause();
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.unpause", error, { chainId, address: auction });
+    }
+}

package/dist/contracts/zeno/priceAt.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.priceAt = void 0;
+/**
+ * An auction's price at `now`, computed locally without an RPC call. Mirrors `Auction.getPrice()` exactly, truncating
+ * division included: the starting price before the window, the reserve from `endTime` on, a linear fall between.
+ *
+ * @param terms The auction's price terms, e.g. from `getAuctionState` or the subgraph's `BondAuction`.
+ * @param now UNIX timestamp (seconds). Use the latest block timestamp to match the contract exactly.
+ * @returns The price in payment token base units per whole ZENO.
+ */
+const priceAt = (terms, now) => {
+    if (now < terms.startTime)
+        return terms.startingPrice;
+    if (now >= terms.endTime)
+        return terms.reservePrice;
+    return (terms.startingPrice -
+        ((terms.startingPrice - terms.reservePrice) * (now - terms.startTime)) / (terms.endTime - terms.startTime));
+};
+exports.priceAt = priceAt;

package/dist/contracts/zeno/quoteBuy.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quoteBuy = void 0;
+const BPS = 10000n;
+/**
+ * What a buy mints, computed locally without an RPC call with `Auction.buy`'s integer maths:
+ * `zenoOut = paymentAmount * 10^zenoDecimals / price`, truncated.
+ *
+ * A Dutch price only falls, so a buy mined after the quote mints at least `zenoOut`; `minZenoOut` guards against a
+ * fixed price or a stale quote. The same fall means a payment at exactly `maxPayment` can revert a block later, so
+ * leave headroom when buying out the remainder.
+ *
+ * @param input The price, payment, ZENO decimals, remaining supply and slippage tolerance.
+ * @returns The ZENO out, the `minZenoOut` to send, and the payment ceiling.
+ */
+const quoteBuy = (input) => {
+    if (input.price <= 0n)
+        throw new Error("Price must be positive");
+    const slippageBps = input.slippageBps ?? 0n;
+    if (slippageBps < 0n || slippageBps > BPS)
+        throw new Error("Slippage must be between 0 and 10000 bps");
+    const scale = 10n ** BigInt(input.zenoDecimals);
+    const zenoOut = (input.paymentAmount * scale) / input.price;
+    // floor(p * scale / price) <= remaining  <=>  p * scale < (remaining + 1) * price
+    const maxPayment = ((input.totalRemaining + 1n) * input.price - 1n) / scale;
+    return {
+        zenoOut,
+        minZenoOut: (zenoOut * (BPS - slippageBps)) / BPS,
+        maxPayment,
+        exceedsRemaining: input.paymentAmount > maxPayment,
+    };
+};
+exports.quoteBuy = quoteBuy;

package/dist/contracts/zeno/redeem.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redeem = redeem;
+exports.redeemAll = redeemAll;
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Redeems ZENO 1:1 for the underlying. Reverts before maturity, and while the bond's collateral is short of its
+ * outstanding supply (`getBondState(...).isFunded`).
+ * @param chainId The chain id.
+ * @param zeno The ZENO bond address.
+ * @param amount ZENO to redeem, in base units.
+ * @param signer The holder, who receives the underlying.
+ * @returns The transaction receipt.
+ */
+async function redeem(chainId, zeno, amount, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getZenoContract)(chainId, zeno, signer).redeem(amount);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.redeem", error, { chainId, address: zeno });
+    }
+}
+/**
+ * Redeems the signer's whole ZENO balance for the underlying. Same conditions as `redeem`.
+ * @param chainId The chain id.
+ * @param zeno The ZENO bond address.
+ * @param signer The holder, who receives the underlying.
+ * @returns The transaction receipt.
+ */
+async function redeemAll(chainId, zeno, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getZenoContract)(chainId, zeno, signer).redeemAll();
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.redeemAll", error, { chainId, address: zeno });
+    }
+}

package/dist/contracts/zeno/setAuction.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Binds a ZENO to the auction that sells it. One-shot, ZENO owner only; reverts unless the auction's `zeno()` points
+ * back at this ZENO. Until it is set, the auction's buys revert.
+ * @param chainId The chain id.
+ * @param zeno The ZENO bond address.
+ * @param auction The auction created for it.
+ * @param signer The ZENO owner.
+ * @returns The transaction receipt.
+ */
+async function setAuction(chainId, zeno, auction, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getZenoContract)(chainId, zeno, signer).setAuction(auction);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.setAuction", error, { chainId, address: zeno });
+    }
+}
+exports.default = setAuction;

package/dist/contracts/zeno/sweepSurplus.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Sweeps underlying held above the ZENO's outstanding supply: unsold prefill, overpayments and post-maturity residue.
+ * ZENO owner only, and only once the bound auction has ended. `getBondState(...).sweepableSurplus` is the most it takes.
+ * @param chainId The chain id.
+ * @param zeno The ZENO bond address.
+ * @param to The recipient of the underlying.
+ * @param amount Underlying to sweep, in base units.
+ * @param signer The ZENO owner.
+ * @returns The transaction receipt.
+ */
+async function sweepSurplus(chainId, zeno, to, amount, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getZenoContract)(chainId, zeno, signer).sweepSurplus(to, amount);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.sweepSurplus", error, { chainId, address: zeno });
+    }
+}
+exports.default = sweepSurplus;

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

@@ -74,6 +74,17 @@ import getAuctions from "./contracts/zeno/getAuctions";
 import createAuction from "./contracts/zeno/createAuction";
 import createZeno from "./contracts/zeno/createZeno";
 import getZenos from "./contracts/zeno/getZenos";
+import getAuctionState from "./contracts/zeno/getAuctionState";
+import getBondState from "./contracts/zeno/getBondState";
+import getAuctionPrice from "./contracts/zeno/getPrice";
+import buyZeno from "./contracts/zeno/buy";
+import { redeem as redeemZeno, redeemAll as redeemAllZeno } from "./contracts/zeno/redeem";
+import setAuction from "./contracts/zeno/setAuction";
+import sweepSurplus from "./contracts/zeno/sweepSurplus";
+import { pause as pauseAuction, unpause as unpauseAuction } from "./contracts/zeno/pause";
+import { grantRole as grantRoleAuction, revokeRole as revokeRoleAuction } from "./contracts/zeno/grantRole";
+import { priceAt } from "./contracts/zeno/priceAt";
+import { quoteBuy } from "./contracts/zeno/quoteBuy";
 import { ChainId } from "./configs/chains";
 import getBaseUri from "./nfts/getBaseUri";
 import claimRewardFromPool from "./contracts/feeCollector/claimRewardFromPool";
@@ -106,6 +117,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 +255,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 +359,8 @@ declare class RPCLibrary {
         getApprovedForAll: typeof getApprovedForAll;
         setApprovalForAll: typeof setApprovalForAll;
         approveNFT: typeof approveNFT;
+        getNFTBalance: typeof getNFTBalance;
+        transferNFT: typeof transferNFT;
     };
     contracts: {
         housePrices: {
@@ -549,8 +573,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: {
@@ -671,6 +707,20 @@ declare class RPCLibrary {
         getAuctions: typeof getAuctions;
         createZeno: typeof createZeno;
         getZenos: typeof getZenos;
+        getAuctionState: typeof getAuctionState;
+        getBondState: typeof getBondState;
+        getPrice: typeof getAuctionPrice;
+        buy: typeof buyZeno;
+        redeem: typeof redeemZeno;
+        redeemAll: typeof redeemAllZeno;
+        setAuction: typeof setAuction;
+        sweepSurplus: typeof sweepSurplus;
+        pause: typeof pauseAuction;
+        unpause: typeof unpauseAuction;
+        grantRole: typeof grantRoleAuction;
+        revokeRole: typeof revokeRoleAuction;
+        priceAt: typeof priceAt;
+        quoteBuy: typeof quoteBuy;
     };
     provider: any;
     estimateGasPrice: any;

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/contracts/zeno/_helpers.d.ts

@@ -0,0 +1,17 @@
+import { Provider, Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+import { Auction, ZENO } from "../../typechain-types";
+/** The one ERC20 call the zeno methods make: the underlying held by a ZENO. */
+export declare const ERC20_ABI: string[];
+/** A ZENO bond. Bonds are created by the factory, so the address is passed in rather than read from the config. */
+export declare function getZenoContract(chainId: ChainId, zeno: string, runner?: Provider | Signer): ZENO;
+/** A ZENO auction. Auctions are created by the factory, so the address is passed in rather than read from the config. */
+export declare function getAuctionContract(chainId: ChainId, auction: string, runner?: Provider | Signer): Auction;
+/**
+ * A ZENO amount. ZENO takes its decimals from its underlying, so they come from the underlying's registry entry; a
+ * ZENO address itself is never in the registry. Falls back to 18 decimals when the underlying is not listed.
+ */
+export declare function toZenoAmount(chainId: ChainId, underlying: string, value: bigint, symbol?: string): TokenAmount;
+/** `ZENO.auction()` and other unset address fields read as the zero address; this maps that to null. */
+export declare function addressOrNull(address: string): string | null;

package/dist/types/contracts/zeno/buy.d.ts

@@ -0,0 +1,15 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Buys ZENO: spends exactly `paymentAmount` of the payment token, sent to the issuer, at the price of the block it is
+ * mined in. Needs a payment token allowance for the auction (`wallet.assets.approveAsset`). Reverts while paused,
+ * outside the auction window, when the ZENO out would exceed what is left, or when it is below `minZenoOut`.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param paymentAmount Payment token to spend, in base units.
+ * @param minZenoOut The least ZENO to accept, in ZENO base units; `quoteBuy` sizes it.
+ * @param signer The buyer, who receives the ZENO.
+ * @returns The transaction receipt; its `ZENOPurchased` log carries the ZENO minted and the price paid.
+ */
+declare function buy(chainId: ChainId, auction: string, paymentAmount: bigint, minZenoOut: bigint, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+export default buy;

package/dist/types/contracts/zeno/getAuctionState.d.ts

@@ -0,0 +1,45 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+import { FundingMode } from "./createAuction";
+/** A ZENO auction's terms and live state. Prices take the payment token's decimals, ZENO amounts the underlying's. */
+export interface AuctionState {
+    /** The auction contract. */
+    auction: string;
+    /** The ZENO bond it sells. */
+    zeno: string;
+    /** What buyers pay with. */
+    paymentToken: string;
+    /** Receives every payment. */
+    issuer: string;
+    fundingMode: FundingMode;
+    /** UNIX timestamp (seconds) buying opens. */
+    startTime: bigint;
+    /** UNIX timestamp (seconds) buying closes, unless it sells out first. */
+    endTime: bigint;
+    /** Price at `startTime`, in payment token base units per whole ZENO. */
+    startingPrice: TokenAmount;
+    /** Price at and after `endTime`; equal to `startingPrice` for a fixed-price bond. */
+    reservePrice: TokenAmount;
+    /** True when the price does not decay. */
+    isFixedPrice: boolean;
+    /** `getPrice()` as of the block read. A Dutch price keeps falling every block, also while paused. */
+    price: TokenAmount;
+    /** ZENO on offer. */
+    totalAllocated: TokenAmount;
+    /** ZENO not yet sold; `buy` reverts when it would mint more. */
+    totalRemaining: TokenAmount;
+    /** True while `buy` is halted by the pauser. */
+    paused: boolean;
+    /** True once past `endTime` or sold out, as `checkAuctionEnded()` says. */
+    ended: boolean;
+}
+/**
+ * Reads one auction's terms and live state.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns The auction's state.
+ */
+declare function getAuctionState(chainId: ChainId, auction: string, provider?: Provider): Promise<AuctionState>;
+export default getAuctionState;

package/dist/types/contracts/zeno/getAuctions.d.ts

@@ -33,8 +33,9 @@ export interface AuctionDetails {
  * Lists every auction created by the AuctionFactory.
  * @param chainId The chain id.
  * @param provider The provider to read with. Defaults to the chain's first configured RPC.
- * @returns One record per auction. Price amounts use the auction's payment token, ZENO amounts the ZENO
- * token; decimals and symbols come from the chain config registry and fall back to 18 when the token is not listed.
+ * @returns One record per auction. Price amounts use the auction's payment token, ZENO amounts the ZENO's underlying,
+ * whose decimals ZENO shares; decimals and symbols come from the chain config registry and fall back to 18 when the
+ * token is not listed.
  */
 declare function getAuctions(chainId: ChainId, provider?: Provider): Promise<AuctionDetails[]>;
 export default getAuctions;