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

package/dist/RPCLibrary.js

@@ -133,6 +133,17 @@ const getAuctions_1 = __importDefault(require("./contracts/zeno/getAuctions"));
 const createAuction_1 = __importDefault(require("./contracts/zeno/createAuction"));
 const createZeno_1 = __importDefault(require("./contracts/zeno/createZeno"));
 const getZenos_1 = __importDefault(require("./contracts/zeno/getZenos"));
+const getAuctionState_1 = __importDefault(require("./contracts/zeno/getAuctionState"));
+const getBondState_1 = __importDefault(require("./contracts/zeno/getBondState"));
+const getPrice_1 = __importDefault(require("./contracts/zeno/getPrice"));
+const buy_1 = __importDefault(require("./contracts/zeno/buy"));
+const redeem_1 = require("./contracts/zeno/redeem");
+const setAuction_1 = __importDefault(require("./contracts/zeno/setAuction"));
+const sweepSurplus_1 = __importDefault(require("./contracts/zeno/sweepSurplus"));
+const pause_2 = require("./contracts/zeno/pause");
+const grantRole_1 = require("./contracts/zeno/grantRole");
+const priceAt_1 = require("./contracts/zeno/priceAt");
+const quoteBuy_1 = require("./contracts/zeno/quoteBuy");
 const getBaseUri_1 = __importDefault(require("./nfts/getBaseUri"));
 const claimRewardFromPool_1 = __importDefault(require("./contracts/feeCollector/claimRewardFromPool"));
 const getRawUserDepositsInLendingPool_1 = __importDefault(require("./pools/lendingPool/getRawUserDepositsInLendingPool"));
@@ -179,7 +190,7 @@ const previewProportionalSplit_1 = require("./contracts/psm/previewProportionalS
 const deposit_1 = require("./contracts/psm/deposit");
 const requestExit_1 = require("./contracts/psm/requestExit");
 const cancelExit_1 = require("./contracts/psm/cancelExit");
-const redeem_1 = require("./contracts/psm/redeem");
+const redeem_2 = require("./contracts/psm/redeem");
 const swap_1 = require("./contracts/psm/swap");
 const artifacts_1 = require("./utils/artifacts");
 const rpcError_1 = require("./utils/rpcError");
@@ -328,10 +339,10 @@ const getConfig_3 = require("./contracts/lockers/botLocker/getConfig");
 const getUnlockWindow_1 = require("./contracts/lockers/botLocker/getUnlockWindow");
 const getRoles_3 = require("./contracts/lockers/botLocker/getRoles");
 const hasRole_3 = require("./contracts/lockers/botLocker/hasRole");
-const grantRole_1 = require("./contracts/lockers/botLocker/grantRole");
+const grantRole_2 = require("./contracts/lockers/botLocker/grantRole");
 const addRewardTokens_1 = require("./contracts/lockers/botLocker/addRewardTokens");
 const distributeRewardToken_1 = require("./contracts/lockers/botLocker/distributeRewardToken");
-const pause_2 = require("./contracts/lockers/botLocker/pause");
+const pause_3 = require("./contracts/lockers/botLocker/pause");
 const rescueTokens_1 = require("./contracts/lockers/botLocker/rescueTokens");
 // leRAAC token
 const getBalance_8 = require("./contracts/tokens/leRAAC/getBalance");
@@ -644,12 +655,12 @@ class RPCLibrary {
                 getUnlockWindow: getUnlockWindow_1.getUnlockWindow,
                 getRoles: getRoles_3.getRoles,
                 hasRole: hasRole_3.hasRole,
-                grantRole: grantRole_1.grantRole,
-                revokeRole: grantRole_1.revokeRole,
+                grantRole: grantRole_2.grantRole,
+                revokeRole: grantRole_2.revokeRole,
                 addRewardTokens: addRewardTokens_1.addRewardTokens,
                 distributeRewardToken: distributeRewardToken_1.distributeRewardToken,
-                pause: pause_2.pause,
-                unpause: pause_2.unpause,
+                pause: pause_3.pause,
+                unpause: pause_3.unpause,
                 rescueTokens: rescueTokens_1.rescueTokens,
             },
         };
