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

package/dist/contracts/zeno/getZenos.js

@@ -7,14 +7,14 @@ const ethers_1 = require("ethers");
 const chains_1 = __importDefault(require("../../configs/chains"));
 const contracts_1 = require("../../utils/contracts");
 const artifacts_1 = require("../../utils/artifacts");
-const amount_1 = require("../../utils/amount");
 const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
 /**
  * Lists every ZENO bond created by the ZENOFactory.
  * @param chainId The chain id.
  * @param provider The provider to read with. Defaults to the chain's first configured RPC.
- * @returns One record per bond. Amounts take decimals from the chain config registry and fall back to 18 when the
- * bond is not listed.
+ * @returns One record per bond. ZENO shares its underlying's decimals, so amounts take the underlying's from the chain
+ * config registry and fall back to 18 when it is not listed.
  */
 async function getZenos(chainId, provider) {
     if (!provider) {
@@ -26,14 +26,14 @@ async function getZenos(chainId, provider) {
         const zenoAddresses = await zenoFactoryContract.getZENOs();
         return await Promise.all(zenoAddresses.map(async (address) => {
             const zenoContract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("zeno"), provider);
-            const details = await zenoContract.getDetails();
+            const [details, underlying] = await Promise.all([zenoContract.getDetails(), zenoContract.underlyingAsset()]);
             return {
                 zenoAddress: details.zenoAddress,
                 maturityDate: details.maturityDate,
                 name: details.name,
                 symbol: details.symbol,
-                totalMinted: (0, amount_1.toTokenAmount)(chainId, details.zenoAddress, details.totalMinted),
-                totalRedeemed: (0, amount_1.toTokenAmount)(chainId, details.zenoAddress, details.totalRedeemed),
+                totalMinted: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalMinted, details.symbol),
+                totalRedeemed: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalRedeemed, details.symbol),
             };
         }));
     }

package/dist/contracts/zeno/grantRole.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.grantRole = grantRole;
+exports.revokeRole = revokeRole;
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Grants an auction role, e.g. PAUSER_ROLE to a guardian bot. DEFAULT_ADMIN_ROLE only.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param role The bytes32 role identifier: `keccak256("PAUSER_ROLE")`, or the zero hash for DEFAULT_ADMIN_ROLE.
+ * @param account The address to grant it to.
+ * @param signer A DEFAULT_ADMIN_ROLE holder.
+ * @returns The transaction receipt.
+ */
+async function grantRole(chainId, auction, role, account, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getAuctionContract)(chainId, auction, signer).grantRole(role, account);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.grantRole", error, { chainId, address: auction });
+    }
+}
+/**
+ * Revokes an auction role. DEFAULT_ADMIN_ROLE only.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param role The bytes32 role identifier: `keccak256("PAUSER_ROLE")`, or the zero hash for DEFAULT_ADMIN_ROLE.
+ * @param account The address to revoke it from.
+ * @param signer A DEFAULT_ADMIN_ROLE holder.
+ * @returns The transaction receipt.
+ */
+async function revokeRole(chainId, auction, role, account, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getAuctionContract)(chainId, auction, signer).revokeRole(role, account);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.revokeRole", error, { chainId, address: auction });
+    }
+}

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/pools/lendingPool/adapters/erc20/getERC20AdapterBalance.js

@@ -9,16 +9,16 @@ const rpcError_1 = require("../../../../utils/rpcError");
  * @param chainId The chain id, used to look up the adapter token's decimals in the token registry.
  * @param adapterAddress The ERC20 asset adapter address.
  * @param userAddress The user.
- * @param signer The signer to read with.
+ * @param runner The signer or provider to read with. A read-only provider is enough.
  * @returns The deposited balance in base units of the adapter's token, with its registry decimals and symbol (18 decimals if the token is not in the registry).
  */