@@ -732,7 +743,7 @@ class RPCLibrary {
             deposit: deposit_1.deposit,
             requestExit: requestExit_1.requestExit,
             cancelExit: cancelExit_1.cancelExit,
-            redeem: redeem_1.redeem,
+            redeem: redeem_2.redeem,
             swap: swap_1.swap,
         };
         this.pools = {
@@ -820,6 +831,20 @@ class RPCLibrary {
             getAuctions: getAuctions_1.default,
             createZeno: createZeno_1.default,
             getZenos: getZenos_1.default,
+            getAuctionState: getAuctionState_1.default,
+            getBondState: getBondState_1.default,
+            getPrice: getPrice_1.default,
+            buy: buy_1.default,
+            redeem: redeem_1.redeem,
+            redeemAll: redeem_1.redeemAll,
+            setAuction: setAuction_1.default,
+            sweepSurplus: sweepSurplus_1.default,
+            pause: pause_2.pause,
+            unpause: pause_2.unpause,
+            grantRole: grantRole_1.grantRole,
+            revokeRole: grantRole_1.revokeRole,
+            priceAt: priceAt_1.priceAt,
+            quoteBuy: quoteBuy_1.quoteBuy,
         };
         this.prices = {
             getPrices: getPrices_1.getPrices,

package/dist/configs/chains/11155111.json

@@ -22,12 +22,12 @@
         "auctionfactory": {
             "id": "auctionfactory",
             "name": "Auction Factory",
-            "contract": "0xC644A84734A7329eE46d3B6704746179d272f990"
+            "contract": "0xeb4b30b853BCf687c91C3a20f3ad0816EEf002BD"
         },
         "zenofactory": {
             "id": "zenofactory",
             "name": "Zeno Factory",
-            "contract": "0xa9eE59A113bCB4B2CC10f802D1efF0Bae1Ab91D2"
+            "contract": "0x55F6F6801Bda0AD55753B4B89a525F1E36fC8333"
         },
         "raacminter": {
             "id": "raacminter",

package/dist/configs/chains/8453.json

@@ -22,12 +22,12 @@
         "auctionfactory": {
             "id": "auctionfactory",
             "name": "Auction Factory",
-            "contract": "0xC644A84734A7329eE46d3B6704746179d272f990"
+            "contract": "0x98eDDadCfde04dC22a0e62119617e74a6Bc77313"
         },
         "zenofactory": {
             "id": "zenofactory",
             "name": "Zeno Factory",
-            "contract": "0xa9eE59A113bCB4B2CC10f802D1efF0Bae1Ab91D2"
+            "contract": "0x95bD8D42f30351685e96C62EDdc0d0613bf9a87A"
         },
         "raacminter": {
             "id": "raacminter",
@@ -299,6 +299,27 @@
             "symbol": "leRAAC",
             "decimals": 18,
             "contract": "0xa513E6E4b8f2a923D98304ec87F64353C4D5C853"
+        },
+        "zenocrvusd": {
+            "id": "zenocrvusd",
+            "name": "crvUSD (bond seed mock)",
+            "symbol": "crvUSD",
+            "decimals": 18,
+            "contract": "0x2B574555158337Cd46d47c2Ca57E4698A1f04e70"
+        },
+        "zenousdc": {
+            "id": "zenousdc",
+            "name": "USDC (bond seed mock)",
+            "symbol": "USDC",
+            "decimals": 6,
+            "contract": "0xcA8b49076D1A8039599e24979abf819af784c27a"
+        },
+        "zenousdt": {
+            "id": "zenousdt",
+            "name": "USDT (bond seed mock)",
+            "symbol": "USDT",
+            "decimals": 6,
+            "contract": "0xc039b3B46814D8388e5205D37Dd0D154D806F1f4"
         }
     },
     "lockers": {

package/dist/contracts/zeno/_helpers.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC20_ABI = void 0;
+exports.getZenoContract = getZenoContract;
+exports.getAuctionContract = getAuctionContract;
+exports.toZenoAmount = toZenoAmount;
+exports.addressOrNull = addressOrNull;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../configs/chains"));
+const artifacts_1 = require("../../utils/artifacts");
+const amount_1 = require("../../utils/amount");
+/** The one ERC20 call the zeno methods make: the underlying held by a ZENO. */
+exports.ERC20_ABI = ["function balanceOf(address) view returns (uint256)"];
+/** A ZENO bond. Bonds are created by the factory, so the address is passed in rather than read from the config. */
+function getZenoContract(chainId, zeno, runner) {
+    if (!runner) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        runner = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    return new ethers_1.ethers.Contract(zeno, (0, artifacts_1.getABI)("zeno"), runner);
+}
+/** A ZENO auction. Auctions are created by the factory, so the address is passed in rather than read from the config. */
+function getAuctionContract(chainId, auction, runner) {
+    if (!runner) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        runner = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    return new ethers_1.ethers.Contract(auction, (0, artifacts_1.getABI)("auction"), runner);
+}
+/**
+ * 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.
+ */
+function toZenoAmount(chainId, underlying, value, symbol) {
+    return (0, amount_1.toAmount)(value, (0, amount_1.getTokenInfo)(chainId, underlying)?.decimals ?? amount_1.WAD_DECIMALS, symbol);
+}
+/** `ZENO.auction()` and other unset address fields read as the zero address; this maps that to null. */
+function addressOrNull(address) {
+    return address === ethers_1.ethers.ZeroAddress ? null : address;
+}

package/dist/contracts/zeno/buy.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+async function buy(chainId, auction, paymentAmount, minZenoOut, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getAuctionContract)(chainId, auction, signer).buy(paymentAmount, minZenoOut);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.buy", error, { chainId, address: auction });
+    }
+}
+exports.default = buy;

package/dist/contracts/zeno/getAuctionState.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const amount_1 = require("../../utils/amount");
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+async function getAuctionState(chainId, auction, provider) {
+    try {
+        const contract = (0, _helpers_1.getAuctionContract)(chainId, auction, provider);
+        const [details, paymentToken, paused, ended] = await Promise.all([
+            contract.getDetails(),
+            contract.token(),
+            contract.paused(),
+            contract.checkAuctionEnded(),
+        ]);
+        const underlying = await (0, _helpers_1.getZenoContract)(chainId, details.zenoAddress, contract.runner).underlyingAsset();
+        return {
+            auction: details.auctionAddress,
+            zeno: details.zenoAddress,
+            paymentToken,
+            issuer: details.issuer,
+            fundingMode: Number(details.fundingMode),
+            startTime: details.auctionStartTime,
+            endTime: details.auctionEndTime,
+            startingPrice: (0, amount_1.toTokenAmount)(chainId, paymentToken, details.startingPrice),
+            reservePrice: (0, amount_1.toTokenAmount)(chainId, paymentToken, details.reservePrice),
+            isFixedPrice: details.startingPrice === details.reservePrice,
+            price: (0, amount_1.toTokenAmount)(chainId, paymentToken, details.price),
+            totalAllocated: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalZENOAllocated),
+            totalRemaining: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalZENORemaining),
+            paused,
+            ended,
+        };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.getAuctionState", error, { chainId, address: auction });
+    }
+}
+exports.default = getAuctionState;

package/dist/contracts/zeno/getAuctions.js

@@ -9,12 +9,14 @@ 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 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.
  */
 async function getAuctions(chainId, provider) {
     if (!provider) {
@@ -30,6 +32,7 @@ async function getAuctions(chainId, provider) {
                 auctionContract.getDetails(),
                 auctionContract.token(),
             ]);
+            const underlying = await (0, _helpers_1.getZenoContract)(chainId, details.zenoAddress, provider).underlyingAsset();
             return {
                 auctionAddress: details.auctionAddress,
                 zenoAddress: details.zenoAddress,
@@ -40,8 +43,8 @@ async function getAuctions(chainId, provider) {
                 startingPrice: (0, amount_1.toTokenAmount)(chainId, tokenAddress, details.startingPrice),
                 reservePrice: (0, amount_1.toTokenAmount)(chainId, tokenAddress, details.reservePrice),
                 price: (0, amount_1.toTokenAmount)(chainId, tokenAddress, details.price),
-                totalZENOAllocated: (0, amount_1.toTokenAmount)(chainId, details.zenoAddress, details.totalZENOAllocated),
-                totalZENORemaining: (0, amount_1.toTokenAmount)(chainId, details.zenoAddress, details.totalZENORemaining),
+                totalZENOAllocated: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalZENOAllocated),
+                totalZENORemaining: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalZENORemaining),
                 fundingMode: Number(details.fundingMode),
             };
         }));