-async function getERC20AdapterBalance(chainId, adapterAddress, userAddress, signer) {
-    if (!signer) {
+async function getERC20AdapterBalance(chainId, adapterAddress, userAddress, runner) {
+    if (!runner) {
         throw new Error("Wallet not connected");
     }
     try {
         const abi = (0, artifacts_1.getABI)("erc20assetadapter");
-        const adapterContract = new ethers_1.ethers.Contract(adapterAddress, abi, signer);
+        const adapterContract = new ethers_1.ethers.Contract(adapterAddress, abi, runner);
         const [balance, token] = await Promise.all([
             adapterContract.balanceOf(userAddress),
             adapterContract.token(),

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";
@@ -123,11 +134,13 @@ import { cancelExit as cancelExitPsm } from "./contracts/psm/cancelExit";
 import { redeem as redeemPsm } from "./contracts/psm/redeem";
 import { swap as swapPsm } from "./contracts/psm/swap";
 import { getABI } from "./utils/artifacts";
-import { toAmount, toScaled, parseAmount, toDecimalString, serializeAmount, deserializeAmount, getAssetDecimals, getTokenInfo, toTokenAmount } from "./utils/amount";
+import { toAmount, toScaled, parseAmount, toDecimalString, toNumber, serializeAmount, deserializeAmount, getAssetDecimals, getTokenInfo, toTokenAmount } from "./utils/amount";
 import * as distributorMethods from "./contracts/governance/distributor";
 import * as gaugeMethods from "./contracts/governance/gauge";
 import * as controllerMethods from "./contracts/governance/gaugeController";
 import * as gaugeSystemMethods from "./contracts/governance/gaugeSystems";
+import * as curveCommonMethods from "./contracts/curve/common";
+import * as userMethods from "./user";
 import { cancel as cancelProposals } from "./contracts/governance/proposals/cancel";
 import { getQuorumNumerator as getQuorumNumeratorProposals } from "./contracts/governance/proposals/getQuorumNumerator";
 import { getVotingPeriod as getVotingPeriodProposals } from "./contracts/governance/proposals/getVotingPeriod";
@@ -305,6 +318,10 @@ declare class RPCLibrary {
     address: JsonRpcSigner | string;
     chainId: ChainId | bigint | null;
     privateKey: any;
+    curve: {
+        common: typeof curveCommonMethods;
+    };
+    user: typeof userMethods;
     prices: {
         getPrices: typeof getPrices;
         getTokenPriceUSD: typeof getTokenPriceUSD;
@@ -696,6 +713,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;
@@ -707,6 +738,7 @@ declare class RPCLibrary {
         toScaled: typeof toScaled;
         parseAmount: typeof parseAmount;
         toDecimalString: typeof toDecimalString;
+        toNumber: typeof toNumber;
         serializeAmount: typeof serializeAmount;
         deserializeAmount: typeof deserializeAmount;
         getAssetDecimals: typeof getAssetDecimals;

package/dist/types/contracts/curve/common/_helpers.d.ts

@@ -0,0 +1,16 @@
+import { ethers, Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { CurvePoolEntry, CurvePools } from "../../../configs/chains/chain";
+/**
+ * Reads every Curve pool flavour shares. Coin indexes differ (uint256 vs int128) only in swap and liquidity
+ * methods, which are not here.
+ */
+export declare const CURVE_POOL_READ_ABI: string[];
+export declare const getCurvePools: (chainId: ChainId) => CurvePools;
+/** Resolves a Curve pool by its config key (any casing) or its address. */
+export declare function resolveCurvePool(chainId: ChainId, poolAddressOrId: string): CurvePoolEntry;
+export declare function getCurvePoolContract(chainId: ChainId, poolAddressOrId: string, provider?: Provider): {
+    entry: CurvePoolEntry;
+    contract: ethers.Contract;
+    provider: ethers.Provider;
+};

package/dist/types/contracts/curve/common/getPools.d.ts

@@ -0,0 +1,30 @@
+import { ChainId } from "../../../configs/chains";
+import { CurvePoolEntry } from "../../../configs/chains/chain";
+export interface CurvePoolCoin {
+    /** Asset key in the chain config, e.g. "pmusd". */
+    asset: string;
+    address: string;
+    /** From the token registry; the asset key when the registry has no symbol. */
+    symbol: string;
+    decimals: number;
+}
+export interface CurvePool extends Omit<CurvePoolEntry, "coins"> {
+    /** In pool index order: coins[i] is coin i on chain. */
+    coins: CurvePoolCoin[];
+}
+/**
+ * Lists the Curve pools in the chain config.
+ *
+ * @param chainId - The chain/network to use.
+ * @returns Every configured pool with its flavour and coins in pool index order; empty when the chain has none.
+ */
+export declare const getPools: (chainId: ChainId) => CurvePool[];
+/**
+ * Looks up one Curve pool in the chain config. Reads the config only; no RPC call is made.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's config key or its address.
+ * @returns The pool with its flavour and coins in pool index order.
+ * @throws If the pool is not configured on the chain.
+ */
+export declare const getPool: (chainId: ChainId, poolAddressOrId: string) => CurvePool;

package/dist/types/contracts/curve/common/getVirtualPrice.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+/**
+ * Reads a Curve pool's virtual price: the value of one whole LP token in units of the pool's underlying coins,
+ * which only grows with fees. For a stableswap pool of $1 coins it is the LP token's USD price.
+ *
+ * @param chainId - The chain/network to use.
+ * @param poolAddressOrId - The pool's key in the chain config's `curve` section, or its address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns `get_virtual_price()` as an 18-decimal amount, e.g. 1.0021 underlying per LP token.
+ */
+export declare const getVirtualPrice: (chainId: ChainId, poolAddressOrId: string, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/curve/common/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./getPools";
+export * from "./getVirtualPrice";

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;

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

@@ -0,0 +1,42 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+/** A ZENO bond's live state. ZENO amounts take the underlying's decimals. */
+export interface BondState {
+    /** The ZENO bond contract. */
+    zeno: string;
+    /** ERC20 name, e.g. `ZENO Bond 20270101`. */
+    name: string;
+    /** ERC20 symbol, e.g. `ZENO-20270101`. */
+    symbol: string;
+    /** What 1 ZENO redeems for at maturity. */
+    underlying: string;
+    /** The auction bound by `setAuction`, the only one that can mint; null until it is set. */
+    auction: string | null;
+    /** UNIX timestamp (seconds) the bond matures. */
+    maturityDate: bigint;
+    /** True once maturity has passed. Redemption also needs `isFunded`. */
+    isRedeemable: boolean;
+    /** ZENO minted over the bond's lifetime; never falls. */
+    totalMinted: TokenAmount;
+    /** ZENO outstanding, still to be redeemed. */
+    totalSupply: TokenAmount;
+    /** ZENO redeemed for the underlying. */
+    totalRedeemed: TokenAmount;
+    /** Underlying held by the ZENO, in the underlying's base units. */
+    collateral: TokenAmount;
+    /** Underlying above outstanding supply, which the owner may sweep once the auction has ended. */
+    sweepableSurplus: TokenAmount;
+    /** True when collateral covers outstanding supply. `redeem` reverts with `InsufficientCollateral` while it is false, which only a Float bond the issuer has not topped up can reach. */
+    isFunded: boolean;
+}
+/**
+ * Reads a ZENO bond's live state: supply, collateral and whether it can be redeemed. Collateral is read here rather
+ * than indexed, because top-ups are plain transfers on the underlying that no ZENO event records.
+ * @param chainId The chain id.
+ * @param zeno The ZENO bond address.
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns The bond's state.
+ */
+declare function getBondState(chainId: ChainId, zeno: string, provider?: Provider): Promise<BondState>;
+export default getBondState;

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

@@ -0,0 +1,12 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains";
+import { TokenAmount } from "../../utils/amount";
+/**
+ * Reads an auction's current price. Read it right before `buy` to size `minZenoOut`: a Dutch price falls every block.
+ * @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 price in payment token base units per whole ZENO.
+ */
+declare function getPrice(chainId: ChainId, auction: string, provider?: Provider): Promise<TokenAmount>;
+export default getPrice;

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

@@ -20,8 +20,8 @@ export interface ZenoDetails {
  * Lists every ZENO bond created by the ZENOFactory.
  * @param chainId The chain id.
  * @param provider The provider to read with. Defaults to the chain's first configured RPC.
- * @returns One record per bond. Amounts take decimals from the chain config registry and fall back to 18 when the
- * bond is not listed.
+ * @returns One record per bond. ZENO shares its underlying's decimals, so amounts take the underlying's from the chain
+ * config registry and fall back to 18 when it is not listed.
  */
 declare function getZenos(chainId: ChainId, provider?: Provider): Promise<ZenoDetails[]>;
 export default getZenos;

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

@@ -0,0 +1,22 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * Grants an auction role, e.g. PAUSER_ROLE to a guardian bot. DEFAULT_ADMIN_ROLE only.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param role The bytes32 role identifier: `keccak256("PAUSER_ROLE")`, or the zero hash for DEFAULT_ADMIN_ROLE.
+ * @param account The address to grant it to.
+ * @param signer A DEFAULT_ADMIN_ROLE holder.
+ * @returns The transaction receipt.
+ */
+export declare function grantRole(chainId: ChainId, auction: string, role: string, account: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+/**
+ * Revokes an auction role. DEFAULT_ADMIN_ROLE only.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param role The bytes32 role identifier: `keccak256("PAUSER_ROLE")`, or the zero hash for DEFAULT_ADMIN_ROLE.
+ * @param account The address to revoke it from.
+ * @param signer A DEFAULT_ADMIN_ROLE holder.
+ * @returns The transaction receipt.
+ */
+export declare function revokeRole(chainId: ChainId, auction: string, role: string, account: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;