package/dist/contracts/zeno/getBondState.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const amount_1 = require("../../utils/amount");
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+async function getBondState(chainId, zeno, provider) {
+    try {
+        const contract = (0, _helpers_1.getZenoContract)(chainId, zeno, provider);
+        const [details, underlying, auction, totalSupply, sweepableSurplus, isRedeemable] = await Promise.all([
+            contract.getDetails(),
+            contract.underlyingAsset(),
+            contract.auction(),
+            contract.totalSupply(),
+            contract.sweepableSurplus(),
+            contract.isRedeemable(),
+        ]);
+        const collateral = await new ethers_1.ethers.Contract(underlying, _helpers_1.ERC20_ABI, contract.runner).balanceOf(zeno);
+        return {
+            zeno: details.zenoAddress,
+            name: details.name,
+            symbol: details.symbol,
+            underlying,
+            auction: (0, _helpers_1.addressOrNull)(auction),
+            maturityDate: details.maturityDate,
+            isRedeemable,
+            totalMinted: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalMinted, details.symbol),
+            totalSupply: (0, _helpers_1.toZenoAmount)(chainId, underlying, totalSupply, details.symbol),
+            totalRedeemed: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalRedeemed, details.symbol),
+            collateral: (0, amount_1.toTokenAmount)(chainId, underlying, collateral),
+            sweepableSurplus: (0, amount_1.toTokenAmount)(chainId, underlying, sweepableSurplus),
+            isFunded: collateral >= totalSupply,
+        };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.getBondState", error, { chainId, address: zeno });
+    }
+}
+exports.default = getBondState;

package/dist/contracts/zeno/getPrice.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const amount_1 = require("../../utils/amount");
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * 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.
+ */
+async function getPrice(chainId, auction, provider) {
+    try {
+        const contract = (0, _helpers_1.getAuctionContract)(chainId, auction, provider);
+        const [price, paymentToken] = await Promise.all([contract.getPrice(), contract.token()]);
+        return (0, amount_1.toTokenAmount)(chainId, paymentToken, price);
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.getPrice", error, { chainId, address: auction });
+    }
+}
+exports.default = getPrice;

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/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";
@@ -696,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/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>;

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

@@ -0,0 +1,18 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * 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.
+ */
+export declare function pause(chainId: ChainId, auction: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+/**
+ * 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.
+ */
+export declare function unpause(chainId: ChainId, auction: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

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

@@ -0,0 +1,20 @@
+/** The auction terms that set its price. All values as the contract stores them. */
+export interface AuctionPriceTerms {
+    /** UNIX timestamp (seconds). */
+    startTime: bigint;
+    /** UNIX timestamp (seconds). */
+    endTime: bigint;
+    /** Payment token base units per whole ZENO. */
+    startingPrice: bigint;
+    /** Payment token base units per whole ZENO. */
+    reservePrice: bigint;
+}
+/**
+ * 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.
+ */
+export declare const priceAt: (terms: AuctionPriceTerms, now: bigint) => bigint;

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

@@ -0,0 +1,34 @@
+export interface BuyQuoteInput {
+    /** Price in payment token base units per whole ZENO, from `priceAt` or `getPrice`. */
+    price: bigint;
+    /** Payment token to spend, in base units. */
+    paymentAmount: bigint;
+    /** ZENO decimals, equal to the underlying's. */
+    zenoDecimals: number;
+    /** ZENO left to sell, in base units (`totalRemaining`). */
+    totalRemaining: bigint;
+    /** Tolerance below `zenoOut` for `minZenoOut`, in basis points (10000 = 100%). Defaults to 0. */
+    slippageBps?: bigint;
+}
+export interface BuyQuote {
+    /** ZENO minted for `paymentAmount` at `price`, in base units. */
+    zenoOut: bigint;
+    /** `zenoOut` less the slippage tolerance; pass it to `buy` as `minZenoOut`. */
+    minZenoOut: bigint;
+    /** The largest payment `buy` accepts at `price`; anything above mints more than `totalRemaining` and reverts. */
+    maxPayment: bigint;
+    /** True when `paymentAmount` is above `maxPayment`. */
+    exceedsRemaining: boolean;
+}
+/**
+ * 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.
+ */
+export declare const quoteBuy: (input: BuyQuoteInput) => BuyQuote;

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

@@ -0,0 +1,20 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * 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.
+ */
+export declare function redeem(chainId: ChainId, zeno: string, amount: bigint, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+/**
+ * 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.
+ */
+export declare function redeemAll(chainId: ChainId, zeno: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;

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

@@ -0,0 +1,13 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * 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.
+ */
+declare function setAuction(chainId: ChainId, zeno: string, auction: string, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+export default setAuction;

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

@@ -0,0 +1,14 @@
+import { Signer } from "ethers";
+import { ChainId } from "../../configs/chains";
+/**
+ * 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.
+ */
+declare function sweepSurplus(chainId: ChainId, zeno: string, to: string, amount: bigint, signer: Signer): Promise<import("ethers").ContractTransactionReceipt>;
+export default sweepSurplus;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@raac/rpc",
-	"version": "2.0.0-beta.5",
+	"version": "2.0.0-beta.6",
 	"description": "RPC Library for RAAC",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",